作者：上官佳雨

第一講知識導圖

image

變量、運算符與數(shù)據(jù)類型

• 注釋

• 單行注釋：#

• 多行注釋：''' ''' 或者 """ """

• 運算符

• 算術(shù)運算符：+ - * / // % **

• 比較運算符：> >= < <= == !=

• 邏輯運算符：and, or, not

• 位運算符：~ & | ^ << >>

• 三元運算符

• 三元運算符通常在Python里被稱為條件表達式，它可以使用一條語句來完成條件判斷和賦值操作。

• 語法形式：True_statements if expression else False_statements

• 其他運算符：in, not in, is, is not

• ? is, is not （是&不是）對比的是兩個變量的<u>內(nèi)存地址</u>，==, != （等于&不等于）對比的是兩個變量的<u>值</u>。

• 比較的兩個變量，指向的都是<u>地址不可變</u>的類型（str等），那么is，is not 和 ==，！= 是<u>完全等價</u>的。

• 對比的兩個變量，指向的是<u>地址可變</u>的類型（list，dict，tuple等），則兩者是有區(qū)別的。

• 運算符的優(yōu)先級

• 一元運算符優(yōu)于二元運算符。

• 先算術(shù)運算，后移位運算，最后位運算。

• 邏輯運算最后結(jié)合。

• 變量和賦值

• 使用變量前，需要對其先賦值。

• 變量名可以包括字母、數(shù)字、下劃線、但變量名不能以數(shù)字開頭。

• Python 變量名是大小寫敏感的。

• 數(shù)據(jù)類型與轉(zhuǎn)換

• 整型（int）

• 浮點型（float）

• ?調(diào)整精度

• str.format() 方法：使用字符串格式化來產(chǎn)生限定長度的有效位數(shù)。

image

<figcaption>例如：print(&quot;{:.2f}&quot;.format(3.1415926)) —&gt;輸出3.14</figcaption>

• round() 函數(shù)：不精確但可以用來“事后舍入”，使得實際的結(jié)果值可以做相互比較。
  語法形式：round(number[, ndigits])?返回 number 舍入到小數(shù)點后 ndigits 位精度的值。 如果 ndigits 被省略或為 None，則返回最接近輸入值的整數(shù)。

• decimal 模塊：如果需要非常精確的結(jié)果（如會計方面的應(yīng)用），可以用 decimal 包里的 Decimal 對象和 getcontext() 方法來實現(xiàn)，用用 getcontext().prec 來調(diào)整精度。

• 布爾型（bool）

• 數(shù)字運算中，用 1 和 0 代表 True 和 False。

• ?確定bool(X) 的值是 True 還是 False，就看 <u>X 是不是空</u>。

• 對于數(shù)值變量，0, 0.0 都可認為是空的。

print(type(10.31), bool(0.00), bool(10.31))

運行結(jié)果為：
<class 'float'> False True

• 對于<u>容器變量</u>，里面沒元素就是空的。eg. '', (), [], {}, set()

print(type(''), bool(''), bool('python'))

運行結(jié)果為：
 <class 'str'> False True

• 獲取類型信息

• type(object)

• isinstance(object, classinfo)
  classinfo -- 可以是直接或間接類名、基本類型或者由它們組成的元組。eg. ?int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

• 兩個函數(shù)的區(qū)別：

• type() 不會認為子類是一種父類類型，不考慮繼承關(guān)系。

• isinstance() 會認為子類是一種父類類型，考慮繼承關(guān)系。

• 如果要<u>判斷兩個類型是否相同</u>推薦使用 isinstance()。

• 類型轉(zhuǎn)換

• 轉(zhuǎn)換為整型 int(x, base=10)

• 轉(zhuǎn)換為字符串 str(object='')

• 轉(zhuǎn)換為浮點型 float(x)

• 轉(zhuǎn)化為布爾型 bool(x)

• print() 函數(shù)

• 語法形式：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• sep是實現(xiàn)分隔符。

• end是輸出結(jié)束時的字符，默認是換行符\n。

• file是定義流輸出的文件。

• flush是立即把內(nèi)容輸出到流文件，不作緩存。

位運算

• 二進制3種表示形式：原碼、反碼和補碼

• 符號位：最高位為符號位，0表示正數(shù)，1表示負數(shù)。在位運算中符號位也參與運算。

• 原碼：就是其二進制表示，有一位符號位。

