你见过的最全面的python重点
生活随笔
收集整理的這篇文章主要介紹了
你见过的最全面的python重点
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
首先和大家說個對不起，由于總結了太多的東西，所以篇幅有點長，這也是我"縫縫補補"總結了好久的東西，對于Nginx的東西我沒總結在這里，大家可以Python聚焦看，點擊直達專欄哦。
前端
- span設置margin上下無效果，因為span是行內元素，是沒有寬高的。
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 Enumclass COLOR(Enum): YELLOW=1 #YELLOW=2#會報錯 GREEN=1#不會報錯,GREEN可以看作是YELLOW的別名 BLACK=3 RED=4 print(COLOR.GREEN)#COLOR.YELLOW,還是會打印出YELLOW for i in COLOR:#遍歷一下COLOR并不會有GREEN print(i) #COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎么把別名遍歷出來 for i in COLOR.__members__.items(): print(i) # output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>) for i in COLOR.__members__: print(i) # output:YELLOW\nGREEN\nBLACK\nRED #枚舉轉換 #最好在數據庫存取使用枚舉的數值而不是使用標簽名字字符串 #在代碼里面使用枚舉類 a=1 print(COLOR(a))# output:COLOR.YELLOW
py2/3轉換工具
- six模塊：兼容pyton2和pyton3的模塊
- 2to3工具：改變代碼語法版本
- __future__：使用下一版本的功能
常用的庫
- 必須知道的collections
- python排序操作及heapq模塊
- itertools模塊超實用方法
不常用但很重要的庫
- dis(代碼字節碼分析)
- inspect(生成器狀態)
- cProfile(性能分析)
- bisect(維護有序列表)
-
fnmatch
-
fnmatch根據系統決定
- fnmatch(string,"*.txt") #win下不區分大小寫
- fnmatchcase完全區分大小寫
-
- timeit(代碼執行時間)
-
contextlib
- @contextlib.contextmanager使生成器函數變成一個上下文管理器
- types(包含了標準解釋器定義的所有類型的類型對象,可以將生成器函數修飾為異步模式)
- html(實現對html的轉義)
- mock(解決測試依賴)
-
concurrent(創建進程池河線程池)
- from concurrent.futures import ThreadPoolExecutorpool = 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
-
set集合運用
- {1,2}.issubset({1,2,3})#判斷是否是其子集
- {1,2,3}.issuperset({1,2})
- {}.isdisjoint({})#判斷兩個set交集是否為空,是空集則為True
-
代碼中中文匹配
- [u4E00-u9FA5]匹配中文文字區間[一到龥]
-
查看系統默認編碼格式
- import syssys.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每三個為一組分組
-
什么是元類？
- 即創建類的類，創建類的時候只需要將metaclass=元類，元類需要繼承type而不是object,因為type就是元類
- type.__bases__ #(<class 'object'>,) object.__bases__ #() type(object) #<class 'type'>
-
什么是鴨子類型(即:多態)？
- Python在使用傳入參數的過程中不會默認判斷參數類型，只要參數具備執行條件就可以執行
-
深拷貝和淺拷貝
- 深拷貝拷貝內容，淺拷貝拷貝地址(增加引用計數)
- copy模塊實現神拷貝
-
單元測試
- 一般測試類繼承模塊unittest下的TestCase
- pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭，并且不能帶有 init 方法)
- coverage統計測試覆蓋率
- gil會根據執行的字節碼行數以及時間片釋放gil，gil在遇到io的操作時候主動釋放
-
什么是monkey patch?
- 猴子補丁，在運行的時候替換掉會阻塞的語法修改為非阻塞的方法
-
什么是自省(Introspection)？
- 運行時判斷一個對象的類型的能力，id,type,isinstance
-
python是值傳遞還是引用傳遞？
- 都不是，python是共享傳參，默認參數在執行時只會執行一次
-
try-except-else-finally中else和finally的區別
- else在不發生異常的時候執行，finally無論是否發生異常都會執行
- except一次可以捕獲多個異常，但一般為了對不同異常進行不同處理，我們分次捕獲處理
-
GIL全局解釋器鎖
- 同一時間只能有一個線程執行，CPython(IPython)的特點，其他解釋器不存在
- cpu密集型：多進程+進程池
- io密集型：多線程/協程
-
什么是Cython
- 將python解釋成C代碼工具
-
生成器和迭代器
-
實現__next__和__iter__方法的對象就是迭代器
- 可迭代對象只需要實現__iter__方法
- 使用生成器表達式或者yield的生成器函數(生成器是一種特殊的迭代器)
-
-
什么是協程
- 比線程更輕量的多任務方式
-
實現方式
- yield
- async-awiat
-
dict底層結構
- 為了支持快速查找使用了哈希表作為底層結構
- 哈希表平均查找時間復雜度為o(1)
- CPython解釋器使用二次探查解決哈希沖突問題
-
Hash擴容和Hash沖突解決方案
- 循環復制到新空間實現擴容
-
沖突解決：
- 鏈接法
- 二次探查(開放尋址法)：python使用
- 判斷是否為生成器或者協程
-
斐波那契解決的問題及變形
- #一只青蛙一次可以跳上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)
- 獲取電腦設置的環境變量
-
垃圾回收機制
- 引用計數
- 標記清除
- 分代回收
- 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進制
- list1 = ['A', 'B', 'C', 'D'] 如何才能得到以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢
- memoryview與bytearray$\color{#000}(不常用，只是看到了記載一下)$
-
Ellipsis類型
- # 代碼中出現...省略號的現象就是一個Ellipsis對象 L = [1,2,3] L.append(L) print(L) # output:[1,2,3,[…]]
- lazy惰性計算
-
遍歷文件，傳入一個文件夾，將里面所有文件的路徑打印出來(遞歸)
- 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 datetimedatetime.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排名會更高
- 常見響應狀態碼
- http請求方法的冪等性及安全性
- WSGI
- RPC
- CDN
- SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全（Transport Layer Security，TLS）是為網絡通信提供安全及數據完整性的一種安全協議。
- SSH（安全外殼協議） 為 Secure Shell 的縮寫，由 IETF 的網絡小組（Network Working Group）所制定；SSH 為建立在應用層基礎上的安全協議。SSH 是目前較可靠，專為遠程登錄會話和其他網絡服務提供安全性的協議。利用 SSH 協議可以有效防止遠程管理過程中的信息泄露問題。SSH最初是UNIX系統上的一個程序，后來又迅速擴展到其他操作平臺。SSH在正確使用時可彌補網絡中的漏洞。SSH客戶端適用于多種平臺。幾乎所有UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其他平臺，都可運行SSH。
-
TCP/IP
- TCP:面向連接/可靠/基于字節流
- UDP:無連接/不可靠/面向報文
-
三次握手四次揮手
- 三次握手(SYN/SYN+ACK/ACK)
- 四次揮手(FIN/ACK/FIN/ACK)
-
為什么連接的時候是三次握手，關閉的時候卻是四次握手？
- 因為當Server端收到Client端的SYN連接請求報文后，可以直接發送SYN+ACK報文。其中ACK報文是用來應答的，SYN報文是用來同步的。但是關閉連接時，當Server端收到FIN報文時，很可能并不會立即關閉SOCKET，所以只能先回復一個ACK報文，告訴Client端，"你發的FIN報文我收到了"。只有等到我Server端所有的報文都發送完了，我才能發送FIN報文，因此不能一起發送。故需要四步握手。
-
為什么TIME_WAIT狀態需要經過2MSL(最大報文段生存時間)才能返回到CLOSE狀態？
- 雖然按道理，四個報文都發送完畢，我們可以直接進入CLOSE狀態了，但是我們必須假象網絡是不可靠的，有可以最后一個ACK丟失。所以TIME_WAIT狀態就是用來重發可能丟失的ACK報文。
-
XSS/CSRF
- HttpOnly禁止js腳本訪問和操作Cookie,可以有效防止XSS
Mysql
-
索引改進過程
- 線性結構->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)
- Mysql面試總結基礎篇
- Mysql面試總結進階篇
- 深入淺出Mysql
- 清空整個表時，InnoDB是一行一行的刪除，而MyISAM則會從新刪除建表
- text/blob數據類型不能有默認值，查詢時不存在大小寫轉換
-
什么時候索引失效
- 以%開頭的like模糊查詢
- 出現隱士類型轉換
-
沒有滿足最左前綴原則
- 對于多列索引，不是使用的第一部分，則不會使用索引
-
失效場景：
- 應盡量避免在 where 子句中使用 != 或 <> 操作符，否則引擎將放棄使用索引而進行全表掃描
- 盡量避免在 where 子句中使用 or 來連接條件，否則將導致引擎放棄使用索引而進行全表掃描，即使其中有條件帶索引也不會使用，這也是為什么盡量少用 or 的原因
- 如果列類型是字符串，那一定要在條件中將數據使用引號引用起來，否則不會使用索引
-
應盡量避免在 where 子句中對字段進行函數操作，這將導致引擎放棄使用索引而進行全表掃描
- 例如： select id from t where substring(name,1,3) = 'abc' – name; 以abc開頭的，應改成： select id from t where name like ‘abc%’ 例如： select id from t where datediff(day, createdate, '2005-11-30') = 0 – '2005-11-30'; 應改為:
- 不要在 where 子句中的 “=” 左邊進行函數、算術運算或其他表達式運算，否則系統將可能無法正確使用索引
-
應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描
- 如： select id from t where num/2 = 100 應改為: select id from t where num = 100*2；
- 不適合鍵值較少的列（重復數據較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似，但只可以添加64個值)
- 如果MySQL估計使用全表掃描要比使用索引快，則不使用索引
-
什么是聚集索引
- B+Tree葉子節點保存的是數據還是指針
- MyISAM索引和數據分離，使用非聚集
- InnoDB數據文件就是索引文件，主鍵索引就是聚集索引
Redis命令總結
-
為什么這么快？
- 基于內存，由C語言編寫
- 使用多路I/O復用模型，非阻塞IO
-
使用單線程減少線程間切換
- 因為Redis是基于內存的操作，CPU不是Redis的瓶頸，Redis的瓶頸最有可能是機器內存的大小或者網絡帶寬。既然單線程容易實現，而且CPU不會成為瓶頸，那就順理成章地采用單線程的方案了（畢竟采用多線程會有很多麻煩！）。
- 數據結構簡單
- 自己構建了VM機制，減少調用系統函數的時間
-
優勢
- 性能高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s
- 豐富的數據類型
- 原子 – Redis的所有操作都是原子性的，同時Redis還支持對幾個操作全并后的原子性執行
- 豐富的特性 – Redis還支持 publish/subscribe（發布/訂閱）, 通知, key 過期等等特性
-
什么是redis事務？
- 將多個請求打包，一次性、按序執行多個命令的機制
- 通過multi,exec,watch等命令實現事務功能
- Python redis-py pipeline=conn.pipeline(transaction=True)
-
持久化方式
-
RDB(快照)
- save(同步，可以保證數據一致性)
- bgsave(異步，shutdown時，無AOF則默認使用)
- AOF(追加日志)
-
-
怎么實現隊列
- push
- rpop
-
常用的數據類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)
-
String(字符串):計數器
- 整數或sds(Simple Dynamic String)
-
List(列表)：用戶的關注，粉絲列表
- ziplist(連續內存塊，每個entry節點頭部保存前后節點長度信息實現雙向鏈表功能)或double linked list
- Hash(哈希)：
-
Set(集合)：用戶的關注者
- intset或hashtable
-
Zset(有序集合)：實時信息排行榜
- skiplist(跳躍表)
-
-
與Memcached區別
- Memcached只能存儲字符串鍵
- Memcached用戶只能通過APPEND的方式將數據添加到已有的字符串的末尾，并將這個字符串當做列表來使用。但是在刪除這些元素的時候，Memcached采用的是通過黑名單的方式來隱藏列表里的元素，從而避免了對元素的讀取、更新、刪除等操作
- Redis和Memcached都是將數據存放在內存中，都是內存數據庫。不過Memcached還可用于緩存其他東西，例如圖片、視頻等等
- 虛擬內存–Redis當物理內存用完時，可以將一些很久沒用到的Value 交換到磁盤
- 存儲數據安全–Memcached掛掉后，數據沒了；Redis可以定期保存到磁盤（持久化）
- 應用場景不一樣：Redis出來作為NoSQL數據庫使用外，還能用做消息隊列、數據堆棧和數據緩存等；Memcached適合于緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和Session等
-
Redis實現分布式鎖
- 使用setnx實現加鎖，可以同時通過expire添加超時時間
- 鎖的value值可以是一個隨機的uuid或者特定的命名
- 釋放鎖的時候，通過uuid判斷是否是該鎖，是則執行delete釋放鎖
-
常見問題
-
緩存雪崩
- 短時間內緩存數據過期，大量請求訪問數據庫
-
緩存穿透
- 請求訪問數據時，查詢緩存中不存在，數據庫中也不存在
-
緩存預熱
- 初始化項目，將部分常用數據加入緩存
-
緩存更新
- 數據過期，進行更新緩存數據
-
緩存降級
- 當訪問量劇增、服務出現問題（如響應時間慢或不響應）或非核心服務影響到核心流程的性能時，仍然需要保證服務還是可用的，即使是有損服務。系統可以根據一些關鍵數據進行自動降級，也可以配置開關實現人工降級
-
-
一致性Hash算法
- 使用集群的時候保證數據的一致性
-
基于redis實現一個分布式鎖，要求一個超時的參數
- setnx
- 虛擬內存
- 內存抖動
Linux
-
Unix五種i/o模型
- 阻塞io
- 非阻塞io
-
多路復用io(Python下使用selectot實現io多路復用)
-
select
- 并發不高，連接數很活躍的情況下
-
poll
- 比select提高的并不多
-
epoll
- 適用于連接數量較多，但活動鏈接數少的情況
-
- 信號驅動io
- 異步io(Gevent/Asyncio實現異步)
-
比man更好使用的命令手冊
- tldr:一個有命令示例的手冊
-
kill -9和-15的區別
- -15：程序立刻停止/當程序釋放相應資源后再停止/程序可能仍然繼續運行
- -9：由于-15的不確定性，所以直接使用-9立即殺死進程
-
分頁機制（邏輯地址和物理地址分離的內存分配管理方案）：
- 操作系統為了高效管理內存，減少碎片
- 程序的邏輯地址劃分為固定大小的頁
- 物理地址劃分為同樣大小的幀
- 通過頁表對應邏輯地址和物理地址
-
分段機制
- 為了滿足代碼的一些邏輯需求
- 數據共享/數據保護/動態鏈接
- 每個段內部連續內存分配，段和段之間是離散分配的
-
查看cpu內存使用情況？
- top
- free 查看可用內存，排查內存泄漏問題
設計模式
單例模式
# 方式一def Single(cls,*args,**kwargs): instances = {} def get_instance (*args, **kwargs): if cls not in instances: instances[cls] = cls(*args, **kwargs) return instances[cls] return get_instance工廠模式
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 nsmallestdef heap_sort(_list): return nsmallest(len(_list),_list)棧
from collections import dequeclass 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 dequeclass Queue: def __init__(self): self.s = deque() def push(self, el): self.s.append(el) def pop(self): return self.popleft()二分查找
def binary_search(_list,num): mid = len(_list)//2 if len(_list) < 1: return Flase if num > _list[mid]: BinarySearch(_list[mid:],num) elif num < _list[mid]: BinarySearch(_list[:mid],num) else: return _list.index(num)面試加強題：
關于數據庫優化及設計
- 如何使用兩個棧實現一個隊列
- 反轉鏈表
- 合并兩個有序鏈表
- 刪除鏈表節點
- 反轉二叉樹
- 設計短網址服務？62進制實現
- 設計一個秒殺系統(feed流)？
-
為什么mysql數據庫的主鍵使用自增的整數比較好？使用uuid可以嗎？為什么？
- 如果InnoDB表的數據寫入順序能和B+樹索引的葉子節點順序一致的話，這時候存取效率是最高的。為了存儲和查詢性能應該使用自增長id做主鍵。
- 對于InnoDB的主索引，數據會按照主鍵進行排序，由于UUID的無序性，InnoDB會產生巨大的IO壓力，此時不適合使用UUID做物理主鍵，可以把它作為邏輯主鍵，物理主鍵依然使用自增ID。為了全局的唯一性，應該用uuid做索引關聯其他表或做外鍵
-
如果是分布式系統下我們怎么生成數據庫的自增id呢？
- 使用redis
-
基于redis實現一個分布式鎖，要求一個超時的參數
- setnx
- 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? ?
閱讀原文
轉載于:https://www.cnblogs.com/276815076/p/10684118.html
總結
以上是生活随笔為你收集整理的你见过的最全面的python重点的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 计算机网络05
- 下一篇： python基础教程:包的创建及导入