這是一份來自于 SegmentFault 上的開發(fā)者 @二十一 總結的 Python 重點。由于總結了太多的東西，所以篇幅有點長，這也是作者"縫縫補補"總結了好久的東西，強烈建議收藏再慢慢看~

Py2 VS Py3

Py2 和 Py3 的差別

• print 成為了函數(shù)，python2 是關鍵字
• 不再有 unicode 對象，默認 str 就是 unicode
• python3 除號返回浮點數(shù)
• 沒有了long類型
• xrange 不存在，range 替代了 xrange
• 可以使用中文定義函數(shù)名變量名
• 高級解包和*解包
• 限定關鍵字參數(shù) *后的變量必須加入名字=值
• raise from
• iteritems 移除變成 items()
• yield from 鏈接子生成器
• asyncio,async/await 原生協(xié)程支持異步編程
• 新增 enum, mock, ipaddress, concurrent.futures, asyncio urllib, selector
• 不同枚舉類間不能進行比較
• 同一枚舉類間只能進行相等的比較
• 枚舉類的使用(編號默認從1開始)
• 為了避免枚舉類中相同枚舉值的出現(xiàn)，可以使用@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

#枚舉轉換
#最好在數(shù)據(jù)庫存取使用枚舉的數(shù)值而不是使用標簽名字字符串
#在代碼里面使用枚舉類
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(代碼字節(jié)碼分析)
• inspect(生成器狀態(tài))
• cProfile(性能分析)
• bisect(維護有序列表)
• fnmatch
• fnmatch(string,"*.txt") # win下不區(qū)分大小寫
• fnmatch 根據(jù)系統(tǒng)決定
• fnmatchcase 完全區(qū)分大小寫
• timeit(代碼執(zhí)行時間)

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 使生成器函數(shù)變成一個上下文管理器
• types(包含了標準解釋器定義的所有類型的類型對象,可以將生成器函數(shù)修飾為異步模式)

import?types
types.coroutine?#相當于實現(xiàn)了__await__

• html(實現(xiàn)對html的轉義)

import?html
html.escape("
I'm?Jim
")?#?output:'<h1>I'm?Jim</h1>'
html.unescape('<h1>I'm?Jim</h1>')?#?
I'm?Jim

• mock(解決測試依賴)
• concurrent(創(chuàng)建進程池和線程池)

from?concurrent.futures?import?ThreadPoolExecutor

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

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

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

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

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

future=asyncio.ensure_future(協(xié)程)??等于后面的方式??future=loop.create_task(協(xié)程)
future.add_done_callback()添加一個完成后的回調函數(shù)
loop.run_until_complete(future)
future.result()查看寫成返回結果

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

一個線程中只有一個loop

在loop.stop時一定要loop.run_forever()否則會報錯
loop.run_forever()可以執(zhí)行非協(xié)程
最后執(zhí)行finally模塊中?loop.close()

asyncio.Task.all_tasks()拿到所有任務?然后依次迭代并使用任務.cancel()取消

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

loop.call_soon(函數(shù),參數(shù))
call_soon_threadsafe()線程安全????
loop.call_later(時間,函數(shù),參數(shù))
在同一代碼塊中call_soon優(yōu)先執(zhí)行，然后多個later根據(jù)時間的升序進行執(zhí)行

如果非要運行有阻塞的代碼
使用loop.run_in_executor(executor,函數(shù)，參數(shù))包裝成一個多線程，然后放入到一個task列表中，通過wait(task列表)來運行

通過asyncio實現(xiàn)http
reader,writer=await?asyncio.open_connection(host,port)
writer.writer()發(fā)送請求
async?for?data?in?reader:
????data=data.decode("utf-8")
????list.append(data)
然后list中存儲的就是html

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

協(xié)程鎖
async?with?Lock():

Python 進階

• 進程間通信：
• Manager(內置了好多數(shù)據(jù)結構，可以實現(xiàn)多進程間內存共享)

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 命令行參數(shù)list,第一個是程序本身的路徑
• path 返回模塊的搜索路徑
• modules.keys() 返回已經(jīng)導入的所有模塊的列表
• 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]匹配中文文字區(qū)間[一到龥]

• 查看系統(tǒng)默認編碼格式

import?sys
sys.getdefaultencoding()????#?setdefaultencodeing()設置系統(tǒng)編碼方式

• getattr VS getattribute

class?A(dict):
????def?__getattr__(self,value):#當訪問屬性不存在的時候返回
????????return?2
????def?__getattribute__(self,item):#屏蔽所有的元素訪問
????????return?item

• 類變量是不會存入實例__dict__中的，只會存在于類的__dict__中

• globals/locals(可以變相操作代碼)

• globals中保存了當前模塊中所有的變量屬性與值
• locals中保存了當前環(huán)境中的所有變量屬性與值

• python變量名的解析機制(LEGB)

• 本地作用域(Local)
• 當前作用域被嵌入的本地作用域(Enclosing locals)
• 全局/模塊作用域(Global)
• 內置作用域(Built-in)

• 實現(xiàn)從1-100每三個為一組分組

print([[x?for?x?in?range(1,101)][i:i+3]?for?i?in?range(0,100,3)])

• 什么是元類？
• 即創(chuàng)建類的類，創(chuàng)建類的時候只需要將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

• 什么是鴨子類型(即:多態(tài))？

• Python在使用傳入?yún)?shù)的過程中不會默認判斷參數(shù)類型，只要參數(shù)具備執(zhí)行條件就可以執(zhí)行

