你見過的最全面的 Python 重點

時間 2019-11-07

原文原文鏈接

因爲總結了太多的東西，因此篇幅有點長，這也是我"縫縫補補"總結了很久的東西。html

Py2 VS Py3python

print成爲了函數，python2是關鍵字mysql
再也不有unicode對象，默認str就是unicodegit
python3除號返回浮點數web
沒有了long類型面試
xrange不存在，range替代了xrangeredis
可使用中文定義函數名變量名算法
高級解包和*解包sql
限定關鍵字參數 *後的變量必須加入名字=值數據庫
raise from
iteritems移除變成items()
yield from 連接子生成器
asyncio,async/await原生協程支持異步編程
新增enum,mock,ipaddress,concurrent.futures,asyncio urllib，selector
- 不一樣枚舉類間不能進行比較
- 同一枚舉類間只能進行相等的比較
- 枚舉類的使用(編號默認從1開始)
- 爲了不枚舉類中相同枚舉值的出現，可使用@unique裝飾枚舉類

#枚舉的注意事項
from enum import Enum

class COLOR(Enum):
    YELLOW=1
#YELLOW=2#會報錯
    GREEN=1#不會報錯,GREEN能夠看做是YELLOW的別名
    BLACK=3
    RED=4
print(COLOR.GREEN)#COLOR.YELLOW,仍是會打印出YELLOW
for i in COLOR:#遍歷一下COLOR並不會有GREEN
    print(i)
#COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎麼把別名遍歷出來
for i in COLOR.__members__.items():
    print(i)
# output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>)
for i in COLOR.__members__:
    print(i)
# output:YELLOW\nGREEN\nBLACK\nRED

#枚舉轉換
#最好在數據庫存取使用枚舉的數值而不是使用標籤名字字符串
#在代碼裏面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW
複製代碼

py2/3轉換工具

six模塊：兼容pyton2和pyton3的模塊
2to3工具：改變代碼語法版本
future：使用下一版本的功能

經常使用的庫

必須知道的collections

segmentfault.com/a/119000001…
python排序操做及heapq模塊

segmentfault.com/a/119000001…
itertools模塊超實用方法

segmentfault.com/a/119000001…

不經常使用但很重要的庫

dis(代碼字節碼分析)
inspect(生成器狀態)
cProfile(性能分析)
bisect(維護有序列表)
fnmatch
- fnmatch(string,"*.txt") #win下不區分大小寫
- fnmatch根據系統決定
- fnmatchcase徹底區分大小寫
timeit(代碼執行時間)

def isLen(strString):
        #仍是應該使用三元表達式，更快
        return True if len(strString)>6 else False

    def isLen1(strString):
        #這裏注意false和true的位置
        return [False,True][len(strString)>6]
    import timeit
    print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))

    print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))
複製代碼

contextlib
- @contextlib.contextmanager使生成器函數變成一個上下文管理器
types(包含了標準解釋器定義的全部類型的類型對象,能夠將生成器函數修飾爲異步模式)

import types
    types.coroutine #至關於實現了__await__
複製代碼

html(實現對html的轉義)

import html
    html.escape("<h1>I'm Jim</h1>") # output:'&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;'
    html.unescape('&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;') # <h1>I'm Jim</h1>
複製代碼

mock(解決測試依賴)
concurrent(建立進程池河線程池)

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor()
task = pool.submit(函數名，（參數）) #此方法不會阻塞，會當即返回
task.done()#查看任務執行是否完成
task.result()#阻塞的方法，查看任務返回值
task.cancel()#取消未執行的任務，返回True或False,取消成功返回True
task.add_done_callback()#回調函數
task.running()#是否正在執行 task就是一個Future對象

for data in pool.map(函數，參數列表):#返回已經完成的任務結果列表，根據參數順序執行
    print(返回任務完成得執行結果data)

from concurrent.futures import as_completed
as_completed(任務列表)#返回已經完成的任務列表，完成一個執行一個

wait(任務列表,return_when=條件)#根據條件進行阻塞主線程，有四個條件
複製代碼

selector(封裝select,用戶多路複用io編程)
asyncio

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
future=asyncio.ensure_future(協程)  等於後面的方式  future=loop.create_task(協程)
future.add_done_callback()添加一個完成後的回調函數
loop.run_until_complete(future)
future.result()查看寫成返回結果

