python基礎(chǔ)大全（python的基礎(chǔ)知識(shí)）

簡(jiǎn)介

Python 是一種高層次的結(jié)合了解釋性、編譯性、互動(dòng)性和面向?qū)ο蟮哪_本語言。Python 由 Guido van Rossum 于 1989 年底在荷蘭國(guó)家數(shù)學(xué)和計(jì)算機(jī)科學(xué)研究所發(fā)明，第一個(gè)公開發(fā)行版發(fā)行于 1991 年。

特點(diǎn)

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

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

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

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

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

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

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

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

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

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

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

基礎(chǔ)語法

運(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ì)大小寫敏感。

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

保留字

保留字即關(guān)鍵字，我們不能把它們用作任何標(biāo)識(shí)符名稱。Python 的標(biāo)準(zhǔn)庫提供了一個(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)來表示代碼塊，不需要使用大括號(hào) {}。 縮進(jìn)的空格數(shù)是可變的，但是同一個(gè)代碼塊的語句必須包含相同的縮進(jìn)空格數(shù)。縮進(jìn)不一致，會(huì)導(dǎo)致運(yùn)行錯(cuò)誤。

多行語句

Python 通常是一行寫完一條語句，但如果語句很長(zhǎng)，我們可以使用反斜杠來實(shí)現(xiàn)多行語句。

total = item_one +

item_two +

item_three

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

空行

函數(shù)之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數(shù)入口之間也用一行空行分隔，以突出函數(shù)入口的開始。

空行與代碼縮進(jìn)不同，空行并不是 Python 語法的一部分。書寫時(shí)不插入空行，Python 解釋器運(yùn)行也不會(huì)出錯(cuò)。但是空行的作用在于分隔兩段不同功能或含義的代碼，便于日后代碼的維護(hù)或重構(gòu)。

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

等待用戶輸入

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

content = input("

請(qǐng)輸入點(diǎn)東西并按 Enter 鍵

")

print(content)

同一行寫多條語句

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

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

')

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

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

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

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

print 輸出

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

print('123') # 默認(rèn)換行

print('123', end = "") # 不換行

import 與 from…import

在 Python 用 import 或者 from...import 來導(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ò)：

>>> name

Traceback (most recent call last):

File "", line 1, in

NameError: name 'name' is not defined

數(shù)據(jù)類型

布爾(bool)

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

數(shù)字(number)

整型(int)

整數(shù)值，可正數(shù)亦可復(fù)數(shù)，無小數(shù)。 3.x 整型是沒有限制大小的，可以當(dāng)作 Long 類型使用，所以 3.x 沒有 2.x 的 Long 類型。

浮點(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)算

不同類型的數(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ù)類型的數(shù)，它與分母分子的數(shù)據(jù)類型有關(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)義符(反斜杠)可以用來轉(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 開始，從右往左以 -1 開始

字符串不能改變

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

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

轉(zhuǎn)義字符

字符串運(yùn)算符

字符串格式化

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

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

// 輸出:

我叫小明， 今年 10 歲！

格式化符號(hào):

輔助指令:

Python 2.6 開始，新增了一種格式化字符串的函數(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 字符串，這樣能夠表示更多的字符集。使用的語法是在字符串前面加上前綴 u。

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

字符串函數(shù)

字節(jié)(bytes)

在 3.x 中，字符串和二進(jìn)制數(shù)據(jù)完全區(qū)分開。文本總是 Unicode，由 str 類型表示，二進(jìn)制數(shù)據(jù)則由 bytes 類型表示。Python 3 不會(huì)以任意隱式的方式混用 str 和 bytes，你不能拼接字符串和字節(jié)流，也無法在字節(jié)流里搜索字符串（反之亦然），也不能將字符串傳入?yún)?shù)為字節(jié)流的函數(shù)（反之亦然）。

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

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

只有在需要將 str 編碼(encode)成 bytes 的時(shí)候，比如：通過網(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)

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

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

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

列表元素值可以是任意類型，包括變量

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

列表的元素訪問可以嵌套

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

創(chuàng)建列表

hello = (1, 2, 3)

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

訪問元素

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

print(li[3]) # (1, 3)

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

切片訪問

格式: 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)]

訪問內(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

修改列表

通過使用方括號(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 語句來刪除列表的指定范圍的元素。

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] # True

for 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) # 5

len(li) # 3

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

列表方法

list.append(obj)

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

