python 初級/中級/高級/核心

"一等對象":
知足條件：1.在運行時建立 2.能賦值給變量或數據結構中的元素 3.能做爲參數傳遞給函數 4.能做爲函數的返回結果
[ 整數、字符串、字典、"全部函數" ]等都是一等對象

"什麼是函數"
調用：直接使用、不須要類或對象進行調用
定義：定義在模塊中、類體外
做用：數據處理

"什麼是方法"
調用：不能直接使用、須要類或對象進行調用
定義：定義在類體中
做用：狀態處理、狀態(對象的屬性、類的屬性)

"實例方法"
實例方法、接受一個self參數、該參數指向類的實例.
實例方法、經過self參數能夠自由地訪問同一個對象的屬性和其餘方法.
實例方法、不只能夠修改對象的狀態、還能夠修改類的狀態、經過self.__class__屬性訪問類自己.
實例方法、須要一個類的實例對象、並經過self訪問實例.

"類的方法"
類的方法、用一個@classmethod裝飾器標記.
類的方法、接受一個cls參數、該參數指向類自己、而不是實例.
類的方法、只能訪問cls參數、所以沒法修改實例對象.
類的方法、仍然能夠修改適用於此類的全部實例的類狀態.
類的方法、不須要類實例、沒法訪問實例、但他們能夠經過cls訪問類自己. 經常使用於定義備選構造方法

"靜態方法"
靜態方法、用@staticmethod裝飾器標記.
靜態方法、既不須要self也不須要cls參數.
靜態方法、既不能修改對象狀態也不能修改類狀態.
靜態方法、沒法訪問cls或self、它們像常規函數同樣工做，但屬於類的命名空間.
靜態方法和類的方法通訊並(在某種程度上)強制開發人員 關於類設計的意圖、這能夠帶來維護益處.
將方法標記爲靜態方法不只僅是一個方法不會修改類或實例狀態的提示 - 這個限制也是由Python運行時強制執行的

"高階函數"
參數包含函數、或返回值是函數 的函數就是高階函數。
如內置高階函數：map、filter、reduce

"匿名函數"
匿名函數就是沒有名字的函數、lambda關鍵字用來建立匿名函數、
lambda函數只能是純表達式、不能賦值、不能使用while、try等語句、在參數列表中最適合使用匿名函數

"鉤子函數"
鉤子函數也叫回調函數，是經過函數指針來實現的. 函數的指針能夠指向不一樣的函數, 從而完成不一樣的功能. 函數指針每每被聲明爲全局變量. 實例方法見C語言代碼😯

"序列類型"
序列類型 Sequence Types
有三種基本序列類型：list、tuple、range
專門用於處理二進制數據"binary data"和文本字符串"text strings"的附加序列類型

"序列操做"
大多數序列類型都支持下表中的操做，包括可變和不可變的序列類型。相同類型的序列也支持比較.
[in, not in,+, *, 切片, len(), min(), max(), index(), count()]
collections.abc.Sequence 使其更容易正確地執行自定義序列類型這些操做
序列能夠迭代的緣由是：iter()函數、解釋器須要迭代對象x時、會自動調用iter(x)
"對序列使用+和*"
+ * 都不會修改原有對象、而是構建一個全新的序列
對序列增量賦值、+=、*=的表現取決於他們的第一個操做對象、+=背後的特殊方法__iadd__()就地加法、
a+=b 等價於 a=a+b、*=、-=、/= 等都和+=原理相同、只是對應的特殊方法不一樣
增量運算只能用於可變序列、增量運算後可變序列的ID沒有變、新元素追加到序列上
對不可變序列進行重複拼接(*n)效率很低、每次都建立新對象、在將原對象複製到新對象裏

"不可變序列類型"
Immutable Sequence Types
不可變序列類型一般實現的惟一操做是對hash() 內置的支持.
不可變序列能夠做爲字典的鍵key;能夠存儲在set和frozenset實例中
tuple 就是不可變序列

"可變序列類型"
Mutable Sequence Types
可變序列、不能夠哈希、不能夠做爲字典的鍵key
"collections.abc.MutableSequence ABC" 更容易在自定義序列類型上正確實現這些操做.

"可散列數據類型"
可散列是指這個對象的生命週期中、它的散列值不變、而這個對象須要實現__hash__()方法
可散列的對象還有__eq__()方法、這樣才能夠和其鍵作比較、對象相等散列值必相同
原子不可變數據類型(str、bytes、數值類型)都是可散列類型、frozenset也是可散列類型
抽象基類的主要做用是和instanse一塊兒判斷某個數據是否是廣義上的映射類型


"容器序列"
容器序列存放的是它們所包含的任意類型的對象的引用;
容器序列(存放引用)：能夠存放不一樣類型的數據、如: "list"、"tuple"、"conllections.duque"
容器序列存放的是它們所包含的任意類型的對象的引用; 扁平序列存放的是數據自己的值、而不是引用


"扁平序列"
扁平序列存放的是數據自己的值、而不是引用、扁平序列其實就是一段連續的內存空間
扁平序列體積更小、速度更快、用起來更方便、但只能保存一些原子性的數據、數字、字符、字節
扁平序列(存放數據)：只能存放一種類型、如:"str"、"bytearray"、"memoryview"和"array.array" 、


"函數式編程"
函數式編程就是將問題分解爲一組函數。
理想狀況下、函數只接受輸入併產生輸出、並不影響內部狀態
一個函數應該僅具備一個功能、複雜函數拆分爲多個簡單函數
每一個函數都接收輸入產生輸出、每一個函數的輸出必須僅取決於其輸入
徹底沒有反作用的函數稱爲純函數
函數式編程能夠被認爲是面向對象編程的反面
函數式編程但願儘量避免狀態變化，並使用函數之間的數據流
對象是包含一些內部狀態的小膠囊以及一組方法調用, 可讓您修改此狀態, 程序包括進行正確的狀態更改


"可變類型"
可變類型: "內存中的數據能夠被修改：列表、字典"
"不可變類型"
不可變類型: "內存中的數據不容許被修改：數字、字符串、元組"