asyncio.wait()接受一個可迭代的協程對象
asynicio.gather(*可迭代對象,*可迭代對象）    二者結果相同，但gather能夠批量取消，gather對象.cancel()

一個線程中只有一個loop

在loop.stop時必定要loop.run_forever()不然會報錯
loop.run_forever()能夠執行非協程
最後執行finally模塊中 loop.close()

asyncio.Task.all_tasks()拿到全部任務 而後依次迭代並使用任務.cancel()取消

偏函數partial(函數，參數)把函數包裝成另外一個函數名  其參數必須放在定義函數的前面

loop.call_soon(函數,參數)
call_soon_threadsafe()線程安全
loop.call_later(時間,函數,參數)
在同一代碼塊中call_soon優先執行，而後多個later根據時間的升序進行執行

若是非要運行有阻塞的代碼
使用loop.run_in_executor(executor,函數，參數)包裝成一個多線程，而後放入到一個task列表中，經過wait(task列表)來運行

經過asyncio實現http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()發送請求
async for data in reader:
    data=data.decode("utf-8")
    list.append(data)
而後list中存儲的就是html

as_completed(tasks)完成一個返回一個,返回的是一個可迭代對象

協程鎖
async with Lock():
複製代碼

P****ython進階

進程間通訊：
- Manager(內置了好多數據結構，能夠實現多進程間內存共享)

from multiprocessing import Manager,Process
def add_data(p_dict, key, value):
    p_dict[key] = value

if __name__ == "__main__":
    progress_dict = Manager().dict()
    from queue import PriorityQueue

    first_progress = Process(target=add_data, args=(progress_dict, "bobby1", 22))
    second_progress = Process(target=add_data, args=(progress_dict, "bobby2", 23))

    first_progress.start()
    second_progress.start()
    first_progress.join()
    second_progress.join()

    print(progress_dict)
複製代碼

- Pipe(適用於兩個進程)

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
from multiprocessing import Pipe,Process
#pipe的性能高於queue
def producer(pipe):
    pipe.send("bobby")

def consumer(pipe):
    print(pipe.recv())

if __name__ == "__main__":
    recevie_pipe, send_pipe = Pipe()
    #pipe只能適用於兩個進程
    my_producer= Process(target=producer, args=(send_pipe, ))
    my_consumer = Process(target=consumer, args=(recevie_pipe,))

    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()
複製代碼

- Queue(不能用於進程池,進程池間通訊須要使用Manager().Queue())

from multiprocessing import Queue,Process
def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Queue(10)
    my_producer = Process(target=producer, args=(queue,))
    my_consumer = Process(target=consumer, args=(queue,))
    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()
複製代碼

- 進程池

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Manager().Queue(10)
    pool = Pool(2)

    pool.apply_async(producer, args=(queue,))
    pool.apply_async(consumer, args=(queue,))

    pool.close()
    pool.join()
複製代碼

sys模塊幾個經常使用方法
- argv 命令行參數list,第一個是程序自己的路徑
- path 返回模塊的搜索路徑
- modules.keys() 返回已經導入的全部模塊的列表
- exit(0) 退出程序
a in s or b in s or c in s簡寫
- 採用any方式：all() 對於任何可迭代對象爲空都會返回True

# 方法一
    True in [i in s for i in [a,b,c]]
    # 方法二
    any(i in s for i in [a,b,c])
    # 方法三
    list(filter(lambda x:x in s,[a,b,c]))
複製代碼

set集合運用
- {1,2}.issubset({1,2,3})#判斷是不是其子集
- {1,2,3}.issuperset({1,2})
- {}.isdisjoint({})#判斷兩個set交集是否爲空,是空集則爲True
代碼中中文匹配
- [u4E00-u9FA5]匹配中文文字區間[一到龥]
查看系統默認編碼格式

import sys
    sys.getdefaultencoding()    # setdefaultencodeing()設置系統編碼方式
複製代碼

getattr VS getattribute

class A(dict):
    def __getattr__(self,value):#當訪問屬性不存在的時候返回
        return 2
    def __getattribute__(self,item):#屏蔽全部的元素訪問
        return item
複製代碼

類變量是不會存入實例__dict__中的，只會存在於類的__dict__中
globals/locals(能夠變相操做代碼)
- globals中保存了當前模塊中全部的變量屬性與值
- locals中保存了當前環境中的全部變量屬性與值
python變量名的解析機制(LEGB)
- 本地做用域(Local)
- 當前做用域被嵌入的本地做用域(Enclosing locals)
- 全局/模塊做用域(Global)
- 內置做用域(Built-in)
實現從1-100每三個爲一組分組

print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])
複製代碼

