你見過的最全面的 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', )\n('GREEN', )\n('BLACK', )\n('RED', )
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("
I'm Jim
") # output:'
I'm Jim
'
 html.unescape('
I'm Jim
') # 
I'm Jim

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

• selector(封裝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()設置系統編碼方式

• 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__ #(,)
object.__bases__ #()
type(object) #

 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代碼工具
• 生成器和迭代器
• 可迭代對象只需要實現__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

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

#一隻青蛙一次可以跳上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進制

 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 '

Hello, web!

'

• 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 查看可用內存，排查內存洩漏問題

設計模式

單例模式

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

面試加強題：

關於數據庫優化及設計

https://segmentfault.com/a/1190000018426586

• 如何使用兩個棧實現一個隊列
• 反轉鏈表
• 合併兩個有序鏈表
• 刪除鏈表節點
• 反轉二叉樹
• 設計短網址服務？62進制實現
• 設計一個秒殺系統(feed流)？
• https://www.jianshu.com/p/ea0259d109f9
• 為什麼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

來源網絡，侵權聯繫刪除

私信我，回覆：學習，獲取免費學習資源包。