"PEP8"
包和模塊名稱：模塊應該有簡短的全小寫名稱. 若是提升可讀性, 能夠在模塊名稱中使用下劃線. Python包也應該有簡短的全小寫名稱, 但不鼓勵使用下劃線.
類的名稱：類名一般應使用CapWords大小約定.
類型變量名：類型變量的名稱一般應使用CapWords, 而不是短名稱：T, AnyStr, Num.
全局變量名稱：與函數和變量名稱相同規則、名稱應爲小寫, 並根據須要用下劃線分隔
函數和變量名稱：函數名稱應爲小寫, 並根據須要用下劃線分隔, 以提升可讀性. 變量名稱遵循與函數名稱相同的約定.
方法和方法參數：老是使用self做爲實例方法的第一個參數. 老是使用cls做爲類方法的第一個參數. 若是函數參數的名稱與保留關鍵字衝突, 一般最好附加單個尾隨下劃線而不是使用縮寫或拼寫損壞
方法名稱和實例變量：小寫, 必要時用下劃線分隔, 以提升可讀性. 僅對非公共方法和實例變量使用一個前導下劃線.
常量：常量一般在模塊級別定義, 並以所有大寫字母書寫, 下劃線分隔單詞.


"python"
python 既是一門面向對象的高級編程語言,同時也是支持函數式編程的腳本語言.
python 簡單、免費、開源、可移植、解釋性語言、自動內存管理.
python 可擴展性強、和混合C語言、Java語言等編寫. 還有豐富的第三方庫.
python 中的函數都是一等對象: 1.在運行時建立 2.能賦值給變量 3.能做爲參數傳遞給函數 4.能做爲函數的返回結果.


"切片"
`list、tuple、str、`都支持切片操做、經過索引來進行切片[:]、[:-1]、[1:3]、[3:5]、[5:]、
爲何切片和區間會忽略最後一個元素？
"一般都以0做爲起始下標"、 "在切片和區間不含最後一個元素"
(1)當只有一個位置信息時、咱們能夠快速看出切片和區間裏有幾個元素
(2)當起止位置信息均可見時、能夠快速計數出切片和區間的長度
(3)能夠利用下標將序列分割成不重疊的兩部分
(4)多維切片和省略表示法( ... )


"函數屬性"
__annoations__ dict 參數和返回值的註解
__call__ method-wrapper 實現()運算符、便可調用對象協議
__closure__ tuple 函數閉包、即自由變量的綁定(None)
__code__ code 編譯成字節碼的函數元數據和函數定義體
__defaults__ tuple 所有形參的默認值
__get__ method-wrapper 實現只讀掃描符協議
__globals__ dict 函數所在模塊中的全局變量
__kwdefaults__ dict 僅限關鍵字形參參數的默認值
__name__ str 函數的名稱
__qualname__ str 函數的限定名稱

"位置參數、關鍵字參數"
關鍵字參數不必定要又默認值、只要是放在*參數後面的參數都是關鍵字參數、def func(a, *, b): 參數b就是一個關鍵字參數、強制必須傳入實參、
函數對象有個__defaults__屬性、它的值是一個元組、裏面保存着定位參數和關鍵字參數的默認值
僅限關鍵字參數的默認追在__kwdefaults__屬性中、參數的名稱在__code__屬性中、它的值是一個code對象的引用、自身也有不少屬性"


"裝飾器"
裝飾器能夠把被裝飾的函數替換成其餘函數、裝飾器是加載模塊時當即執行、
裝飾器在源代碼中標記函數已加強函數的行爲、裝飾器本質是一個高階函數、
裝飾器只是語法糖、裝飾器能夠像常規函數那樣調用、其參數是另外一函數、
裝飾器在被裝飾函數定義以後當即運行、一般在導入時、
被裝飾的函數只是在明確調用時運行、裝飾器能夠疊放、裝飾器也能夠帶有參數
裝飾器做用: "引入日誌、函數執行時間的統計、執行函數的前預處理、執行函數後的清理功能、權限校驗場景、緩存等"


"閉包"
閉包、指的是延伸了做用域的函數、其中包含函數定義體中引用、可是不在定義體中定義的非全局變量、
閉包的關鍵在於能訪問定義體以外的非全局變量、一般閉包表現爲函數內部定義的函數、
閉包是回調異步編程和函數式編程風格的基礎、使用內部函數的代碼幾乎都要靠閉包才能正確運做、
一個函數的參數、內部定義的局部變量、內部定義的函數、和組成了閉包、
閉包是一種函數、會保留定義函數時存在的自由變量的綁定、
注意：只有嵌套在其餘函數中的函數纔可能須要處理不在全局做用域中的外部變量

"遞歸"
遞歸是算法中核心的概念有三個特色,
1.調用自身 2.具備結束條件 3.代碼規模逐漸減小


"global"
函數體中定義全局變量、使用global先聲明變量、而後再給變量賦值使用


"nonlocal"
nonlocal 的做用是把變量標記爲自由變量、若是給自由變量賦了新值、閉包中保存的綁定的新值


"變量"
變量就是對象的一個標籤、先有對象、纔將標籤添加到對象上、而不是將對象裝入變量
先建立了對象、而後將對象賦值給變量、此時變量才被建立、變量必須賦值纔有效、變量僅僅是對象的一個標籤


"對象"
對象包含的三個基本要素 分別是：id(身份標識)、type(數據類型)、value(值)
對象的一旦建立、它的標識毫不會改變、能夠將標識理解爲內存地址、id()返回內存地址
對象是包含一些內部狀態的小膠囊以及一組方法調用, 可讓您修改此狀態, 程序包括進行正確的狀態更改


"參數的默認值"
不要使用可變類型做爲參數的默認值、函數的參數的默認值是在函數建立時賦值的而不是函數調用時,
因此須要特別注意、對象不會自動銷燬、沒法獲得對象時、可能會被看成垃圾回收


"幫助"
help()、dir()
help('keywords')、help('modules')、help("modules json")、help("topics"))
help("os.path")、help("list")、help("str.find")、help("open")、help("builtins")


"形參、實參"
形參：定義函數時使用的變量
實參：調用函數時傳遞的對象