什麼是元類？
- 即建立類的類，建立類的時候只須要將metaclass=元類，元類須要繼承type而不是object,由於type就是元類

type.__bases__  #(<class 'object'>,)
object.__bases__    #()
type(object)    #<class 'type'>
複製代碼

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    class Yuan(type):
        def __new__(cls,name,base,attr,*args,**kwargs):
            return type(name,base,attr,*args,**kwargs)
    class MyClass(metaclass=Yuan):
        pass
複製代碼

什麼是鴨子類型(即:多態)？
- Python在使用傳入參數的過程當中不會默認判斷參數類型，只要參數具有執行條件就能夠執行
深拷貝和淺拷貝
- 深拷貝拷貝內容，淺拷貝拷貝地址(增長引用計數)
- copy模塊實現神拷貝
單元測試
- 通常測試類繼承模塊unittest下的TestCase
- pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭，而且不能帶有 init 方法)
- coverage統計測試覆蓋率

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    class MyTest(unittest.TestCase):
        def tearDown(self):# 每一個測試用例執行前執行
            print('本方法開始測試了')

        def setUp(self):# 每一個測試用例執行以前作操做
            print('本方法測試結束')

 @classmethod
        def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 全部test運行完後運行一次
            print('開始測試')
 @classmethod
        def setUpClass(self):# 必須使用@classmethod 裝飾器,全部test運行前運行一次
            print('結束測試')

        def test_a_run(self):
            self.assertEqual(1, 1)  # 測試用例
複製代碼

gil會根據執行的字節碼行數以及時間片釋放gil，gil在遇到io的操做時候主動釋放
什麼是monkey patch?
- 猴子補丁，在運行的時候替換掉會阻塞的語法修改成非阻塞的方法
什麼是自省(Introspection)？
- 運行時判斷一個對象的類型的能力，id,type,isinstance
python是值傳遞仍是引用傳遞？
- 都不是，python是共享傳參，默認參數在執行時只會執行一次
try-except-else-finally中else和finally的區別
- else在不發生異常的時候執行，finally不管是否發生異常都會執行
- except一次能夠捕獲多個異常，但通常爲了對不一樣異常進行不一樣處理，咱們分次捕獲處理
GIL全局解釋器鎖
- 同一時間只能有一個線程執行，CPython(IPython)的特色，其餘解釋器不存在
- cpu密集型：多進程+進程池
- io密集型：多線程/協程
什麼是Cython
- 將python解釋成C代碼工具
生成器和迭代器
- 可迭代對象只須要實現__iter__方法
- - 實現__next__和__iter__方法的對象就是迭代器
- 使用生成器表達式或者yield的生成器函數(生成器是一種特殊的迭代器)
什麼是協程
- yield
- async-awiat
- - 比線程更輕量的多任務方式
  - 實現方式
dict底層結構
- 爲了支持快速查找使用了哈希表做爲底層結構
- 哈希表平均查找時間複雜度爲o(1)
- CPython解釋器使用二次探查解決哈希衝突問題
Hash擴容和Hash衝突解決方案
- 連接法
- 二次探查(開放尋址法)：python使用
- - 循環複製到新空間實現擴容
  - 衝突解決：

for gevent import monkey
    monkey.patch_all()  #將代碼中全部的阻塞方法都進行修改，能夠指定具體要修改的方法
複製代碼

判斷是否爲生成器或者協程

co_flags = func.__code__.co_flags

    # 檢查是不是協程
    if co_flags & 0x180:
        return func

    # 檢查是不是生成器
    if co_flags & 0x20:
        return func
複製代碼

斐波那契解決的問題及變形

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
#一隻青蛙一次能夠跳上1級臺階，也能夠跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
#請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
#方式一：
fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)
#方式二：
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return b

#一隻青蛙一次能夠跳上1級臺階，也能夠跳上2級……它也能夠跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)
複製代碼

獲取電腦設置的環境變量

import os
    os.getenv(env_name,None)#獲取環境變量若是不存在爲None
複製代碼

垃圾回收機制
- 引用計數
- 標記清除
- 分代回收

