"一等對象":
滿足條件：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.內存管理"
一對象的引用計數機制,二垃圾回收機制,三內存池機制
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變數據（如數字和字符串），解釋器會在程序的不同部分共享內存，以便節約內存。
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中所有小於256個字節的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
協程、抽象基類、可哈希、`__slots__`、MRO、鴨子類型、、
協程、coroutine、coroutine function
struct sequence、結構序列
context manager、上下文管理器
垃圾回收、引用計數、
可哈希、`__hash__()`、`__eq__()`
`__slots__`、通過預先聲明空間實例屬性和消除實例字典來節省內存、、
MRO、方法解析順序、 method resolution order、
鴨子類型、duck - typing、編程風格、`hasattr()`