list.count(obj)

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

list.extend(seq)

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

list.index(obj)

返回查找對(duì)象的索引位置，如果沒有找到對(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)境中生成出來的列表。如果希望表達(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 子句作為過濾器：

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)

元組與列表類似，不同之處在于元組的元素不能修改

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

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

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

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

元組中只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào)，否則括號(hào)會(huì)被當(dāng)作運(yù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 語句來刪除整個(gè)元組

元組函數(shù)

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

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

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

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

元組推導(dǎo)式

t = 1, 2, 3

print(t)

# (1, 2, 3)

u = t, (3, 4, 5)

print(u)

# ((1, 2, 3), (3, 4, 5))

字典(dict)

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

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

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

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

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

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

字典的元素沒有順序，不能通過下標(biāo)引用元素，通過鍵來引用

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

格式如下:

d = {key1 : value1, key2 : value2 }

訪問字典

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

print(dis['b'][2])

修改字典

dis = {'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}

dis[9]['name'] = 999

print(dis)

# {'a': 1, 9: {'name': 999}, 'b': [1, 2, 3]}

刪除字典

用 del 語句刪除字典或字典的元素。

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) 返回輸入的變量類型，如果變量是字典就返回字典類型

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)可以用來創(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è)無序不重復(fù)元素的序列

創(chuàng)建集合

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

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

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

創(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ì)稱差集，不同時(shí)出現(xiàn)在兩個(gè)集合中的元素

set.isdisjoint(set2)

如果兩個(gè)集合沒有相同的元素，返回 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:

語句

if 表達(dá)式2:

語句

elif 表達(dá)式3:

語句

else:

語句

elif 表達(dá)式4:

語句

else:

語句

1、每個(gè)條件后面要使用冒號(hào) :，表示接下來是滿足條件后要執(zhí)行的語句塊。 2、使用縮進(jìn)來劃分語句塊，相同縮進(jìn)數(shù)的語句在一起組成一個(gè)語句塊。 3、在 Python 中沒有 switch - case 語句。

三元運(yùn)算符：

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

編寫條件語句時(shí)，應(yīng)該盡量避免使用嵌套語句。嵌套語句不便于閱讀，而且可能會(huì)忽略一些可能性。

for 遍歷

for <循環(huán)變量> in <循環(huán)對(duì)象>：

<語句1>

else:

<語句2>

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

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

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<條件>：

<語句1>

else：

<語句2>

break、continue、pass

break 語句用在 while 和 for 循環(huán)中，break 語句用來終止循環(huán)語句，即循環(huán)條件沒有 False 條件或者序列還沒被完全遞歸完，也會(huì)停止執(zhí)行循環(huán)語句。 continue 語句用在 while 和 for 循環(huán)中，continue 語句用來告訴 Python 跳過當(dāng)前循環(huán)的剩余語句，然后繼續(xù)進(jìn)行下一輪循環(huán)。 continue 語句跳出本次循環(huán)，而 break 跳出整個(gè)循環(huán)。

pass 是空語句，是為了保持程序結(jié)構(gòu)的完整性。pass 不做任何事情，一般用做占位語句。

迭代器

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

迭代器對(duì)象從集合的第一個(gè)元素開始訪問，直到所有的元素被訪問完結(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ù)訪問下一個(gè)元素值：

import sys

li = [1,2,3,4]

it = iter(li)

while True:

try:

print (next(it))

except StopIteration:

sys.exit()

生成器

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

跟普通函數(shù)不同的是，生成器是一個(gè)返回迭代器的函數(shù)，只能用于迭代操作，更簡(jiǎn)單點(diǎn)理解生成器就是一個(gè)迭代器。

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

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

import sys

def fibonacci(n): # 生成器函數(shù) - 斐波那契

a, b, counter = 0, 1, 0

while True:

if (counter > n):

return

yield a

a, b = b, a + b

counter += 1

f = fibonacci(10) # f 是一個(gè)迭代器，由生成器返回生成

while True:

try:

print(next(f))

except StopIteration:

sys.exit()

函數(shù)

自定義函數(shù)

函數(shù)（Functions）是指可重復(fù)使用的程序片段。它們?cè)试S你為某個(gè)代碼塊賦予名字，允許你通過這一特殊的名字在你的程序任何地方來運(yùn)行代碼塊，并可重復(fù)任何次數(shù)。這就是所謂的調(diào)用（Calling）函數(shù)。

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

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

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

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

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

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

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

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