#查看分代回收觸發
    import gc
    gc.get_threshold()  #output:(700, 10, 10)
複製代碼

True和False在代碼中徹底等價於1和0,能夠直接和數字進行計算，inf表示無窮大
C10M/C10K
- C10M:8核心cpu，64G內存，在10gbps的網絡上保持1000萬併發鏈接
- C10K：1GHz CPU,2G內存，1gbps網絡環境下保持1萬個客戶端提供FTP服務
yield from與yield的區別：
- yield from跟的是一個可迭代對象，而yield後面沒有限制
- GeneratorExit生成器中止時觸發
單下劃線的幾種使用
- 在定義變量時，表示爲私有變量
- 在解包時，表示捨棄無用的數據
- 在交互模式中表示上一次代碼執行結果
- 能夠作數字的拼接(111_222_333)
使用break就不會執行else
10進制轉2進制

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    def conver_bin(num):
        if num == 0:
            return num
        re = []
        while num:
            num, rem = divmod(num,2)
            re.append(str(rem))
        return "".join(reversed(re))
    conver_bin(10)
複製代碼

list1 = ['A', 'B', 'C', 'D'] 如何才能獲得以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢

list1 = ['A', 'B', 'C', 'D']

    # 方法一
    for i in list1:
        globals()[i] = []   # 能夠用於實現python版反射

    # 方法二
    for i in list1:
        exec(f'{i} = []')   # exec執行字符串語句
複製代碼

