最全面的Python重點(diǎn)知識(shí)匯總，建議收藏！
↑ 關(guān)注 + 星標(biāo) ，每天學(xué)Python新技能
后臺(tái)回復(fù)【大禮包】送你Python自學(xué)大禮包
來(lái)源丨網(wǎng)絡(luò)
Py2 VS Py3
print成為了函數(shù)，python2是關(guān)鍵字
不再有unicode對(duì)象，默認(rèn)str就是unicode
python3除號(hào)返回浮點(diǎn)數(shù)
沒(méi)有了long類型
xrange不存在，range替代了xrange
可以使用中文定義函數(shù)名變量名
高級(jí)解包 和*解包
限定關(guān)鍵字參數(shù) *后的變量必須加入名字=值
raise from
iteritems移除變成items()
yield from 鏈接子生成器
asyncio,async/await原生協(xié)程支持異步編程
新增 enum, mock, ipaddress, concurrent.futures, asyncio urllib, selector
不同枚舉類間不能進(jìn)行比較
同一枚舉類間只能進(jìn)行相等的比較
枚舉類的使用(編號(hào)默認(rèn)從1開(kāi)始)
為了避免枚舉類中相同枚舉值的出現(xiàn)，可以使用@unique裝飾枚舉類
#枚舉的注意事項(xiàng)
from enum import Enum
class COLOR(Enum):
YELLOW=1
#YELLOW=2#會(huì)報(bào)錯(cuò)
GREEN=1#不會(huì)報(bào)錯(cuò),GREEN可以看作是YELLOW的別名
BLACK=3
RED=4
print(COLOR.GREEN)#COLOR.YELLOW,還是會(huì)打印出YELLOW
for i in COLOR:#遍歷一下COLOR并不會(huì)有GREEN
print(i)
#COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎么把別名遍歷出來(lái)
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
#枚舉轉(zhuǎn)換
#最好在數(shù)據(jù)庫(kù)存取使用枚舉的數(shù)值而不是使用標(biāo)簽名字字符串
#在代碼里面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW
py2/3 轉(zhuǎn)換工具
six模塊：兼容pyton2和pyton3的模塊
2to3工具：改變代碼語(yǔ)法版本
__future__：使用下一版本的功能
常用的庫(kù)
必須知道的collections
https://segmentfault.com/a/1190000017385799
python排序操作及heapq模塊
https://segmentfault.com/a/1190000017383322
itertools模塊超實(shí)用方法
https://segmentfault.com/a/1190000017416590
不常用但很重要的庫(kù)
dis(代碼字節(jié)碼分析)
inspect(生成器狀態(tài))
cProfile(性能分析)
bisect(維護(hù)有序列表)
fnmatch
fnmatch(string,"*.txt") #win下不區(qū)分大小寫(xiě)
fnmatch根據(jù)系統(tǒng)決定
fnmatchcase完全區(qū)分大小寫(xiě)
timeit(代碼執(zhí)行時(shí)間)
def isLen(strString):
#還是應(yīng)該使用三元表達(dá)式，更快
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ù)變成一個(gè)上下文管理器
types(包含了標(biāo)準(zhǔn)解釋器定義的所有類型的類型對(duì)象,可以將生成器函數(shù)修飾為異步模式)
import types
types.coroutine #相當(dāng)于實(shí)現(xiàn)了__await__
html(實(shí)現(xiàn)對(duì)html的轉(zhuǎn)義)
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(解決測(cè)試依賴)
concurrent(創(chuàng)建進(jìn)程池和線程池)
from concurrent.futures import ThreadPoolExecutor
pool = ThreadPoolExecutor()
task = pool.submit(函數(shù)名，（參數(shù)）) #此方法不會(huì)阻塞，會(huì)立即返回
task.done()#查看任務(wù)執(zhí)行是否完成
task.result()#阻塞的方法，查看任務(wù)返回值
task.cancel()#取消未執(zhí)行的任務(wù)，返回True或False,取消成功返回True
task.add_done_callback()#回調(diào)函數(shù)
task.running()#是否正在執(zhí)行 task就是一個(gè)Future對(duì)象
for data in pool.map(函數(shù)，參數(shù)列表):#返回已經(jīng)完成的任務(wù)結(jié)果列表，根據(jù)參數(shù)順序執(zhí)行
print(返回任務(wù)完成得執(zhí)行結(jié)果data)
from concurrent.futures import as_completed
as_completed(任務(wù)列表)#返回已經(jīng)完成的任務(wù)列表，完成一個(gè)執(zhí)行一個(gè)
wait(任務(wù)列表,return_when=條件)#根據(jù)條件進(jìn)行阻塞主線程，有四個(gè)條件
selector(封裝select,用戶多路復(fù)用io編程)
asyncio
future=asyncio.ensure_future(協(xié)程) 等于后面的方式 future=loop.create_task(協(xié)程)
future.add_done_callback()添加一個(gè)完成后的回調(diào)函數(shù)
loop.run_until_complete(future)
future.result()查看寫(xiě)成返回結(jié)果
asyncio.wait()接受一個(gè)可迭代的協(xié)程對(duì)象
asynicio.gather(*可迭代對(duì)象,*可迭代對(duì)象） 兩者結(jié)果相同，但gather可以批量取消，gather對(duì)象.cancel()
一個(gè)線程中只有一個(gè)loop
在loop.stop時(shí)一定要loop.run_forever()否則會(huì)報(bào)錯(cuò)
loop.run_forever()可以執(zhí)行非協(xié)程
最后執(zhí)行finally模塊中 loop.close()
asyncio.Task.all_tasks()拿到所有任務(wù) 然后依次迭代并使用任務(wù).cancel()取消
偏函數(shù)partial(函數(shù)，參數(shù))把函數(shù)包裝成另一個(gè)函數(shù)名 其參數(shù)必須放在定義函數(shù)的前面
loop.call_soon(函數(shù),參數(shù))
call_soon_threadsafe()線程安全
loop.call_later(時(shí)間,函數(shù),參數(shù))
在同一代碼塊中call_soon優(yōu)先執(zhí)行，然后多個(gè)later根據(jù)時(shí)間的升序進(jìn)行執(zhí)行
如果非要運(yùn)行有阻塞的代碼
使用loop.run_in_executor(executor,函數(shù)，參數(shù))包裝成一個(gè)多線程，然后放入到一個(gè)task列表中，通過(guò)wait(task列表)來(lái)運(yùn)行
通過(guò)asyncio實(shí)現(xiàn)http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()發(fā)送請(qǐng)求
async for data in reader:
data=data.decode("utf-8")
list.append(data)
然后list中存儲(chǔ)的就是html
as_completed(tasks)完成一個(gè)返回一個(gè),返回的是一個(gè)可迭代對(duì)象
協(xié)程鎖
async with Lock():
Python進(jìn)階
進(jìn)程間通信：
Manager(內(nèi)置了好多數(shù)據(jù)結(jié)構(gòu)，可以實(shí)現(xiàn)多進(jìn)程間內(nèi)存共享)
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(適用于兩個(gè)進(jìn)程)
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只能適用于兩個(gè)進(jìn)程
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(不能用于進(jìn)程池,進(jìn)程池間通信需要使用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()
進(jìn)程池
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模塊幾個(gè)常用方法
argv 命令行參數(shù)list,第一個(gè)是程序本身的路徑
path 返回模塊的搜索路徑
modules.keys() 返回已經(jīng)導(dǎo)入的所有模塊的列表
exit(0) 退出程序
a in s or b in s or c in s簡(jiǎn)寫(xiě)
采用any方式：all() 對(duì)于任何可迭代對(duì)象為空都會(huì)返回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集合運(yùn)用
{1,2}.issubset({1,2,3})#判斷是否是其子集
{1,2,3}.issuperset({1,2})
{}.isdisjoint({})#判斷兩個(gè)set交集是否為空,是空集則為True
代碼中中文匹配
[u4E00-u9FA5]匹配中文文字區(qū)間[一到龥](méi)
查看系統(tǒng)默認(rèn)編碼格式
import sys
sys.getdefaultencoding() # setdefaultencodeing()設(shè)置系統(tǒng)編碼方式
getattr VS getattribute
class A(dict):
def __getattr__(self,value):#當(dāng)訪問(wèn)屬性不存在的時(shí)候返回
return 2
def __getattribute__(self,item):#屏蔽所有的元素訪問(wèn)
return item
類變量是不會(huì)存入實(shí)例__dict__中的，只會(huì)存在于類的__dict__中
globals/locals(可以變相操作代碼)
globals中保存了當(dāng)前模塊中所有的變量屬性與值
locals中保存了當(dāng)前環(huán)境中的所有變量屬性與值
python變量名的解析機(jī)制(LEGB)
本地作用域(Local)
當(dāng)前作用域被嵌入的本地作用域(Enclosing locals)
全局/模塊作用域(Global)
內(nèi)置作用域(Built-in)
實(shí)現(xiàn)從1-100每三個(gè)為一組分組
print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])
什么是元類？
即創(chuàng)建類的類，創(chuàng)建類的時(shí)候只需要將metaclass=元類，元類需要繼承type而不是object,因?yàn)閠ype就是元類
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
什么是鴨子類型(即:多態(tài))？
Python在使用傳入?yún)?shù)的過(guò)程中不會(huì)默認(rèn)判斷參數(shù)類型，只要參數(shù)具備執(zhí)行條件就可以執(zhí)行
深拷貝和淺拷貝
深拷貝拷貝內(nèi)容，淺拷貝拷貝地址(增加引用計(jì)數(shù))
copy模塊實(shí)現(xiàn)神拷貝
單元測(cè)試
一般測(cè)試類繼承模塊unittest下的TestCase
pytest模塊快捷測(cè)試(方法以test_開(kāi)頭/測(cè)試文件以test_開(kāi)頭/測(cè)試類以Test開(kāi)頭，并且不能帶有 init 方法)
coverage統(tǒng)計(jì)測(cè)試覆蓋率
class MyTest(unittest.TestCase):
def tearDown(self):# 每個(gè)測(cè)試用例執(zhí)行前執(zhí)行
print('本方法開(kāi)始測(cè)試了')
def setUp(self):# 每個(gè)測(cè)試用例執(zhí)行之前做操作
print('本方法測(cè)試結(jié)束')
@classmethod
def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運(yùn)行完后運(yùn)行一次
print('開(kāi)始測(cè)試')
@classmethod
def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運(yùn)行前運(yùn)行一次
print('結(jié)束測(cè)試')
def test_a_run(self):
self.assertEqual(1, 1) # 測(cè)試用例
gil會(huì)根據(jù)執(zhí)行的字節(jié)碼行數(shù)以及時(shí)間片釋放gil，gil在遇到io的操作時(shí)候主動(dòng)釋放
什么是monkey patch?
猴子補(bǔ)丁，在運(yùn)行的時(shí)候替換掉會(huì)阻塞的語(yǔ)法修改為非阻塞的方法
什么是自省(Introspection)？
運(yùn)行時(shí)判斷一個(gè)對(duì)象的類型的能力，id,type,isinstance
python是值傳遞還是引用傳遞？
都不是，python是共享傳參，默認(rèn)參數(shù)在執(zhí)行時(shí)只會(huì)執(zhí)行一次
try-except-else-finally中else和finally的區(qū)別
else在不發(fā)生異常的時(shí)候執(zhí)行，finally無(wú)論是否發(fā)生異常都會(huì)執(zhí)行
except一次可以捕獲多個(gè)異常，但一般為了對(duì)不同異常進(jìn)行不同處理，我們分次捕獲處理
GIL全局解釋器鎖
同一時(shí)間只能有一個(gè)線程執(zhí)行，CPython(IPython)的特點(diǎn)，其他解釋器不存在
cpu密集型：多進(jìn)程+進(jìn)程池
io密集型：多線程/協(xié)程
什么是Cython
將python解釋成C代碼工具
生成器和迭代器
可迭代對(duì)象只需要實(shí)現(xiàn)__iter__方法
實(shí)現(xiàn)__next__和__iter__方法的對(duì)象就是迭代器
使用生成器表達(dá)式或者yield的生成器函數(shù)(生成器是一種特殊的迭代器)
什么是協(xié)程
yield
async-awiat
比線程更輕量的多任務(wù)方式
實(shí)現(xiàn)方式
dict底層結(jié)構(gòu)
為了支持快速查找使用了哈希表作為底層結(jié)構(gòu)
哈希表平均查找時(shí)間復(fù)雜度為o(1)
CPython解釋器使用二次探查解決哈希沖突問(wèn)題
Hash擴(kuò)容和Hash沖突解決方案
鏈接法
二次探查(開(kāi)放尋址法)：python使用
循環(huán)復(fù)制到新空間實(shí)現(xiàn)擴(kuò)容
沖突解決：
for gevent import monkey
monkey.patch_all() #將代碼中所有的阻塞方法都進(jìn)行修改，可以指定具體要修改的方法
判斷是否為生成器或者協(xié)程
co_flags = func.__code__.co_flags
# 檢查是否是協(xié)程
if co_flags & 0x180:
return func
# 檢查是否是生成器
if co_flags & 0x20:
return func
斐波那契解決的問(wèn)題及變形
#一只青蛙一次可以跳上1級(jí)臺(tái)階，也可以跳上2級(jí)。求該青蛙跳上一個(gè)n級(jí)的臺(tái)階總共有多少種跳法。
#請(qǐng)問(wèn)用n個(gè)2*1的小矩形無(wú)重疊地覆蓋一個(gè)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級(jí)臺(tái)階，也可以跳上2級(jí)……它也可以跳上n級(jí)。求該青蛙跳上一個(gè)n級(jí)的臺(tái)階總共有多少種跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)
獲取電腦設(shè)置的環(huán)境變量
import os
os.getenv(env_name,None)#獲取環(huán)境變量如果不存在為None
垃圾回收機(jī)制
引用計(jì)數(shù)
標(biāo)記清除
分代回收
#查看分代回收觸發(fā)
import gc
gc.get_threshold() #output:(700, 10, 10)
True和False在代碼中完全等價(jià)于1和0,可以直接和數(shù)字進(jìn)行計(jì)算，inf表示無(wú)窮大
C10M/C10K
C10M:8核心cpu，64G內(nèi)存，在10gbps的網(wǎng)絡(luò)上保持1000萬(wàn)并發(fā)連接
C10K：1GHz CPU,2G內(nèi)存，1gbps網(wǎng)絡(luò)環(huán)境下保持1萬(wàn)個(gè)客戶端提供FTP服務(wù)
yield from與yield的區(qū)別：
yield from跟的是一個(gè)可迭代對(duì)象，而yield后面沒(méi)有限制
GeneratorExit生成器停止時(shí)觸發(fā)
單下劃線的幾種使用
在定義變量時(shí)，表示為私有變量
在解包時(shí)，表示舍棄無(wú)用的數(shù)據(jù)
在交互模式中表示上一次代碼執(zhí)行結(jié)果
可以做數(shù)字的拼接(111_222_333)
使用break就不會(huì)執(zhí)行else
10進(jìn)制轉(zhuǎn)2進(jìn)制
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] = [] # 可以用于實(shí)現(xiàn)python版反射
# 方法二
for i in list1:
exec(f'{i} = []') # exec執(zhí)行字符串語(yǔ)句
memoryview與bytearray$\color{#000}(不常用，只是看到了記載一下)$
# bytearray是可變的，bytes是不可變的,memoryview不會(huì)產(chǎn)生新切片和對(duì)象
a = 'aaaaaa'
ma = memoryview(a)
ma.readonly # 只讀的memoryview
mb = ma[:2] # 不會(huì)產(chǎn)生新的字符串
a = bytearray('aaaaaa')
ma = memoryview(a)
ma.readonly # 可寫(xiě)的memoryview
mb = ma[:2] # 不會(huì)會(huì)產(chǎn)生新的bytearray
mb[:2] = 'bb' # 對(duì)mb的改動(dòng)就是對(duì)ma的改動(dòng)
Ellipsis類型
# 代碼中出現(xiàn)...省略號(hào)的現(xiàn)象就是一個(gè)Ellipsis對(duì)象
L = [1,2,3]
L.append(L)
print(L) # output:[1,2,3,[…]]
lazy惰性計(jì)算
class lazy(object):
def __init__(self, func):
self.func = func
def __get__(self, instance, cls):
val = self.func(instance) #其相當(dāng)于執(zhí)行的area(c),c為下面的Circle對(duì)象
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
遍歷文件，傳入一個(gè)文件夾，將里面所有文件的路徑打印出來(lái)(遞歸)
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
文件存儲(chǔ)時(shí)，文件名的處理
#secure_filename將字符串轉(zhuǎn)化為安全的文件名
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使用+=奇怪的問(wèn)題
# 會(huì)報(bào)錯(cuò)，但是tuple的值會(huì)改變，因?yàn)閠[1]id沒(méi)有發(fā)生變化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用append\extend方法并不會(huì)報(bào)錯(cuò)，并可以成功執(zhí)行
__missing__你應(yīng)該知道
class Mydict(dict):
def __missing__(self,key): # 當(dāng)Mydict使用切片訪問(wèn)屬性不存在的時(shí)候返回的值
return key
+與+=
# +不能用來(lái)連接列表和元祖，而+=可以（通過(guò)iadd實(shí)現(xiàn)，內(nèi)部實(shí)現(xiàn)方式為extends(),所以可以增加元組），+會(huì)創(chuàng)建新對(duì)象
#不可變對(duì)象沒(méi)有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進(jìn)行元祖之間的相加
如何將一個(gè)可迭代對(duì)象的每個(gè)元素變成一個(gè)字典的所有鍵？
dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}
wireshark抓包軟件
網(wǎng)絡(luò)知識(shí)
什么是HTTPS?
安全的HTTP協(xié)議，https需要cs證書(shū)，數(shù)據(jù)加密，端口為443，安全，同一網(wǎng)站https seo排名會(huì)更高
常見(jiàn)響應(yīng)狀態(tài)碼
204 No Content //請(qǐng)求成功處理，沒(méi)有實(shí)體的主體返回，一般用來(lái)表示刪除成功
206 Partial Content //Get范圍請(qǐng)求已成功處理
303 See Other //臨時(shí)重定向，期望使用get定向獲取
304 Not Modified //請(qǐng)求緩存資源
307 Temporary Redirect //臨時(shí)重定向，Post不會(huì)變成Get
401 Unauthorized //認(rèn)證失敗
403 Forbidden //資源請(qǐng)求被拒絕
400 //請(qǐng)求參數(shù)錯(cuò)誤
201 //添加或更改成功
503 //服務(wù)器維護(hù)或者超負(fù)載
http請(qǐng)求方法的冪等性及安全性
WSGI
# environ：一個(gè)包含所有HTTP請(qǐng)求信息的dict對(duì)象
# start_response：一個(gè)發(fā)送HTTP響應(yīng)的函數(shù)
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）是為網(wǎng)絡(luò)通信提供安全及數(shù)據(jù)完整性的一種安全協(xié)議。
SSH（安全外殼協(xié)議） 為 Secure Shell 的縮寫(xiě)，由 IETF 的網(wǎng)絡(luò)小組（Network Working Group）所制定；SSH 為建立在應(yīng)用層基礎(chǔ)上的安全協(xié)議。SSH 是目前較可靠，專為遠(yuǎn)程登錄會(huì)話和其他網(wǎng)絡(luò)服務(wù)提供安全性的協(xié)議。利用 SSH 協(xié)議可以有效防止遠(yuǎn)程管理過(guò)程中的信息泄露問(wèn)題。SSH最初是UNIX系統(tǒng)上的一個(gè)程序，后來(lái)又迅速擴(kuò)展到其他操作平臺(tái)。SSH在正確使用時(shí)可彌補(bǔ)網(wǎng)絡(luò)中的漏洞。SSH客戶端適用于多種平臺(tái)。幾乎所有UNIX平臺(tái)—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其他平臺(tái)，都可運(yùn)行SSH。
TCP/IP
TCP:面向連接/可靠/基于字節(jié)流
UDP:無(wú)連接/不可靠/面向報(bào)文
三次握手四次揮手
三次握手(SYN/SYN+ACK/ACK)
四次揮手(FIN/ACK/FIN/ACK)
為什么連接的時(shí)候是三次握手，關(guān)閉的時(shí)候卻是四次握手？
因?yàn)楫?dāng)Server端收到Client端的SYN連接請(qǐng)求報(bào)文后，可以直接發(fā)送SYN+ACK報(bào)文。其中ACK報(bào)文是用來(lái)應(yīng)答的，SYN報(bào)文是用來(lái)同步的。但是關(guān)閉連接時(shí)，當(dāng)Server端收到FIN報(bào)文時(shí)，很可能并不會(huì)立即關(guān)閉SOCKET，所以只能先回復(fù)一個(gè)ACK報(bào)文，告訴Client端，"你發(fā)的FIN報(bào)文我收到了"。只有等到我Server端所有的報(bào)文都發(fā)送完了，我才能發(fā)送FIN報(bào)文，因此不能一起發(fā)送。故需要四步握手。
為什么TIME_WAIT狀態(tài)需要經(jīng)過(guò)2MSL(最大報(bào)文段生存時(shí)間)才能返回到CLOSE狀態(tài)？
雖然按道理，四個(gè)報(bào)文都發(fā)送完畢，我們可以直接進(jìn)入CLOSE狀態(tài)了，但是我們必須假象網(wǎng)絡(luò)是不可靠的，有可以最后一個(gè)ACK丟失。所以TIME_WAIT狀態(tài)就是用來(lái)重發(fā)可能丟失的ACK報(bào)文。
XSS/CSRF
HttpOnly禁止js腳本訪問(wèn)和操作Cookie,可以有效防止XSS
Mysql
索引改進(jìn)過(guò)程
線性結(jié)構(gòu)->二分查找->hash->二叉查找樹(shù)->平衡二叉樹(shù)->多路查找樹(shù)->多路平衡查找樹(shù)(B-Tree)
Mysql面試總結(jié)基礎(chǔ)篇
https://segmentfault.com/a/1190000018371218
Mysql面試總結(jié)進(jìn)階篇
https://segmentfault.com/a/1190000018380324
深入淺出Mysql
http://ningning.today/2017/02/13/database/深入淺出mysql/
清空整個(gè)表時(shí)，InnoDB是一行一行的刪除，而MyISAM則會(huì)從新刪除建表
text/blob數(shù)據(jù)類型不能有默認(rèn)值，查詢時(shí)不存在大小寫(xiě)轉(zhuǎn)換
什么時(shí)候索引失效
以%開(kāi)頭的like模糊查詢
出現(xiàn)隱式類型轉(zhuǎn)換
沒(méi)有滿足最左前綴原則
對(duì)于多列索引，不是使用的第一部分，則不會(huì)使用索引
失效場(chǎng)景：
應(yīng)盡量避免在 where 子句中使用 != 或 <> 操作符，否則引擎將放棄使用索引而進(jìn)行全表掃描
盡量避免在 where 子句中使用 or 來(lái)連接條件，否則將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描，即使其中有條件帶索引也不會(huì)使用，這也是為什么盡量少用 or 的原因
如果列類型是字符串，那一定要在條件中將數(shù)據(jù)使用引號(hào)引用起來(lái)，否則不會(huì)使用索引
應(yīng)盡量避免在 where 子句中對(duì)字段進(jìn)行函數(shù)操作，這將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描
例如：
select id from t where substring(name,1,3) = 'abc' – name;
以abc開(kāi)頭的，應(yīng)改成：
select id from t where name like 'abc%'
例如：
select id from t where datediff(day, createdate, '2005-11-30') = 0 – '2005-11-30';
應(yīng)改為:
不要在 where 子句中的 “=” 左邊進(jìn)行函數(shù)、算術(shù)運(yùn)算或其他表達(dá)式運(yùn)算，否則系統(tǒng)將可能無(wú)法正確使用索引
應(yīng)盡量避免在 where 子句中對(duì)字段進(jìn)行表達(dá)式操作，這將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描
如：
select id from t where num/2 = 100
應(yīng)改為:
select id from t where num = 100*2；
不適合鍵值較少的列（重復(fù)數(shù)據(jù)較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認(rèn)的值會(huì)自動(dòng)過(guò)濾空格集合(set)和枚舉類似，但只可以添加64個(gè)值)
如果MySQL估計(jì)使用全表掃描要比使用索引快，則不使用索引
什么是聚集索引
B+Tree葉子節(jié)點(diǎn)保存的是數(shù)據(jù)還是指針
MyISAM索引和數(shù)據(jù)分離，使用非聚集
InnoDB數(shù)據(jù)文件就是索引文件，主鍵索引就是聚集索引
Redis命令總結(jié)
為什么這么快？
基于內(nèi)存，由C語(yǔ)言編寫(xiě)
使用多路I/O復(fù)用模型，非阻塞IO
使用單線程減少線程間切換
因?yàn)镽edis是基于內(nèi)存的操作，CPU不是Redis的瓶頸，Redis的瓶頸最有可能是機(jī)器內(nèi)存的大小或者網(wǎng)絡(luò)帶寬。既然單線程容易實(shí)現(xiàn)，而且CPU不會(huì)成為瓶頸，那就順理成章地采用單線程的方案了（畢竟采用多線程會(huì)有很多麻煩！）。
數(shù)據(jù)結(jié)構(gòu)簡(jiǎn)單
自己構(gòu)建了VM機(jī)制，減少調(diào)用系統(tǒng)函數(shù)的時(shí)間
優(yōu)勢(shì)
性能高 – Redis能讀的速度是110000次/s,寫(xiě)的速度是81000次/s
豐富的數(shù)據(jù)類型
原子 – Redis的所有操作都是原子性的，同時(shí)Redis還支持對(duì)幾個(gè)操作全并后的原子性執(zhí)行
豐富的特性 – Redis還支持 publish/subscribe（發(fā)布/訂閱）, 通知, key 過(guò)期等等特性
什么是redis事務(wù)？
將多個(gè)請(qǐng)求打包，一次性、按序執(zhí)行多個(gè)命令的機(jī)制
通過(guò)multi,exec,watch等命令實(shí)現(xiàn)事務(wù)功能
Python redis-py pipeline=conn.pipeline(transaction=True)
持久化方式
RDB(快照)
save(同步，可以保證數(shù)據(jù)一致性)
bgsave(異步，shutdown時(shí)，無(wú)AOF則默認(rèn)使用)
AOF(追加日志)
怎么實(shí)現(xiàn)隊(duì)列
push
rpop
常用的數(shù)據(jù)類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)
String(字符串):計(jì)數(shù)器
整數(shù)或sds(Simple Dynamic String)
List(列表)：用戶的關(guān)注，粉絲列表
ziplist(連續(xù)內(nèi)存塊，每個(gè)entry節(jié)點(diǎn)頭部保存前后節(jié)點(diǎn)長(zhǎng)度信息實(shí)現(xiàn)雙向鏈表功能)或double linked list
Hash(哈希)：
Set(集合)：用戶的關(guān)注者
intset或hashtable
Zset(有序集合)：實(shí)時(shí)信息排行榜
skiplist(跳躍表)
與Memcached區(qū)別
Memcached只能存儲(chǔ)字符串鍵
Memcached用戶只能通過(guò)APPEND的方式將數(shù)據(jù)添加到已有的字符串的末尾，并將這個(gè)字符串當(dāng)做列表來(lái)使用。但是在刪除這些元素的時(shí)候，Memcached采用的是通過(guò)黑名單的方式來(lái)隱藏列表里的元素，從而避免了對(duì)元素的讀取、更新、刪除等操作
Redis和Memcached都是將數(shù)據(jù)存放在內(nèi)存中，都是內(nèi)存數(shù)據(jù)庫(kù)。不過(guò)Memcached還可用于緩存其他東西，例如圖片、視頻等等
虛擬內(nèi)存–Redis當(dāng)物理內(nèi)存用完時(shí)，可以將一些很久沒(méi)用到的Value 交換到磁盤
存儲(chǔ)數(shù)據(jù)安全–Memcached掛掉后，數(shù)據(jù)沒(méi)了；Redis可以定期保存到磁盤（持久化）
應(yīng)用場(chǎng)景不一樣：Redis出來(lái)作為NoSQL數(shù)據(jù)庫(kù)使用外，還能用做消息隊(duì)列、數(shù)據(jù)堆棧和數(shù)據(jù)緩存等；Memcached適合于緩存SQL語(yǔ)句、數(shù)據(jù)集、用戶臨時(shí)性數(shù)據(jù)、延遲查詢數(shù)據(jù)和Session等
Redis實(shí)現(xiàn)分布式鎖
使用setnx實(shí)現(xiàn)加鎖，可以同時(shí)通過(guò)expire添加超時(shí)時(shí)間
鎖的value值可以是一個(gè)隨機(jī)的uuid或者特定的命名
釋放鎖的時(shí)候，通過(guò)uuid判斷是否是該鎖，是則執(zhí)行delete釋放鎖
常見(jiàn)問(wèn)題
緩存雪崩
短時(shí)間內(nèi)緩存數(shù)據(jù)過(guò)期，大量請(qǐng)求訪問(wèn)數(shù)據(jù)庫(kù)
緩存穿透
請(qǐng)求訪問(wèn)數(shù)據(jù)時(shí)，查詢緩存中不存在，數(shù)據(jù)庫(kù)中也不存在
緩存預(yù)熱
初始化項(xiàng)目，將部分常用數(shù)據(jù)加入緩存
緩存更新
數(shù)據(jù)過(guò)期，進(jìn)行更新緩存數(shù)據(jù)
緩存降級(jí)
當(dāng)訪問(wèn)量劇增、服務(wù)出現(xiàn)問(wèn)題（如響應(yīng)時(shí)間慢或不響應(yīng)）或非核心服務(wù)影響到核心流程的性能時(shí)，仍然需要保證服務(wù)還是可用的，即使是有損服務(wù)。系統(tǒng)可以根據(jù)一些關(guān)鍵數(shù)據(jù)進(jìn)行自動(dòng)降級(jí)，也可以配置開(kāi)關(guān)實(shí)現(xiàn)人工降級(jí)
一致性Hash算法
使用集群的時(shí)候保證數(shù)據(jù)的一致性
基于redis實(shí)現(xiàn)一個(gè)分布式鎖，要求一個(gè)超時(shí)的參數(shù)
setnx
虛擬內(nèi)存
內(nèi)存抖動(dòng)
Linux
Unix五種i/o模型
阻塞io
非阻塞io
多路復(fù)用io(Python下使用selectot實(shí)現(xiàn)io多路復(fù)用)
select
并發(fā)不高，連接數(shù)很活躍的情況下
poll
比select提高的并不多
epoll
適用于連接數(shù)量較多，但活動(dòng)鏈接數(shù)少的情況
信號(hào)驅(qū)動(dòng)io
異步io(Gevent/Asyncio實(shí)現(xiàn)異步)
比man更好使用的命令手冊(cè)
tldr:一個(gè)有命令示例的手冊(cè)
kill -9和-15的區(qū)別
-15：程序立刻停止/當(dāng)程序釋放相應(yīng)資源后再停止/程序可能仍然繼續(xù)運(yùn)行
-9：由于-15的不確定性，所以直接使用-9立即殺死進(jìn)程
分頁(yè)機(jī)制（邏輯地址和物理地址分離的內(nèi)存分配管理方案）：
操作系統(tǒng)為了高效管理內(nèi)存，減少碎片
程序的邏輯地址劃分為固定大小的頁(yè)
物理地址劃分為同樣大小的幀
通過(guò)頁(yè)表對(duì)應(yīng)邏輯地址和物理地址
分段機(jī)制
為了滿足代碼的一些邏輯需求
數(shù)據(jù)共享/數(shù)據(jù)保護(hù)/動(dòng)態(tài)鏈接
每個(gè)段內(nèi)部連續(xù)內(nèi)存分配，段和段之間是離散分配的
查看cpu內(nèi)存使用情況？
top
free 查看可用內(nèi)存，排查內(nèi)存泄漏問(wèn)題
設(shè)計(jì)模式
單例模式
# 方式一
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("單例模式實(shí)現(xiàn)方式二。。。")
single = Single()
del Single # 每次調(diào)用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("對(duì)不起，必須是：dog,cat")
構(gòu)造模式
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 #為了方便鏈?zhǔn)秸{(diào)用
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ù)結(jié)構(gòu)和算法內(nèi)置數(shù)據(jù)結(jié)構(gòu)和算法
python實(shí)現(xiàn)各種數(shù)據(jù)結(jié)構(gòu)
快速排序
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()
隊(duì)列
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)
面試加強(qiáng)題：
關(guān)于數(shù)據(jù)庫(kù)優(yōu)化及設(shè)計(jì)
https://segmentfault.com/a/1190000018426586
如何使用兩個(gè)棧實(shí)現(xiàn)一個(gè)隊(duì)列
反轉(zhuǎn)鏈表
合并兩個(gè)有序鏈表
刪除鏈表節(jié)點(diǎn)
反轉(zhuǎn)二叉樹(shù)
設(shè)計(jì)短網(wǎng)址服務(wù)？62進(jìn)制實(shí)現(xiàn)
設(shè)計(jì)一個(gè)秒殺系統(tǒng)(feed流)？
https://www.jianshu.com/p/ea0259d109f9
為什么mysql數(shù)據(jù)庫(kù)的主鍵使用自增的整數(shù)比較好？使用uuid可以嗎？為什么？
如果InnoDB表的數(shù)據(jù)寫(xiě)入順序能和B+樹(shù)索引的葉子節(jié)點(diǎn)順序一致的話，這時(shí)候存取效率是最高的。為了存儲(chǔ)和查詢性能應(yīng)該使用自增長(zhǎng)id做主鍵。
對(duì)于InnoDB的主索引，數(shù)據(jù)會(huì)按照主鍵進(jìn)行排序，由于UUID的無(wú)序性，InnoDB會(huì)產(chǎn)生巨大的IO壓力，此時(shí)不適合使用UUID做物理主鍵，可以把它作為邏輯主鍵，物理主鍵依然使用自增ID。為了全局的唯一性，應(yīng)該用uuid做索引關(guān)聯(lián)其他表或做外鍵
如果是分布式系統(tǒng)下我們?cè)趺瓷蓴?shù)據(jù)庫(kù)的自增id呢？
使用redis
基于redis實(shí)現(xiàn)一個(gè)分布式鎖，要求一個(gè)超時(shí)的參數(shù)
setnx
setnx + expire
如果redis單個(gè)節(jié)點(diǎn)宕機(jī)了，如何處理？還有其他業(yè)界的方案實(shí)現(xiàn)分布式鎖碼?
使用hash一致算法
緩存算法
LRU(least-recently-used):替換最近最少使用的對(duì)象
LFU(Least frequently used):最不經(jīng)常使用，如果一個(gè)數(shù)據(jù)在最近一段時(shí)間內(nèi)使用次數(shù)很少，那么在將來(lái)一段時(shí)間內(nèi)被使用的可能性也很小
服務(wù)端性能優(yōu)化方向
使用數(shù)據(jù)結(jié)構(gòu)和算法
數(shù)據(jù)庫(kù)
索引優(yōu)化
慢查詢消除
slow_query_log_file開(kāi)啟并且查詢慢查詢?nèi)罩?/p>
通過(guò)explain排查索引問(wèn)題
調(diào)整數(shù)據(jù)修改索引
批量操作，從而減少io操作
使用NoSQL:比如Redis
網(wǎng)絡(luò)io
批量操作
pipeline
緩存
Redis
異步
Asyncio實(shí)現(xiàn)異步操作
使用Celery減少io阻塞
并發(fā)
多線程
Gevent
萬(wàn)水千山總是情，點(diǎn)個(gè) ?? 行不行。
推薦閱讀