"函數內省"
內省，有時也叫類型內省，是在運行時進行的一種對象檢測機制。
咱們能夠經過內省來獲取一個對象的全部信息，好比這個對象的類型，其中包含哪些屬性等等
省：檢查某些事物以肯定它是什麼、內省：自我檢查、已肯定本身是什麼、有什麼、函數對象又不少屬性、__doc__、__call__、__class__、__init__、__new__、__str__等、函數使用__doc__屬性存儲賦予它的用戶的屬性


"==和is的區別"
== 是比較運算符 == 比較的是對象的value
is 是身份運算符 is 比較的是對象的id
== 比較的是兩個對象的值(對象中保存的數據); is 比較的是對象的標識、即對象的內存地址信息、
繼承字object的__eq__()方法比較兩個對象的ID、結果與is同樣、而 a == b 是語法糖、等同於 a.__eq__(b)、
可是大多數內置類型使用更有意義的方式覆蓋了__eq__()方法、會考慮對象屬性的值
"變量和單例值比較應該使用is"、is 運算比==速度快、由於它不能重載、is運算符不調用特殊方法、直接比較兩個整數ID


"函數返回值類型"
無返回值時 None
一個返回值 值的類型
多個返回值 元組類型


"上下文管理器"
with 語句會設置一個臨時的上下文、交給上下文管理對象控制、並負責清理上下文、
with 還有不少用途、除了關閉文件以外、with 語句存在的目的簡化 try / finally 模式、
"上下文管理對象存在的目的是管理 with 語句"、"迭代器存在的目的是爲了管理 for 循環語句"、
上下文管理協議包含__enter__和__exit__兩個方法、
with 語句開始運行時、會在上下文管理對象上調用__enter__方法、
with 語句開始結束時、會在上下文管理對象上調用__exit__方法、扮演finally子句


"可調用對象"
1.用戶定義的函數、2.內置函數、3.內置方法、4.方法、5.類、6.類的實例、7.生成器函數、
經過內置callable()函數、判斷對象是否能夠調用


"del 語句"
del 語句刪除的是名稱、而不是對象、del 語句可能會致使對象被看成垃圾回收、
Cpython中、垃圾回收使用的主要算法是引用計數、正由於有引用、對象纔會在內存中存在、當對象的引用歸零、垃圾回收程序會銷燬對象


"__slots__"
__slots__ 類的屬性、目的節省空間、
一般各個實例中名爲__dict__的字典裏存儲實例屬性、爲了使用底層的三列表提高訪問速度、
字典會消耗大量內存、經過使用__slots__類屬性、可以節省大量內存、讓解釋器在元組中存儲實例屬性、而不是字典、
python只會使用各個類中本身定義的__slots__屬性、繼承的沒有效果、
定義__slots__的方式、名稱爲__slots__、值爲屬性字符串組成的元組、
__slots__ = ('__x', '__y')、__slots__屬性的目的就是告訴解釋器、這個類中的全部實例屬性都在這了、缺點：不能動態添加屬性了"


"__add__"
若是a有__add__方法、則進行a.__add__(b)運算、
不然檢查b有沒有__radd__方法、若是有、則調用b.__radd__(a)，不然返回Notimplemented


" __eq__ "
__eq__ 定義了類的等號(==)行爲、其餘魔術方法原理相似
def __eq__(self, obj):
return self.name == obj.name


"__xxx__"
__xxx__爲系統定義的名稱、普通變量不可使用此方式命名
可變參數 *args 類型爲 tuple 類型、關鍵字參數 **kwargs 爲 dict 類型.


"局部變量、全局變量"
"局部變量" 是在 "函數內部" 定義的變量、只能在函數內部使用；
函數執行結束後, 函數內部的局部變量, 會被系統回收；
不一樣的函數, 能夠定義相同的名字的局部變量, 可是 彼此之間 不會產生影響；
局部變量通常臨時 保存 函數內部須要使用的數據
"全局變量" 是在 "函數外部" 定義的變量、全部函數內部均可以使用這個變量

"*args 與 **kwargs"
*args 數據類型元組 位置參數
**kwargs 數據類型字典 關鍵字參數
*和** 表示可變參數 能夠傳遞任意數量的參數
*和** 也能夠在函數調用的時候使用, 稱之爲解包裹(unpacking)
*args 數據類型元組 位置參數
**kwargs 數據類型字典 關鍵字參數


"可迭代對象"
for語句在容器對象上調用iter()內置函數,能夠獲取迭代器對象、
若是對象實現了能返回迭代器的__iter__方法, 那麼對象就是可迭代的、
python 從可迭代的對象中獲取迭代器
序列均可以迭代、實現了__getitem__方法、參數索引從0開始的對象、也能夠進行迭代
<可迭代對象必定不能是自身的迭代器>、也就是說、可迭代的對象必須實現__iter__方法、但不能實現__next__方法


"運算符"
1.算術運算符 2.比較運算符 3.賦值運算符 4.邏輯運算符 5.位運算符 6.成員運算符 7.身份運算符


"迭代器"
迭代器存在的目的是爲了管理 for 循環語句、迭代器是表示數據流的帶有位置狀態的對象;
該對象調用next()函數返回容器中的下一個值、此對象一次返回一個元素的數、任何一個實現了_iter_方法和_next_方法的類對象，就是迭代器.
若是流中沒有更多元素，則 __next__() 必須引起 StopIteration 異常.
內置iter()函數接受一個任意對象，並嘗試返回一個迭代器，該迭代器將返回對象的內容或元素，若是該對象不支持迭代，則會引起TypeError，
迭代器、掃描內存中放不下的數據集時、產生了一種惰性獲取數據的方式、迭代器模式、迭代器模式：一次獲取一個數據項
標準的迭代器接口有兩個方法：__next__和__iter__、__next__ 返回一個可用的元素、若是沒有元素了、會拋出Stopiteration異常、
__iter__() 返回 self，以便在應該使用對象的地方使用迭代器、如 for 循環


"生成器"
生成器是隻能遍歷一次的、生成器是一類特殊的迭代器.
生成器函數: 使用 def 定義函數, 使用yield語句返回結果而不是return語句.
yield語句一次返回一個結果, 在每一個結果中間, 掛起函數的狀態, 以便下次從它離開的地方繼續執行.
生成器是能夠暫停和恢復的函數，返回能夠迭代的對象。與列表不一樣，它們是懶惰的，所以只能在被詢問時生成一個項目(items)。
所以，在處理大型數據集時，它們的內存效率更高.
請記住，當數據大小大於可用內存時，生成器表達式會大大加快。
生成器很是適合讀取大量大型文件，由於不管輸入流的大小如何，它們一次只能生成一個數據塊。
它們還能夠經過將迭代過程分離爲更小的組件來實現更清晰的代碼.
生成器容許咱們在須要時詢問值，使咱們的應用程序更高效，很是適合無限數據流。
它們還可用於從循環中重構處理，從而產生更清晰，分離的代碼.