• 深拷貝和淺拷貝

• 深拷貝拷貝內容，淺拷貝拷貝地址(增加引用計數(shù))
• copy模塊實現(xiàn)神拷貝

• 單元測試

• 一般測試類繼承模塊unittest下的TestCase
• pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭，并且不能帶有 init 方法)
• coverage統(tǒng)計測試覆蓋率

class?MyTest(unittest.TestCase):
????def?tearDown(self):#?每個測試用例執(zhí)行前執(zhí)行
????????print('本方法開始測試了')

????def?setUp(self):#?每個測試用例執(zhí)行之前做操作
????????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 會根據(jù)執(zhí)行的字節(jié)碼行數(shù)以及時間片釋放 gil，gil 在遇到 io 的操作時候主動釋放

• 什么是 monkey patch?

• 猴子補丁，在運行的時候替換掉會阻塞的語法修改為非阻塞的方法

• 什么是自省(Introspection)？

• 運行時判斷一個對象的類型的能力，id,type,isinstance

• python 是值傳遞還是引用傳遞？

• 都不是，python是共享傳參，默認參數(shù)在執(zhí)行時只會執(zhí)行一次

• try-except-else-finally中 else 和 finally 的區(qū)別

• else在不發(fā)生異常的時候執(zhí)行，finally無論是否發(fā)生異常都會執(zhí)行
• except一次可以捕獲多個異常，但一般為了對不同異常進行不同處理，我們分次捕獲處理

• GIL 全局解釋器鎖

• 同一時間只能有一個線程執(zhí)行，CPython(IPython)的特點，其他解釋器不存在
• cpu 密集型：多進程+進程池
• io 密集型：多線程/協(xié)程

• 什么是 Cython

• 將 python 解釋 成 C 代碼工具

• 生成器和迭代器

• 實現(xiàn)__next__和__iter__方法的對象就是迭代器
• 可迭代對象只需要實現(xiàn)__iter__方法
• 使用生成器表達式或者yield的生成器函數(shù)(生成器是一種特殊的迭代器)

• 什么是協(xié)程

• 比線程更輕量的多任務方式
• 實現(xiàn)方式
• yield
• async-awiat

• dict 底層結構

• 為了支持快速查找使用了哈希表作為底層結構
• 哈希表平均查找時間復雜度為o(1)
• CPython 解釋器使用二次探查解決哈希沖突問題

• Hash擴容和Hash沖突解決方案

• 循環(huán)復制到新空間實現(xiàn)擴容
• 沖突解決：
• 鏈接法
• 二次探查(開放尋址法)：python使用

for?gevent?import?monkey
monkey.patch_all()??#將代碼中所有的阻塞方法都進行修改，可以指定具體要修改的方法

• 判斷是否為生成器或者協(xié)程

co_flags?=?func.__code__.co_flags