函數(shù)體

參數(shù)傳遞

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

a = [1,2,3]

a = "Runoob"

以上代碼中，[1,2,3] 是 List 類型，”Runoob” 是 String 類型，而變量 a 是沒有類型，她僅僅是一個(gè)對(duì)象的引用（一個(gè)指針），可以是指向 List 類型對(duì)象，也可以是指向 String 類型對(duì)象。

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

在 Python 中，字符串，數(shù)字和元組是不可更改的對(duì)象，而列表、字典等則是可以修改的對(duì)象。

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

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

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

不可變類型：類似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對(duì)象本身。比如在 fun（a）內(nèi)部修改 a 的值，只是修改另一個(gè)復(fù)制的對(duì)象，不會(huì)影響 a 本身。

可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會(huì)受影響

Python 中一切都是對(duì)象，嚴(yán)格意義我們不能說值傳遞還是引用傳遞，我們應(yīng)該說傳不可變對(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ù)來確定傳入的參數(shù)值。 使用關(guān)鍵字參數(shù)允許函數(shù)調(diào)用時(shí)參數(shù)的順序與聲明時(shí)不一致，因?yàn)?Python 解釋器能夠用參數(shù)名匹配參數(shù)值。

def print_info(name, age):

"打印任何傳入的字符串"

print("名字: ", name)

print("年齡: ", age)

return

print_info(age=50, name="john")

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

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

def print_info(name, age=35):

print ("名字: ", name)

print ("年齡: ", age)

return

print_info(age=50, name="john")

print("------------------------")

print_info(name="john")

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

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

如果在函數(shù)調(diào)用時(shí)沒有指定參數(shù)，它就是一個(gè)空元組。我們也可以不向函數(shù)傳遞未命名的變量。

def print_info(arg1, *vartuple):

print("輸出: ")

print(arg1)

for var in vartuple:

print (var)

return

print_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 來創(chuàng)建匿名函數(shù)。

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

lambda 只是一個(gè)表達(dá)式，函數(shù)體比 def 簡(jiǎn)單很多。 lambda 的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊。僅僅能在 lambda 表達(dá)式中封裝有限的邏輯進(jìn)去。 lambda 函數(shù)擁有自己的命名空間，且不能訪問自己參數(shù)列表之外或全局命名空間里的參數(shù)。 雖然 lambda 函數(shù)看起來只能寫一行，卻不等同于 C 或 C++ 的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時(shí)不占用棧內(nèi)存從而增加運(yùn)行效率。

# 語法格式

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），類（class）以及函數(shù)（def、lambda）才會(huì)引入新的作用域，其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會(huì)引入新的作用域的，也就是說這些語句內(nèi)定義的變量，外部也可以訪問。

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

局部變量只能在其被聲明的函數(shù)內(nèi)部訪問，而全局變量可以在整個(gè)程序范圍內(nèi)訪問。調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱都將被加入到作用域中。

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

num = 1

def 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()

模塊

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

另一種方法是使用撰寫 Python 解釋器本身的本地語言來編寫模塊。舉例來說，你可以使用 C 語言來撰寫 Python 模塊，并且在編譯后，你可以通過標(biāo)準(zhǔn) Python 解釋器在你的 Python 代碼中使用它們。

模塊是一個(gè)包含所有你定義的函數(shù)和變量的文件，其后綴名是.py。模塊可以被別的程序引入，以使用該模塊中的函數(shù)等功能。這也是使用 Python 標(biāo)準(zhǔn)庫的方法。

當(dāng)解釋器遇到 import 語句，如果模塊在當(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__ 屬性來使該程序塊僅在該模塊自身運(yùn)行時(shí)執(zhí)行。

if __name__ == '__main__':

print('程序自身在運(yùn)行')

else:

print('我來自另一模塊')

dir 函數(shù)

內(nèi)置的函數(shù) dir() 可以找到模塊內(nèi)定義的所有名稱。以一個(gè)字符串列表的形式返回。

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

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

包

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

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

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

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

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

最簡(jiǎn)單的情況，放一個(gè)空的 __init__.py 文件就可以了。當(dāng)然這個(gè)文件中也可以包含一些初始化代碼或者為 __all__ 變量賦值。

第三方模塊

easy_install 和 pip 都是用來下載安裝 Python 一個(gè)公共資源庫 PyPI 的相關(guān)資源包的，pip 是 easy_install 的改進(jìn)版，提供更好的提示信息，刪除 package 等功能。老版本的 python 中只有 easy_install，沒有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>

類與對(duì)象是面向?qū)ο缶幊痰膬蓚€(gè)主要方面。一個(gè)類（Class）能夠創(chuàng)建一種新的類型（Type），其中對(duì)象（Object）就是類的實(shí)例（Instance）。可以這樣來類比：你可以擁有類型 int 的變量，也就是說存儲(chǔ)整數(shù)的變量是 int 類的實(shí)例（對(duì)象）。