"生成器函數"
只要函數定義體中有yield關鍵字、該函數就是生成器函數、調用生成器函數、會返回一個生成器對象、
也就是說生成器函數就是一個工廠函數、生成器工廠函數、生成器函數都有個 yield 關鍵字、
生成器函數的定義體中一般都有循環、但不是必須條件、生成器函數返回一個生成器對象、
生成器就是迭代器、會生成傳給yield關鍵字的表達式的值、生成器函數執行完畢會拋出一個StopIteration異常


"迭代器於生成器的區別"
迭代器用於從集合中取出元素、生成器用於"憑空"生成元素、
一般狀況下能夠視爲一個概念、全部生成器都是迭代器、由於生成器徹底實現了迭代器接口


"面向對象"
封裝、繼承、多態、封裝了屬性和方法的代碼塊。


"封裝"
封裝就是將相關細節隱藏、僅對外提供訪問接口.
相關細節包括、屬性、方法、實現方式、邏輯判斷等。
類自己就是一個封裝, 封裝了屬性和方法.
方法也是封裝, 對一些業務邏輯的封裝.
私有也是封裝, 將一些方法和屬性私有化, 對外提供可訪問的接口.


"繼承"
將共性的內容放在父類中, 子類只須要關注本身特有的內容, 共性的繼承過來就好了.簡化開發符合邏輯習慣, 利於擴展


"多態"
一個對象在不一樣的狀況下顯示不一樣的形態。
在python中由於是弱類型語言，對類型沒有限定，全部python中不徹底支持多態，可是多態的思想，python也是能體現的


"字典"
字典 class dict(object):
方法: ['clear', 'copy', 'fromkeys', 'get', 'pop', 'popitem', 'keys', 'values', 'items', 'setdefault', 'update', ]
字典是映射類型、是關聯數組、是`鍵集合`到`值集合`的映射、字典表現爲鍵值對、
value能夠是任意類型對象、key必須是不可變類型對象、key惟一且不可變、元組能夠充當鍵。
字典被普遍使用、模塊的命名空間、實例的屬性、函數的關鍵字、都使用到字典 、
內置函數都在`__buil__builtins__.__dict__`模塊中、字典被高度優化、
散列表則是字典類型性能出衆的根本緣由、集合的實現也依賴散列表。


"元組"
class tuple(object):
方法:`count`、`index`
元組是不可變序列、存放的是數據的引用、能夠存聽任何類型的數據、一般用於存儲異構元素(不一樣數據類型的元素)
元組不只僅是不可變的列表、還包含len屬性和元素位置
元組是對數據的記錄、元組中的每一個元素都存放着記錄中一個字段的數據、外加字段位置、正是這個位置信息給數據賦予類意義。
"元組的相對不可變性"
元組和大多數python容器(列表、字典、集、等)同樣、保存的都是對象的引用、
若是引用的元素是可變的、即便元組自己不可變、元素依然可變
元組的不可變性、是指元組數據結構的物理內容不可變(即引用不可變)、與引用的對象無關、
元組的值會隨着引用的可變對象變化而變化、元組中不可變的是元素的引用


"列表"
class list(object):
列表是可變序列、存放的是數據的引用、能夠存儲任何類型的數據、一般用於存儲同類型的數據、列表使用 [] 表示
方法：['append', 'clear', 'copy', 'count', 'extend','index', 'insert', 'pop', 'remove', 'reverse', 'sort']

"集合"
Set Types — set, frozenset
set對象是不一樣的可哈希對象的無序集合.
集合不支持索引、切片或其餘相似序列的行爲.
目前有兩種內置集類型、set和 frozenset
因爲它是可變的、所以它沒有哈希值、不能用做字典鍵或另外一組的元素.
該frozenset類型是不可變的和可散列的 - 其內容在建立後不能更改.
set常見用途包括成員資格測試、從序列中刪除重複項、以及計算數學運算、如交集、並集、差別和對稱差別.

class set(object):
['add','clear','copy','difference','difference_update',
'discard','update','intersection','intersection_update',
'isdisjoint','issubset','issuperset','pop','remove',
'symmetric_difference','symmetric_difference_update','union',]


class frozenset(object):
['copy','difference','intersection','union'
'isdisjoint','issubset','issuperset','symmetric_difference']

"數組"
array.array支持全部可變序列的操做、包括pop、insert、extend、
數組還提供從文件讀取、存入文件的更快方法、.frombytes、.tofile、
數組背後存的不是float對象、而是數字的字節表示

"內存視圖"
memoryview是一個內置類、可以讓用戶在不復制內容的狀況下操做同一個數組的不一樣切片

"列表推導式"
List Comprehensions
容許您將該代碼的三個主要方面表達爲一行
•從中檢索值的序列 •用於肯定是否應包含值的表達式 •用於爲新列表提供值的表達式
列表推導式是構建列表的快捷方式
filter和map合起來能作的事情、列表推導式也能夠作、
列表推導式的惟一做用就是生成列表 [ i for i in range(10) ]
生成器表達式遵照迭代協議、能夠逐個產生元素、而不是先創建一個列表


"生成器表達式"
generator expression
生成器表達式則能夠用來建立任何類型的序列
python 會忽略[]、{}、()、中的換行、所以能夠有多行列表、列表推導式、生成器表達式等
若是生成器表達式是一個函數調用過程當中的"惟一參數",就不須要將其用括號圍起來
生成器表達式是逐個產生元素


"字典推導"
還有集合推導式(後面出現)
字典推導能夠從任何以鍵值做爲元素的可迭代對象中構建出字典
字典推導式能夠把一個裝滿元組的列表變爲兩個不一樣的字典
若是要生成其餘類型的序列、就須要生成器表達式


"模塊"
模塊對象具備一個祕密的只讀屬性[`__dict__`]

