簡(jiǎn)介

Python 是一種高層次的結(jié)合了解釋性、編譯性、互動(dòng)性和面向?qū)ο蟮哪_本語(yǔ)言。

Python 由 Guido van Rossum 于 1989 年底在荷蘭國(guó)家數(shù)學(xué)和計(jì)算機(jī)科學(xué)研究所發(fā)明，第一個(gè)公開(kāi)發(fā)行版發(fā)行于 1991 年。

特點(diǎn)

易于學(xué)習(xí)：Python 有相對(duì)較少的關(guān)鍵字，結(jié)構(gòu)簡(jiǎn)單，和一個(gè)明確定義的語(yǔ)法，學(xué)習(xí)起來(lái)更加簡(jiǎn)單。

易于閱讀：Python 代碼定義的更清晰。

易于維護(hù)：Python 的成功在于它的源代碼是相當(dāng)容易維護(hù)的。

一個(gè)廣泛的標(biāo)準(zhǔn)庫(kù)：Python 的最大的優(yōu)勢(shì)之一是豐富的庫(kù)，跨平臺(tái)的，在 UNIX，Windows 和 macOS 兼容很好。

互動(dòng)模式：互動(dòng)模式的支持，您可以從終端輸入執(zhí)行代碼并獲得結(jié)果的語(yǔ)言，互動(dòng)的測(cè)試和調(diào)試代碼片斷。

可移植：基于其開(kāi)放源代碼的特性，Python 已經(jīng)被移植（也就是使其工作）到許多平臺(tái)。

可擴(kuò)展：如果你需要一段運(yùn)行很快的關(guān)鍵代碼，或者是想要編寫(xiě)一些不愿開(kāi)放的算法，你可以使用 C 或 C++ 完成那部分程序，然后從你的 Python 程序中調(diào)用。

數(shù)據(jù)庫(kù)：Python 提供所有主要的商業(yè)數(shù)據(jù)庫(kù)的接口。

GUI 編程：Python 支持 GUI 可以創(chuàng)建和移植到許多系統(tǒng)調(diào)用。

可嵌入：你可以將 Python 嵌入到 C/C++ 程序，讓你的程序的用戶(hù)獲得”腳本化”的能力。

面向?qū)ο螅篜ython 是強(qiáng)面向?qū)ο蟮恼Z(yǔ)言，程序中任何內(nèi)容統(tǒng)稱(chēng)為對(duì)象，包括數(shù)字、字符串、函數(shù)等。

基礎(chǔ)語(yǔ)法

運(yùn)行 Python

交互式解釋器

在命令行窗口執(zhí)行python后，進(jìn)入 Python 的交互式解釋器。

exit()或Ctrl + D組合鍵退出交互式解釋器。

命令行腳本

在命令行窗口執(zhí)行python script-file.py，以執(zhí)行 Python 腳本文件。

指定解釋器

如果在 Python 腳本文件首行輸入#!/usr/bin/env python，那么可以在命令行窗口中執(zhí)行/path/to/script-file.py以執(zhí)行該腳本文件。

注：該方法不支持 Windows 環(huán)境。

編碼

默認(rèn)情況下，3.x 源碼文件都是 UTF-8 編碼，字符串都是 Unicode 字符。

也可以手動(dòng)指定文件編碼：

# -*- coding: utf-8 -*-

或者

# encoding: utf-8

注意: 該行標(biāo)注必須位于文件第一行。

標(biāo)識(shí)符

第一個(gè)字符必須是英文字母或下劃線_。

標(biāo)識(shí)符的其他的部分由字母、數(shù)字和下劃線組成。

標(biāo)識(shí)符對(duì)大小寫(xiě)敏感。

注：從 3.x 開(kāi)始，非 ASCII 標(biāo)識(shí)符也是允許的，但不建議。

保留字

保留字即關(guān)鍵字，我們不能把它們用作任何標(biāo)識(shí)符名稱(chēng)。

Python 的標(biāo)準(zhǔn)庫(kù)提供了一個(gè) keyword 模塊，可以輸出當(dāng)前版本的所有關(guān)鍵字：

>>> import keyword>>> keyword.kwlist['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注釋

單行注釋采用#，多行注釋采用'''或"""。

# 這是單行注釋'''這是多行注釋這是多行注釋'''"""這也是多行注釋這也是多行注釋"""

行與縮進(jìn)

Python 最具特色的就是使用縮進(jìn)來(lái)表示代碼塊，不需要使用大括號(hào){}。

縮進(jìn)的空格數(shù)是可變的，但是同一個(gè)代碼塊的語(yǔ)句必須包含相同的縮進(jìn)空格數(shù)，縮進(jìn)不一致，會(huì)導(dǎo)致運(yùn)行錯(cuò)誤。

多行語(yǔ)句

Python 通常是一行寫(xiě)完一條語(yǔ)句。

但如果語(yǔ)句很長(zhǎng)，我們可以使用反斜杠來(lái)實(shí)現(xiàn)多行語(yǔ)句。

total = item_one + item_two + item_three

在[],{}, 或()中的多行語(yǔ)句，不需要使用反斜杠。

空行

函數(shù)之間或類(lèi)的方法之間用空行分隔，表示一段新的代碼的開(kāi)始。

類(lèi)和函數(shù)入口之間也用一行空行分隔，以突出函數(shù)入口的開(kāi)始。

空行與代碼縮進(jìn)不同，空行并不是 Python 語(yǔ)法的一部分。

書(shū)寫(xiě)時(shí)不插入空行，Python 解釋器運(yùn)行也不會(huì)出錯(cuò)。

但是空行的作用在于分隔兩段不同功能或含義的代碼，便于日后代碼的維護(hù)或重構(gòu)。

記住：空行也是程序代碼的一部分。

等待用戶(hù)輸入

input函數(shù)可以實(shí)現(xiàn)等待并接收命令行中的用戶(hù)輸入。

content = input(" 請(qǐng)輸入點(diǎn)東西并按 Enter 鍵 ")print(content)

同一行寫(xiě)多條語(yǔ)句

Python 可以在同一行中使用多條語(yǔ)句，語(yǔ)句之間使用分號(hào);分割。

import sys; x = 'hello world'; sys.stdout.write(x + ' ')

多個(gè)語(yǔ)句構(gòu)成代碼組

縮進(jìn)相同的一組語(yǔ)句構(gòu)成一個(gè)代碼塊，我們稱(chēng)之代碼組。

像if、while、def和class這樣的復(fù)合語(yǔ)句，首行以關(guān)鍵字開(kāi)始，以冒號(hào):結(jié)束，該行之后的一行或多行代碼構(gòu)成代碼組。

我們將首行及后面的代碼組稱(chēng)為一個(gè)子句(clause)。

print 輸出

print 默認(rèn)輸出是換行的，如果要實(shí)現(xiàn)不換行需要在變量末尾加上end=""或別的非換行符字符串：

print('123') # 默認(rèn)換行print('123', end = "") # 不換行

import 與 from…import

在 Python 用import或者from...import來(lái)導(dǎo)入相應(yīng)的模塊。

將整個(gè)模塊導(dǎo)入，格式為：import module_name

從某個(gè)模塊中導(dǎo)入某個(gè)函數(shù),格式為：from module_name import func1

從某個(gè)模塊中導(dǎo)入多個(gè)函數(shù),格式為：from module_name import func1, func2, func3

將某個(gè)模塊中的全部函數(shù)導(dǎo)入，格式為：from module_name import *

運(yùn)算符

算術(shù)運(yùn)算符

運(yùn)算符	描述
+	加
-	減
*	乘
/	除
%	取模
**	冪
//	取整除

比較運(yùn)算符

運(yùn)算符	描述
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

賦值運(yùn)算符

運(yùn)算符	描述
=	簡(jiǎn)單的賦值運(yùn)算符
+=	加法賦值運(yùn)算符
-=	減法賦值運(yùn)算符
*=	乘法賦值運(yùn)算符
/=	除法賦值運(yùn)算符
%=	取模賦值運(yùn)算符
**=	冪賦值運(yùn)算符
//=	取整除賦值運(yùn)算符

位運(yùn)算符

邏輯運(yùn)算符

成員運(yùn)算符

身份運(yùn)算符

運(yùn)算符優(yōu)先級(jí)

具有相同優(yōu)先級(jí)的運(yùn)算符將從左至右的方式依次進(jìn)行，用小括號(hào)()可以改變運(yùn)算順序。

變量

變量在使用前必須先”定義”（即賦予變量一個(gè)值），否則會(huì)報(bào)錯(cuò)：

>>> nameTraceback (most recent call last): File "", line 1, in NameError: name 'name' is not defined

數(shù)據(jù)類(lèi)型

布爾(bool)

只有True和False兩個(gè)值，表示真或假。

數(shù)字(number)

整型(int)

整數(shù)值，可正數(shù)亦可復(fù)數(shù)，無(wú)小數(shù)。

3.x 整型是沒(méi)有限制大小的，可以當(dāng)作 Long 類(lèi)型使用，所以 3.x 沒(méi)有 2.x 的 Long 類(lèi)型。

浮點(diǎn)型(float)

浮點(diǎn)型由整數(shù)部分與小數(shù)部分組成。

浮點(diǎn)型也可以使用科學(xué)計(jì)數(shù)法表示（2.5e2 = 2.5 x 10^2 = 250）

復(fù)數(shù)(complex)

復(fù)數(shù)由實(shí)數(shù)部分和虛數(shù)部分構(gòu)成，可以用a + bj，或者complex(a,b)表示。

復(fù)數(shù)的實(shí)部 a 和虛部 b 都是浮點(diǎn)型。

數(shù)字運(yùn)算

不同類(lèi)型的數(shù)字混合運(yùn)算時(shí)會(huì)將整數(shù)轉(zhuǎn)換為浮點(diǎn)數(shù)

在不同的機(jī)器上浮點(diǎn)運(yùn)算的結(jié)果可能會(huì)不一樣

在整數(shù)除法中，除法/總是返回一個(gè)浮點(diǎn)數(shù)。

如果只想得到整數(shù)的結(jié)果，丟棄可能的分?jǐn)?shù)部分，可以使用運(yùn)算符//。