類(Class)：用來描述具有相同的屬性和方法的對(duì)象的集合。它定義了該集合中每個(gè)對(duì)象所共有的屬性和方法。對(duì)象是類的實(shí)例。

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

類變量：類變量在整個(gè)實(shí)例化的對(duì)象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實(shí)例變量使用。

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

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

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

繼承：即一個(gè)派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個(gè)派生類的對(duì)象作為一個(gè)基類對(duì)象對(duì)待。例如，有這樣一個(gè)設(shè)計(jì)：一個(gè)Dog類型的對(duì)象派生自Animal類，這是模擬”是一個(gè)（is-a）”關(guān)系（例圖，Dog是一個(gè)Animal）。

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

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

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

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

self

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

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

類

類由 class 關(guān)鍵字來創(chuàng)建。 類實(shí)例化后，可以使用其屬性，實(shí)際上，創(chuàng)建一個(gè)類之后，可以通過類名訪問其屬性。

對(duì)象方法

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

類方法

裝飾器 @classmethod 可以將方法標(biāo)識(shí)為類方法。類方法的第一個(gè)參數(shù)必須為 cls，而不再是 self。

靜態(tài)方法

裝飾器 @staticmethod 可以將方法標(biāo)識(shí)為靜態(tài)方法。靜態(tài)方法的第一個(gè)參數(shù)不再指定，也就不需要 self 或 cls。

__init__ 方法

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

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

變量

類變量（Class Variable）是共享的（Shared）——它們可以被屬于該類的所有實(shí)例訪問。該類變量只擁有一個(gè)副本，當(dāng)任何一個(gè)對(duì)象對(duì)類變量作出改變時(shí)，發(fā)生的變動(dòng)將在其它所有實(shí)例中都會(huì)得到體現(xiàn)。

對(duì)象變量（Object variable）由類的每一個(gè)獨(dú)立的對(duì)象或?qū)嵗鶕碛小Ｔ谶@種情況下，每個(gè)對(duì)象都擁有屬于它自己的字段的副本，也就是說，它們不會(huì)被共享，也不會(huì)以任何方式與其它不同實(shí)例中的相同名稱的字段產(chǎn)生關(guān)聯(lián)。

在 Python 中，變量名類似 __xxx__ 的，也就是以雙下劃線開頭，并且以雙下劃線結(jié)尾的，是特殊變量，特殊變量是可以直接訪問的，不是 private 變量，所以，不能用 __name__、__score__ 這樣的變量名。

訪問控制

私有屬性

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

私有方法

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

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

繼承

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

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

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

方法重寫

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

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

類的專有方法：

__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__: 乘方

類的專有方法也支持重載。

實(shí)例

class Person:

"""人員信息"""

# 姓名(共有屬性)

name = ''

# 年齡(共有屬性)

age = 0

def __init__(self, name='', age=0):

self.name = name

self.age = age

# 重載專有方法: __str__

def __str__(self):

return "這里重載了 __str__ 專有方法, " + str({'name': self.name, 'age': self.age})

def set_age(self, age):

self.age = age

class Account:

"""賬戶信息"""

# 賬戶余額(私有屬性)

__balance = 0

# 所有賬戶總額

__total_balance = 0

# 獲取賬戶余額

# self 必須是方法的第一個(gè)參數(shù)

def balance(self):

return self.__balance

# 增加賬戶余額

def balance_add(self, cost):

# self 訪問的是本實(shí)例

self.__balance += cost

# self.__class__ 可以訪問類

self.__class__.__total_balance += cost

# 類方法(用 @classmethod 標(biāo)識(shí)，第一個(gè)參數(shù)為 cls)

@classmethod

def total_balance(cls):

return cls.__total_balance