memoryview與bytearray $\color{#000}(不經常使用，只是看到了記載一下)$

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    # bytearray是可變的，bytes是不可變的,memoryview不會產生新切片和對象
    a = 'aaaaaa'
    ma = memoryview(a)
    ma.readonly  # 只讀的memoryview
    mb = ma[:2]  # 不會產生新的字符串

    a = bytearray('aaaaaa')
    ma = memoryview(a)
    ma.readonly  # 可寫的memoryview
    mb = ma[:2]      # 不會會產生新的bytearray
    mb[:2] = 'bb'    # 對mb的改動就是對ma的改動
複製代碼

Ellipsis類型

# 代碼中出現...省略號的現象就是一個Ellipsis對象
L = [1,2,3]
L.append(L)
print(L)    # output:[1,2,3,[…]]
複製代碼

lazy惰性計算

class lazy(object):
        def __init__(self, func):
            self.func = func

        def __get__(self, instance, cls):
            val = self.func(instance)    #其至關於執行的area(c),c爲下面的Circle對象
            setattr(instance, self.func.__name__, val)
            return val`

    class Circle(object):
        def __init__(self, radius):
            self.radius = radius

 @lazy
        def area(self):
            print('evalute')
            return 3.14 * self.radius ** 2
複製代碼

遍歷文件，傳入一個文件夾，將裏面全部文件的路徑打印出來(遞歸)

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
all_files = []
def getAllFiles(directory_path):
    import os
    for sChild in os.listdir(directory_path):
        sChildPath = os.path.join(directory_path,sChild)
        if os.path.isdir(sChildPath):
            getAllFiles(sChildPath)
        else:
            all_files.append(sChildPath)
    return all_files
複製代碼

文件存儲時，文件名的處理

#secure_filename將字符串轉化爲安全的文件名
from werkzeug import secure_filename
secure_filename("My cool movie.mov") # output:My_cool_movie.mov
secure_filename("../../../etc/passwd") # output:etc_passwd
secure_filename(u'i contain cool \xfcml\xe4uts.txt') # output:i_contain_cool_umlauts.txt
複製代碼

日期格式化

from datetime import datetime

datetime.now().strftime("%Y-%m-%d")

import time
#這裏只有localtime能夠被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())
複製代碼

tuple使用+=奇怪的問題

# 會報錯，可是tuple的值會改變，由於t[1]id沒有發生變化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用append\extend方法並不會報錯，並能夠成功執行
複製代碼

__missing__你應該知道

class Mydict(dict):
    def __missing__(self,key): # 當Mydict使用切片訪問屬性不存在的時候返回的值
        return key
複製代碼

+與+=

# +不能用來鏈接列表和元祖，而+=能夠（經過iadd實現，內部實現方式爲extends(),因此能夠增長元組），+會建立新對象
#不可變對象沒有__iadd__方法，因此直接使用的是__add__方法，所以元祖可使用+=進行元祖之間的相加
複製代碼

如何將一個可迭代對象的每一個元素變成一個字典的全部鍵？

dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}
複製代碼

wireshark抓包軟件

網絡知識

什麼是HTTPS?
- 安全的HTTP協議，https須要cs證書，數據加密，端口爲443，安全，同一網站https seo排名會更高
常見響應狀態碼

204 No Content //請求成功處理，沒有實體的主體返回，通常用來表示刪除成功
    206 Partial Content //Get範圍請求已成功處理
    303 See Other //臨時重定向，指望使用get定向獲取
    304 Not Modified //求情緩存資源
    307 Temporary Redirect //臨時重定向，Post不會變成Get
    401 Unauthorized //認證失敗
    403 Forbidden //資源請求被拒絕
    400 //請求參數錯誤
    201 //添加或更改爲功
    503 //服務器維護或者超負載

複製代碼

http請求方法的冪等性及安全性
WSGI

# environ：一個包含全部HTTP請求信息的dict對象
    # start_response：一個發送HTTP響應的函數
    def application(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return '<h1>Hello, web!</h1>'

複製代碼

RPC
CDN
SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全（Transport Layer Security，TLS）是爲網絡通訊提供安全及數據完整性的一種安全協議。
SSH（安全外殼協議）爲 Secure Shell 的縮寫，由 IETF 的網絡小組（Network Working Group）所制定；SSH 爲創建在應用層基礎上的安全協議。SSH 是目前較可靠，專爲遠程登陸會話和其餘網絡服務提供安全性的協議。利用 SSH 協議能夠有效防止遠程管理過程當中的信息泄露問題。SSH最初是UNIX系統上的一個程序，後來又迅速擴展到其餘操做平臺。SSH在正確使用時可彌補網絡中的漏洞。SSH客戶端適用於多種平臺。幾乎全部UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其餘平臺，均可運行SSH。
TCP/IP
- TCP:面向鏈接/可靠/基於字節流
- UDP:無鏈接/不可靠/面向報文
- 三次握手四次揮手
- - 三次握手(SYN/SYN+ACK/ACK)
  - 四次揮手(FIN/ACK/FIN/ACK)
- 爲何鏈接的時候是三次握手，關閉的時候倒是四次握手？
- - 由於當Server端收到Client端的SYN鏈接請求報文後，能夠直接發送SYN+ACK報文。其中ACK報文是用來應答的，SYN報文是用來同步的。可是關閉鏈接時，當Server端收到FIN報文時，極可能並不會當即關閉SOCKET，因此只能先回復一個ACK報文，告訴Client端，"你發的FIN報文我收到了"。只有等到我Server端全部的報文都發送完了，我才能發送FIN報文，所以不能一塊兒發送。故須要四步握手。
- 爲何TIME_WAIT狀態須要通過2MSL(最大報文段生存時間)才能返回到CLOSE狀態？
- - 雖然按道理，四個報文都發送完畢，咱們能夠直接進入CLOSE狀態了，可是咱們必須假象網絡是不可靠的，有能夠最後一個ACK丟失。因此TIME_WAIT狀態就是用來重發可能丟失的ACK報文。
XSS/CSRF
- HttpOnly禁止js腳本訪問和操做Cookie,能夠有效防止XSS

Mysql

索引改進過程
- 線性結構->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)
Mysql面試總結基礎篇

segmentfault.com/a/119000001…
Mysql面試總結進階篇

segmentfault.com/a/119000001…
深刻淺出Mysql

ningning.today/2017/02/13/…
清空整個表時，InnoDB是一行一行的刪除，而MyISAM則會重新刪除建表
text/blob數據類型不能有默認值，查詢時不存在大小寫轉換
何時索引失效
- 以%開頭的like模糊查詢
- 出現隱士類型轉換
- 沒有知足最左前綴原則
- - 對於多列索引，不是使用的第一部分，則不會使用索引
- 失效場景：
- - 應儘可能避免在 where 子句中使用 != 或 <> 操做符，不然引擎將放棄使用索引而進行全表掃描
  - 儘可能避免在 where 子句中使用 or 來鏈接條件，不然將致使引擎放棄使用索引而進行全表掃描，即便其中有條件帶索引也不會使用，這也是爲何儘可能少用 or 的緣由
  - 若是列類型是字符串，那必定要在條件中將數據使用引號引用起來，不然不會使用索引
  - 應儘可能避免在 where 子句中對字段進行函數操做，這將致使引擎放棄使用索引而進行全表掃描

例如：
select id from t where substring(name,1,3) = 'abc' – name;
以abc開頭的，應改爲：
select id from t where name like 'abc%' 
例如：
select id from t where datediff(day, createdate, '2005-11-30') = 0 – '2005-11-30';
應改成:
複製代碼

- - 不要在 where 子句中的「=」左邊進行函數、算術運算或其餘表達式運算，不然系統將可能沒法正確使用索引
  - 應儘可能避免在 where 子句中對字段進行表達式操做，這將致使引擎放棄使用索引而進行全表掃描

如：
select id from t where num/2 = 100 
應改成:
select id from t where num = 100*2；
複製代碼

- - 不適合鍵值較少的列（重複數據較多的列）好比：set enum列就不適合(枚舉類型(enum)能夠添加null,而且默認的值會自動過濾空格集合(set)和枚舉相似，但只能夠添加64個值)
  - 若是MySQL估計使用全表掃描要比使用索引快，則不使用索引
什麼是彙集索引
- B+Tree葉子節點保存的是數據仍是指針
- MyISAM索引和數據分離，使用非彙集
- InnoDB數據文件就是索引文件，主鍵索引就是彙集索引

Redis命令總結

爲何這麼快？
- 基於內存，由C語言編寫
- 使用多路I/O複用模型，非阻塞IO
- 使用單線程減小線程間切換
- - 由於Redis是基於內存的操做，CPU不是Redis的瓶頸，Redis的瓶頸最有多是機器內存的大小或者網絡帶寬。既然單線程容易實現，並且CPU不會成爲瓶頸，那就瓜熟蒂落地採用單線程的方案了（畢竟採用多線程會有不少麻煩！）。
- 數據結構簡單
- 本身構建了VM機制，減小調用系統函數的時間
優點
- 性能高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s
- 豐富的數據類型
- 原子 – Redis的全部操做都是原子性的，同時Redis還支持對幾個操做全並後的原子性執行
- 豐富的特性 – Redis還支持 publish/subscribe（發佈/訂閱）, 通知, key 過時等等特性
什麼是redis事務？
- 將多個請求打包，一次性、按序執行多個命令的機制
- 經過multi,exec,watch等命令實現事務功能
- Python redis-py pipeline=conn.pipeline(transaction=True)
持久化方式
- RDB(快照)
- - save(同步，能夠保證數據一致性)
  - bgsave(異步，shutdown時，無AOF則默認使用)
- AOF(追加日誌)
怎麼實現隊列
- push
- rpop
經常使用的數據類型(Bitmaps,Hyperloglogs,範圍查詢等不經常使用)
- String(字符串):計數器
- - 整數或sds(Simple Dynamic String)
- List(列表)：用戶的關注，粉絲列表
- - ziplist(連續內存塊，每一個entry節點頭部保存先後節點長度信息實現雙向鏈表功能)或double linked list
- Hash(哈希)：
- Set(集合)：用戶的關注者
- - intset或hashtable
- Zset(有序集合)：實時信息排行榜
- - skiplist(跳躍表)
與Memcached區別
- Memcached只能存儲字符串鍵
- Memcached用戶只能經過APPEND的方式將數據添加到已有的字符串的末尾，並將這個字符串當作列表來使用。可是在刪除這些元素的時候，Memcached採用的是經過黑名單的方式來隱藏列表裏的元素，從而避免了對元素的讀取、更新、刪除等操做
- Redis和Memcached都是將數據存放在內存中，都是內存數據庫。不過Memcached還可用於緩存其餘東西，例如圖片、視頻等等
- 虛擬內存–Redis當物理內存用完時，能夠將一些好久沒用到的Value 交換到磁盤
- 存儲數據安全–Memcached掛掉後，數據沒了；Redis能夠按期保存到磁盤（持久化）
- 應用場景不同：Redis出來做爲NoSQL數據庫使用外，還能用作消息隊列、數據堆棧和數據緩存等；Memcached適合於緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和Session等
Redis實現分佈式鎖
- 使用setnx實現加鎖，能夠同時經過expire添加超時時間
- 鎖的value值能夠是一個隨機的uuid或者特定的命名
- 釋放鎖的時候，經過uuid判斷是不是該鎖，是則執行delete釋放鎖
常見問題
- 緩存雪崩
- - 短期內緩存數據過時，大量請求訪問數據庫
- 緩存穿透
- - 請求訪問數據時，查詢緩存中不存在，數據庫中也不存在
- 緩存預熱
- - 初始化項目，將部分經常使用數據加入緩存
- 緩存更新
- - 數據過時，進行更新緩存數據
- 緩存降級
- - 當訪問量劇增、服務出現問題（如響應時間慢或不響應）或非核心服務影響到核心流程的性能時，仍然須要保證服務仍是可用的，即便是有損服務。系統能夠根據一些關鍵數據進行自動降級，也能夠配置開關實現人工降級
一致性Hash算法
- 使用集羣的時候保證數據的一致性
基於redis實現一個分佈式鎖，要求一個超時的參數
- setnx
虛擬內存
內存抖動

Linux

Unix五種i/o模型
- 阻塞io
- 非阻塞io
- 多路複用io(Python下使用selectot實現io多路複用)
- - select
  - - 併發不高，鏈接數很活躍的狀況下
  - poll
  - - 比select提升的並很少
  - epoll
  - - 適用於鏈接數量較多，但活動連接數少的狀況
- 信號驅動io
- 異步io(Gevent/Asyncio實現異步)
比man更好使用的命令手冊
- tldr:一個有命令示例的手冊
kill -9和-15的區別
- -15：程序馬上中止/當程序釋放相應資源後再中止/程序可能仍然繼續運行
- -9：因爲-15的不肯定性，因此直接使用-9當即殺死進程
分頁機制（邏輯地址和物理地址分離的內存分配管理方案）：
- 操做系統爲了高效管理內存，減小碎片
- 程序的邏輯地址劃分爲固定大小的頁
- 物理地址劃分爲一樣大小的幀
- 經過頁表對應邏輯地址和物理地址
分段機制
- 爲了知足代碼的一些邏輯需求
- 數據共享/數據保護/動態連接
- 每一個段內部連續內存分配，段和段之間是離散分配的
查看cpu內存使用狀況？
- top
- free 查看可用內存，排查內存泄漏問題

設計模式

單例模式

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    # 方式一
    def Single(cls,*args,**kwargs):
        instances = {}
        def get_instance (*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]
        return get_instance
 @Single
    class B:
        pass
    # 方式二
    class Single:
        def __init__(self):
            print("單例模式實現方式二。。。")

    single = Single()
    del Single  # 每次調用single就能夠了
    # 方式三(最經常使用的方式)
    class Single:
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance'):
                cls._instance = super().__new__(cls,*args,**kwargs)
            return cls._instance
複製代碼

工廠模式

class Dog:
        def __init__(self):
            print("Wang Wang Wang")
    class Cat:
        def __init__(self):
            print("Miao Miao Miao")


    def fac(animal):
        if animal.lower() == "dog":
            return Dog()
        if animal.lower() == "cat":
            return Cat()
        print("對不起，必須是：dog,cat")
複製代碼

構造模式

'''
遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 
尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！
'''
    class Computer:
        def __init__(self,serial_number):
            self.serial_number = serial_number
            self.memory = None
            self.hadd = None
            self.gpu = None
        def __str__(self):
            info = (f'Memory:{self.memoryGB}',
            'Hard Disk:{self.hadd}GB',
            'Graphics Card:{self.gpu}')
            return ''.join(info)
    class ComputerBuilder：
        def __init__(self):
            self.computer = Computer('Jim1996')
        def configure_memory(self,amount):
            self.computer.memory = amount
            return self #爲了方便鏈式調用
        def configure_hdd(self,amount):
            pass
        def configure_gpu(self,gpu_model):
            pass
    class HardwareEngineer:
        def __init__(self):
            self.builder = None
        def construct_computer(self,memory,hdd,gpu)
            self.builder = ComputerBuilder()
            self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
        @property
        def computer(self):
            return self.builder.computer
複製代碼

數據結構和算法內置數據結構和算法

python實現各類數據結構

快速排序

def quick_sort(_list):
            if len(_list) < 2:
                return _list
            pivot_index = 0
            pivot = _list(pivot_index)
            left_list = [i for i in _list[:pivot_index] if i < pivot]
            right_list = [i for i in _list[pivot_index:] if i > pivot]
        return quick_sort(left) + [pivot] + quick_sort(right)
複製代碼

選擇排序

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    def select_sort(seq):
        n = len(seq)
        for i in range(n-1)
        min_idx = i
            for j in range(i+1,n):
                if seq[j] < seq[min_inx]:
                    min_idx = j
            if min_idx != i:
                seq[i], seq[min_idx] = seq[min_idx],seq[i]
複製代碼

插入排序

def insertion_sort(_list):
        n = len(_list)
        for i in range(1,n):
            value = _list[i]
            pos = i
            while pos > 0 and value < _list[pos - 1]
                _list[pos] = _list[pos - 1]
                pos -= 1
            _list[pos] = value
            print(sql)
複製代碼

歸併排序

def merge_sorted_list(_list1,_list2):   #合併有序列表
        len_a, len_b = len(_list1),len(_list2)
        a = b = 0
        sort = []
        while len_a > a and len_b > b:
            if _list1[a] > _list2[b]:
                sort.append(_list2[b])
                b += 1
            else:
                sort.append(_list1[a])
                a += 1
        if len_a > a:
            sort.append(_list1[a:])
        if len_b > b:
            sort.append(_list2[b:])
        return sort

    def merge_sort(_list):
        if len(list1)<2:
            return list1
        else:
            mid = int(len(list1)/2)
            left = mergesort(list1[:mid])
            right = mergesort(list1[mid:])
            return merge_sorted_list(left,right)
複製代碼

堆排序heapq模塊

from heapq import nsmallest
    def heap_sort(_list):
        return nsmallest(len(_list),_list)
複製代碼

棧

''' 遇到問題沒人解答？小編建立了一個Python學習交流QQ羣：857662006 尋找有志同道合的小夥伴，互幫互助,羣裏還有不錯的視頻學習教程和PDF電子書！ '''
    from collections import deque
    class Stack:
        def __init__(self):
            self.s = deque()
        def peek(self):
            p = self.pop()
            self.push(p)
            return p
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.pop()
複製代碼

隊列

from collections import deque
    class Queue:
        def __init__(self):
            self.s = deque()
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.popleft()
複製代碼

二分查找

def binary_search(_list,num):
        mid = len(_list)//2
        if len(_list) < 1:
            return Flase
        if num > _list[mid]:
            BinarySearch(_list[mid:],num)
        elif num < _list[mid]:
            BinarySearch(_list[:mid],num)
        else:
            return _list.index(num)
複製代碼

面試增強題：

關於數據庫優化及設計

如何使用兩個棧實現一個隊列
反轉鏈表
合併兩個有序鏈表
刪除鏈表節點
反轉二叉樹
設計短網址服務？62進制實現
設計一個秒殺系統(feed流)？
爲何mysql數據庫的主鍵使用自增的整數比較好？使用uuid能夠嗎？爲何？
- 若是InnoDB表的數據寫入順序能和B+樹索引的葉子節點順序一致的話，這時候存取效率是最高的。爲了存儲和查詢性能應該使用自增加id作主鍵。
- 對於InnoDB的主索引，數據會按照主鍵進行排序，因爲UUID的無序性，InnoDB會產生巨大的IO壓力，此時不適合使用UUID作物理主鍵，能夠把它做爲邏輯主鍵，物理主鍵依然使用自增ID。爲了全局的惟一性，應該用uuid作索引關聯其餘表或作外鍵
若是是分佈式系統下咱們怎麼生成數據庫的自增id呢？
- 使用redis
基於redis實現一個分佈式鎖，要求一個超時的參數
- setnx
- setnx + expire
若是redis單個節點宕機了，如何處理？還有其餘業界的方案實現分佈式鎖碼?
- 使用hash一致算法

緩存算法

LRU(least-recently-used):替換最近最少使用的對象
LFU(Least frequently used):最不常用，若是一個數據在最近一段時間內使用次數不多，那麼在未來一段時間內被使用的可能性也很小

服務端性能優化方向

使用數據結構和算法
數據庫
- 索引優化
- 慢查詢消除
- - slow_query_log_file開啓而且查詢慢查詢日誌
  - 經過explain排查索引問題
  - 調整數據修改索引
- 批量操做，從而減小io操做
- 使用NoSQL:好比Redis
網絡io
- 批量操做
- pipeline
緩存
- Redis
異步
- Asyncio實現異步操做
- 使用Celery減小io阻塞
併發
- 多線程
- Gevent

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。