#?檢查是否是協(xié)程
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)

• 獲取電腦設置的環(huán)境變量

import?os
os.getenv(env_name,None)#獲取環(huán)境變量如果不存在為None

• 垃圾回收機制
• 引用計數(shù)
• 標記清除
• 分代回收

#查看分代回收觸發(fā)
import?gc
gc.get_threshold()??#output:(700,?10,?10)

• True 和 False 在代碼中完全等價于1和0,可以直接和數(shù)字進行計算，inf 表示無窮大

• C10M/C10K

• C10M:8核心cpu，64G內存，在10gbps的網(wǎng)絡上保持1000萬并發(fā)連接
• C10K：1GHz CPU,2G內存，1gbps網(wǎng)絡環(huán)境下保持1萬個客戶端提供FTP服務

• yield from 與 yield 的區(qū)別：

• yield from 跟的是一個可迭代對象，而 yield 后面沒有限制
• GeneratorExit 生成器停止時觸發(fā)

• 單下劃線的幾種使用

• 在定義變量時，表示為私有變量
• 在解包時，表示舍棄無用的數(shù)據(jù)
• 在交互模式中表示上一次代碼執(zhí)行結果
• 可以做數(shù)字的拼接(111_222_333)

• 使用 brea k就不會執(zhí)行 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]?=?[]???#?可以用于實現(xiàn)python版反射

#?方法二
for?i?in?list1:
????exec(f'{i}?=?[]')???#?exec執(zhí)行字符串語句

• memoryview與bytearray

#?bytearray是可變的，bytes是不可變的,memoryview不會產(chǎn)生新切片和對象
a?=?'aaaaaa'
ma?=?memoryview(a)
ma.readonly??#?只讀的memoryview
mb?=?ma[:2]??#?不會產(chǎn)生新的字符串

a?=?bytearray('aaaaaa')
ma?=?memoryview(a)
ma.readonly??#?可寫的memoryview
mb?=?ma[:2]??????#?不會會產(chǎn)生新的bytearray
mb[:2]?=?'bb'????#?對mb的改動就是對ma的改動

• Ellipsis類型

#?代碼中出現(xiàn)...省略號的現(xiàn)象就是一個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)????#其相當于執(zhí)行的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
#這里只有l(wèi)ocaltime可以被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())

• tuple使用+=奇怪的問題

#?會報錯，但是tuple的值會改變，因為t[1]id沒有發(fā)生變化
t=(1,[2,3])
t[1]+=[4,5]
#?t[1]使用append\extend方法并不會報錯，并可以成功執(zhí)行

• __missing__你應該知道

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

• +與+=

#?+不能用來連接列表和元祖，而+=可以（通過iadd實現(xiàn)，內部實現(xiàn)方式為extends(),所以可以增加元組），+會創(chuàng)建新對象
#不可變對象沒有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進行元祖之間的相加

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

dict.fromkeys(['jim','han'],21)?#?output:{'jim':?21,?'han':?21}

網(wǎng)絡知識

• 什么是 HTTPS?

• 安全的 HTTP 協(xié)議，https 需要 cs 證書，數(shù)據(jù)加密，端口為443，安全，同一網(wǎng)站 https seo 排名會更高

• 常見響應狀態(tài)碼

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

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

• WSGI

# environ：一個包含所有HTTP請求信息的dict對象
# start_response：一個發(fā)送HTTP響應的函數(shù)
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）是為網(wǎng)絡通信提供安全及數(shù)據(jù)完整性的一種安全協(xié)議。

• SSH（安全外殼協(xié)議） 為 Secure Shell 的縮寫，由 IETF 的網(wǎng)絡小組（Network Working Group）所制定；SSH 為建立在應用層基礎上的安全協(xié)議。SSH 是目前較可靠，專為遠程登錄會話和其他網(wǎng)絡服務提供安全性的協(xié)議。利用 SSH 協(xié)議可以有效防止遠程管理過程中的信息泄露問題。SSH最初是UNIX系統(tǒng)上的一個程序，后來又迅速擴展到其他操作平臺。SSH在正確使用時可彌補網(wǎng)絡中的漏洞。SSH客戶端適用于多種平臺。幾乎所有UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其他平臺，都可運行SSH。

