你見過的最全面的python重點

摘要： 前端 span設定margin上下無效果，因為span是行內元素，是沒有寬高的。 Py2 VS Py3 print成為了函式，python2是關鍵字 不再有unicode物件，預設str就是unicode python3除號返回浮點數 ...

前端

• span設定margin上下無效果，因為span是行內元素，是沒有寬高的。

Py2 VS Py3

• print成為了函式，python2是關鍵字
• 不再有unicode物件，預設str就是unicode
• python3除號返回浮點數
• 沒有了long型別
• rangex不存在，range替代了rangex
• 可以使用中文定義函式名變數名
• 高階解包 和*解包
• 限定關鍵字引數 *後的變數必須加入名字=值
• 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
• python排序操作及heapq模組
• itertools模組超實用方法

不常用但很重要的庫

• dis(程式碼位元組碼分析)
• inspect(生成器狀態)
• cProfile(效能分析)
• bisect(維護有序列表)

• fnmatch

  • fnmatch根據系統決定

    • fnmatch(string,"*.txt") #win下不區分大小寫
  • 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:'<h1>I'm Jim</h1>'
html.unescape('<h1>I'm Jim</h1>') # <h1>I'm Jim</h1>

• mock(解決測試依賴)

• concurrent(建立程序池河執行緒池)

  • 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=條件)#根據條件進行阻塞主執行緒，有四個條件

• selectot(封裝select,使用者多路複用io程式設計)

• asyncio

  • 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(適用於兩個程序)

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

  • 程序池

  • 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()設定系統編碼方式

• getattrVSgetattribute

  • 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'>

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統計測試覆蓋率

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程式碼工具

• 生成器和迭代器

  • 實現__next__和__iter__方法的物件就是迭代器

    • 可迭代物件只需要實現__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

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

  • #一隻青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
    #請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
    #方式一：
    fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)+fib(n-3)
    #方式二：
    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進位制

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}(不常用，只是看到了記載一下)$

# 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

• 遍歷檔案，傳入一個資料夾，將裡面所有檔案的路徑打印出來(遞迴)

  • 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面試總結基礎篇
• Mysql面試總結進階篇
• 深入淺出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 檢視可用記憶體，排查記憶體洩漏問題

設計模式

單例模式

# 方式一
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")

構造模式

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)

選擇排序

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)

棧

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

• 如果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