標準庫中的裝飾器
@property、@classmethod、@staticmethod
@functools.wraps 協助構建行爲良好的裝飾器
@functools.lru_cache() 實現了備忘的功能、把耗時的函數結果保存起來、避免傳入相同的參數時重複計算
@functools.singledispatch 能夠把總體方案拆分紅多個模塊、裝飾的函數會變成泛函數、根據參數類型、以不一樣的方式執行相同操做的一組函數

內置iter函數做用?
"檢查對象是否實現了__iter__方法、若是實現了就調用獲取一個迭代器、若是沒有實現__iter__方法、可是實現了__getitem__方法、python會本身建立一個迭代器、若是仍是失敗、會拋出異常"

if __name__ == '__main__'是什麼？
"模塊是對象、而且全部的模塊都有一個內置屬性 __name__"
一個模塊的 __name__ 的值取決於如何使用模塊
若是模塊被導入: '模塊__name__ 屬性 的值一般爲模塊文件名'
若是直接運行模塊: '模塊__name__屬性 的值將是一個特別缺省 __main__'

"Mapping Types": dict
"Set Types": set、frozenset
"Sequence Types": range、tuple、list


tuple()
1.建立空元組 2.建立元組 3.將列表轉換爲元組 4.將range轉換爲元組
list()
1.建立空列表 2.建立列表 3.將元組轉換爲列表 4.將range轉換爲列表
dict()
1.建立空字典 2.建立字典

#字符串的相關內容
name='xin yue'; age = '15'; grade = '0525'
student0 =f"姓名: {name},年齡: {age},班級: {grade}" # f-string來組合字符串
student2 = ("姓名: " 'xin yue' ",年齡: " '15' ",班級: " '0525') # 元組方式()組合字符串
student3 = "姓名: "+"xin yue"+",年齡: "+"15"+",班級: "+"0525" # 使用+方式
student4 = "".join(['姓名: ', 'xin yue', ',年齡: ', '15', ',班級: ', '0525']) # join()拼接組合字符串
student5 = "姓名: %s,年齡: %d,班級: %s" %('xin yue',15,'0525') # 使用C語言格式%
student6 = "姓名: {},年齡: {},班級: {}".format('xin yue',15,'0525')
student7 = "姓名: {0},年齡: {1},班級: {2}".format('xin yue', 15, '0525')
student8 = "姓名: {name},年齡: {age},班級: {grade}".format(name='xin yue', age=15, grade='0525')

"functools"
可調用對象的高階函數和操做
高階函數採用一個或更多個函數做爲參數，並返回一個新的函數。

"operator"
標準運算符做爲函數
包含一組與Python運算符相對應的函數。
這些函數一般在函數式代碼中頗有用，由於它們能夠避免編寫執行單個操做的簡單函數。

"conllections"
泛映射類型
conllections.abc模塊中有MultableMapping和Mapping兩個抽象基類
MultableMapping---->Mapping--->Container
MultableMapping: __setitem__、__delitem__、clear、pop、popitem、setdefault、update
Mapping: __getitem__、__contains__、__eq__、__ne__、get、items、keys、values
Container: __contains__ && iterable: __iter__ && Sized: __len__

"itertools"
函數建立迭代器以實現高效循環
該itertools模塊包含許多經常使用的迭代器以及組合多個迭代器的函數。
該模塊的功能分爲幾大類
(1)基於現有迭代器建立新迭代器的函數。
(2)用於將迭代器元素視爲函數參數的函數。
(3)用於選擇迭代器輸出部分的函數。
(4)用於對迭代器輸出進行分組的函數。
(5)支持迭代器的數據類型。


"字典生成式實例"
code_list=[ (0,'未註冊'), (1,"已註冊"), (2,'未登錄'), (3,'已登錄')]
code_dict={ state:code for code, state in code_list}
print(code_dict)
# {'未註冊': 0, '已註冊': 1, '未登錄': 2, '以登錄': 3}

 

"json"
json模塊老是生成str對象、而不是字節對象. 所以、fp.write()必須支持str輸入
import json
skipkeys=True # True時若是dict的keys不是基本類型、則忽略、也不會發生異常
ensure_ascii=True # 全部中文等非ASCII字符輸出用``\ uXXXX``序列進行轉義
ensure_ascii=False # 全部中文等非ASCII字符都不轉義、輸出原始值
check_circular=False # 將跳過對容器類型的循環引用檢查、循環引用將致使"OverflowError"(或更糟)
allow_nan=False # 嚴格遵照JSON規範、而不是使用JavaScript等價物 (``NaN``, ``Infinity``, ``-Infinity``).
indent=4 # index控制縮進、格式化輸出的JSON數組元素和對象成員
separators=(',', ': ') # 分隔符若是指定,應該使用元組(item_separator, key_separator) 、
encoding='utf-8' # 只有python2中有此參數、python3中沒有
default # 若是指定，則default應該是爲沒法以其餘方式序列化的對象調用的函數
sort_keys=True # 若是sort_keys爲true（默認值：False），則字典的輸出將按鍵排序。

"將對象(obj)序列化爲到文件(fp)的JSON格式的流"
json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
"將obj序列化爲JSON格式的str"
json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
"將包含JSON文檔的文本文件或二進制文件fp反序列化爲Python對象"
json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
"將s(包含JSON文檔的str、bytes或bytearray實例)反序列化爲Python對象"
json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

 

"defaultdict "
conllections.defaultdict能夠優雅的解決、處理找不到鍵的一個選擇
在用戶建立defaultdict對象的時候就須要給他配置一個爲找不到的鍵建立默認值的方法
具體來講、在實例化一個defaultdict的時候、須要給構造方法提供一個可調用對象、
這個可調用對象在__getitem__找不到鍵的時候調用、讓__getitem__返回某種默認值
這一切的背後特殊方法是 __missing__
它會在defaultdict遇到找不到鍵的狀況下調用 defaultdict裏的default_factory方法
特殊方法__missing__
全部映射類型在處理找不到鍵的時候、都會牽扯到__missing__方法

"字典視圖"
dictionary view
字典視圖是 dict.keys(), dict.values(), and dict.items() 返回的對象、
能夠轉爲列表類型list(dictview)