• TCP/IP

• 雖然按道理，四個報文都發(fā)送完畢，我們可以直接進入CLOSE狀態(tài)了，但是我們必須假象網(wǎng)絡是不可靠的，有可以最后一個ACK丟失。所以TIME_WAIT狀態(tài)就是用來重發(fā)可能丟失的ACK報文。
• 因為當Server端收到Client端的SYN連接請求報文后，可以直接發(fā)送SYN+ACK報文。其中ACK報文是用來應答的，SYN報文是用來同步的。但是關閉連接時，當Server端收到FIN報文時，很可能并不會立即關閉SOCKET，所以只能先回復一個ACK報文，告訴Client端，"你發(fā)的FIN報文我收到了"。只有等到我Server端所有的報文都發(fā)送完了，我才能發(fā)送FIN報文，因此不能一起發(fā)送。故需要四步握手。
• 三次握手(SYN/SYN+ACK/ACK)
• 四次揮手(FIN/ACK/FIN/ACK)
• TCP:面向連接/可靠/基于字節(jié)流
• UDP:無連接/不可靠/面向報文
• 三次握手四次揮手
• 為什么連接的時候是三次握手，關閉的時候卻是四次握手？
• 為什么TIME_WAIT狀態(tài)需要經(jīng)過2MSL(最大報文段生存時間)才能返回到CLOSE狀態(tài)？

• 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數(shù)據(jù)類型不能有默認值，查詢時不存在大小寫轉換

• 什么時候索引失效

• 應盡量避免在 where 子句中使用 != 或 <> 操作符，否則引擎將放棄使用索引而進行全表掃描
• 盡量避免在 where 子句中使用 or 來連接條件，否則將導致引擎放棄使用索引而進行全表掃描，即使其中有條件帶索引也不會使用，這也是為什么盡量少用 or 的原因
• 如果列類型是字符串，那一定要在條件中將數(shù)據(jù)使用引號引用起來，否則不會使用索引
• 應盡量避免在 where 子句中對字段進行函數(shù)操作，這將導致引擎放棄使用索引而進行全表掃描
• 對于多列索引，不是使用的第一部分，則不會使用索引
• 以%開頭的like模糊查詢
• 出現(xiàn)隱式類型轉換
• 沒有滿足最左前綴原則
• 失效場景：

例如：
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 子句中的 “=” 左邊進行函數(shù)、算術運算或其他表達式運算，否則系統(tǒng)將可能無法正確使用索引

應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描

如：
select id from t where num/2 = 100 
應改為:
select id from t where num = 100*2；

不適合鍵值較少的列（重復數(shù)據(jù)較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似，但只可以添加64個值)

如果MySQL估計使用全表掃描要比使用索引快，則不使用索引

• 什么是聚集索引
• B+Tree葉子節(jié)點保存的是數(shù)據(jù)還是指針
• MyISAM索引和數(shù)據(jù)分離，使用非聚集
• InnoDB數(shù)據(jù)文件就是索引文件，主鍵索引就是聚集索引

Redis 命令總結

• 為什么這么快？

• 因為Redis是基于內存的操作，CPU不是Redis的瓶頸，Redis的瓶頸最有可能是機器內存的大小或者網(wǎng)絡帶寬。既然單線程容易實現(xiàn)，而且CPU不會成為瓶頸，那就順理成章地采用單線程的方案了（畢竟采用多線程會有很多麻煩?。?。
• 基于內存，由 C 語言編寫
• 使用多路I/O復用模型，非阻塞 IO
• 使用單線程減少線程間切換
• 數(shù)據(jù)結構簡單
• 自己構建了 VM 機制，減少調用系統(tǒng)函數(shù)的時間

• 優(yōu)勢

• 性能高 – Redis 能讀的速度是110000次/s,寫的速度是81000次/s
• 豐富的數(shù)據(jù)類型
• 原子 – Redis 的所有操作都是原子性的，同時 Redis 還支持對幾個操作全并后的原子性執(zhí)行
• 豐富的特性 – Redis 還支持 publish/subscribe（發(fā)布/訂閱）, 通知, key 過期等等特性

• 什么是 redis 事務？

