你見過的最全面的Python重點知識彙總

↑↑↑點擊上方藍字,回覆資料,10個G的驚喜

原文鏈接:

https://segmentfault.com/a/1190000018737045


這是一份來自於 SegmentFault 上的開發者 @二十一 總結的 Python 重點。由於總結了太多的東西,所以篇幅有點長,這也是作者"縫縫補補"總結了好久的東西。

Py2 VS Py3

  • print成爲了函數,python2是關鍵字

  • 不再有unicode對象,默認str就是unicode

  • python3除號返回浮點數

  • 沒有了long類型

  • xrange不存在,range替代了xrange

  • 可以使用中文定義函數名變量名

  • 高級解包 和*解包

  • 限定關鍵字參數 *後的變量必須加入名字=值

  • raise from

  • iteritems移除變成items()

  • yield from 鏈接子生成器

  • asyncio,async/await原生協程支持異步編程

  • 新增 enum, mock, ipaddress, concurrent.futures, asyncio urllib, selector

    • 不同枚舉類間不能進行比較

    • 同一枚舉類間只能進行相等的比較

    • 枚舉類的使用(編號默認從1開始)

    • 爲了避免枚舉類中相同枚舉值的出現,可以使用@unique裝飾枚舉類

#枚舉的注意事項
from enum import Enum

class COLOR(Enum):
YELLOW=1
#YELLOW=2#會報錯
GREEN=1#不會報錯,GREEN可以看作是YELLOW的別名
BLACK=3
RED=4
print(COLOR.GREEN)#COLOR.YELLOW,還是會打印出YELLOW
for i in COLOR:#遍歷一下COLOR並不會有GREEN
print(i)
#COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎麼把別名遍歷出來
for i in COLOR.__members__.items():
print(i)
# output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>)
for i in COLOR.__members__:
print(i)
# output:YELLOW\nGREEN\nBLACK\nRED

#枚舉轉換
#最好在數據庫存取使用枚舉的數值而不是使用標籤名字字符串
#在代碼裏面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW

py2/3 轉換工具

  • six模塊:兼容pyton2和pyton3的模塊

  • 2to3工具:改變代碼語法版本

  • __future__:使用下一版本的功能


常用的庫

  • 必須知道的collections

    https://segmentfault.com/a/1190000017385799

  • python排序操作及heapq模塊

    https://segmentfault.com/a/1190000017383322

  • itertools模塊超實用方法

    https://segmentfault.com/a/1190000017416590

不常用但很重要的庫

  • dis(代碼字節碼分析)

  • inspect(生成器狀態)

  • cProfile(性能分析)

  • bisect(維護有序列表)

  • fnmatch

    • fnmatch(string,"*.txt") #win下不區分大小寫

    • fnmatch根據系統決定

    • fnmatchcase完全區分大小寫

  • timeit(代碼執行時間)

def isLen(strString):
#還是應該使用三元表達式,更快
return True if len(strString)>6 else False

def isLen1(strString):
#這裏注意false和true的位置
return [False,True][len(strString)>6]
import timeit
print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))

print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))

  • contextlib

    • @contextlib.contextmanager使生成器函數變成一個上下文管理器

  • types(包含了標準解釋器定義的所有類型的類型對象,可以將生成器函數修飾爲異步模式)

import types
types.coroutine #相當於實現了__await__

  • html(實現對html的轉義)

import html
html.escape("<h1>I'm Jim</h1>") # output:'&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;'
html.unescape('&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;') # <h1>I'm Jim</h1>

  • mock(解決測試依賴)

  • concurrent(創建進程池和線程池)

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__ #(<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代碼工具

  • 生成器和迭代器

    • 可迭代對象只需要實現__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 '<h1>Hello, web!</h1>'

  • RPC

  • CDN

  • SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全(Transport Layer Security,TLS)是爲網絡通信提供安全及數據完整性的一種安全協議。

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

  • TCP/IP

    • TCP:面向連接/可靠/基於字節流

    • UDP:無連接/不可靠/面向報文

    • 三次握手四次揮手

      • 三次握手(SYN/SYN+ACK/ACK)

      • 四次揮手(FIN/ACK/FIN/ACK)

    • 爲什麼連接的時候是三次握手,關閉的時候卻是四次握手?

      • 因爲當Server端收到Client端的SYN連接請求報文後,可以直接發送SYN+ACK報文。其中ACK報文是用來應答的,SYN報文是用來同步的。但是關閉連接時,當Server端收到FIN報文時,很可能並不會立即關閉SOCKET,所以只能先回復一個ACK報文,告訴Client端,"你發的FIN報文我收到了"。只有等到我Server端所有的報文都發送完了,我才能發送FIN報文,因此不能一起發送。故需要四步握手。

    • 爲什麼TIME_WAIT狀態需要經過2MSL(最大報文段生存時間)才能返回到CLOSE狀態?

      • 雖然按道理,四個報文都發送完畢,我們可以直接進入CLOSE狀態了,但是我們必須假象網絡是不可靠的,有可以最後一個ACK丟失。所以TIME_WAIT狀態就是用來重發可能丟失的ACK報文。

  • XSS/CSRF

    • HttpOnly禁止js腳本訪問和操作Cookie,可以有效防止XSS