"範圍"
class range(object):
做用: 產生並返回一個整數序列對象
方法: ['count', 'index']

"關鍵字函數"
key function、關鍵字函數是可調用的，它返回用於排序或排序的值、
Python中的許多工具接受關鍵函數來控制元素的排序或分組方式。They include
min(), max(), sorted(), list.sort(),
heapq.merge(), heapq.nsmallest(), heapq.nlargest(), and itertools.groupby().

"字典變種"
conllections.OrderedDict() 這個類型在添加鍵時會保持順序、所以鍵的迭代次序老是一致的
conllections.ChainMap() 這個類型能夠容納數個不一樣的映射對象、查找操做時被看成一個總體
conllections.Counter() 這個類型會給鍵準備一個整數計數器、能夠用來給散列對象計數
conllections.UserDict 這個類實際上是把標準dict用純python又實現來一遍、讓用戶繼承使用
標準庫裏全部映射類型都是可變的

"通用函數"
generic function 通用函數 由多個函數組成的函數，爲不一樣類型實現相同的操做。
調用期間應使用哪一種實現由調度算法肯定。

拆包
unpacking
for 循環能夠分別提取元組裏的元素、也叫拆包、
拆包時、能夠將不關注的元素賦值給_佔位符
拆包讓元組能夠完美的被看成記錄來使用。
拆包能夠應用到任何可迭代對象上、若是元素數量與變量不一致可使用*參數忽略多餘的元素

 

list.sort方法、內置函數sorted
list.sort方法會就地排序列表、不會把原列表複製一份、因此返回值爲None、
若是一個函數或方法對對象進行的是就地改掉、它就應該返回None、python慣例、random.shuffle函數也遵照這個慣例
內置sorted方法、會新建一個列表做爲返回值、能夠接受任何形式的可迭代對象做爲參數
內置sorted方法無論傳入的參數是什麼類型的始終返回一個列表
list.sort 和sorted 都有兩個可選參數
"reverse": reverse=True 時、被排序的序列中元素會以降序輸出、反之亦然
"key": key是一個函數做爲參數、這個函數會被用在序列裏的每一個元素上
如對字符串進行排序sorted("Python Method",key=str.lower)
不少內置方法和標準庫中的方法都支持key參數、itertools.groupby()、heapq.nlargest()
bisect 來管理以排序的序列
bisect模塊包含兩個主要函數、後續研究

變量查找規則
當咱們使用一個變量時, 會優先在當前做用域中尋找該變量, 若是有則使用;
若是沒有則繼續去上一級做用域中尋找, 若是有則使用;
若是依然沒有則繼續去上一級做用尋找, 依次類推, 直到找到全局做用域, 依然沒有找到的話, 則會拋出異常;

"全局做用域"
在全局都有效, 全局做用域在程序執行時建立, 在程序執行結束時銷燬;
全部函數之外的區域都是全局做用域;
在全局做用域中定義的變量, 都屬於全局變量, 全局變量能夠在程序的任意位置被訪問;

"函數做用域"
函數做用域在函數調用時建立, 在調用結束時銷燬, 函數每調用一次就會產生一個新的函數做用域;
在函數做用域中定義的變量, 都是局部變量, 只能在函數內部被訪問;
在函數中爲變量賦值時, 默認都是爲局部變量賦值;
若是須要在函數內部修改全局變量, 則須要使用global關鍵字來 聲明 使用全局變量。

# requests 是一個第三方類庫、很是不錯、強烈建議學習源碼
"requests"
請求參數: 
['method', 'url', 'params', 'data', 'json','headers', 'cookies', 'files', 'auth',
'timeout', 'allow_redirects','proxies', 'verify', 'stream', 'cert']
請求方法: 
['REQUEST','GET','POST','PUT','HEAD','DELETE','PATCH']
響應方法: 
"close()、encoding、json()、`raise_for_status`()"
響應屬性: 
"apparent_encoding、content、cookies、elapsed、encoding、headers、history、
is_permanent_redirect、is_redirect、iter_content、iter_lines、links、next、ok、
raw、reason、status_code、text、url"

特殊方法
special method、特殊方法、隱式調用的方法、方法的名稱以雙下劃線開頭和結尾.
特殊方法用於支持: 迭代、集合類、屬性訪問、運算符重載、函數和方法的調用、對象建立和銷燬、字符串表示、字符串格式化、上下文管理

"特殊方法 "
存在是用來被解釋器調用的、一般咱們不會使用它
my_object.__len__() 這種寫法、儘管這麼寫是正確的但不推薦使用
而應該使用 len(my_object) 這種寫法
特殊方法的調用是隱式的
for i in x: 這個語句的背後用的是iter(x) 方法、而iter(x)函數背後則是x.__iter__()方法
前提條件是這個方法在x中被實現了
經過使用內置方法len、iter、str等來使用特殊方法是最好的選擇

"特殊方法一覽"
可調用模擬 __call__
上下文管理 __enter__、__exit__
屬性描述符 __get__、__set__、__delete__
迭代枚舉 __iter__、__reversed__ 、__next__
實例建立和銷燬 __new__、__init__、__del__
類相關服務 __prepare__、__instancecheck__、__subclasscheck__
字符串/字節序列表示形式 __repr__、__str__、__format__、__bytes__
集合模擬 __len__、__getitem__、__setitem__、__delitem__、__contain__
屬性管理 __getattr__、__setattr__、__delattr__、__dir__、__getattribute__
數值轉換 __abs__、__bool__、__complex__、__int__、__float__、__hash__、__index__

一元運算符
__neg__、__pos__、__abs__、 negative、positive、absolute
比較運算符
__lt__、__le__、__eq__、 less than、less equal、equal
__gt__、__ge__、__ne__、 greter than、greter equal、inequality
算術運算符
__truediv__、__floordiv__、 / 、//
__add__、__sub__、__mul__ addition、subtraction、multiplication
__mod__、__divmod__、__pow__、__round__ %、divmod()、**、round()
反向運算符
__radd__、__rsub__、__rmul__、__rtruediv__、__rfloordiv__、__rmod__、__rdivmod__、__rpow__、
增量賦值運算符
__iadd__、__isub__、__imul__、__itruediv__、__ifloordiv__、__rmod__、__rpow__
位運算符
__invert__ ~、__lshift__ <<、__rshift__ >>、__and__ &、__or__ |、__xor__ ^