• 將多個請求打包，一次性、按序執(zhí)行多個命令的機制
• 通過 multi,exec,watch 等命令實現(xiàn)事務功能
• Python redis-py pipeline=conn.pipeline(transaction=True)

• 持久化方式

• save(同步，可以保證數(shù)據(jù)一致性)
• bgsave(異步，shutdown時，無AOF則默認使用)
• RDB(快照)
• AOF(追加日志)

• 怎么實現(xiàn)隊列

• push
• rpop

• 常用的數(shù)據(jù)類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)

• skiplist(跳躍表)
• intset或hashtable
• ziplist(連續(xù)內存塊，每個entry節(jié)點頭部保存前后節(jié)點長度信息實現(xiàn)雙向鏈表功能)或double linked list
• 整數(shù)或sds(Simple Dynamic String)
• String(字符串):計數(shù)器
• List(列表)：用戶的關注，粉絲列表
• Hash(哈希)：
• Set(集合)：用戶的關注者
• Zset(有序集合)：實時信息排行榜

• 與 Memcached 區(qū)別

• Memcached只能存儲字符串鍵
• Memcached用戶只能通過APPEND的方式將數(shù)據(jù)添加到已有的字符串的末尾，并將這個字符串當做列表來使用。但是在刪除這些元素的時候，Memcached采用的是通過黑名單的方式來隱藏列表里的元素，從而避免了對元素的讀取、更新、刪除等操作
• Redis和Memcached都是將數(shù)據(jù)存放在內存中，都是內存數(shù)據(jù)庫。不過Memcached還可用于緩存其他東西，例如圖片、視頻等等
• 虛擬內存–Redis當物理內存用完時，可以將一些很久沒用到的Value 交換到磁盤
• 存儲數(shù)據(jù)安全–Memcached掛掉后，數(shù)據(jù)沒了；Redis可以定期保存到磁盤（持久化）
• 應用場景不一樣：Redis出來作為NoSQL數(shù)據(jù)庫使用外，還能用做消息隊列、數(shù)據(jù)堆棧和數(shù)據(jù)緩存等；Memcached適合于緩存SQL語句、數(shù)據(jù)集、用戶臨時性數(shù)據(jù)、延遲查詢數(shù)據(jù)和Session等

• Redis實現(xiàn)分布式鎖

• 使用setnx實現(xiàn)加鎖，可以同時通過expire添加超時時間
• 鎖的value值可以是一個隨機的uuid或者特定的命名
• 釋放鎖的時候，通過uuid判斷是否是該鎖，是則執(zhí)行delete釋放鎖

• 常見問題

• 當訪問量劇增、服務出現(xiàn)問題（如響應時間慢或不響應）或非核心服務影響到核心流程的性能時，仍然需要保證服務還是可用的，即使是有損服務。系統(tǒng)可以根據(jù)一些關鍵數(shù)據(jù)進行自動降級，也可以配置開關實現(xiàn)人工降級
• 數(shù)據(jù)過期，進行更新緩存數(shù)據(jù)
• 初始化項目，將部分常用數(shù)據(jù)加入緩存
• 請求訪問數(shù)據(jù)時，查詢緩存中不存在，數(shù)據(jù)庫中也不存在
• 短時間內緩存數(shù)據(jù)過期，大量請求訪問數(shù)據(jù)庫
• 緩存雪崩
• 緩存穿透
• 緩存預熱
• 緩存更新
• 緩存降級

• 一致性Hash算法

• 使用集群的時候保證數(shù)據(jù)的一致性

• 基于redis實現(xiàn)一個分布式鎖，要求一個超時的參數(shù)

• setnx

• 虛擬內存

• 內存抖動

Linux

• Unix五種i/o模型

• select
• poll
• epoll
• 并發(fā)不高，連接數(shù)很活躍的情況下
• 比select提高的并不多
• 適用于連接數(shù)量較多，但活動鏈接數(shù)少的情況
• 阻塞io
• 非阻塞io
• 多路復用io(Python下使用selectot實現(xiàn)io多路復用)
• 信號驅動io
• 異步io(Gevent/Asyncio實現(xiàn)異步)

• 比 man 更好使用的命令手冊