Mysql

  • 索引改進過程

    • 線性結構->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)

  • Mysql面試總結基礎篇

    https://segmentfault.com/a/1190000018371218

  • Mysql面試總結進階篇

    https://segmentfault.com/a/1190000018380324

  • 深入淺出Mysql

    http://ningning.today/2017/02/13/database/深入淺出mysql/

  • 清空整個表時,InnoDB是一行一行的刪除,而MyISAM則會從新刪除建表

  • text/blob數據類型不能有默認值,查詢時不存在大小寫轉換

  • 什麼時候索引失效

    • 以%開頭的like模糊查詢

    • 出現隱式類型轉換

    • 沒有滿足最左前綴原則

      • 對於多列索引,不是使用的第一部分,則不會使用索引

    • 失效場景:

      • 應儘量避免在 where 子句中使用 != 或 <> 操作符,否則引擎將放棄使用索引而進行全表掃描

      • 儘量避免在 where 子句中使用 or 來連接條件,否則將導致引擎放棄使用索引而進行全表掃描,即使其中有條件帶索引也不會使用,這也是爲什麼儘量少用 or 的原因

      • 如果列類型是字符串,那一定要在條件中將數據使用引號引用起來,否則不會使用索引

      • 應儘量避免在 where 子句中對字段進行函數操作,這將導致引擎放棄使用索引而進行全表掃描

例如:
select id from t where substring(name,1,3) = 'abc' – name;
以abc開頭的,應改成:
select id from t where name like 'abc%'
例如:
select id from t where datediff(day, createdate, '2005-11-30') = 0'2005-11-30';
應改爲:

      • 不要在 where 子句中的 “=” 左邊進行函數、算術運算或其他表達式運算,否則系統將可能無法正確使用索引

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

如:
select id from t where num/2 = 100
應改爲:
select id from t where num = 100*2

      • 不適合鍵值較少的列(重複數據較多的列)比如:set enum列就不適合(枚舉類型(enum)可以添加null,並且默認的值會自動過濾空格集合(set)和枚舉類似,但只可以添加64個值)

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

  • 什麼是聚集索引

    • B+Tree葉子節點保存的是數據還是指針

    • MyISAM索引和數據分離,使用非聚集

    • InnoDB數據文件就是索引文件,主鍵索引就是聚集索引