• 反碼：正數(shù)的反碼就是原碼，負數(shù)的反碼是符號位不變，其余位取反（對應(yīng)正數(shù)按位取反）。

• 補碼：正數(shù)的補碼就是原碼，負數(shù)的補碼是反碼+1。
  計算機內(nèi)部使用補碼來表示。

• 按位非操作 ~

• ~ 把num的補碼中的 0 和 1 全部取反（0 變?yōu)?1，1 變?yōu)?0）

• 按位與操作 &

• 只有兩個對應(yīng)位都為 1 時才為 1

• 按位或操作 |

• 只要兩個對應(yīng)位中有一個 1 時就為 1

• 按位異或操作 ^

• 只有兩個對應(yīng)位不同時才為 1

• 異或操作的性質(zhì)：滿足交換律和結(jié)合律

• 按位左移操作 <<

• num << i 將num的二進制表示向左移動i位所得的值。

• 按位右移操作 >>

• num >> i 將num的二進制表示向右移動i位所得的值。

• 利用位運算實現(xiàn)快速計算

• 通過 <<，>> 快速計算2的倍數(shù)問題。

• n << 1 -> 計算 n*2

• n >> 1 -> 計算 n/2，負奇數(shù)的運算不可用

• n << m -> 計算 n*(2^m)，即乘以 2 的 m 次方

• n >> m -> 計算 n/(2^m)，即除以 2 的 m 次方

• 1 << n -> 2^n

• 通過 ^ 快速交換兩個整數(shù)。

a ^= b
b ^= a
a ^= b

# 相當于 a, b = b, a

• 通過 a & (-a) 快速獲取a的最后為 1 位置的整數(shù)。

• 利用位運算實現(xiàn)整數(shù)集合

• 一個數(shù)的二進制表示可以看作是一個集合（0 表示不在集合中，1 表示在集合中）。

• 元素與集合的操作：

• a | (1<<i) -> 把 i 插入到集合中

• a & ~(1<<i) -> 把 i 從集合中刪除

• a & (1<<i) -> 判斷 i 是否屬于該集合（零不屬于，非零屬于）

• 集合之間的操作：

• a 補 -> ~a

• a 交 b -> a & b

• a 并 b -> a | b

• a 差 b -> a & (~b)

條件語句

• if 語句

• 單個 if 語句中的 expression 條件表達式可以通過布爾操作符 and，or和not 實現(xiàn)<u>多重條件判斷</u>。

if 2 > 1 and not 2 > 3:
    print('Correct Judgement!')

運行結(jié)果為：
Correct Judgement!

• if - else 語句

• if語句支持嵌套，即在一個if語句中嵌入另一個if語句，從而構(gòu)成<u>不同層次的選擇結(jié)構(gòu)</u>。

hi = 6
if hi > 2:
    if hi > 7:
        print('好棒！好棒！')
else:
    print('切~')

運行結(jié)果為：
無輸出

• if - elif - else 語句

• elif 語句即為 else if，用來檢查多個表達式是否為真，并在為真時執(zhí)行<u>特定代碼塊</u>中的代碼。

• assert 關(guān)鍵詞

• assert這個關(guān)鍵詞稱為“斷言”，當這個關(guān)鍵詞后邊的條件為 False 時，程序自動崩潰并拋出<u>AssertionError</u>的異常。

• 在進行<u>單元測試</u>時，可以用來在程序中置入檢查點，只有條件為 True 才能讓程序正常工作。

assert 3 > 7

運行報錯：
AssertionError

循環(huán)語句

• while 循環(huán)

• while后可以寫入一個<u>非零整數(shù)</u>，也可以寫入<u>str、list或任何序列</u>，值/長度非零則視為真值，執(zhí)行循環(huán)體；否則視為假值，不執(zhí)行循環(huán)體。

• while - else 循環(huán)

• 當while循環(huán)<u>正常執(zhí)行完</u>的情況下，執(zhí)行else輸出。

• 如果while循環(huán)中執(zhí)行了<u>跳出循環(huán)</u>的語句，比如 break，將<u>不執(zhí)行else代碼塊</u>的內(nèi)容。

• for 循環(huán)

• for循環(huán)是迭代循環(huán)，相當于一個通用的序列迭代器，可以遍歷任何<u>有序序列</u>（str、list、tuple等），也可以遍歷任何<u>可迭代對象</u>（dict）。
  for 循環(huán)實際上創(chuàng)建了一個迭代器對象，并為每個循環(huán)執(zhí)行 next() 方法。