# 靜態(tài)方法(用 @staticmethod 標(biāo)識(shí)，不需要類參數(shù)或?qū)嵗齾?shù))

@staticmethod

def exchange(a, b):

return b, a

class Teacher(Person, Account):

"""教師"""

# 班級(jí)名稱

_class_name = ''

def __init__(self, name):

# 第一種重載父類__init__()構(gòu)造方法

# super(子類，self).__init__(參數(shù)1，參數(shù)2，....)

super(Teacher, self).__init__(name)

def get_info(self):

# 以字典的形式返回個(gè)人信息

return {

'name': self.name, # 此處訪問的是父類Person的屬性值

'age': self.age,

'class_name': self._class_name,

'balance': self.balance(), # 此處調(diào)用的是子類重載過的方法

}

# 方法重載

def balance(self):

# Account.__balance 為私有屬性，子類無法訪問，所以父類提供方法進(jìn)行訪問

return Account.balance(self) * 1.1

class Student(Person, Account):

"""學(xué)生"""

_teacher_name = ''

def __init__(self, name, age=18):

# 第二種重載父類__init__()構(gòu)造方法

# 父類名稱.__init__(self,參數(shù)1，參數(shù)2，...)

Person.__init__(self, name, age)

def get_info(self):

# 以字典的形式返回個(gè)人信息

return {

'name': self.name, # 此處訪問的是父類Person的屬性值

'age': self.age,

'teacher_name': self._teacher_name,

'balance': self.balance(),

}

# 教師 John

john = Teacher('John')

john.balance_add(20)

john.set_age(36) # 子類的實(shí)例可以直接調(diào)用父類的方法

print("John's info:", john.get_info())

# 學(xué)生 Mary

mary = Student('Mary', 18)

mary.balance_add(18)

print("Mary's info:", mary.get_info())

# 學(xué)生 Fake

fake = 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))

# 類方法、類屬性

print('Account.total_balance():', Account.total_balance())

print('Teacher.total_balance():', Teacher.total_balance())

print('Student.total_balance():', Student.total_balance())

# 重載專有方法

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(): 0Teacher.total_balance(): 20Student.total_balance(): 48這里重載了 __str__ 專有方法, {'name': 'Fake', 'age': 18}

錯(cuò)誤和異常

語法錯(cuò)誤

SyntaxError 類表示語法錯(cuò)誤，當(dāng)解釋器發(fā)現(xiàn)代碼無法通過語法檢查時(shí)會(huì)觸發(fā)的錯(cuò)誤。語法錯(cuò)誤是無法用 try...except...捕獲的。

>>> print:

File "", line 1

print:

^

SyntaxError: invalid syntax

異常

即便程序的語法是正確的，在運(yùn)行它的時(shí)候，也有可能發(fā)生錯(cuò)誤。運(yùn)行時(shí)發(fā)生的錯(cuò)誤被稱為異常。 錯(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 ... 的語法結(jié)構(gòu)來捕獲和處理異常。

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

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

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

如果在執(zhí)行 try 子句的過程中發(fā)生了異常，那么 try 子句余下的部分將被忽略。如果異常的類型和 except 之后的名稱相符，那么對(duì)應(yīng)的 except 子句將被執(zhí)行。最后執(zhí)行 try 語句之后的代碼。

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

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

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

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

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

最后一個(gè) except 子句可以忽略異常的名稱，它將被當(dāng)作通配符使用。可以使用這種方法打印一個(gè)錯(cuò)誤信息，然后再次把異常拋出。

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

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

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

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

拋出異常

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

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

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

自定義異常

可以通過創(chuàng)建一個(gè)新的異常類來擁有自己的異常。異常類繼承自 Exception 類，可以直接繼承，或者間接繼承。

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

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

實(shí)例

import sys

class 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 = message

try:

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)

pass