Redis命令總結

  • 爲什麼這麼快?

    • 基於內存,由C語言編寫

    • 使用多路I/O複用模型,非阻塞IO

    • 使用單線程減少線程間切換

      • 因爲Redis是基於內存的操作,CPU不是Redis的瓶頸,Redis的瓶頸最有可能是機器內存的大小或者網絡帶寬。既然單線程容易實現,而且CPU不會成爲瓶頸,那就順理成章地採用單線程的方案了(畢竟採用多線程會有很多麻煩!)。

    • 數據結構簡單

    • 自己構建了VM機制,減少調用系統函數的時間

  • 優勢

    • 性能高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s

    • 豐富的數據類型

    • 原子 – Redis的所有操作都是原子性的,同時Redis還支持對幾個操作全並後的原子性執行

    • 豐富的特性 – Redis還支持 publish/subscribe(發佈/訂閱), 通知, key 過期等等特性

  • 什麼是redis事務?

    • 將多個請求打包,一次性、按序執行多個命令的機制

    • 通過multi,exec,watch等命令實現事務功能

    • Python redis-py pipeline=conn.pipeline(transaction=True)

  • 持久化方式

    • RDB(快照)

      • save(同步,可以保證數據一致性)

      • bgsave(異步,shutdown時,無AOF則默認使用)

    • AOF(追加日誌)

  • 怎麼實現隊列

    • push

    • rpop

  • 常用的數據類型(Bitmaps,Hyperloglogs,範圍查詢等不常用)

    • String(字符串):計數器

      • 整數或sds(Simple Dynamic String)

    • List(列表):用戶的關注,粉絲列表

      • ziplist(連續內存塊,每個entry節點頭部保存前後節點長度信息實現雙向鏈表功能)或double linked list

    • Hash(哈希):

    • Set(集合):用戶的關注者

      • intset或hashtable

    • Zset(有序集合):實時信息排行榜

      • skiplist(跳躍表)

  • 與Memcached區別

    • Memcached只能存儲字符串鍵

    • Memcached用戶只能通過APPEND的方式將數據添加到已有的字符串的末尾,並將這個字符串當做列表來使用。但是在刪除這些元素的時候,Memcached採用的是通過黑名單的方式來隱藏列表裏的元素,從而避免了對元素的讀取、更新、刪除等操作

    • Redis和Memcached都是將數據存放在內存中,都是內存數據庫。不過Memcached還可用於緩存其他東西,例如圖片、視頻等等

    • 虛擬內存–Redis當物理內存用完時,可以將一些很久沒用到的Value 交換到磁盤

    • 存儲數據安全–Memcached掛掉後,數據沒了;Redis可以定期保存到磁盤(持久化)

    • 應用場景不一樣:Redis出來作爲NoSQL數據庫使用外,還能用做消息隊列、數據堆棧和數據緩存等;Memcached適合於緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和Session等

  • Redis實現分佈式鎖

    • 使用setnx實現加鎖,可以同時通過expire添加超時時間

    • 鎖的value值可以是一個隨機的uuid或者特定的命名

    • 釋放鎖的時候,通過uuid判斷是否是該鎖,是則執行delete釋放鎖

  • 常見問題

    • 緩存雪崩

      • 短時間內緩存數據過期,大量請求訪問數據庫

    • 緩存穿透

      • 請求訪問數據時,查詢緩存中不存在,數據庫中也不存在

    • 緩存預熱

      • 初始化項目,將部分常用數據加入緩存

    • 緩存更新

      • 數據過期,進行更新緩存數據

    • 緩存降級

      • 當訪問量劇增、服務出現問題(如響應時間慢或不響應)或非核心服務影響到核心流程的性能時,仍然需要保證服務還是可用的,即使是有損服務。系統可以根據一些關鍵數據進行自動降級,也可以配置開關實現人工降級

  • 一致性Hash算法

    • 使用集羣的時候保證數據的一致性

  • 基於redis實現一個分佈式鎖,要求一個超時的參數

    • setnx

  • 虛擬內存

  • 內存抖動

Linux

  • Unix五種i/o模型

    • 阻塞io

    • 非阻塞io

    • 多路複用io(Python下使用selectot實現io多路複用)

      • select

        • 併發不高,連接數很活躍的情況下

      • poll

        • 比select提高的並不多

      • epoll

        • 適用於連接數量較多,但活動鏈接數少的情況

    • 信號驅動io

    • 異步io(Gevent/Asyncio實現異步)

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

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

  • kill -9和-15的區別

    • -15:程序立刻停止/當程序釋放相應資源後再停止/程序可能仍然繼續運行

    • -9:由於-15的不確定性,所以直接使用-9立即殺死進程

  • 分頁機制(邏輯地址和物理地址分離的內存分配管理方案):

    • 操作系統爲了高效管理內存,減少碎片

    • 程序的邏輯地址劃分爲固定大小的頁

    • 物理地址劃分爲同樣大小的幀

    • 通過頁表對應邏輯地址和物理地址

  • 分段機制

    • 爲了滿足代碼的一些邏輯需求

    • 數據共享/數據保護/動態鏈接

    • 每個段內部連續內存分配,段和段之間是離散分配的

  • 查看cpu內存使用情況?

    • top

    • free 查看可用內存,排查內存泄漏問題

設計模式

單例模式

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

 
    
    
    
也可以加一下老胡的微信
圍觀朋友圈~~~


推薦閱讀

(點擊標題可跳轉閱讀)

機器學習必知必會的 6 種神經網絡類型

我開始學Python網絡編程了

GSU 2021 | 貝葉斯數據分析課程開講

老鐵,三連支持一下,好嗎?↓↓↓

本文分享自微信公衆號 - 機器學習算法與Python實戰(tjxj666)。
如有侵權,請聯繫 [email protected] 刪除。
本文參與“OSC源創計劃”,歡迎正在閱讀的你也加入,一起分享。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章