反向位運算符
、__rlshift__ 、__rrshift__ 、__rand__ 、__ror__ 、__rxor__

增量賦值位運算符
、__ilshift__ 、__irshift__ 、__iand__ 、__ior__ 、__ixor__
當交互兩個數的位置時、就會調用反向運算符
經過特殊方法、自定義數據類型能夠表現的和內置類型同樣、從而寫出更好的代碼

class __generator(object): # 表示生成器函數類型的模擬類
class __asyncgenerator(object): # 表示異步生成器函數類型的模擬類
class __function(object): # 表示函數類型的模擬類
class __method(object): # 表示方法類型的模擬類
class __coroutine(object): # 表明協程類型的模擬類
class __namedtuple(tuple): # 命名元組的模擬基類
class __loader__(object): # 內置模塊的元路徑導入

class object: # 最基本的類型
class int(object):
class str(object):
class bool(int):
class float(object):
class bytearray(object):
class bytes(object):
class complex(object):

class range(object): # 內置range類
class list(object): # 內置可變序列
class tuple(object): # 內置不可變序列。
class set(object): # 無序的獨特元素集合。
class dict(object): # 字典
class map(object): # 建立一個迭代器, 可以返回一個 map 的 obj

class memoryview(object): # 建立一個新memoryview對象引用給定對象的
class slice(object): # 建立切片對象
class reversed(object): # 在給定序列值上返回反向迭代器
class enumerate(object): # 返回一個枚舉對象
class filter(object): # 過濾器對象
class frozenset(object): # 構建一個不可變的無序的獨特元素集合

class property(object): # 提供了可讀可寫可刪除的屬性操做
class staticmethod(object): # 將函數轉換爲靜態方法。
class classmethod(object): # 將函數轉換爲類方法
class super(object): #
class zip(object):
class type(object):

class BaseException(object): # 全部異常的公共基類
class Exception(BaseException): # 全部非退出異常的公共基類
class GeneratorExit(BaseException): # 生成器退出
class SystemExit(BaseException):
class StopAsyncIteration(Exception): # 從iterator.__anext__()發出結束信息
class StopIteration(Exception): # 從iterator.__next__() 發出結束信號
class Warning(Exception):

class object:
__setattr__、__getattribute__、__delattr__
__eq__、__ne__、__ge__、__gt__、__le__、__lt__
__format__、__init__、__new__、__sizeof__、__hash__、__subclasshook__、
__repr__、__str__、__dir__、__reduce_ex__、__reduce__、__init_subclass__
屬性
__class__ = None
__dict__ = {}
__doc__ = ''
__module__ = ''

def __format__(self, *args, **kwargs):
""" Return a formatted version of the string as described by format_spec. """
@staticmethod
def __new__(*args, **kwargs):
""" Create and return a new object. See help(type) for accurate signature. """
def __init__(self, value='', encoding=None, errors='strict'):

def __add__(self, *args, **kwargs): """ Return self+value. """
def __mod__(self, *args, **kwargs): """ Return self%value. """
def __mul__(self, *args, **kwargs): """ Return self*value. """
def __rmod__(self, *args, **kwargs): """ Return value%self. """
def __rmul__(self, *args, **kwargs): """ Return value*self. """
def __eq__(self, *args, **kwargs): """ Return self==value. """
def __ge__(self, *args, **kwargs): """ Return self>=value. """
def __gt__(self, *args, **kwargs): """ Return self>value. """
def __le__(self, *args, **kwargs): """ Return self<=value. """
def __lt__(self, *args, **kwargs): """ Return self<value. """
def __ne__(self, *args, **kwargs): """ Return self!=value. """

def __repr__(self, *args, **kwargs): """ Return repr(self). """
def __str__(self, *args, **kwargs): """ Return str(self). """
def __getitem__(self, *args, **kwargs): """ Return self[key]. """
def __contains__(self, *args, **kwargs): """ Return key in self. """
def __getattribute__(self, *args, **kwargs): """ Return getattr(self, name). """
def __getnewargs__(self, *args, **kwargs):

def __hash__(self, *args, **kwargs): """ Return hash(self). """
def __iter__(self, *args, **kwargs): """ Implement iter(self). """
def __len__(self, *args, **kwargs): """ Return len(self). """
def __sizeof__(self, *args, **kwargs): " Return the size of the string in memory, in bytes. "

"功能編程模塊" [ itertools、functools、functools ]
"itertools模塊" - 建立迭代器函數、用於高效循環
"functools模塊" - 可調用對象的高階函數和操做
"operator模塊" - 標準運算符做爲函數

無限迭代器：itertools模塊、 [ count()、cycle()、repeat() ]


itertools.count(start=0,step=1) "建立一個無限迭代器，返回以數字start開頭的均勻間隔值" for i in count(0,2): print(i) # count(start=0,step=1)、count()、count(9)、count(0,2)
itertools.cycle(iterable) "使迭代器返回迭代中的元素並保存每一個元素的副本" for i in cycle("ABCD"): print(i) # cycle("1234")、cycle("01")
itertools.repeat(object[, times]) "建立一個一遍又一遍地返回對象的迭代器、除非指定了times參數、不然無限期運行" for i in repeat("A",10): print(i) # repeat("A")、repeat("A",100)、repeat("hello world")