• 每次循環(huán)，迭代變量被設(shè)置為可迭代對象的當前元素，提供給代碼塊使用。

• for - else 循環(huán)
  與while - else語句類似。

• 當for循環(huán)<u>正常執(zhí)行完</u>的情況下，執(zhí)行else輸出。

• 如果for循環(huán)中執(zhí)行了<u>跳出循環(huán)</u>的語句，比如 break，將<u>不執(zhí)行else代碼塊</u>的內(nèi)容

• range() 函數(shù)（是BIF（Built-in functions））

• 語法形式：range([start,] stop, [step=1])

• start和step兩個參數(shù)可選

• step參數(shù)的默認值是1

• ? range 生成的序列包含start的值但<u>不包含stop的值</u>。

• enumerate()函數(shù)

• 語法形式：enumerate(sequence, [start=0])

• sequence：一個序列、迭代器或其他支持迭代對象。

• start：下標起始位置。用 enumerate(A, j) 還可以確定索引起始值為 j。

• 返回值： enumerate(枚舉) 對象，

• 例如：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

• 用 enumerate(A) 不僅返回了 A 中的<u>元素</u>，還順便給該元素一個<u>索引值</u> (默認從 0 開始)。

• enumerate()與 for 循環(huán)的結(jié)合使用。

for i, a in enumerate(A)
    do something with a

• break 語句

• break語句可以跳出<u>當前所在層的循環(huán)</u>。（while，for語句等......）

• continue 語句

• continue終止本輪循環(huán)并開始下一輪循環(huán)。

• pass 語句

• pass是空語句，不做任何操作，只起到<u>占位</u>的作用，其作用是為了保持程序結(jié)構(gòu)的完整性。

• 盡管pass語句不做任何操作，但如果<u>暫時不確定要在一個位置放上什么樣的代碼</u>，可以先放置一個pass語句，讓代碼可以正常運行。

• 推導式

• 列表推導式：[ expr forvalue in collection [ifcondition] ]

a = [(i, j) for i in range(0, 3) for j in range(0, 3)]
print(a)

運行結(jié)果為：
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

• 元組推導式：( expr forvalue in collection [ifcondition] )

a = (x for x in range(10))
print(a)

運行結(jié)果為：
<generator object <genexpr> at 0x0000025BE511CC48>

print(tuple(a))

運行結(jié)果為：
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

• 元組推導式生成的結(jié)果是一個生成器對象（與列表推導式不同）。

• 獲得新元組或新元組中的元素，有以下三種方式：

• 1. 使用 tuple() 函數(shù)，可以直接將生成器對象轉(zhuǎn)換成元組。

a = (x for x in range(1,10))
print(tuple(a))

運行結(jié)果為：
(1, 2, 3, 4, 5, 6, 7, 8, 9)

• 2. 直接使用 for 循環(huán)遍歷生成器對象，可以獲得各個元素。

a = (x for x in range(1,10))
for i in a:
    print(i,end=' ')
print(tuple(a))

運行結(jié)果為：
1 2 3 4 5 6 7 8 9 ()

• 3. 使用next() 方法遍歷生成器對象，也可以獲得各個元素。

a = (x for x in range(3))
print(a.__next__())
print(a.__next__())
print(a.__next__())
a = tuple(a)
print("轉(zhuǎn)換后的元組：",a)

運行結(jié)果為：
0
1
2
轉(zhuǎn)換后的元組： ()

• 注意<u>遍歷后原生成器對象將不復存在</u>，會得到空元組！

Python元組推導式?c.biancheng.net

• 字典推導式：{ key_expr: value_expr for value in collection [if condition] }

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)

運行結(jié)果為：
{0: True, 3: False, 6: True, 9: False}

• 集合推導式：{ expr for value in collection [if condition] }

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)

運行結(jié)果為：
{1, 2, 3, 4, 5, 6}

• 其它：next(iterator[, default])

• Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.

異常處理

• Python 標準異常總結(jié)（常見）

image

<figcaption>上圖為Python異常體系中的部分關(guān)系。</figcaption>

• BaseException：所有異常的基類

• Exception：常規(guī)異常的基類

• OverflowError：數(shù)值運算超出最大限制

• ZeroDivisionError：除數(shù)為零

• AssertionError：斷言語句（assert）失敗