• tldr:一個有命令示例的手冊

• kill -9和-15的區(qū)別

• -15：程序立刻停止/當程序釋放相應資源后再停止/程序可能仍然繼續(xù)運行
• -9：由于-15的不確定性，所以直接使用-9立即殺死進程

• 分頁機制（邏輯地址和物理地址分離的內存分配管理方案）：

• 操作系統(tǒng)為了高效管理內存，減少碎片
• 程序的邏輯地址劃分為固定大小的頁
• 物理地址劃分為同樣大小的幀
• 通過頁表對應邏輯地址和物理地址

• 分段機制

• 為了滿足代碼的一些邏輯需求
• 數(shù)據(jù)共享/數(shù)據(jù)保護/動態(tài)鏈接
• 每個段內部連續(xù)內存分配，段和段之間是離散分配的

• 查看 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("單例模式實現(xiàn)方式二。。。")

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

數(shù)據(jù)結構和算法

python實現(xiàn)各種數(shù)據(jù)結構

快速排序

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?????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]?????????????????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?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?????????BinarySearch(_list[:mid],num)
????else:
????????return?_list.index(num)

面試加強題

• 關于數(shù)據(jù)庫優(yōu)化及設計
• 使用hash一致算法
• setnx
• setnx + expire
• 使用redis
• 如果InnoDB表的數(shù)據(jù)寫入順序能和B+樹索引的葉子節(jié)點順序一致的話，這時候存取效率是最高的。為了存儲和查詢性能應該使用自增長id做主鍵。
• 對于InnoDB的主索引，數(shù)據(jù)會按照主鍵進行排序，由于UUID的無序性，InnoDB會產(chǎn)生巨大的IO壓力，此時不適合使用UUID做物理主鍵，可以把它作為邏輯主鍵，物理主鍵依然使用自增ID。為了全局的唯一性，應該用uuid做索引關聯(lián)其他表或做外鍵
• https://segmentfault.com/a/1190000018426586
• 如何使用兩個棧實現(xiàn)一個隊列
• 反轉鏈表
• 合并兩個有序鏈表
• 刪除鏈表節(jié)點
• 反轉二叉樹
• 設計短網(wǎng)址服務？62進制實現(xiàn)
• 設計一個秒殺系統(tǒng)(feed流)？
• https://www.jianshu.com/p/ea0259d109f9
• 為什么mysql數(shù)據(jù)庫的主鍵使用自增的整數(shù)比較好？使用uuid可以嗎？為什么？
• 如果是分布式系統(tǒng)下我們怎么生成數(shù)據(jù)庫的自增id呢？
• 基于redis實現(xiàn)一個分布式鎖，要求一個超時的參數(shù)
• 如果redis單個節(jié)點宕機了，如何處理？還有其他業(yè)界的方案實現(xiàn)分布式鎖碼?
  
  

緩存算法

• LRU(least-recently-used):替換最近最少使用的對象

• LFU(Least frequently used):最不經(jīng)常使用，如果一個數(shù)據(jù)在最近一段時間內使用次數(shù)很少，那么在將來一段時間內被使用的可能性也很小

服務端性能優(yōu)化方向

• 使用數(shù)據(jù)結構和算法

• 數(shù)據(jù)庫

• slow_query_log_file開啟并且查詢慢查詢日志
• 通過explain排查索引問題
• 調整數(shù)據(jù)修改索引
• 索引優(yōu)化
• 慢查詢消除
• 批量操作，從而減少io操作
• 使用NoSQL:比如Redis

• 網(wǎng)絡io

• 批量操作
• pipeline

• 緩存

• Redis

• 異步

• Asyncio實現(xiàn)異步操作
• 使用Celery減少io阻塞

• 并發(fā)

• 多線程

• Gevent

來自：SegmentFault ，作者：二十一

鏈接：https://segmentfault.com/a/1190000018737045

好了，今天的分享就到這里，喜歡就點個贊吧！

這是我開發(fā)的機器人公眾號小號，目前增加了天氣查詢，955公司名單，關注時間查詢；后面還會增加圖片功能和每日送書抽獎送書活動，以及調戲功能，歡迎來體驗，捧場。