except (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)無任何異常時(shí), 會(huì)執(zhí)行 else 子句"""

print('"else" 子句...')

finally:

"""無論有無異常, 均會(huì)執(zhí)行 finally"""

print('finally, ending')

文件操作

打開文件

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

open(filename, mode)

filename：包含了你要訪問的文件名稱的字符串值

mode：決定了打開文件的模式：只讀，寫入，追加等

文件打開模式：

文件對(duì)象方法

fileObject.close()

close() 方法用于關(guān)閉一個(gè)已打開的文件。關(guān)閉后的文件不能再進(jìn)行讀寫操作，否則會(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() 方法是用來刷新緩沖區(qū)的，即將緩沖區(qū)中的數(shù)據(jù)立刻寫入文件，同時(shí)清空緩沖區(qū)，不需要是被動(dòng)的等待輸出緩沖區(qū)寫入。

一般情況下，文件關(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() 通過迭代器調(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 表示開頭, 如果是 1 表示當(dāng)前位置, 2 表示文件的結(jié)尾。whence 值為默認(rèn)為0，即文件開頭。例如：

seek(x, 0)：從起始位置即文件首行首字符開始移動(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() 方法用于從文件的首行首字符開始截?cái)啵財(cái)辔募?size 個(gè)字符，無 size 表示從當(dāng)前位置截?cái)啵唤財(cái)嘀?V 后面的所有字符被刪除，其中 Widnows 系統(tǒng)下的換行代表2個(gè)字符大小。

fileObject.write([str])

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

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

如果文件打開模式帶 b，那寫入文件內(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() 方法用于向文件中寫入一序列的字符串。這一序列字符串可以是由迭代對(duì)象產(chǎn)生的，如一個(gè)字符串列表。換行需要指定換行符 。

實(shí)例

filename = 'data.log'

# 打開文件(a+ 追加讀寫模式)

# 用 with 關(guān)鍵字的方式打開文件，會(huì)自動(dòng)關(guān)閉文件資源

with open(filename, 'w+', encoding='utf-8') as file:

print('文件名稱: {}'.format(file.name))

print('文件編碼: {}'.format(file.encoding))

print('文件打開模式: {}'.format(file.mode))

print('文件是否可讀: {}'.format(file.readable()))

print('文件是否可寫: {}'.format(file.writable()))

print('此時(shí)文件指針位置為: {}'.format(file.tell()))

# 寫入內(nèi)容

num = file.write("第一行內(nèi)容

")

print('寫入文件 {} 個(gè)字符'.format(num))

# 文件指針在文件尾部，故無內(nèi)容

print(file.readline(), file.tell())

# 改變文件指針到文件頭部

file.seek(0)

# 改變文件指針后，讀取到第一行內(nèi)容

print(file.readline(), file.tell())

# 但文件指針的改變，卻不會(huì)影響到寫入的位置

file.write('第二次寫入的內(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()

輸出：

文件名稱: data.log

文件編碼: utf-8

文件打開模式: w+

文件是否可讀: True

文件是否可寫: True

此時(shí)文件指針位置為: 0

寫入文件 6 個(gè)字符

16

第一行內(nèi)容

16

41

第一行內(nèi)容

第二次

['第一行內(nèi)容

', '第二次寫入的內(nèi)容

']

第一行內(nèi)容

第二次寫入的內(nèi)容

序列化

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

方法

dump

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

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

必填參數(shù) obj 表示將要封裝的對(duì)象。 必填參數(shù) file 表示 obj 要寫入的文件對(duì)象，file 必須以二進(jìn)制可寫模式打開，即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)制可讀模式打開，即rb，其他都為可選參數(shù)。

dumps

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

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 pickle

data = [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']q(KKKe.'

pickle.loads(): [1, 2, 3]

pickle.load(): [1, 2, 3]

命名規(guī)范

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

-END-

Python 面向?qū)ο缶幊?/p>

版權(quán)聲明：本文內(nèi)容由網(wǎng)絡(luò)用戶投稿，版權(quán)歸原作者所有，本站不擁有其著作權(quán)，亦不承擔(dān)相應(yīng)法律責(zé)任。如果您發(fā)現(xiàn)本站中有涉嫌抄襲或描述失實(shí)的內(nèi)容，請(qǐng)聯(lián)系我們jiasou666@gmail.com 處理，核實(shí)后本網(wǎng)站將在24小時(shí)內(nèi)刪除侵權(quán)內(nèi)容。

版權(quán)聲明：本文內(nèi)容由網(wǎng)絡(luò)用戶投稿，版權(quán)歸原作者所有，本站不擁有其著作權(quán)，亦不承擔(dān)相應(yīng)法律責(zé)任。如果您發(fā)現(xiàn)本站中有涉嫌抄襲或描述失實(shí)的內(nèi)容，請(qǐng)聯(lián)系我們jiasou666@gmail.com 處理，核實(shí)后本網(wǎng)站將在24小時(shí)內(nèi)刪除侵權(quán)內(nèi)容。