• AttributeError：嘗試訪問未知的對象屬性

• OSError：操作系統(tǒng)產(chǎn)生的異常（例如打開一個不存在的文件）

• ImportError：導入模塊失敗的時候

• IndexError：索引超出序列的范圍

• KeyError：字典中查找一個不存在的關(guān)鍵字

• MemoryError：內(nèi)存溢出（可通過刪除對象釋放內(nèi)存）

• NameError：嘗試訪問一個不存在的變量

• SyntaxError：語法錯誤導致的異常

• TypeError：不同類型間的無效操作

• ValueError：傳入無效的參數(shù)

• Python 標準警告總結(jié)

• try - except 語句

• 語法形式：

try:
    檢測范圍
except Exception[as reason]:
    出現(xiàn)異常后的處理代碼

• 工作方式：

• 首先，執(zhí)行try子句。

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

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

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

• 注意：

• 使用except而不帶任何異常類型，不是一個很好的方式。我們不能通過該程序識別出具體的異常信息，因為<u>它捕獲所有的異常</u>。

• 一個try語句可能包含多個except子句，分別來處理不同的特定的異常。<u>最多只有一個分支會被執(zhí)行。</u>

• 使用多個except代碼塊時，必須堅持對其規(guī)范排序，要<u>從最具針對性的異常到最通用的異常。</u>

dict1 = {'a': 1, 'b': 2, 'v': 22}
try:
    x = dict1['y']
except KeyError:
    print('鍵錯誤')
except LookupError:
    print('查詢錯誤')
else:
    print(x)

運行結(jié)果為：
鍵錯誤

• 一個 except 子句可以同時處理多個異常，這些異常將被放在一個括號里成為一個<u>元組</u>。

try:
    s = 1 + '1'
    int("abc")
    f = open('test.txt')
    print(f.read())
    f.close()
except (OSError, TypeError, ValueError) as error:
    print('出錯了！\n原因是：' + str(error))

運行結(jié)果為：
出錯了！
原因是：unsupported operand type(s) for +: 'int' and 'str'

• try - except - finally 語句

• 語法形式：

try:
    檢測范圍
except Exception[as reason]:
    出現(xiàn)異常后的處理代碼
finally:
    不管try子句里面有沒有發(fā)生異常,都會被執(zhí)行的代碼

• 如果一個異常在try子句里被拋出，而又沒有任何的except把它截住，那么這個異常會在finally子句執(zhí)行后被拋出。

• try - except - else 語句

• 語法形式：

try:
    檢測范圍
except:
    出現(xiàn)異常后的處理代碼
else:
    如果沒有異常執(zhí)行這塊代碼

• 注意：else語句的存在必須以except語句的存在為前提，在沒有except語句的try語句中使用else語句，會引發(fā)語法錯誤。

• raise語句

• Python 使用raise語句拋出一個指定的異常。

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')

運行結(jié)果為：
An exception flew by!

python 多重嵌套循環(huán)跳出方法記錄

目的:多重嵌套循環(huán)的情況下,最里面一層循環(huán)中止時,直接中止整個多重嵌套循環(huán).

for i in range(10): # 循環(huán)2
    for j in range(9): # 循環(huán)1
        print(j)
        if i ==3 and j == 2:
            break  # break1
    else:
        continue
    break  # break2

重點在于 continue 和 break 的配合使用

循環(huán)1為 for-else模式

循環(huán)1的結(jié)果只會有2種情況: 1.循環(huán)結(jié)束,執(zhí)行else部分; 2.符合if判斷條件,循環(huán)中斷,執(zhí)行if下的break.

那么就是說,如果循環(huán)1完成一個循環(huán),那么就繼續(xù)進行循環(huán)2的下一個循環(huán),如果循環(huán)1的循環(huán)中斷,那么循環(huán)2也必須要中斷,跳出整個嵌套循環(huán)(目的)

也就是說,

循環(huán)1的情況2,循環(huán)break中斷之后,循環(huán)2也必須break,因此與循環(huán)1同級,在循環(huán)1之后放了break2.

循環(huán)1的情況1,循環(huán)結(jié)束,此時不能執(zhí)行循環(huán)2的break2,因此在else下放了continue,在循環(huán)1結(jié)束后會執(zhí)行else部分的continue,這個continue是對循環(huán)2起作用,因此會跳過執(zhí)行break2,進行循環(huán)2的下一輪循環(huán).

至此,目的達到.