//得到的并不一定是整數(shù)類(lèi)型的數(shù)，它與分母分子的數(shù)據(jù)類(lèi)型有關(guān)系。

在交互模式中，最后被輸出的表達(dá)式結(jié)果被賦值給變量_，_是個(gè)只讀變量

數(shù)學(xué)函數(shù)

注：以下函數(shù)的使用，需先導(dǎo)入 math 包。

隨機(jī)數(shù)函數(shù)

注：以下函數(shù)的使用，需先導(dǎo)入 random 包。

三角函數(shù)

注：以下函數(shù)的使用，需先導(dǎo)入 math包。

數(shù)學(xué)常量

字符串(string)

單引號(hào)和雙引號(hào)使用完全相同。

使用三引號(hào)('''或""")可以指定一個(gè)多行字符串。

轉(zhuǎn)義符(反斜杠)可以用來(lái)轉(zhuǎn)義，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義。

如r"this is a line with "，則 會(huì)顯示，并不是換行。

按字面意義級(jí)聯(lián)字符串。

如"this " "is " "string"會(huì)被自動(dòng)轉(zhuǎn)換為this is string。

字符串可以用+運(yùn)算符連接在一起，用*運(yùn)算符重復(fù)。

字符串有兩種索引方式，從左往右以 0 開(kāi)始，從右往左以 -1 開(kāi)始。

字符串不能改變。

沒(méi)有單獨(dú)的字符類(lèi)型，一個(gè)字符就是長(zhǎng)度為 1 的字符串。

字符串的截取的語(yǔ)法格式如下：變量[頭下標(biāo):尾下標(biāo)]。

轉(zhuǎn)義字符

字符串運(yùn)算符

字符串格式化

在 Python 中，字符串格式化不是 sprintf 函數(shù)，而是用%符號(hào)。

例如：

print("我叫%s， 今年 %d 歲！" % ('小明', 10))// 輸出:我叫小明， 今年 10 歲！

格式化符號(hào):

輔助指令:

Python 2.6 開(kāi)始，新增了一種格式化字符串的函數(shù)str.format()，它增強(qiáng)了字符串格式化的功能。

多行字符串

用三引號(hào)('''或""")包裹字符串內(nèi)容

多行字符串內(nèi)容支持轉(zhuǎn)義符，用法與單雙引號(hào)一樣

三引號(hào)包裹的內(nèi)容，有變量接收或操作即字符串，否則就是多行注釋

實(shí)例：

string = '''print( math.fabs(-10))print( random.choice(li))'''print(string)

輸出：

print( math.fabs(-10))print(random.choice(li))

Unicode

在 2.x 中，普通字符串是以 8 位 ASCII 碼進(jìn)行存儲(chǔ)的。

而 Unicode 字符串則存儲(chǔ)為 16 位 Unicode 字符串，這樣能夠表示更多的字符集。

使用的語(yǔ)法是在字符串前面加上前綴u。

在 3.x 中，所有的字符串都是 Unicode 字符串。

字符串函數(shù)

字節(jié)(bytes)

在 3.x 中，字符串和二進(jìn)制數(shù)據(jù)完全區(qū)分開(kāi)。

文本總是 Unicode，由 str 類(lèi)型表示，二進(jìn)制數(shù)據(jù)則由 bytes 類(lèi)型表示。

Python 3 不會(huì)以任意隱式的方式混用 str 和 bytes，你不能拼接字符串和字節(jié)流，也無(wú)法在字節(jié)流里搜索字符串（反之亦然），也不能將字符串傳入參數(shù)為字節(jié)流的函數(shù)（反之亦然）。

bytes 類(lèi)型與 str 類(lèi)型，二者的方法僅有 encode() 和 decode() 不同。

bytes 類(lèi)型數(shù)據(jù)需在常規(guī)的 str 類(lèi)型前加個(gè)b以示區(qū)分，例如b'abc'。

只有在需要將 str 編碼(encode)成 bytes 的時(shí)候。

比如：通過(guò)網(wǎng)絡(luò)傳輸數(shù)據(jù)；或者需要將 bytes 解碼(decode)成 str 的時(shí)候， 我們才會(huì)關(guān)注 str 和 bytes 的區(qū)別。

bytes 轉(zhuǎn) str：

b'abc'.decode()str(b'abc')str(b'abc', encoding='utf-8')

str 轉(zhuǎn) bytes：

'中國(guó)'.encode()bytes('中國(guó)', encoding='utf-8')

列表(list)

列表是一種無(wú)序的、可重復(fù)的數(shù)據(jù)序列，可以隨時(shí)添加、刪除其中的元素。

列表頁(yè)的每個(gè)元素都分配一個(gè)數(shù)字索引，從 0 開(kāi)始。

列表使用方括號(hào)創(chuàng)建，使用逗號(hào)分隔元素。

列表元素值可以是任意類(lèi)型，包括變量。

使用方括號(hào)對(duì)列表進(jìn)行元素訪問(wèn)、切片、修改、刪除等操作，開(kāi)閉合區(qū)間為[)形式。

列表的元素訪問(wèn)可以嵌套。

方括號(hào)內(nèi)可以是任意表達(dá)式。

創(chuàng)建列表

hello = (1, 2, 3)li = [1, "2", [3, 'a'], (1, 3), hello]

訪問(wèn)元素

li = [1, "2", [3, 'a'], (1, 3)]print(li[3]) # (1, 3)print(li[-2]) # [3, 'a']

切片訪問(wèn)

格式:list_name[begin:end:step]begin 表示起始位置(默認(rèn)為0)，end 表示結(jié)束位置(默認(rèn)為最后一個(gè)元素)，step 表示步長(zhǎng)(默認(rèn)為1)。

hello = (1, 2, 3)li = [1, "2", [3, 'a'], (1, 3), hello]print(li) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]print(li[1:2]) # ['2']print(li[:2]) # [1, '2']print(li[:]) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]print(li[2:]) # [[3, 'a'], (1, 3), (1, 2, 3)]print(li[1:-1:2]) # ['2', (1, 3)]

訪問(wèn)內(nèi)嵌 list 的元素：

li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ['a', 'b', 'c']]print(li[1:-1:2][1:3]) # (3, 5)print(li[-1][1:3]) # ['b', 'c']print(li[-1][1]) # b

修改列表

通過(guò)使用方括號(hào)，可以非常靈活的對(duì)列表的元素進(jìn)行修改、替換、刪除等操作。

li = [0, 1, 2, 3, 4, 5]li[len(li) - 2] = 22 # 修改 [0, 1, 2, 22, 4, 5]li[3] = 33 # 修改 [0, 1, 2, 33, 4, 5]li[1:-1] = [9, 9] # 替換 [0, 9, 9, 5]li[1:-1] = [] # 刪除 [0, 5]

刪除元素

可以用 del 語(yǔ)句來(lái)刪除列表的指定范圍的元素。

li = [0, 1, 2, 3, 4, 5]del li[3] # [0, 1, 2, 4, 5]del li[2:-1] # [0, 1, 5]

列表操作符

+用于合并列表。

*用于重復(fù)列表元素。

in用于判斷元素是否存在于列表中。

for ... in ...用于遍歷列表元素。

[1, 2, 3] + [3, 4, 5] # [1, 2, 3, 3, 4, 5][1, 2, 3] * 2 # [1, 2, 3, 1, 2, 3]3 in [1, 2, 3] # Truefor x in [1, 2, 3]: print(x) # 1 2 3

列表函數(shù)

len(list)列表元素個(gè)數(shù)

max(list)列表元素中的最大值

min(list)列表元素中的最小值

list(seq)將元組轉(zhuǎn)換為列表

li = [0, 1, 5]max(li) # 5len(li) # 3

注:對(duì)列表使用 max/min 函數(shù)，2.x 中對(duì)元素值類(lèi)型無(wú)要求，3.x 則要求元素值類(lèi)型必須一致。

列表方法

list.append(obj)

在列表末尾添加新的對(duì)象

list.count(obj)

返回元素在列表中出現(xiàn)的次數(shù)

list.extend(seq)

在列表末尾一次性追加另一個(gè)序列中的多個(gè)值

list.index(obj)

返回查找對(duì)象的索引位置，如果沒(méi)有找到對(duì)象則拋出異常

list.insert(index, obj)

將指定對(duì)象插入列表的指定位置

list.pop([index=-1]])

移除列表中的一個(gè)元素（默認(rèn)最后一個(gè)元素），并且返回該元素的值

list.remove(obj)

移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)

list.reverse()

反向排序列表的元素

list.sort(cmp=None, key=None, reverse=False)

對(duì)原列表進(jìn)行排序，如果指定參數(shù)，則使用比較函數(shù)指定的比較函數(shù)

list.clear()

清空列表 還可以使用del list[:]、li = []等方式實(shí)現(xiàn)

list.copy()

復(fù)制列表 默認(rèn)使用等號(hào)賦值給另一個(gè)變量，實(shí)際上是引用列表變量。如果要實(shí)現(xiàn)

列表推導(dǎo)式

列表推導(dǎo)式提供了從序列創(chuàng)建列表的簡(jiǎn)單途徑。

通常應(yīng)用程序?qū)⒁恍┎僮鲬?yīng)用于某個(gè)序列的每個(gè)元素，用其獲得的結(jié)果作為生成新列表的元素，或者根據(jù)確定的判定條件創(chuàng)建子序列。

每個(gè)列表推導(dǎo)式都在 for 之后跟一個(gè)表達(dá)式，然后有零到多個(gè) for 或 if 子句。

返回結(jié)果是一個(gè)根據(jù)表達(dá)從其后的 for 和 if 上下文環(huán)境中生成出來(lái)的列表。

如果希望表達(dá)式推導(dǎo)出一個(gè)元組，就必須使用括號(hào)。

將列表中每個(gè)數(shù)值乘三，獲得一個(gè)新的列表：

vec = [2, 4, 6][(x, x**2) for x in vec]# [(2, 4), (4, 16), (6, 36)]

對(duì)序列里每一個(gè)元素逐個(gè)調(diào)用某方法：

freshfruit = [' banana', ' loganberry ', 'passion fruit '][weapon.strip() for weapon in freshfruit]# ['banana', 'loganberry', 'passion fruit']

用 if 子句作為過(guò)濾器：

vec = [2, 4, 6][3*x for x in vec if x > 3]# [12, 18]vec1 = [2, 4, 6]vec2 = [4, 3, -9][x*y for x in vec1 for y in vec2]# [8, 6, -18, 16, 12, -36, 24, 18, -54][vec1[i]*vec2[i] for i in range(len(vec1))]# [8, 12, -54]

列表嵌套解析：

matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9],]new_matrix = [[row[i] for row in matrix] for i in range(len(matrix[0]))]print(new_matrix)# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

元組(tuple)

元組與列表類(lèi)似，不同之處在于元組的元素不能修改

元組使用小括號(hào)，列表使用方括號(hào)

元組創(chuàng)建很簡(jiǎn)單，只需要在括號(hào)中添加元素，并使用逗號(hào)隔開(kāi)即可

沒(méi)有 append()，insert() 這樣進(jìn)行修改的方法，其他方法都與列表一樣

字典中的鍵必須是唯一的同時(shí)不可變的，值則沒(méi)有限制

元組中只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào)，否則括號(hào)會(huì)被當(dāng)作運(yùn)算符使用

訪問(wèn)元組

訪問(wèn)元組的方式與列表是一致的。

元組的元素可以直接賦值給多個(gè)變量，但變量數(shù)必須與元素?cái)?shù)量一致。

a, b, c = (1, 2, 3)print(a, b, c)

組合元組

元組中的元素值是不允許修改的，但我們可以對(duì)元組進(jìn)行連接組合。

tup1 = (12, 34.56);tup2 = ('abc', 'xyz')tup3 = tup1 + tup2;print (tup3)# (12, 34.56, 'abc', 'xyz')

刪除元組

元組中的元素值是不允許刪除的，但我們可以使用 del 語(yǔ)句來(lái)刪除整個(gè)元組

元組函數(shù)

len(tuple)元組元素個(gè)數(shù)

max(tuple)元組元素中的最大值

min(tuple)元組元素中的最小值

tuple(tuple)將列表轉(zhuǎn)換為元組

元組推導(dǎo)式

t = 1, 2, 3print(t)# (1, 2, 3)u = t, (3, 4, 5)print(u)# ((1, 2, 3), (3, 4, 5))

字典(dict)

字典是另一種可變?nèi)萜髂Ｐ停纱鎯?chǔ)任意類(lèi)型對(duì)象

字典的每個(gè)鍵值(key=>value)對(duì)用冒號(hào)(:)分割，每個(gè)對(duì)之間用逗號(hào)(,)分割，整個(gè)字典包括在花括號(hào)({})中

鍵必須是唯一的，但值則不必

值可以是任意數(shù)據(jù)類(lèi)型

鍵必須是不可變的，例如：數(shù)字、字符串、元組可以，但列表就不行

如果用字典里沒(méi)有的鍵訪問(wèn)數(shù)據(jù)，會(huì)報(bào)錯(cuò)

字典的元素沒(méi)有順序，不能通過(guò)下標(biāo)引用元素，通過(guò)鍵來(lái)引用

字典內(nèi)部存放的順序和 key 放入的順序是沒(méi)有關(guān)系的

格式如下:

d = {key1 : value1, key2 : value2 }

訪問(wèn)字典

dis = {'a': 1, 'b': [1, 2, 3]}print(dis['b'][2])

修改字典

dis = {'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}dis[9]['name'] = 999print(dis)# {'a': 1, 9: {'name': 999}, 'b': [1, 2, 3]}

刪除字典

用 del 語(yǔ)句刪除字典或字典的元素。

dis = {'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}del dis[9]['name']print(dis)del dis # 刪除字典# {'a': 1, 9: {}, 'b': [1, 2, 3]}

字典函數(shù)

len(dict)計(jì)算字典元素個(gè)數(shù)，即鍵的總數(shù)

str(dict)輸出字典，以可打印的字符串表示

type(variable)返回輸入的變量類(lèi)型，如果變量是字典就返回字典類(lèi)型

key in dict判斷鍵是否存在于字典中

字典方法

dict.clear()

刪除字典內(nèi)所有元素

dict.copy()

返回一個(gè)字典的淺復(fù)制

dict.fromkeys(seq[, value])

創(chuàng)建一個(gè)新字典，以序列 seq 中元素做字典的鍵，value 為字典所有鍵對(duì)應(yīng)的初始值

dict.get(key, default=None)

返回指定鍵的值，如果值不在字典中返回默認(rèn)值

dict.items()

以列表形式返回可遍歷的(鍵, 值)元組數(shù)組

dict.keys()

以列表返回一個(gè)字典所有的鍵

dict.values()

以列表返回字典中的所有值

dict.setdefault(key, default=None)

如果 key 在字典中，返回對(duì)應(yīng)的值。

如果不在字典中，則插入 key 及設(shè)置的默認(rèn)值 default，并返回 default ，default 默認(rèn)值為 None。

dict.update(dict2)

把字典參數(shù) dict2 的鍵/值對(duì)更新到字典 dict 里

dic1 = {'a': 'a'}dic2 = {9: 9, 'a': 'b'}dic1.update(dic2)print(dic1)# {'a': 'b', 9: 9}

dict.pop(key[,default])

刪除字典給定鍵 key 所對(duì)應(yīng)的值，返回值為被刪除的值。key 值必須給出，否則返回 default 值。

dict.popitem()

隨機(jī)返回并刪除字典中的一對(duì)鍵和值(一般刪除末尾對(duì))

字典推導(dǎo)式

構(gòu)造函數(shù) dict() 直接從鍵值對(duì)元組列表中構(gòu)建字典。如果有固定的模式，列表推導(dǎo)式指定特定的鍵值對(duì)：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推導(dǎo)可以用來(lái)創(chuàng)建任意鍵和值的表達(dá)式詞典：

>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}

如果關(guān)鍵字只是簡(jiǎn)單的字符串，使用關(guān)鍵字參數(shù)指定鍵值對(duì)有時(shí)候更方便：

>>> dict(sape=4139, guido=4127, jack=4098){'sape': 4139, 'jack': 4098, 'guido': 4127}

集合(set)

集合是一個(gè)無(wú)序不重復(fù)元素的序列

創(chuàng)建集合

可以使用大括號(hào){}或者set()函數(shù)創(chuàng)建集合

創(chuàng)建一個(gè)空集合必須用set()而不是{}，因?yàn)閧}是用來(lái)創(chuàng)建一個(gè)空字典

set(value)方式創(chuàng)建集合，value 可以是字符串、列表、元組、字典等序列類(lèi)型

創(chuàng)建、添加、修改等操作，集合會(huì)自動(dòng)去重

{1, 2, 1, 3} # {} {1, 2, 3}set('12345') # 字符串 {'3', '5', '4', '2', '1'}set([1, 'a', 23.4]) # 列表 {1, 'a', 23.4}set((1, 'a', 23.4)) # 元組 {1, 'a', 23.4}set({1:1, 'b': 9}) # 字典 {1, 'b'}

添加元素

將元素 val 添加到集合 set 中，如果元素已存在，則不進(jìn)行任何操作：

set.add(val)

也可以用 update 方法批量添加元素，參數(shù)可以是列表，元組，字典等：

set.update(list1, list2,...)

移除元素

如果存在元素 val 則移除，不存在就報(bào)錯(cuò)：

set.remove(val)

如果存在元素 val 則移除，不存在也不會(huì)報(bào)錯(cuò)：

set.discard(val)

隨機(jī)移除一個(gè)元素：

set.pop()

元素個(gè)數(shù)

與其他序列一樣，可以用len(set)獲取集合的元素個(gè)數(shù)。

清空集合

set.clear()set = set()

判斷元素是否存在

val in set

其他方法

set.copy()

復(fù)制集合

set.difference(set2)

求差集，在 set 中卻不在 set2 中

set.intersection(set2)

求交集，同時(shí)存在于 set 和 set2 中

set.union(set2)

求并集，所有 set 和 set2 的元素

set.symmetric_difference(set2)

求對(duì)稱(chēng)差集，不同時(shí)出現(xiàn)在兩個(gè)集合中的元素

set.isdisjoint(set2)

如果兩個(gè)集合沒(méi)有相同的元素，返回 True

set.issubset(set2)

如果 set 是 set2 的一個(gè)子集，返回 True

set.issuperset(set2)

如果 set 是 set2 的一個(gè)超集，返回 True

集合計(jì)算

a = set('abracadabra')b = set('alacazam')print(a) # a 中唯一的字母# {'a', 'r', 'b', 'c', 'd'}print(a - b) # 在 a 中的字母，但不在 b 中# {'r', 'd', 'b'}print(a | b) # 在 a 或 b 中的字母# {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}print(a & b) # 在 a 和 b 中都有的字母# {'a', 'c'}print(a ^ b) # 在 a 或 b 中的字母，但不同時(shí)在 a 和 b 中# {'r', 'd', 'b', 'm', 'z', 'l'}

集合推導(dǎo)式

a = {x for x in 'abracadabra' if x not in 'abc'}print(a)# {'d', 'r'}

流程控制

if 控制

if 表達(dá)式1: 語(yǔ)句 if 表達(dá)式2: 語(yǔ)句 elif 表達(dá)式3: 語(yǔ)句 else: 語(yǔ)句elif 表達(dá)式4: 語(yǔ)句else: 語(yǔ)句

1、每個(gè)條件后面要使用冒號(hào):，表示接下來(lái)是滿(mǎn)足條件后要執(zhí)行的語(yǔ)句塊。

2、使用縮進(jìn)來(lái)劃分語(yǔ)句塊，相同縮進(jìn)數(shù)的語(yǔ)句在一起組成一個(gè)語(yǔ)句塊。

3、在 Python 中沒(méi)有 switch - case 語(yǔ)句。

三元運(yùn)算符：

<表達(dá)式1> if <條件> else <表達(dá)式2>

編寫(xiě)條件語(yǔ)句時(shí)，應(yīng)該盡量避免使用嵌套語(yǔ)句。

嵌套語(yǔ)句不便于閱讀，而且可能會(huì)忽略一些可能性。

for 遍歷

for <循環(huán)變量> in <循環(huán)對(duì)象>： <語(yǔ)句1>else: <語(yǔ)句2>

else 語(yǔ)句中的語(yǔ)句2只有循環(huán)正常退出（遍歷完所有遍歷對(duì)象中的值）時(shí)執(zhí)行。

在字典中遍歷時(shí)，關(guān)鍵字和對(duì)應(yīng)的值可以使用items()方法同時(shí)解讀出來(lái)：

knights = {'gallahad': 'the pure', 'robin': 'the brave'}for k, v in knights.items(): print(k, v)

在序列中遍歷時(shí)，索引位置和對(duì)應(yīng)值可以使用enumerate()函數(shù)同時(shí)得到：

for i, v in enumerate(['tic', 'tac', 'toe']): print(i, v)

同時(shí)遍歷兩個(gè)或更多的序列，可以使用zip()組合：

questions = ['name', 'quest', 'favorite color']answers = ['lancelot', 'the holy grail', 'blue']for q, a in zip(questions, answers): print('What is your {0}? It is {1}.'.format(q, a))

要反向遍歷一個(gè)序列，首先指定這個(gè)序列，然后調(diào)用reversed()函數(shù)：

for i in reversed(range(1, 10, 2)): print(i)

要按順序遍歷一個(gè)序列，使用sorted()函數(shù)返回一個(gè)已排序的序列，并不修改原值：

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']for f in sorted(set(basket)): print(f)

while 循環(huán)

while<條件>： <語(yǔ)句1>else： <語(yǔ)句2>

break、continue、pass

break 語(yǔ)句用在 while 和 for 循環(huán)中，break 語(yǔ)句用來(lái)終止循環(huán)語(yǔ)句。

即循環(huán)條件沒(méi)有 False 條件或者序列還沒(méi)被完全遞歸完，也會(huì)停止執(zhí)行循環(huán)語(yǔ)句。

continue 語(yǔ)句用在 while 和 for 循環(huán)中，continue 語(yǔ)句用來(lái)告訴 Python 跳過(guò)當(dāng)前循環(huán)的剩余語(yǔ)句，然后繼續(xù)進(jìn)行下一輪循環(huán)。

continue 語(yǔ)句跳出本次循環(huán)，而 break 跳出整個(gè)循環(huán)。

pass 是空語(yǔ)句，是為了保持程序結(jié)構(gòu)的完整性。

pass 不做任何事情，一般用做占位語(yǔ)句。

迭代器

迭代器是一個(gè)可以記住遍歷的位置的對(duì)象。

迭代器對(duì)象從集合的第一個(gè)元素開(kāi)始訪問(wèn)，直到所有的元素被訪問(wèn)完結(jié)束。

迭代器只能往前不會(huì)后退。

迭代器有兩個(gè)基本的方法：iter()和next()。

字符串，列表或元組對(duì)象都可用于創(chuàng)建迭代器。

迭代器可以被 for 循環(huán)進(jìn)行遍歷：

li = [1, 2, 3]it = iter(li)for val in it: print(val)

迭代器也可以用 next() 函數(shù)訪問(wèn)下一個(gè)元素值：

import sysli = [1,2,3,4]it = iter(li)while True: try: print (next(it)) except StopIteration: sys.exit()

生成器

在 Python 中，使用了 yield 的函數(shù)被稱(chēng)為生成器（generator）。

跟普通函數(shù)不同的是，生成器是一個(gè)返回迭代器的函數(shù)，只能用于迭代操作。

更簡(jiǎn)單點(diǎn)理解生成器就是一個(gè)迭代器。

在調(diào)用生成器運(yùn)行的過(guò)程中，每次遇到 yield 時(shí)函數(shù)會(huì)暫停并保存當(dāng)前所有的運(yùn)行信息，返回 yield 的值,并在下一次執(zhí)行 next() 方法時(shí)從當(dāng)前位置繼續(xù)運(yùn)行。

調(diào)用一個(gè)生成器函數(shù)，返回的是一個(gè)迭代器對(duì)象。

import sysdef fibonacci(n): # 生成器函數(shù) - 斐波那契 a, b, counter = 0, 1, 0 while True: if (counter > n): return yield a a, b = b, a + b counter += 1f = fibonacci(10) # f 是一個(gè)迭代器，由生成器返回生成while True: try: print(next(f)) except StopIteration: sys.exit()

函數(shù)

自定義函數(shù)

函數(shù)（Functions）是指可重復(fù)使用的程序片段。

它們?cè)试S你為某個(gè)代碼塊賦予名字，允許你通過(guò)這一特殊的名字在你的程序任何地方來(lái)運(yùn)行代碼塊，并可重復(fù)任何次數(shù)。

這就是所謂的調(diào)用（Calling）函數(shù)。

函數(shù)代碼塊以def關(guān)鍵詞開(kāi)頭，后接函數(shù)標(biāo)識(shí)符名稱(chēng)和圓括號(hào)()。

任何傳入?yún)?shù)和自變量必須放在圓括號(hào)中間，圓括號(hào)之間可以用于定義參數(shù)。

函數(shù)的第一行語(yǔ)句可以選擇性地使用文檔字符串—用于存放函數(shù)說(shuō)明。

函數(shù)內(nèi)容以冒號(hào)起始，并且縮進(jìn)。

return [表達(dá)式]結(jié)束函數(shù)，選擇性地返回一個(gè)值給調(diào)用方。

不帶表達(dá)式的 return 相當(dāng)于返回 None。

return可以返回多個(gè)值，此時(shí)返回的數(shù)據(jù)未元組類(lèi)型。

定義參數(shù)時(shí)，帶默認(rèn)值的參數(shù)必須在無(wú)默認(rèn)值參數(shù)的后面。

def 函數(shù)名（參數(shù)列表）: 函數(shù)體

參數(shù)傳遞

在 Python 中，類(lèi)型屬于對(duì)象，變量是沒(méi)有類(lèi)型的：

a = [1,2,3]a = "Runoob"

以上代碼中，[1,2,3] 是 List 類(lèi)型，”Runoob” 是 String 類(lèi)型。

而變量 a 是沒(méi)有類(lèi)型，她僅僅是一個(gè)對(duì)象的引用（一個(gè)指針），可以是指向 List 類(lèi)型對(duì)象，也可以是指向 String 類(lèi)型對(duì)象。

可更改與不可更改對(duì)象

在 Python 中，字符串，數(shù)字和元組是不可更改的對(duì)象。

而列表、字典等則是可以修改的對(duì)象。

不可變類(lèi)型：變量賦值 a=5 后再賦值 a=10，這里實(shí)際是新生成一個(gè) int 值對(duì)象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當(dāng)于新生成了a。

可變類(lèi)型：變量賦值 la=[1,2,3,4] 后再賦值 la[2]=5 ，則是將 list la 的第三個(gè)元素值更改，本身la沒(méi)有動(dòng)，只是其內(nèi)部的一部分值被修改了。

Python 函數(shù)的參數(shù)傳遞：

不可變類(lèi)型：類(lèi)似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒(méi)有影響a對(duì)象本身。

比如在 fun（a）內(nèi)部修改 a 的值，只是修改另一個(gè)復(fù)制的對(duì)象，不會(huì)影響 a 本身。

可變類(lèi)型：類(lèi)似 c++ 的引用傳遞，如 列表，字典。

如 fun（la），則是將 la 真正的傳過(guò)去，修改后fun外部的la也會(huì)受影響

Python 中一切都是對(duì)象，嚴(yán)格意義我們不能說(shuō)值傳遞還是引用傳遞，我們應(yīng)該說(shuō)傳不可變對(duì)象和傳可變對(duì)象。

參數(shù)

必需參數(shù)

必需參數(shù)須以正確的順序傳入函數(shù)。

調(diào)用時(shí)的數(shù)量必須和聲明時(shí)的一樣。

關(guān)鍵字參數(shù)

關(guān)鍵字參數(shù)和函數(shù)調(diào)用關(guān)系緊密，函數(shù)調(diào)用使用關(guān)鍵字參數(shù)來(lái)確定傳入的參數(shù)值。

使用關(guān)鍵字參數(shù)允許函數(shù)調(diào)用時(shí)參數(shù)的順序與聲明時(shí)不一致，因?yàn)?Python 解釋器能夠用參數(shù)名匹配參數(shù)值。

def print_info(name, age): "打印任何傳入的字符串" print("名字: ", name) print("年齡: ", age) returnprint_info(age=50, name="john")

默認(rèn)參數(shù)

調(diào)用函數(shù)時(shí)，如果沒(méi)有傳遞參數(shù)，則會(huì)使用默認(rèn)參數(shù)。

def print_info(name, age=35): print ("名字: ", name) print ("年齡: ", age) returnprint_info(age=50, name="john")print("------------------------")print_info(name="john")

不定長(zhǎng)參數(shù)

加了星號(hào)*的參數(shù)會(huì)以元組的形式導(dǎo)入，存放所有未命名的變量參數(shù)。

如果在函數(shù)調(diào)用時(shí)沒(méi)有指定參數(shù)，它就是一個(gè)空元組。

我們也可以不向函數(shù)傳遞未命名的變量。

def print_info(arg1, *vartuple): print("輸出: ") print(arg1) for var in vartuple: print (var) returnprint_info(10)print_info(70, 60, 50)

加了兩個(gè)星號(hào)**的參數(shù)會(huì)以字典的形式導(dǎo)入，變量名為鍵，變量值為字典元素值。

def print_info(arg1, **vardict): print("輸出: ") print(arg1) print(vardict)print_info(1, a=2, b=3)

匿名函數(shù)

Python 使用 lambda 來(lái)創(chuàng)建匿名函數(shù)。

所謂匿名，意即不再使用def語(yǔ)句這樣標(biāo)準(zhǔn)的形式定義一個(gè)函數(shù)。

lambda 只是一個(gè)表達(dá)式，函數(shù)體比 def 簡(jiǎn)單很多。

lambda 的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊。

僅僅能在 lambda 表達(dá)式中封裝有限的邏輯進(jìn)去。

lambda 函數(shù)擁有自己的命名空間，且不能訪問(wèn)自己參數(shù)列表之外或全局命名空間里的參數(shù)。

雖然 lambda 函數(shù)看起來(lái)只能寫(xiě)一行，卻不等同于 C 或 C++ 的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時(shí)不占用棧內(nèi)存從而增加運(yùn)行效率。

# 語(yǔ)法格式lambda [arg1 [,arg2,.....argn]]:expression

變量作用域

L （Local） 局部作用域

E （Enclosing） 閉包函數(shù)外的函數(shù)中

G （Global） 全局作用域

B （Built-in） 內(nèi)建作用域

以 L –> E –> G –> B 的規(guī)則查找，即：在局部找不到，便會(huì)去局部外的局部找（例如閉包），再找不到就會(huì)去全局找，再者去內(nèi)建中找。

Python 中只有模塊（module），類(lèi)（class）以及函數(shù)（def、lambda）才會(huì)引入新的作用域，其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會(huì)引入新的作用域的。

也就是說(shuō)這些語(yǔ)句內(nèi)定義的變量，外部也可以訪問(wèn)。

定義在函數(shù)內(nèi)部的變量擁有一個(gè)局部作用域，定義在函數(shù)外的擁有全局作用域。

局部變量只能在其被聲明的函數(shù)內(nèi)部訪問(wèn)，而全局變量可以在整個(gè)程序范圍內(nèi)訪問(wèn)。

調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱(chēng)都將被加入到作用域中。

當(dāng)內(nèi)部作用域想修改外部作用域的變量時(shí)，就要用到global和nonlocal關(guān)鍵字。

num = 1def fun1(): global num # 需要使用 global 關(guān)鍵字聲明 print(num) num = 123 print(num)fun1()

如果要修改嵌套作用域（enclosing 作用域，外層非全局作用域）中的變量則需要 nonlocal 關(guān)鍵字。

def outer(): num = 10 def inner(): nonlocal num # nonlocal關(guān)鍵字聲明 num = 100 print(num) inner() print(num)outer()

模塊

編寫(xiě)模塊有很多種方法。

其中最簡(jiǎn)單的一種便是創(chuàng)建一個(gè)包含函數(shù)與變量、以 .py 為后綴的文件。

另一種方法是使用撰寫(xiě) Python 解釋器本身的本地語(yǔ)言來(lái)編寫(xiě)模塊。

舉例來(lái)說(shuō)，你可以使用 C 語(yǔ)言來(lái)撰寫(xiě) Python 模塊，并且在編譯后，你可以通過(guò)標(biāo)準(zhǔn) Python 解釋器在你的 Python 代碼中使用它們。

模塊是一個(gè)包含所有你定義的函數(shù)和變量的文件，其后綴名是.py。

模塊可以被別的程序引入，以使用該模塊中的函數(shù)等功能。

這也是使用 Python 標(biāo)準(zhǔn)庫(kù)的方法。

當(dāng)解釋器遇到 import 語(yǔ)句，如果模塊在當(dāng)前的搜索路徑就會(huì)被導(dǎo)入。

搜索路徑是一個(gè)解釋器會(huì)先進(jìn)行搜索的所有目錄的列表。

如想要導(dǎo)入模塊，需要把命令放在腳本的頂端。

一個(gè)模塊只會(huì)被導(dǎo)入一次，這樣可以防止導(dǎo)入模塊被一遍又一遍地執(zhí)行。

搜索路徑被存儲(chǔ)在 sys 模塊中的 path 變量。

當(dāng)前目錄指的是程序啟動(dòng)的目錄。

導(dǎo)入模塊

導(dǎo)入模塊：

import module1[, module2[,... moduleN]]

從模塊中導(dǎo)入一個(gè)指定的部分到當(dāng)前命名空間中：

from modname import name1[, name2[, ... nameN]]

把一個(gè)模塊的所有內(nèi)容全都導(dǎo)入到當(dāng)前的命名空間：

from modname import *

__name__ 屬性

每個(gè)模塊都有一個(gè)__name__屬性，當(dāng)其值是'__main__'時(shí)，表明該模塊自身在運(yùn)行，否則是被引入。

一個(gè)模塊被另一個(gè)程序第一次引入時(shí)，其主程序?qū)⑦\(yùn)行。

如果我們想在模塊被引入時(shí)，模塊中的某一程序塊不執(zhí)行，我們可以用__name__屬性來(lái)使該程序塊僅在該模塊自身運(yùn)行時(shí)執(zhí)行。

if __name__ == '__main__': print('程序自身在運(yùn)行')else: print('我來(lái)自另一模塊')

dir 函數(shù)

內(nèi)置的函數(shù)dir()可以找到模塊內(nèi)定義的所有名稱(chēng)。

以一個(gè)字符串列表的形式返回。

如果沒(méi)有給定參數(shù)，那么dir()函數(shù)會(huì)羅列出當(dāng)前定義的所有名稱(chēng)。

在 Python 中萬(wàn)物皆對(duì)象，int、str、float、list、tuple等內(nèi)置數(shù)據(jù)類(lèi)型其實(shí)也是類(lèi)，也可以用dir(int)查看int包含的所有方法，也可以使用help(int)查看int類(lèi)的幫助信息。

包

包是一種管理 Python 模塊命名空間的形式，采用”點(diǎn)模塊名稱(chēng)”。

比如一個(gè)模塊的名稱(chēng)是 A.B， 那么他表示一個(gè)包 A中的子模塊 B 。

就好像使用模塊的時(shí)候，你不用擔(dān)心不同模塊之間的全局變量相互影響一樣，采用點(diǎn)模塊名稱(chēng)這種形式也不用擔(dān)心不同庫(kù)之間的模塊重名的情況。

在導(dǎo)入一個(gè)包的時(shí)候，Python 會(huì)根據(jù) sys.path 中的目錄來(lái)尋找這個(gè)包中包含的子目錄。

目錄只有包含一個(gè)叫做__init__.py的文件才會(huì)被認(rèn)作是一個(gè)包，主要是為了避免一些濫俗的名字（比如叫做 string）不小心的影響搜索路徑中的有效模塊。

最簡(jiǎn)單的情況，放一個(gè)空的__init__.py文件就可以了。

當(dāng)然這個(gè)文件中也可以包含一些初始化代碼或者為_(kāi)_all__變量賦值。

第三方模塊

easy_install 和 pip 都是用來(lái)下載安裝 Python 一個(gè)公共資源庫(kù) PyPI 的相關(guān)資源包的，pip 是 easy_install 的改進(jìn)版，提供更好的提示信息，刪除 package 等功能。

老版本的 python 中只有 easy_install，沒(méi)有pip。

easy_install 打包和發(fā)布 Python 包，pip 是包管理。

easy_install 的用法：

安裝一個(gè)包

easy_install 包名easy_install "包名 == 包的版本號(hào)"

升級(jí)一個(gè)包

easy_install -U "包名 >= 包的版本號(hào)"

pip 的用法：

安裝一個(gè)包

pip install 包名pip install 包名 == 包的版本號(hào)

升級(jí)一個(gè)包 （如果不提供version號(hào)，升級(jí)到最新版本）

pip install —upgrade 包名 >= 包的版本號(hào)

刪除一個(gè)包

pip uninstall 包名

已安裝包列表

pip list

面向?qū)ο?/p>

類(lèi)與對(duì)象是面向?qū)ο缶幊痰膬蓚€(gè)主要方面。

一個(gè)類(lèi)（Class）能夠創(chuàng)建一種新的類(lèi)型（Type），其中對(duì)象（Object）就是類(lèi)的實(shí)例（Instance）。

可以這樣來(lái)類(lèi)比：你可以擁有類(lèi)型int的變量，也就是說(shuō)存儲(chǔ)整數(shù)的變量是int類(lèi)的實(shí)例（對(duì)象）。

類(lèi)(Class)：用來(lái)描述具有相同的屬性和方法的對(duì)象的集合。

它定義了該集合中每個(gè)對(duì)象所共有的屬性和方法。對(duì)象是類(lèi)的實(shí)例。

方法：類(lèi)中定義的函數(shù)。

類(lèi)變量：類(lèi)變量在整個(gè)實(shí)例化的對(duì)象中是公用的。

類(lèi)變量定義在類(lèi)中且在函數(shù)體之外。類(lèi)變量通常不作為實(shí)例變量使用。

數(shù)據(jù)成員：類(lèi)變量或者實(shí)例變量用于處理類(lèi)及其實(shí)例對(duì)象的相關(guān)的數(shù)據(jù)。

方法重寫(xiě)：如果從父類(lèi)繼承的方法不能滿(mǎn)足子類(lèi)的需求，可以對(duì)其進(jìn)行改寫(xiě)，這個(gè)過(guò)程叫方法的覆蓋（override），也稱(chēng)為方法的重寫(xiě)。

實(shí)例變量：定義在方法中的變量，只作用于當(dāng)前實(shí)例的類(lèi)。

繼承：即一個(gè)派生類(lèi)（derived class）繼承基類(lèi)（base class）的字段和方法。

繼承也允許把一個(gè)派生類(lèi)的對(duì)象作為一個(gè)基類(lèi)對(duì)象對(duì)待。

例如，有這樣一個(gè)設(shè)計(jì)：一個(gè)Dog類(lèi)型的對(duì)象派生自Animal類(lèi)，這是模擬”是一個(gè)（is-a）”關(guān)系（例圖，Dog是一個(gè)Animal）。

實(shí)例化：創(chuàng)建一個(gè)類(lèi)的實(shí)例，類(lèi)的具體對(duì)象。

對(duì)象：通過(guò)類(lèi)定義的數(shù)據(jù)結(jié)構(gòu)實(shí)例。對(duì)象包括兩個(gè)數(shù)據(jù)成員（類(lèi)變量和實(shí)例變量）和方法。

Python 中的類(lèi)提供了面向?qū)ο缶幊痰乃谢竟δ埽侯?lèi)的繼承機(jī)制允許多個(gè)基類(lèi)，派生類(lèi)可以覆蓋基類(lèi)中的任何方法，方法中可以調(diào)用基類(lèi)中的同名方法。

對(duì)象可以包含任意數(shù)量和類(lèi)型的數(shù)據(jù)。

self

self表示的是當(dāng)前實(shí)例，代表當(dāng)前對(duì)象的地址。

類(lèi)由self.__class__表示。

self不是關(guān)鍵字，其他名稱(chēng)也可以替代，但self是個(gè)通用的標(biāo)準(zhǔn)名稱(chēng)。

類(lèi)

類(lèi)由class關(guān)鍵字來(lái)創(chuàng)建。

類(lèi)實(shí)例化后，可以使用其屬性，實(shí)際上，創(chuàng)建一個(gè)類(lèi)之后，可以通過(guò)類(lèi)名訪問(wèn)其屬性。

對(duì)象方法

方法由def關(guān)鍵字定義，與函數(shù)不同的是：方法必須包含參數(shù)self, 且為第一個(gè)參數(shù)，self代表的是本類(lèi)的實(shí)例。

類(lèi)方法

裝飾器@classmethod可以將方法標(biāo)識(shí)為類(lèi)方法。

類(lèi)方法的第一個(gè)參數(shù)必須為cls，而不再是self。

靜態(tài)方法

裝飾器@staticmethod可以將方法標(biāo)識(shí)為靜態(tài)方法。

靜態(tài)方法的第一個(gè)參數(shù)不再指定，也就不需要self或cls。

__init__ 方法

__init__方法即構(gòu)造方法，會(huì)在類(lèi)的對(duì)象被實(shí)例化時(shí)先運(yùn)行，可以將初始化的操作放置到該方法中。

如果重寫(xiě)了__init__，實(shí)例化子類(lèi)就不會(huì)調(diào)用父類(lèi)已經(jīng)定義的__init__。

變量

類(lèi)變量（Class Variable）是共享的（Shared）——它們可以被屬于該類(lèi)的所有實(shí)例訪問(wèn)。

該類(lèi)變量只擁有一個(gè)副本，當(dāng)任何一個(gè)對(duì)象對(duì)類(lèi)變量作出改變時(shí)，發(fā)生的變動(dòng)將在其它所有實(shí)例中都會(huì)得到體現(xiàn)。

對(duì)象變量（Object variable）由類(lèi)的每一個(gè)獨(dú)立的對(duì)象或?qū)嵗鶕碛小?/p>

在這種情況下，每個(gè)對(duì)象都擁有屬于它自己的字段的副本。

也就是說(shuō)，它們不會(huì)被共享，也不會(huì)以任何方式與其它不同實(shí)例中的相同名稱(chēng)的字段產(chǎn)生關(guān)聯(lián)。

在 Python 中，變量名類(lèi)似__xxx__的，也就是以雙下劃線開(kāi)頭，并且以雙下劃線結(jié)尾的，是特殊變量，特殊變量是可以直接訪問(wèn)的，不是 private 變量。

所以，不能用__name__、__score__這樣的變量名。

訪問(wèn)控制

私有屬性

__private_attr：兩個(gè)下劃線開(kāi)頭，聲明該屬性為私有，不能在類(lèi)地外部被使用或直接訪問(wèn)。

私有方法

__private_method：兩個(gè)下劃線開(kāi)頭，聲明該方法為私有方法，只能在類(lèi)的內(nèi)部調(diào)用，不能在類(lèi)地外部調(diào)用。

我們還認(rèn)為約定，一個(gè)下劃線開(kāi)頭的屬性或方法為受保護(hù)的。

比如，_protected_attr、_protected_method。

繼承

類(lèi)可以繼承，并且支持繼承多個(gè)父類(lèi)。

在定義類(lèi)時(shí)，類(lèi)名后的括號(hào)中指定要繼承的父類(lèi)，多個(gè)父類(lèi)之間用逗號(hào)分隔。

子類(lèi)的實(shí)例可以完全訪問(wèn)所繼承所有父類(lèi)的非私有屬性和方法。

若是父類(lèi)中有相同的方法名，而在子類(lèi)使用時(shí)未指定，Python 從左至右搜索，即方法在子類(lèi)中未找到時(shí)，從左到右查找父類(lèi)中是否包含方法。

方法重寫(xiě)

子類(lèi)的方法可以重寫(xiě)父類(lèi)的方法。

重寫(xiě)的方法參數(shù)不強(qiáng)制要求保持一致，不過(guò)合理的設(shè)計(jì)都應(yīng)該保持一致。

super()函數(shù)可以調(diào)用父類(lèi)的一個(gè)方法，以多繼承問(wèn)題。

類(lèi)的專(zhuān)有方法：

__init__: 構(gòu)造函數(shù)，在生成對(duì)象時(shí)調(diào)用

__del__: 析構(gòu)函數(shù)，釋放對(duì)象時(shí)使用

__repr__: 打印，轉(zhuǎn)換

__setitem__: 按照索引賦值

__getitem__: 按照索引獲取值

__len__: 獲得長(zhǎng)度

__cmp__: 比較運(yùn)算

__call__: 函數(shù)調(diào)用

__add__: 加運(yùn)算

__sub__: 減運(yùn)算

__mul__: 乘運(yùn)算

__div__: 除運(yùn)算

__mod__: 求余運(yùn)算

__pow__: 乘方

類(lèi)的專(zhuān)有方法也支持重載。

實(shí)例

class Person: """人員信息""" # 姓名(共有屬性) name = '' # 年齡(共有屬性) age = 0 def __init__(self, name='', age=0): self.name = name self.age = age # 重載專(zhuān)有方法: __str__ def __str__(self): return "這里重載了 __str__ 專(zhuān)有方法, " + str({'name': self.name, 'age': self.age}) def set_age(self, age): self.age = age class Account: """賬戶(hù)信息""" # 賬戶(hù)余額(私有屬性) __balance = 0 # 所有賬戶(hù)總額 __total_balance = 0 # 獲取賬戶(hù)余額 # self 必須是方法的第一個(gè)參數(shù) def balance(self): return self.__balance # 增加賬戶(hù)余額 def balance_add(self, cost): # self 訪問(wèn)的是本實(shí)例 self.__balance += cost # self.__class__ 可以訪問(wèn)類(lèi) self.__class__.__total_balance += cost # 類(lèi)方法(用 @classmethod 標(biāo)識(shí)，第一個(gè)參數(shù)為 cls) @classmethod def total_balance(cls): return cls.__total_balance # 靜態(tài)方法(用 @staticmethod 標(biāo)識(shí)，不需要類(lèi)參數(shù)或?qū)嵗齾?shù)) @staticmethod def exchange(a, b): return b, a class Teacher(Person, Account): """教師""" # 班級(jí)名稱(chēng) _class_name = '' def __init__(self, name): # 第一種重載父類(lèi)__init__()構(gòu)造方法 # super(子類(lèi)，self).__init__(參數(shù)1，參數(shù)2，....) super(Teacher, self).__init__(name) def get_info(self): # 以字典的形式返回個(gè)人信息 return { 'name': self.name, # 此處訪問(wèn)的是父類(lèi)Person的屬性值 'age': self.age, 'class_name': self._class_name, 'balance': self.balance(), # 此處調(diào)用的是子類(lèi)重載過(guò)的方法 } # 方法重載 def balance(self): # Account.__balance 為私有屬性，子類(lèi)無(wú)法訪問(wèn)，所以父類(lèi)提供方法進(jìn)行訪問(wèn) return Account.balance(self) * 1.1class Student(Person, Account): """學(xué)生""" _teacher_name = '' def __init__(self, name, age=18): # 第二種重載父類(lèi)__init__()構(gòu)造方法 # 父類(lèi)名稱(chēng).__init__(self,參數(shù)1，參數(shù)2，...) Person.__init__(self, name, age) def get_info(self): # 以字典的形式返回個(gè)人信息 return { 'name': self.name, # 此處訪問(wèn)的是父類(lèi)Person的屬性值 'age': self.age, 'teacher_name': self._teacher_name, 'balance': self.balance(), } # 教師 Johnjohn = Teacher('John')john.balance_add(20)john.set_age(36) # 子類(lèi)的實(shí)例可以直接調(diào)用父類(lèi)的方法print("John's info:", john.get_info())# 學(xué)生 Marymary = Student('Mary', 18)mary.balance_add(18)print("Mary's info:", mary.get_info())# 學(xué)生 Fakefake = Student('Fake')fake.balance_add(30)print("Fake's info", fake.get_info())# 三種不同的方式調(diào)用靜態(tài)方法print("john.exchange('a', 'b'):", john.exchange('a', 'b'))print('Teacher.exchange(1, 2)', Teacher.exchange(1, 2))print('Account.exchange(10, 20):', Account.exchange(10, 20))# 類(lèi)方法、類(lèi)屬性print('Account.total_balance():', Account.total_balance())print('Teacher.total_balance():', Teacher.total_balance())print('Student.total_balance():', Student.total_balance())# 重載專(zhuān)有方法print(fake)

輸出：

John's info: {'name': 'John', 'age': 36, 'class_name': '', 'balance': 22.0} Mary's info: {'name': 'Mary', 'age': 18, 'teacher_name': '', 'balance': 18} Fake's info {'name': 'Fake', 'age': 18, 'teacher_name': '', 'balance': 30} john.exchange('a', 'b'): ('b', 'a') Teacher.exchange(1, 2) (2, 1) Account.exchange(10, 20): (20, 10) Account.total_balance(): 0 Teacher.total_balance(): 20 Student.total_balance(): 48 這里重載了 __str__ 專(zhuān)有方法, {'name': 'Fake', 'age': 18}

錯(cuò)誤和異常

語(yǔ)法錯(cuò)誤

SyntaxError 類(lèi)表示語(yǔ)法錯(cuò)誤，當(dāng)解釋器發(fā)現(xiàn)代碼無(wú)法通過(guò)語(yǔ)法檢查時(shí)會(huì)觸發(fā)的錯(cuò)誤。

語(yǔ)法錯(cuò)誤是無(wú)法用try...except...捕獲的。

>>> print: File "", line 1 print: ^SyntaxError: invalid syntax

異常

即便程序的語(yǔ)法是正確的，在運(yùn)行它的時(shí)候，也有可能發(fā)生錯(cuò)誤。

運(yùn)行時(shí)發(fā)生的錯(cuò)誤被稱(chēng)為異常。

錯(cuò)誤信息的前面部分顯示了異常發(fā)生的上下文，并以調(diào)用棧的形式顯示具體信息。

>>> 1 + '0'Traceback (most recent call last): File "", line 1, in TypeError: unsupported operand type(s) for +: 'int' and 'str'

異常處理

Python 提供了try ... except ...的語(yǔ)法結(jié)構(gòu)來(lái)捕獲和處理異常。

try 語(yǔ)句執(zhí)行流程大致如下：

首先，執(zhí)行 try 子句（在關(guān)鍵字 try 和關(guān)鍵字 except 之間的語(yǔ)句）。

如果沒(méi)有異常發(fā)生，忽略 except 子句，try 子句執(zhí)行后結(jié)束。

如果在執(zhí)行 try 子句的過(guò)程中發(fā)生了異常，那么 try 子句余下的部分將被忽略。

如果異常的類(lèi)型和 except 之后的名稱(chēng)相符，那么對(duì)應(yīng)的 except 子句將被執(zhí)行。

最后執(zhí)行 try 語(yǔ)句之后的代碼。

如果一個(gè)異常沒(méi)有與任何的 except 匹配，那么這個(gè)異常將會(huì)傳遞給上層的 try 中。

一個(gè) try 語(yǔ)句可能包含多個(gè) except 子句，分別來(lái)處理不同的特定的異常。

最多只有一個(gè) except 子句會(huì)被執(zhí)行。

處理程序?qū)⒅会槍?duì)對(duì)應(yīng)的 try 子句中的異常進(jìn)行處理，而不是其他的 try 的處理程序中的異常。

一個(gè) except 子句可以同時(shí)處理多個(gè)異常，這些異常將被放在一個(gè)括號(hào)里成為一個(gè)元組。

最后一個(gè) except 子句可以忽略異常的名稱(chēng)，它將被當(dāng)作通配符使用。

可以使用這種方法打印一個(gè)錯(cuò)誤信息，然后再次把異常拋出。

try except 語(yǔ)句還有一個(gè)可選的 else 子句，如果使用這個(gè)子句，那么必須放在所有的 except 子句之后，這個(gè)子句將在 try 子句沒(méi)有發(fā)生任何異常的時(shí)候執(zhí)行。

異常處理并不僅僅處理那些直接發(fā)生在 try 子句中的異常，而且還能處理子句中調(diào)用的函數(shù)（甚至間接調(diào)用的函數(shù)）里拋出的異常。

不管 try 子句里面有沒(méi)有發(fā)生異常，finally 子句都會(huì)執(zhí)行。

如果一個(gè)異常在 try 子句里（或者在 except 和 else 子句里）被拋出，而又沒(méi)有任何的 except 把它截住，那么這個(gè)異常會(huì)在 finally 子句執(zhí)行后再次被拋出。

拋出異常

使用raise語(yǔ)句拋出一個(gè)指定的異常。

raise 唯一的一個(gè)參數(shù)指定了要被拋出的異常，它必須是一個(gè)異常的實(shí)例或者是異常的類(lèi)（也就是 Exception 的子類(lèi)）。

如果你只想知道這是否拋出了一個(gè)異常，并不想去處理它，那么一個(gè)簡(jiǎn)單的 raise 語(yǔ)句就可以再次把它拋出。

自定義異常

可以通過(guò)創(chuàng)建一個(gè)新的異常類(lèi)來(lái)?yè)碛凶约旱漠惓！?/p>

異常類(lèi)繼承自 Exception 類(lèi)，可以直接繼承，或者間接繼承。

當(dāng)創(chuàng)建一個(gè)模塊有可能拋出多種不同的異常時(shí)，一種通常的做法是為這個(gè)包建立一個(gè)基礎(chǔ)異常類(lèi)，然后基于這個(gè)基礎(chǔ)類(lèi)為不同的錯(cuò)誤情況創(chuàng)建不同的子類(lèi)。

大多數(shù)的異常的名字都以”Error”結(jié)尾，就跟標(biāo)準(zhǔn)的異常命名一樣。

實(shí)例

import sysclass Error(Exception): """Base class for exceptions in this module.""" pass# 自定義異常class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = messagetry: print('code start running...') raise InputError('input()', 'input error') # ValueError int('a') # TypeError s = 1 + 'a' dit = {'name': 'john'} # KeyError print(dit['1'])except InputError as ex: print("InputError:", ex.message)except TypeError as ex: print('TypeError:', ex.args) passexcept (KeyError, IndexError) as ex: """支持同時(shí)處理多個(gè)異常, 用括號(hào)放到元組里""" print(sys.exc_info())except: """捕獲其他未指定的異常""" print("Unexpected error:", sys.exc_info()[0]) # raise 用于拋出異常 raise RuntimeError('RuntimeError')else: """當(dāng)無(wú)任何異常時(shí), 會(huì)執(zhí)行 else 子句""" print('"else" 子句...')finally: """無(wú)論有無(wú)異常, 均會(huì)執(zhí)行 finally""" print('finally, ending')

文件操作

打開(kāi)文件

open()函數(shù)用于打開(kāi)/創(chuàng)建一個(gè)文件，并返回一個(gè) file 對(duì)象：

open(filename, mode)

filename：包含了你要訪問(wèn)的文件名稱(chēng)的字符串值

mode：決定了打開(kāi)文件的模式：只讀，寫(xiě)入，追加等

文件打開(kāi)模式：

文件對(duì)象方法

fileObject.close()

close() 方法用于關(guān)閉一個(gè)已打開(kāi)的文件。

關(guān)閉后的文件不能再進(jìn)行讀寫(xiě)操作，否則會(huì)觸發(fā) ValueError 錯(cuò)誤。

close() 方法允許調(diào)用多次。

當(dāng) file 對(duì)象，被引用到操作另外一個(gè)文件時(shí)，Python 會(huì)自動(dòng)關(guān)閉之前的 file 對(duì)象。 使用 close() 方法關(guān)閉文件是一個(gè)好的習(xí)慣。

fileObject.flush()

flush() 方法是用來(lái)刷新緩沖區(qū)的，即將緩沖區(qū)中的數(shù)據(jù)立刻寫(xiě)入文件，同時(shí)清空緩沖區(qū)，不需要是被動(dòng)的等待輸出緩沖區(qū)寫(xiě)入。

一般情況下，文件關(guān)閉后會(huì)自動(dòng)刷新緩沖區(qū)，但有時(shí)你需要在關(guān)閉前刷它，這時(shí)就可以使用 flush() 方法。

fileObject.fileno()

fileno() 方法返回一個(gè)整型的文件描述符(file descriptor FD 整型)，可用于底層操作系統(tǒng)的 I/O 操作。

fileObject.isatty()

isatty() 方法檢測(cè)文件是否連接到一個(gè)終端設(shè)備，如果是返回 True，否則返回 False。

next(iterator[,default])

Python 3 中的 File 對(duì)象不支持 next() 方法。

Python 3 的內(nèi)置函數(shù)next()通過(guò)迭代器調(diào)用__next__()方法返回下一 項(xiàng)。

在循環(huán)中，next()函數(shù)會(huì)在每次循環(huán)中調(diào)用，該方法返回文件的下一行， 如果到達(dá)結(jié)尾(EOF)，則觸發(fā) StopIteration。

fileObject.read()

read() 方法用于從文件讀取指定的字節(jié)數(shù)，如果未給定或?yàn)樨?fù)則讀取所有。

fileObject.readline()

readline() 方法用于從文件讀取整行，包括 “ ” 字符。

如果指定了一個(gè)非負(fù)數(shù)的參數(shù)，則返回指定大小的字節(jié)數(shù)，包括 “ ” 字符。

fileObject.readlines()

readlines() 方法用于讀取所有行(直到結(jié)束符 EOF)并返回列表，該列表可以由 Python 的for... in ...結(jié)構(gòu)進(jìn)行處理。

如果碰到結(jié)束符 EOF，則返回空字符串。

fileObject.seek(offset[, whence])

seek() 方法用于移動(dòng)文件讀取指針到指定位置。

whence 的值, 如果是 0 表示開(kāi)頭, 如果是 1 表示當(dāng)前位置, 2 表示文件的結(jié)尾。

whence 值為默認(rèn)為0，即文件開(kāi)頭。

例如：

seek(x, 0)：從起始位置即文件首行首字符開(kāi)始移動(dòng) x 個(gè)字符

seek(x, 1)：表示從當(dāng)前位置往后移動(dòng) x 個(gè)字符

seek(-x, 2)：表示從文件的結(jié)尾往前移動(dòng) x 個(gè)字符

fileObject.tell(offset[, whence])

tell() 方法返回文件的當(dāng)前位置，即文件指針當(dāng)前位置。

fileObject.truncate([size])

truncate() 方法用于從文件的首行首字符開(kāi)始截?cái)啵財(cái)辔募?size 個(gè)字符，無(wú) size 表示從當(dāng)前位置截?cái)啵唤財(cái)嘀?V 后面的所有字符被刪除，其中 Widnows 系統(tǒng)下的換行代表2個(gè)字符大小。

fileObject.write([str])

write() 方法用于向文件中寫(xiě)入指定字符串。

在文件關(guān)閉前或緩沖區(qū)刷新前，字符串內(nèi)容存儲(chǔ)在緩沖區(qū)中，這時(shí)你在文件中是看不到寫(xiě)入的內(nèi)容的。

如果文件打開(kāi)模式帶 b，那寫(xiě)入文件內(nèi)容時(shí)，str (參數(shù))要用 encode 方法轉(zhuǎn)為 bytes 形式，否則報(bào)錯(cuò)：TypeError: a bytes-like object is required, not 'str'。

fileObject.writelines([str])

writelines() 方法用于向文件中寫(xiě)入一序列的字符串。

這一序列字符串可以是由迭代對(duì)象產(chǎn)生的，如一個(gè)字符串列表。換行需要指定換行符 。

實(shí)例

filename = 'data.log'# 打開(kāi)文件(a+ 追加讀寫(xiě)模式)# 用 with 關(guān)鍵字的方式打開(kāi)文件，會(huì)自動(dòng)關(guān)閉文件資源with open(filename, 'w+', encoding='utf-8') as file: print('文件名稱(chēng): {}'.format(file.name)) print('文件編碼: {}'.format(file.encoding)) print('文件打開(kāi)模式: {}'.format(file.mode)) print('文件是否可讀: {}'.format(file.readable())) print('文件是否可寫(xiě): {}'.format(file.writable())) print('此時(shí)文件指針位置為: {}'.format(file.tell())) # 寫(xiě)入內(nèi)容 num = file.write("第一行內(nèi)容 ") print('寫(xiě)入文件 {} 個(gè)字符'.format(num)) # 文件指針在文件尾部，故無(wú)內(nèi)容 print(file.readline(), file.tell()) # 改變文件指針到文件頭部 file.seek(0) # 改變文件指針后，讀取到第一行內(nèi)容 print(file.readline(), file.tell()) # 但文件指針的改變，卻不會(huì)影響到寫(xiě)入的位置 file.write('第二次寫(xiě)入的內(nèi)容 ') # 文件指針又回到了文件尾 print(file.readline(), file.tell()) # file.read() 從當(dāng)前文件指針位置讀取指定長(zhǎng)度的字符 file.seek(0) print(file.read(9)) # 按行分割文件，返回字符串列表 file.seek(0) print(file.readlines()) # 迭代文件對(duì)象，一行一個(gè)元素 file.seek(0) for line in file: print(line, end='')# 關(guān)閉文件資源if not file.closed: file.close()

輸出：

文件名稱(chēng): data.log文件編碼: utf-8文件打開(kāi)模式: w+文件是否可讀: True文件是否可寫(xiě): True此時(shí)文件指針位置為: 0寫(xiě)入文件 6 個(gè)字符 16第一行內(nèi)容 16 41第一行內(nèi)容第二次['第一行內(nèi)容 ', '第二次寫(xiě)入的內(nèi)容 ']第一行內(nèi)容第二次寫(xiě)入的內(nèi)容

序列化

在 Python 中 pickle 模塊實(shí)現(xiàn)對(duì)數(shù)據(jù)的序列化和反序列化。pickle 支持任何數(shù)據(jù)類(lèi)型，包括內(nèi)置數(shù)據(jù)類(lèi)型、函數(shù)、類(lèi)、對(duì)象等。

方法

dump

將數(shù)據(jù)對(duì)象序列化后寫(xiě)入文件

pickle.dump(obj, file, protocol=None, fix_imports=True)

必填參數(shù) obj 表示將要封裝的對(duì)象。

必填參數(shù) file 表示 obj 要寫(xiě)入的文件對(duì)象，file 必須以二進(jìn)制可寫(xiě)模式打開(kāi)，即wb。

可選參數(shù) protocol 表示告知 pickle 使用的協(xié)議，支持的協(xié)議有 0,1,2,3，默認(rèn)的協(xié)議是添加在 Python 3 中的協(xié)議3。

load

從文件中讀取內(nèi)容并反序列化

pickle.load(file, fix_imports=True, encoding='ASCII', errors='strict')

必填參數(shù) file 必須以二進(jìn)制可讀模式打開(kāi)，即rb，其他都為可選參數(shù)。

dumps

以字節(jié)對(duì)象形式返回封裝的對(duì)象，不需要寫(xiě)入文件中

pickle.dumps(obj, protocol=None, fix_imports=True)

loads

從字節(jié)對(duì)象中讀取被封裝的對(duì)象，并返回。

pickle.loads(bytes_object, fix_imports=True, encoding='ASCII', errors='strict')

實(shí)例

import pickledata = [1, 2, 3]# 序列化數(shù)據(jù)并以字節(jié)對(duì)象返回dumps_obj = pickle.dumps(data)print('pickle.dumps():', dumps_obj)# 從字節(jié)對(duì)象中反序列化數(shù)據(jù)loads_data = pickle.loads(dumps_obj)print('pickle.loads():', loads_data)filename = 'data.log'# 序列化數(shù)據(jù)到文件中with open(filename, 'wb') as file: pickle.dump(data, file)# 從文件中加載并反序列化with open(filename, 'rb') as file: load_data = pickle.load(file) print('pickle.load():', load_data)

輸出：

pickle.dumps(): b'x80x03]qx00(Kx01Kx02Kx03e.'pickle.loads(): [1, 2, 3]pickle.load(): [1, 2, 3]

命名規(guī)范

Python 之父 Guido 推薦的規(guī)范