itertools.accumulate(iterable[, func]) 建立一個迭代器, 返回累積的總和 accumulate([1,2,3,4,5]) --> 1 3 6 10 15
itertools.chain(*iterables) "用於將連續序列做爲單一序列處理" chain('ABC', 'DEF') --> A B C D E F
itertools.chain.from_iterable(iterable) 替代構造函數[`chain()`]獲取來自懶惰計算的單個可迭代參數的鏈式輸 chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
itertools.compress(data, selectors) 建立一個迭代器，用於過濾數據中的元素，只返回那些在選擇器中具備相應元素且評估爲True的元素 compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
itertools.dropwhile(predicate, iterable) "只要條件成立、就刪除元素、一旦不成立就返回後面的全部數據" for i in dropwhile(lambda x: x<5,[1,4,,8,4,2,1]):
itertools.groupby(iterable, key=None) "建立一個從迭代中返回連續鍵和組的迭代器。關鍵是計算每一個元素的鍵值的函數" k=[k for k, g in groupby('AAAABBBCCDAABBB')]---[A B C D A B]、[list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D
itertools.filterfalse(predicate, iterable) 建立一個迭代器,用於過濾來自iterable的元素,只返回predicate=False時的元素False. filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8


python3 "dict默認是有序的"、即按添加順序排序的


collections — 容器類型 具備: 函數[ namedtuple ]、類[ ChainMap、Counter、OrderedDict、defaultdict、deque、UserDict、UserList、UserString]


dict 建立字典: [ dict(),dict(mapping), dict(iterable), dict(**kwargs)]
dict 方法："[ items(), keys(), values() ]"、"[update(), copy(), clear()]", [pop(k,d=None),popitem()]、"[ get(*args, **kwargs), setdefault(*args, **kwargs), fromkeys(*args, **kwargs) ]"
dict 方法: pop(self, k, d=None) 刪除指定的鍵並返回相應的值、若是指定了d的值、在未找到指定鍵時、返回該值
dict 方法: popitem() "移除字典最後一項、並返回移除項的(2-tuple)2元組表示 (key,value) "
dict 方法：[ __contains__、__delitem__、__getattribute__、__getitem__、__setitem__、__sizeof__、__repr__、__iter__、__len__、__init__、__new__、__lt__、__le__、__eq__、__ne__、__ge__、__gt__ ]


dict屬性：__hash__ = None


"OrderedDict": dict的子類、記住插入順序的字典、支持所有的dict方法、
OrderedDict([('a', 'A'), ('b', 'B'), ('c', 'C'), ('d', 'D')])
OrderedDict 特有的方法：popitem(last=True) 移除字典最後一項、"若是last=True，則以LIFO順序返回對，若是last=False，則以FIFO順序返回."
OrderedDict 特有的方法：move_to_end( key, last=True) "將現有元素移動到末尾(若是last爲false,則開頭)."


"defaultdict": dict的子類、調用工廠函數來提供缺失值、、


"Counter": dict的子類、用於計算可哈希對象的字典的子類、有時叫一個pag或multiset、元素存儲爲字典鍵及其計數存儲爲字典值.
c = Counter('abcdeabcdabcaba') 、c.most_common(3) 、sorted(c)、c.clear()
Counter方法：most_common(n=None), elements(), subtract([iterable-or-mapping]), fromkeys(iterable), update([iterable-or-mapping])


"ChainMap": 將多個 dict或map 組合在一塊兒建立單個可更新視圖、"底層映射存儲在列表中"、該list是公開的, 可使用maps屬性訪問或更新、查找會連續搜索基礎映射直到找到密鑰、"寫入\更新\刪除 僅在第一個上運行映射".
class ChainMap(_collections_abc.MutableMapping):
ChainMap 方法：[ pop()、popitem() ]、[ " new_child(m=None) " ]、[copy()、clear()、get(key, default=None)、fromkeys(cls, iterable, *args) ]
ChainMap 方法：[__setitem__、__delitem__、__getitem__、__len__、__iter__、__contains__、__bool__、__repr__、__init__、__missing__、]


ChainMap 屬性: " maps、parents "


"namedtuple": 是collections模塊的一個函數、用於建立命名元組子類的工廠函數、返回帶有命名字段的元組的新子類、
def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
"建立命名元組": request = namedtuple(typename="request", field_names="method url headers data")
"nametuple對象賦值": req = request('GET', 'http://www.baidu.com', 'None', '數據')
"nametuple按名稱獲取字段的屬性": print(req.method, req.url, req.headers, req.data) # GET http://www.baidu.com None 數據
"nametuple支持解包": method,url,headers,data = req
"nametuple轉換爲OrderedDict字典 _asdict()方法": print(req._asdict()) # OrderedDict([('method', 'GET'), ('url', 'http://www.baidu.com'), ('headers', 'None'), ('data', '數據')])
"nametuple修改命名字段的值 _replace()方法": print(req._replace(method='POST')) # request(method='POST', url='http://www.baidu.com', headers='None', data='數據')


"deque": 相似於list的容器, 兩端都有快速附加和彈出
"deque屬性": maxlen 雙端隊列的大小、若是爲None則無界
"deque方法": [ append(x)、appendleft(x)、extend(iterable)、extendleft(iterable) ]、"[ pop()、popleft()、remove(value)、reverse()、rotate(n=1) ]"、[ index(x)、insert(i, x)、clear()、copy()、count(x) ]


"UserDict": 包裝字典對象以便於字典子類化、"事實上是對內建字典類型的 Python 封裝"、可繼承的字典類、
"UserList": 包裝列表對象以便於列表子類化
"UserString": 包裝字符串對象以便於字符串子類化

"1.內存管理"
一對象的引用計數機制,二垃圾回收機制,三內存池機制

1、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，全部對象都有引用計數。
引用計數增長的狀況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減小的狀況：
1，使用del語句對對象別名顯示的銷燬
2，引用超出做用域或被從新賦值
sys.getrefcount( )函數能夠得到對象的當前引用計數
多數狀況下，引用計數比你猜想得要大得多。對於不可變數據（如數字和字符串），解釋器會在程序的不一樣部分共享內存，以便節約內存。
2、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句能夠減小a和b的引用計數，並銷燬用於引用底層對象的名稱。然而因爲每一個對象都包含一個對其餘對象的應用，所以引用計數不會歸零，對象也不會銷燬。（從而致使內存泄露）。爲解決這一問題，解釋器會按期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
3、內存池機制
Python提供了對內存的垃圾收集機制，可是它將不用的內存放到內存池而不是返回給操做系統。
1，Pymalloc機制。爲了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中全部小於256個字節的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說若是你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

 

協程、抽象基類、可哈希、`__slots__`、MRO、鴨子類型、、協程、coroutine、coroutine functionstruct sequence、結構序列context manager、上下文管理器垃圾回收、引用計數、可哈希、`__hash__()`、`__eq__()``__slots__`、經過預先聲明空間實例屬性和消除實例字典來節省內存、、MRO、方法解析順序、 method resolution order、鴨子類型、duck - typing、編程風格、`hasattr()`