你見過的最全面的 Python 重點

由于總結了太多的東西，是以篇幅有點長，這也是我"縫縫補補"總結了好久的東西。

Py2 VS Py3

• print成為了函數，python2是關鍵字
• 不再有unicode對象，預設str就是unicode
• python3除号傳回浮點數
• 沒有了long類型
• xrange不存在，range替代了xrange
• 可以使用中文定義函數名變量名
• 進階解包 和*解包
• 限定關鍵字參數 *後的變量必須加入名字=值
• 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

https://segmentfault.com/a/1190000017385799

• python排序操作及heapq子產品

https://segmentfault.com/a/1190000017383322

• itertools子產品超實用方法

https://segmentfault.com/a/1190000017416590

不常用但很重要的庫

• 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():           

Python進階

• 程序間通信：
• • 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面試總結基礎篇

https://segmentfault.com/a/1190000018371218

• Mysql面試總結進階篇

https://segmentfault.com/a/1190000018380324

• 深入淺出Mysql

http://ningning.today/2017/02/13/database/

深入淺出mysql/

• 清空整個表時，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
• • 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