合工大python期末复习知识点汇总
文章目錄
- Python序列
- map函數(shù)
- eval函數(shù)
- divmod
- sort sorted
- os與os.path模塊
- 列表
- 切片
- 列表推導(dǎo)式
- 編寫算法實現(xiàn)嵌套列表的平鋪
- 列出當(dāng)前文件夾下所有Python源文件
- 元組
- 序列解包(sequence unpacking
- 生成器推導(dǎo)式
- 字典
- 集合
- 其他數(shù)據(jù)結(jié)構(gòu)：隊列 堆棧 二叉樹
- 程序的控制結(jié)構(gòu)
- 應(yīng)用
- 例：編寫程序，判斷今天是今年的第幾天？
- 例：計算1+2+3+…+100 的值。
- 例：輸出“水仙花數(shù)”。
- 例：判斷一個數(shù)是否為素數(shù)。
- 例：生成一個含有20個隨機數(shù)的列表，
- 計算百錢買百雞問題。
- 例 編寫程序，實現(xiàn)十進(jìn)制整數(shù)到其他任意進(jìn)制的轉(zhuǎn)換。
- 例 計算前n個自然數(shù)的階乘之和1!+2!+3!+...+n!的值。
- 例 判斷一個數(shù)字是否為丑數(shù)。
- 字符串和正則表達(dá)式
- find()、rfind()、index()、rindex()、count()
- split()
- join
- 格式化
- 與字符串處理有關(guān)的標(biāo)準(zhǔn)庫
- 編寫程序，把一個英文句子中的單詞倒置
- 例： 編寫程序，查找一個字符串中最長的數(shù)字子串。
- 面向?qū)ο蟪绦蛟O(shè)計
- self參數(shù)：
- 私有成員和公有成員
- 類中的方法
- 屬性
- 繼承
Python序列
| 類型名稱 | list | tuple | dict | set |
| 定界符 | 方括號[] | 圓括號() | 大括號{} | 大括號{} |
| 是否可變 | 是 | 否 | 是 | 是 |
| 是否有序 | 是 | 是 | 否 | 否 |
| 是否支持下標(biāo) | 是(序號作為下標(biāo)) | 是(序號作為下標(biāo)) | 是(“鍵”作為下標(biāo)) | 否 |
| 元素分隔符 | 逗號 | 逗號 | 逗號 | 逗號 |
| 對元素形式的要求 | 無 | 無 | 鍵:值 | 必須可哈希 |
| 對元素值的要求 | 無 | 無 | “鍵”必須可哈希 | 必須可哈希 |
| 元素是否可重復(fù) | 是 | 是 | “鍵”不允許重復(fù)，“值”可以重復(fù) | 否 |
| 元素查找速度 | 非常慢 | 很慢 | 非常快 | 非常快 |
| 新增和刪除元素速度 | 尾部操作快 其他位置慢 | 不允許 | 快 | 快 |
map函數(shù)
>>> def square(x) : # 計算平方數(shù) ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 計算列表各個元素的平方 <map object at 0x100d3d550> # 返回迭代器 >>> list(map(square, [1,2,3,4,5])) # 使用 list() 轉(zhuǎn)換為列表 [1, 4, 9, 16, 25] >>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函數(shù) [1, 4, 9, 16, 25]eval函數(shù)
以下展示了使用 eval() 方法的實例：>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85eval(input()如果輸入的是數(shù)字，則轉(zhuǎn)換為數(shù)字；如果不是數(shù)字，報錯。
int(input())如果是數(shù)字，整數(shù)的話，沒為題，小數(shù)的話，丟失小數(shù)部分；如果不是數(shù)字，報錯。
divmod
Python divmod() 函數(shù)：
接收兩個數(shù)字類型（非復(fù)數(shù)）參數(shù)，返回一個包含商和余數(shù)的元組(a // b, a % b)
sort sorted
“sort()與sorted()的不同在于,sort是在原位重新排列列表,而sorted()是產(chǎn)生一個新的列表
??sort 是應(yīng)用在 list 上的方法，屬于列表的成員方法，sorted 可以對所有可迭代的對象進(jìn)行排序操作。
??list 的 sort 方法返回的是對已經(jīng)存在的列表進(jìn)行操作，而內(nèi)建函數(shù) sorted 方法返回的是一個新的 list，而不是在原來的基礎(chǔ)上進(jìn)行的操作。
??sort使用方法為ls.sort()，而sorted使用方法為sorted(ls)。
os與os.path模塊
| access(path, mode) | 測試是否可以按照mode指定的權(quán)限訪問文件 |
| chdir(path) | 把path設(shè)為當(dāng)前工作目錄 |
| chmod(path, mode, *, dir_fd=None, follow_symlinks=True) | 改變文件的訪問權(quán)限 |
| curdir | 當(dāng)前文件夾 |
| environ | 包含系統(tǒng)環(huán)境變量和值的字典 |
| extsep | 當(dāng)前操作系統(tǒng)所使用的文件擴展名分隔符 |
| get_exec_path() | 返回可執(zhí)行文件的搜索路徑 |
| getcwd() | 返回當(dāng)前工作目錄 |
| listdir(path) | 返回path目錄下的文件和目錄列表 |
| open(path, flags, mode=0o777, *, dir_fd=None) | 按照mode指定的權(quán)限打開文件，默認(rèn)權(quán)限為可讀、可寫、可執(zhí)行 |
| popen(cmd, mode=‘r’, buffering=-1) | 創(chuàng)建進(jìn)程，啟動外部程序 |
列表
??列表是Python中內(nèi)置有序、可變序列，列表的所有元素放在一對中括號“[]”中，并使用逗號分隔開；
??當(dāng)列表元素增加或刪除時，列表對象自動進(jìn)行擴展或收縮內(nèi)存，保證元素之間沒有縫隙；
??在Python中，一個列表中的數(shù)據(jù)類型可以各不相同
可以同時分別為整數(shù)、浮點數(shù)、字符串等基本類型，甚至是列表、元組、字典、集合以及其他自定義類型的對象。
列表常用方法
| lst *= n | 更新列表lst, 其元素重復(fù)n次 |
| lst.append(x) | 將元素x添加至列表lst尾部 |
| lst.extend(L) 或lst += L | 將列表L中所有元素添加至列表lst尾部 |
| lst.insert(index, x) | 在列表lst指定位置index處添加元素x，該位置后面的所有元素后移一個位置 |
| lst.remove(x) | 在列表lst中刪除首次出現(xiàn)的指定元素，該元素之后的所有元素前移一個位置 |
| lst.pop([index]) | 刪除并返回列表lst中下標(biāo)為index（默認(rèn)為-1）的元素 |
| lst.clear() | 刪除列表lst中所有元素，但保留列表對象 |
| lst.index(x) | 返回列表lst中第一個值為x的元素的下標(biāo)，若不存在值為x的元素則拋出異常 |
| lst.count(x) | 返回指定元素x在列表lst中的出現(xiàn)次數(shù) |
| lst.reverse() | 對列表lst所有元素進(jìn)行逆序 |
| lst.sort(key=None, reverse=False) | 對列表lst中的元素進(jìn)行排序，key用來指定排序依據(jù)，reverse決定升序（False）還是降序（True） |
| lst.copy() | 返回列表lst的淺復(fù)制 |
（1）可以使用“+”運算符將元素添加到列表中
>>> aList = [3,4,5]>>> aList = aList + [7]>>> aList[3, 4, 5, 7]嚴(yán)格意義上來講，這并不是真的為列表添加元素，而是創(chuàng)建了一個新列表，并將原列表中的元素和新元素依次復(fù)制到新列表的內(nèi)存空間。
由于涉及大量元素的復(fù)制，該操作速度較慢，在涉及大量元素添加時不建議使用該方法。
（2）使用列表對象的append()方法在當(dāng)前列表尾部追加元素，原
地修改列表
所謂“原地”，是指不改變列表在內(nèi)存中的首地址。
是真正意義上的在列表尾部添加元素，速度較快。
3）使用列表對象的extend()方法可以將另一個迭代對象的所有元素添加 至該列表對象尾部。
通過extend()方法來增加列表元素也不改變其內(nèi)存首地址，屬原地操作。
（4）使用列表對象的insert()方法將元素添加至列表的指定位置。
>>> a.insert(3, 6) #在下標(biāo)為3的位置插入元素6>>> print(a)[1, 2, 3, 6, 2, 3, 4]>>> id(a)46036232（5）使用乘法來擴展列表對象，將列表與整數(shù)相乘，生成一個新列表， 新列表是原列表中元素的重復(fù)
>>> aList = aList*3 >>> aList [3, 5, 7, 3, 5, 7, 3, 5, 7] >>> bList [3,5,7] >>> id(aList), id(bList) (57092680, 57091464)??使用列表對象的count()方法統(tǒng)計指定元素在列表對象中出現(xiàn)的次數(shù)。
??使用in關(guān)鍵字來判斷一個值是否存在于列表中，返回結(jié)果為“True”或“False”。
切片
切片適用于列表、元組、字符串、range對象等類型，但作用于列表時功能最強大。
可以使用切片來截取列表中的任何部分，得到一個新列表，也可以通過切片來修改和刪除列表中部分元素，甚至可以通過切片操作為列表對象增加元素。
切片使用2個冒號分隔的3個數(shù)字來完成：
形式上，切片使用2個冒號分隔的3個數(shù)字來完成。
[start🔚step]
1
第一個數(shù)字start表示切片開始位置，默認(rèn)為0；
第二個數(shù)字end表示切片截止（但不包含）位置（默認(rèn)為列表長度）；
第三個數(shù)字step表示切片的步長（默認(rèn)為1）。
當(dāng)start為0時可以省略，當(dāng)end為列表長度時可以省略，當(dāng)step為1時可以省略，省略步長時還可以同時省略最后一個冒號。
當(dāng)step為負(fù)整數(shù)時，表示反向切片，這時start應(yīng)該在end的右側(cè)才行。
切片操作不會因為下標(biāo)越界而拋出異常，而是簡單地在列表尾部截斷或者返回一個空列表，代碼具有更強的健壯性。
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17] >>> aList[::] #返回包含所有元素的新列表 [3, 4, 5, 6, 7, 9, 11, 13, 15, 17] >>> aList[::-1] #逆序的所有元素 [17, 15, 13, 11, 9, 7, 6, 5, 4, 3] >>> aList[::2] #偶數(shù)位置，隔一個取一個 [3, 5, 7, 11, 15] >>> aList[1::2] #奇數(shù)位置，隔一個取一個 [4, 6, 9, 13, 17] >>> aList[3::] #從下標(biāo)3開始的所有元素 [6, 7, 9, 11, 13, 15, 17] >>> aList[3:6] #下標(biāo)在[3, 6)之間的所有元素 [6, 7, 9] >>> aList[0:100:1] #前100個元素，自動截斷 切片開始位置大于列表長度時，返回空列表 [3, 4, 5, 6, 7, 9, 11, 13, 15, 17] >>> aList[100:] #下標(biāo)100之后的所有元素，自動截斷 [] >>> aList[100] #直接使用下標(biāo)訪問會發(fā)生越界 IndexError: list index out of range >>> aList = [3, 5, 7] >>> aList[:2] = [1, 2] #替換前2個元素 >>> aList [1, 2, 7] >>> aList = list(range(10)) >>> aList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> aList[::2] = [0]*5 #替換偶數(shù)位置上的元素 >>> aList [0, 1, 0, 3, 0, 5, 0, 7, 0, 9] >>> aList[::2] = [0]*3列表推導(dǎo)式
列表推導(dǎo)式（又稱列表解析式）提供了一種簡明扼要的方法來創(chuàng)建列表。
它的結(jié)構(gòu)是在一個中括號里包含一個表達(dá)式，然后是一個for語句，然后是 0 個或多個 for 或者 if 語句。那個表達(dá)式可以是任意的，意思是你可以在列表中放入任意類型的對象。返回結(jié)果將是一個新的列表，在這個以 if 和 for 語句為上下文的表達(dá)式運行完成之后產(chǎn)生。
列表推導(dǎo)式的執(zhí)行順序：
各語句之間是嵌套關(guān)系，左邊第二個語句是最外層，依次往右進(jìn)一層，左邊第一條語句是最后一層。
[x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]
即：
編寫算法實現(xiàn)嵌套列表的平鋪
[[1,2,3], [4,5,6]] -> [1, 2, 3, 4, 5, 6] 解答一： >>> vec = [[1, 2, 3], [4, 5, 6]] >>> result = [] >>> for elem in vec:for num in elem:result.append(num)>>> result [1, 2, 3, 4, 5, 6] 解答二： >>> vec = [[1, 2, 3], [4, 5, 6]] >>> sum(vec, []) [1, 2, 3, 4, 5, 6, 7, 8, 9]解答三：使用列表推導(dǎo)式實現(xiàn) >>> vec = [[1,2,3], [4,5,6]] >>> [num for elem in vec for num in elem] [1, 2, 3, 4, 5, 6, 7, 8, 9]列出當(dāng)前文件夾下所有Python源文件
>>> import os >>> [filename for filename in os.listdir('.')if filename.endswith(('.py', '.pyw'))]過濾不符合條件的元素>>> aList = [-1,-4,6,7.5,-2.3,9,-11] >>> [i for i in aList if i>0] [6, 7.5, 9]元組
??元組一旦定義就不允許更改。
??元組沒有append()、extend()和insert()等方法，無法向元組中添加元素。
??元組沒有remove()或pop()方法，也無法對元組元素進(jìn)行del操作，不能從元組中刪除元素。
??使用tuple函數(shù)將其他序列轉(zhuǎn)換為元組
??元組的定義方式和列表相同，但定義時所有元素是放在一對圓括號“（）”中，而不是方括號中。
zip() 函數(shù)：用于將可迭代的對象作為參數(shù),將對象中對應(yīng)的元素打包成一個個元組,然后返回由這些元組組成的列表
>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 打包為元組的列表 [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) # 元素個數(shù)與最短的列表一致 [(1, 4), (2, 5), (3, 6)] >>> zip(*zipped) # 與 zip 相反，*zipped 可理解為解壓，返回二維矩陣式 [(1, 2, 3), (4, 5, 6)]tuple函數(shù)的使用：
>>> tuple('abcdefg') #把字符串轉(zhuǎn)換為元組 ('a', 'b', 'c', 'd', 'e', 'f', 'g') >>> aList [-1, -4, 6, 7.5, -2.3, 9, -11] >>> tuple(aList) #把列表轉(zhuǎn)換為元組 (-1, -4, 6, 7.5, -2.3, 9, -11) >>> s = tuple() #空元組 >>> s ()使用del可以刪除元組對象，不能刪除元組中的元素
元組的優(yōu)點
元組的速度比列表更快。如果定義了一系列常量值，而所需做的僅是對它進(jìn)行遍歷，那么一般使用元組而不用列表。
元組對不需要改變的數(shù)據(jù)進(jìn)行“寫保護(hù)”將使得代碼更加安全。
元組可用作字典的“鍵”，也可以作為集合的元素。列表永遠(yuǎn)不能當(dāng)做字典鍵使用，也不能作為集合的元素，因為列表不是不可變的。
序列解包(sequence unpacking
當(dāng)函數(shù)或方法返回元組時，將元組中值賦給變量序列中的變量，這個過程就叫做序列解包。
可以使用序列解包功能對多個變量同時賦值
序列解包遍歷多個序列
>>> keys = ['a', 'b', 'c', 'd']>>> values = [1, 2, 3, 4]>>> for k, v in zip(keys, values):print((k, v), end=' ')('a', 1) ('b', 2) ('c', 3) ('d', 4)使用序列解包遍歷enumerate對象
>>> x = ['a', 'b', 'c'] >>> for i, v in enumerate(x): print('The value on position {0} is {1}'.format(i,v))The value on position 0 is aThe value on position 1 is bThe value on position 2 is c >>> aList = [1,2,3]>>> bList = [4,5,6]>>> cList = [7,8,9]>>> dList = zip(aList, bList, cList)>>> for index, value in enumerate(dList):print(index, ':', value)0 : (1, 4, 7)1 : (2, 5, 8)2 : (3, 6, 9)生成器推導(dǎo)式
生成器推導(dǎo)式的結(jié)果是一個生成器對象。
使用生成器對象的元素時，可以根據(jù)需要將其轉(zhuǎn)化為列表或元組，也可以使用生成器對象__next__()方法或內(nèi)置函數(shù)next()進(jìn)行遍歷，或者直接將其作為迭代器對象來使用。
生成器對象具有惰性求值的特點，只在需要時生成新元素，比列表推導(dǎo)式具有更高的效率，空間占用非常少，尤其適合大數(shù)據(jù)處理的場合。
不管用哪種方法訪問生成器對象，都無法再次訪問已訪問過的元素。
字典
字典是無序、可變序列。
定義字典時，每個元素的鍵和值用冒號分隔，元素之間用逗號分隔，所有的元素放在一對大括號“｛｝”中。
字典中的鍵可以為任意不可變數(shù)據(jù)，比如整數(shù)、實數(shù)、復(fù)數(shù)、字符串、元組等等。
globals()返回包含當(dāng)前作用域內(nèi)所有全局變量和值的字典
locals()返回包含當(dāng)前作用域內(nèi)所有局部變量和值的字典
使用=將一個字典賦值給一個變量
>>> a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}>>> a_dict{'database': 'mysql', 'server': 'db.diveintopython3.org'}>>> x = {} #空字典>>> x{} 使用dict利用已有數(shù)據(jù)創(chuàng)建字典>>> keys = ['a', 'b', 'c', 'd']>>> values = [1, 2, 3, 4]>>> dictionary = dict(zip(keys, values))>>> dictionary{'a': 1, 'c': 3, 'b': 2, 'd': 4}>>> x = dict() #空字典>>> x{}集合
集合是無序、可變序列，使用一對大括號界定，元素不可重復(fù)，同一個集合中每個元素都是唯一的。
集合中只能包含數(shù)字、字符串、元組等不可變類型（或者說可哈希）的數(shù)據(jù)，而不能包含列表、字典、集合等可變類型的數(shù)據(jù)。
使用set將其他類型數(shù)據(jù)轉(zhuǎn)換為集合
>>> a_set = set(range(8,14))
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8]) #自動去除重復(fù)
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> c_set = set() #空集合
>>> c_set
set()
>>> e={}
>>> type(e)
<class 'dict’>
>>> f={4，}
>>> type(f)
<class ‘set’>
當(dāng)不再使用某個集合時，刪除方法包括：
?可以使用del命令刪除整個集合；
?集合對象的pop()方法彈出并刪除其中一個元素；
?remove()方法直接刪除指定元素；
?clear()方法清空集合。
| S.clear() | 移除S中所有數(shù)據(jù)項 |
| S.copy() | 返回集合S的一個拷貝 |
| S.pop() | 隨機返回集合S中的一個元素，如果S為空，產(chǎn)生KeyError異常 |
| S.discard(x) | 如果x在集合S中，移除該元素；如果x不在，不報錯 |
| S.remove(x) | 如果x在集合S中，移除該元素；不在產(chǎn)生KeyError異常 |
| S.isdisjoint(T) | 如果集合S與T沒有相同元素（不相交的），返回True |
| len(S) | 返回集合S元素個數(shù) |
| x in S | 如果x是S的元素，返回True，否則返回False |
| x not in S | 如果x不是S的元素，返回True，否則返回False |
| S – T 或 S.difference(T) | 返回一個新集合，包括在集合S中但不在集合T中的元素 |
| S-=T或S.difference_update(T) | 更新集合S，包括在集合S中但不在集合T中的元素 |
| S & T或S.intersection(T) | 返回一個新集合，包括同時在集合S和T中的元素 |
| S&=T或S.intersection_update(T) | 更新集合S，包括同時在集合S和T中的元素。 |
| S^T或s.symmetric_difference(T) | 返回一個新集合，包括集合S和T中元素，但不包括同時在其中的元素 |
| S=^T或s.symmetric_difference_update(T) | 更新集合S，包括集合S和T中元素，但不包括同時在其中的元素 |
| S|T或S.union(T) | 返回一個新集合，包括集合S和T中所有元素 |
| S=|T或S.update(T) | 更新集合S，包括集合S和T中所有元素 |
| S<=T或S.issubset(T) | 如果S與T相同或S是T的子集，返回True，否則返回False，可以用S<T判斷S是否是T的真子集 |
| S>=T或S.issuperset(T) | 如果S與T相同或S是T的超集，返回True，否則返回False，可以用S>T判斷S是否是T的真超集 |
生成不重復(fù)隨機數(shù)
def RandomNumbersBySet(number, start, end):data = set()while True:data.add(random.randint(start, end))if len(data) == number:breakreturn data
使用sorted排序：
>>> persons = [{‘name’:‘Li’, ‘a(chǎn)ge’:40}, {‘name’:‘Li’, ‘a(chǎn)ge’:37}, {‘name’:‘Dong’, ‘a(chǎn)ge’:43}]
>>> print(persons)
[{‘name’: ‘Li’, ‘a(chǎn)ge’: 40}, {‘name’: ‘Li’, ‘a(chǎn)ge’: 37}, {‘name’: ‘Dong’, ‘a(chǎn)ge’: 43}]
#使用key來指定排序依據(jù)，先按姓名升序排序，姓名相同的按年齡降序排序
>>> print(sorted(persons, key=lambda x:(x[‘name’], -x[‘a(chǎn)ge’])))
[{‘name’: ‘Dong’, ‘a(chǎn)ge’: 43}, {‘name’: ‘Li’, ‘a(chǎn)ge’: 40}, {‘name’: ‘Li’, ‘a(chǎn)ge’: 37}]
其他數(shù)據(jù)結(jié)構(gòu)：隊列 堆棧 二叉樹
堆
堆是非線性的樹形的數(shù)據(jù)結(jié)構(gòu)，包括：最大堆與最小堆。
heapq庫中的堆默認(rèn)是最小堆。
棧是一種“后進(jìn)先出（LIFO）”或“先進(jìn)后出（FILO）”的數(shù)據(jù)結(jié)構(gòu)。
自定義棧的用法>>> import Stack >>> x = Stack.Stack() >>> x.push(1) >>> x.push(2) >>> x.show() [1, 2] >>> x.pop() 2 >>> x.show() [1] >>> x.showRemainderSpace() Stack can still PUSH 9 elements. >>> x.isEmpty() False >>> x.isFull() FalsePython列表本身就可以實現(xiàn)棧結(jié)構(gòu)的基本操作。例如，列表對象的append()方法是在列表尾部追加元素，類似于入棧操作；pop()方法默認(rèn)是彈出并返回列表的最后一個元素，類似于出棧操作。
可以直接使用列表來實現(xiàn)棧結(jié)構(gòu)>>> myStack = [] >>> myStack.append(3) >>> myStack.append(5) >>> myStack.append(7) >>> myStack [3, 5, 7] >>> myStack.pop() 7 >>> myStack.pop() 5 >>> myStack.pop() 3 >>> myStack.pop() 出錯但是直接使用Python列表對象模擬棧操作并不是很方便，例如當(dāng)列表為空時再執(zhí)行pop()出棧操作時則會拋出一個不很友好的異常；另外，也無法限制棧的大小。
列表模擬隊列：
（將上面的pop改為pop(0)即可）
也可以使用標(biāo)準(zhǔn)庫中的Queue
>>> import queue >>> q = queue.Queue() >>> q.put(0) #入隊 >>> q.put(1) >>> q.put(2) >>> q.queue deque([0, 1, 2]) >>> q.get() #出隊 0 >>> q.queue deque([1, 2]) >>> q.get() 1 >>> q.queue優(yōu)先隊列(Priority Queue)
>>> from queue import PriorityQueue #優(yōu)先級隊列 >>> q = PriorityQueue() #創(chuàng)建優(yōu)先級隊列對象 >>> q.put(3) #插入元素 >>> q.put(8) #插入元素 >>> q.put(100) >>> q.queue #查看優(yōu)先級隊列中所有元素 [3, 8, 100] >>> q.put(1) #插入元素，自動調(diào)整優(yōu)先級隊列 >>> q.put(2) >>> q.queue [1, 2, 100, 8, 3] >>> q.get() #返回并刪除優(yōu)先級最低的元素 1 >>> q.get() #請多執(zhí)行幾次該語句并觀察返回的數(shù)據(jù) 2 >>> q.get() 3 >>> q.get() 8 >>> q.get() 100二叉樹：
使用代碼中的類BinaryTree創(chuàng)建的對象不僅支持二叉樹的創(chuàng)建以及前序遍歷、中序遍歷與后序遍歷等三種常用的二叉樹節(jié)點遍歷方式，還支持二叉樹中任意“子樹”的遍歷。
class BinaryTree:def __init__(self, value):self.__left = Noneself.__right = Noneself.__data = valuedef insertLeftChild(self, value): #創(chuàng)建左子樹if self.__left:print('__left child tree already exists.')else:self.__left = BinaryTree(value)return self.__left def preOrder(self): #前序遍歷print(self.__data) #輸出根節(jié)點的值if self.__left:self.__left.preOrder() #遍歷左子樹if self.__right:self.__right.preOrder() #遍歷右子樹def postOrder(self): #后序遍歷if self.__left:self.__left.postOrder()if self.__right:self.__right.postOrder()print(self.__data)def insertRightChild(self, value): #創(chuàng)建右子樹if self.__right:print('Right child tree already exists.')else:self.__right = BinaryTree(value)return self.__rightdef show(self):print(self.__data)程序的控制結(jié)構(gòu)
分支與循環(huán)結(jié)構(gòu): 例子： 一年365天，一周5個工作日，如果每個工作日都很努力，可以提高r%，僅在周末放任一下，能力值每天下降r%，效果如何呢？
dayup, r = 1.0, 0.01 for i in range(365):if i % 7 in [6, 0]:#周六周日dayup = dayup * (1 - r)else:dayup = dayup * (1 + r) print("向上5天向下2天的力量: {:.2f}.".format(dayup))在選擇和循環(huán)結(jié)構(gòu)中，都要使用條件表達(dá)式來確定下一步的執(zhí)行流程。
???條件表達(dá)式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元組、空集合、空字典、空字符串、空range對象或其他空迭代對象，Python解釋器均認(rèn)為與True等價。
???從這個意義上來講，幾乎所有的Python合法表達(dá)式都可以作為條件表達(dá)式，包括含有函數(shù)調(diào)用的表達(dá)式。
算術(shù)運算符：+、-、*、/、//、%、**
關(guān)系運算符：>、<、==、<=、>=、!=
測試運算符：in、not in、is、is not
邏輯運算符：and、or、not
位運算符：~、&、|、 ^、 <<、>>
矩陣乘法運算符：@
邏輯運算符and和or以及關(guān)系運算符具有惰性求值特點，只計算必須計算的表達(dá)式。
以“and”為例，對于表達(dá)式“表達(dá)式1 and 表達(dá)式2”而言，如果“表達(dá)式1”的值為“False”或其他等價值時，不論“表達(dá)式2”的值是什么，整個表達(dá)式的值都是“False”，此時“表達(dá)式2”的值無論是什么都不影響整個表達(dá)式的值，因此將不會被計算，從而減少不必要的計算和判斷。
應(yīng)用
用戶輸入若干個分?jǐn)?shù)，求所有分?jǐn)?shù)的平均分。每輸入一個分?jǐn)?shù)后詢問是否繼續(xù)輸入下一個分?jǐn)?shù)，回答“yes”就繼續(xù)輸入下一個
分?jǐn)?shù)，回答“no”就停止輸入分?jǐn)?shù)。
例：編寫程序，判斷今天是今年的第幾天？
>>>import time>>> date = time.localtime() #獲取當(dāng)前日期時間 time.struct_time(tm_year=2020, tm_mon=12, tm_mday=10, tm_hour=7, tm_min=27, tm_sec=36, tm_wday=3, tm_yday=345, tm_isdst=0) >>> year, month, day = date[:3] >>> day_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]>>> if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0): #判斷是否為閏年day_month[1] = 29>>> if month==1:print(day) else:print(sum(day_month[:month-1])+day)例：計算1+2+3+…+100 的值。
#解法一： s=0 for i in range(1,101):s = s + i print('1+2+3+…+100 = ', s) #解法二： print('1+2+3+…+100 = ', sum(range(1,101)))例：輸出“水仙花數(shù)”。
所謂水仙花數(shù)是指1個3位的十進(jìn)制數(shù)，其各位數(shù)字的立方和等于該數(shù)本身。例如：153是水仙花數(shù)，因為153 = 13 + 53 + 33 。
#解法一： for i in range(100, 1000):bai, shi, ge = map(int, str(i))if ge**3 + shi**3 + bai**3 == i:print(i)例：判斷一個數(shù)是否為素數(shù)。
import mathn = input('Input an integer:') n = int(n) m = math.ceil(math.sqrt(n)+1) for i in range(2, m):if n%i == 0 and i<n:print('No')break else:print('Yes')“ceil函數(shù)定義:將給定的數(shù)值轉(zhuǎn)換成大于或等于它的最小整數(shù)(取不小于給定值的最小整數(shù))”
例：生成一個含有20個隨機數(shù)的列表，
要求所有元素不相同，并且每個元素的值介于1到100之間。
import randomx = [] while True:if len(x)==20:breakn = random.randint(1, 100)if n not in x:x.append(n) print(x) print(len(x)) print(sorted(x))計算百錢買百雞問題。
假設(shè)公雞5元一只，母雞3元一只，小雞1元三只，現(xiàn)在有100塊錢，想買100只雞，問有多少種買法？
#假設(shè)能買x只公雞 for x in range(21):#假設(shè)能買y只母雞for y in range(34):#假設(shè)能買z只小雞z = 100-x-yif z%3==0 and 5*x + 3*y + z//3 == 100:print(x,y,z)例 編寫程序，實現(xiàn)十進(jìn)制整數(shù)到其他任意進(jìn)制的轉(zhuǎn)換。
編程要點：除基取余，逆序排列
十進(jìn)制數(shù)668轉(zhuǎn)換為八進(jìn)制數(shù)字的過程如下圖所示，其中橫著向右的箭頭表示左邊的數(shù)字除以8得到的商，而向下的箭頭表示上面的數(shù)字除以8得到的余數(shù)。當(dāng)商為0時，算法結(jié)束，最后把得到的余數(shù)4321逆序得到1234。
例 計算前n個自然數(shù)的階乘之和1!+2!+3!+…+n!的值。
n = evl(input(“n:”)) result, t = 1, 1 for i in range(2, n+1):t *= iresult += t例 判斷一個數(shù)字是否為丑數(shù)。
一個數(shù)的因數(shù)如果只包含2、3、5，那么這個數(shù)是丑數(shù)。
n = eval(input(“n:”))for i in (2, 3, 5):while True:m, r = divmod(n, i)if r != 0:breakelse:print(m)n = mprint(n==1)字符串和正則表達(dá)式
多種不同的編碼格式，常見的主要有UTF-8、UTF-16、UTF-32、GB2312、GBK、CP936、base64、CP437等；
GB2312是我國制定的中文編碼，使用1個字節(jié)表示英語，2個字節(jié)表示中文；GBK是GB2312的擴充，而CP936是微軟在GBK基礎(chǔ)上開發(fā)的編碼方式。GB2312、GBK和CP936都是使用2個字節(jié)表示中文；
UTF-8對全世界所有國家需要用到的字符進(jìn)行了編碼，以1個字節(jié)表示英語字符(兼容ASCII)，以3個字節(jié)表示常見漢字，還有些語言的符號使用2個字節(jié)（例如俄語和希臘語符號）或4個字節(jié)。
Python 3.x完全支持中文字符，默認(rèn)使用UTF8編碼格式，無論是一個數(shù)字、英文字母，還是一個漢字，在統(tǒng)計字符串長度時都按一個字符對待和處理。
字符串常用方法、
find()、rfind()、index()、rindex()、count()
find()和rfind方法分別用來查找一個字符串在另一個字符串指定范圍（默認(rèn)是整個字符串）中首次和最后一次出現(xiàn)的位置，如果不存在則返回-1；
Python find() 方法檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結(jié)束） 范圍，則檢查是否包含在指定范圍內(nèi)，如果包含子字符串返回開始的索引值，否則返回-1。
語法
find()方法語法：
str.find(str, beg=0, end=len(string))
index()和rindex()方法用來返回一個字符串在另一個字符串指定范圍中首次和最后一次出現(xiàn)的位置，如果不存在則拋出異常；
count()方法用來返回一個字符串在當(dāng)前字符串中出現(xiàn)的次數(shù)。
split()
split()和rsplit()方法如果不指定分隔符，則字符串中的任何空白符號（包括空格、換行符、制表符等）都被認(rèn)為是分隔符，返回包含最終分隔符的列表
split()和rsplit()方法還允許指定最大分割次數(shù)。
join
字符串連接join()
>>> li = ["apple", "peach", "banana", "pear"] >>> ','.join(li) 'apple,peach,banana,pear' >>> '::'.join(li) 'apple::peach::banana::pear'查找替換replace()，類似于Word中的“全部替換”功能。
>>> s = "中國，中國" >>> print(s) 中國，中國 >>> s2 = s.replace("中國", "中華人民共和國") #兩個參數(shù)都作為一個整體 >>> print(s2) 中華人民共和國，中華人民共和國應(yīng)用：測試用戶輸入中是否有敏感詞，如果有的話就把敏感詞替換為3個星號***。
>>> words = ('測試', '非法', '暴力', '話') >>> text = '這句話里含有非法內(nèi)容' >>> for word in words:if word in text:text = text.replace(word, '***') >>> textstrip()、rstrip()、lstrip()
>>> '\n\nhello world \n\n'.strip() #刪除空白字符 'hello world' >>> "aaaassddf".strip("a") #刪除指定字符 'ssddf' >>> "aaaassddfaaa".rstrip("a") #刪除字符串右端指定字符 'aaaassddf' >>> "aaaassddfaaa".lstrip("a") #刪除字符串左端指定字符 'ssddfaaa'Python字符串支持與整數(shù)的乘法運算，表示序列重復(fù)，也就是字符串內(nèi)容的重復(fù)，得到新字符串。
>>> 'abcd' * 3 'abcdabcdabcd's.startswith(t)、s.endswith(t)，判斷字符串是否以指定字符串開始或結(jié)束
isalnum()【用來判斷一個字符是否為英文字母或數(shù)字,相當(dāng)于 isalpha? || isdigit?】、isalpha()、isdigit()、isdecimal()【isdecimal() 方法檢查字符串是否只包含十進(jìn)制字符。】、isnumeric()、isspace()、isupper()、islower()，用來測試字符串是否為數(shù)字或字母、是否為字母、是否為數(shù)字字符、是否為空白字符、是否為大寫字母以及是否為小寫字母。
注意:定義一個十進(jìn)制字符串，只需要在字符串前添加 ‘u’ 前綴即可。
str = u"this2009";
print str.isdecimal();
str = u"23443434";
print str.isdecimal();
以上實例輸出結(jié)果如下：
False
True
格式化
在Python中，字符串屬于不可變序列類型，除了支持序列通用方法（包括分片操作）以外，還支持特有的字符串操作方法。
| %s | 字符串 (采用str()的顯示) |
| %r | 字符串 (采用repr()的顯示)詳細(xì) 見倒數(shù)第2頁PPT |
| %c | 單個字符 |
| %d | 十進(jìn)制整數(shù) |
| %i | 十進(jìn)制整數(shù) |
| %o | 八進(jìn)制整數(shù) |
| %x | 十六進(jìn)制整數(shù) |
| %e | 指數(shù) (基底寫為e) |
| %E | 指數(shù) (基底寫為E) |
| %f、%F | 浮點數(shù) |
| %g | 指數(shù)(e)或浮點數(shù) (根據(jù)顯示長度) |
| %G | 指數(shù)(E)或浮點數(shù) (根據(jù)顯示長度) |
| %% | 一個字符"%" |
例子
>>> int('555') 555 >>> '%s'%[1, 2, 3] #直接把對象轉(zhuǎn)換成字符串 '[1, 2, 3]' >>> str((1,2,3)) #直接把對象轉(zhuǎn)換成字符串 '(1, 2, 3)' >>> str([1,2,3]) '[1, 2, 3]' >>> list(str([1, 2, 3])) #字符串中的每個字符都成為列表的元素（特別注意空格哦，英文規(guī)范） ['[', '1', ',', ' ', '2', ',', ' ', '3', ']'] >>> eval(str([1, 2, 3])) #eval() 函數(shù)用來執(zhí)行一個字符串表達(dá)式，并返回表達(dá)式的值。 [1, 2, 3] >>>x = 7 >>> eval('3 * x') 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85.format:
基本語法是通過 {} 和 : 來代替以前的 % 。 format 函數(shù)可以接受不限個參數(shù)，位置可以不按順序。 >>>"{} {}".format("hello", "world") # 不設(shè)置指定位置，按默認(rèn)順序 'hello world’ >>> "{0} {1}".format("hello", "world") # 設(shè)置指定位置 'hello world’ >>> "{1} {0} {1}".format("hello", "world") # 設(shè)置指定位置 'world hello world’ 數(shù)字格式化： >>> print("{:.2f}".format(3.1415926)); 3.14一些內(nèi)置函數(shù)也可以操作字符串：
>>> x = 'Hello world.' >>> len(x) #字符串長度 12 >>> max(x) #最大字符 'w' >>> min(x) ' ' >>> list(zip(x,x)) #zip()也可以作用于字符串 [('H', 'H'), ('e', 'e'), ('l', 'l'), ('l', 'l'), ('o', 'o'), (' ', ' '), ('w', 'w'), ('o', 'o'), ('r', 'r'), ('l', 'l'), ('d', 'd'), ('.', '.')] >>> max(['abc', 'ABD'], key=str.upper) #忽略大小寫 'ABD'切片也適用于字符串，但僅限于讀取其中的元素，不支持字符串修改。
>>> 'Explicit is better than implicit.'[:8] 'Explicit' >>> 'Explicit is better than implicit.'[9:23] 'is better than與字符串處理有關(guān)的標(biāo)準(zhǔn)庫
#Python標(biāo)準(zhǔn)庫string中定義數(shù)字字符、標(biāo)點符號、英文字母、大寫字母、小寫字母等常量。>>> import string >>> string.digits '0123456789' >>> string.punctuation '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~' >>> string.ascii_letters 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' >>> string.ascii_lowercase 'abcdefghijklmnopqrstuvwxyz' >>> string.ascii_uppercase 'ABCDEFGHIJKLMNOPQRSTUVWXYZ應(yīng)用：隨機密碼生成原理。
string.ascii_uppercase 所有大寫字母
string.ascii_lowercase 所有小寫字母
string.ascii_letters 所有字母
>>> import string >>> characters = string.digits + string.ascii_letters >>> import random >>> ''.join([random.choice(characters) for i in range(8)]) 'J5Cuofhy' >>> ''.join([random.choice(characters) for i in range(10)]) 'RkHA3K3tNl' >>> ''.join([random.choice(characters) for i in range(16)]) 'zSabpGltJ0X4CCjh'編寫程序，把一個英文句子中的單詞倒置
標(biāo)點符號不倒置，例如 I like python. 經(jīng)過函數(shù)后變?yōu)?#xff1a;python. like I
def rev1(s):
return ’ '.join(reversed(s.split()))
def rev2(s):
t = s.split()
t.reverse()
return ’ '.join(t)
def rev5(s):
‘’‘字符串整體逆序，分隔，再各單詞逆序’’’
t = ‘’.join(reversed(s)).split()
t = map(lambda x:’’.join(reversed(x)), t)
return ’ '.join(t)
例： 編寫程序，查找一個字符串中最長的數(shù)字子串。
result = [] temp = [] str = input("請輸入字符串") for character in str:if '0' <= character <='9':temp.append(character)elif temp:result.append(''.join(temp))temp = [] if temp: # 用于處理結(jié)尾為數(shù)字的字符串的情況result.append(''.join(temp)) if result:print(result)print(max(result,key=len)) # 取列表中最大的元素，以元素的長度為條件 else:print("no")面向?qū)ο蟪绦蛟O(shè)計
Python完全采用了面向?qū)ο蟪绦蛟O(shè)計的思想，是真正面向?qū)ο蟮母呒墑討B(tài)編程語言，完全支持面向?qū)ο蟮幕竟δ?#xff0c;如封裝、繼承、多態(tài)以及對基類方法的覆蓋或重寫。
Python中對象的概念很廣泛，Python中的一切內(nèi)容都可以稱為對象，除了數(shù)字、字符串、列表、元組、字典、集合、range對象、zip對象等等，函數(shù)也是對象，類也是對象。
創(chuàng)建類時用變量形式表示的對象屬性稱為數(shù)據(jù)成員，用函數(shù)形式表示的對象行為稱為成員方法，成員屬性和成員方法統(tǒng)稱為類的成員。
Python使用class關(guān)鍵字來定義類
class關(guān)鍵字之后是一個空格，然后是類的名字，再然后是一個冒號，最后換行并定義類的內(nèi)部實現(xiàn)。
類名的首字母一般要大寫
當(dāng)然也可以按照自己的習(xí)慣定義類名，但一般推薦參考慣例來命名，并在整個系統(tǒng)的設(shè)計和實現(xiàn)中保持風(fēng)格一致。
類定義后，可以用來實例化對象，并通過“對象名.成員”的方式來訪問其中的數(shù)據(jù)成員或成員方法
car = Car()
car.infor()
This is a car
self參數(shù)：
???類的所有實例方法都必須至少有一個名為self的參數(shù)，且必須是方法的第一個形參（如果有多個形參的話），self參數(shù)代表將來要創(chuàng)建的對象本身。
???在類的實例方法中訪問實例屬性時需以self為前綴。
???在外部通過對象調(diào)用對象方法時并不需要傳遞這個參數(shù)，如果在外部通過類調(diào)用對象方法則需要顯式為self參數(shù)傳值。
???在類中定義實例方法時將第一個參數(shù)定義為“self”只是一個習(xí)慣，雖不必須使用，仍建議編寫代碼時仍以self作為方法的第一個參數(shù)名字。
???屬于實例的數(shù)據(jù)成員一般是指在構(gòu)造函數(shù)__init__()中定義的，定義和使用時必須以self作為前綴；屬于類的數(shù)據(jù)成員是在類中所有方法之外定義的。
???在主程序中（或類的外部），實例屬性屬于實例(對象)，只能通過對象名訪問；而類屬性屬于類，可以通過類名或?qū)ο竺伎梢栽L問。
???在實例方法中可以調(diào)用該實例的其他方法，也可以訪問類屬性以及實例屬性。
例子：
在Python中，函數(shù)和方法是有區(qū)別的。
方法一般指與特定實例綁定的函數(shù)，通過對象調(diào)用方法時，對象本身將被作為第一個參數(shù)隱式傳遞過去，普通函數(shù)并不具備這個特點。
私有成員和公有成員
Python并沒有對私有成員提供嚴(yán)格的訪問保護(hù)機制。
在定義類的成員時，如果成員名以兩個下劃線“__”或更多下劃線開頭而不以兩個或更多下劃線結(jié)束則表示是私有成員。
私有成員在類的外部不能直接訪問，需要通過調(diào)用對象的公開成員方法來訪問，也可以通過Python支持的特殊方式來訪問。
公開成員既可以在類的內(nèi)部進(jìn)行訪問，也可以在外部程序中使用。
Python中以下劃線開頭的變量名和方法名有特殊含義，尤其是在類的定義中。
_xxx：受保護(hù)成員，不能用’from module import *'導(dǎo)入；
xxx：系統(tǒng)定義的特殊成員；
__xxx：私有成員，只有類對象自己能訪問，子類對象不能直接訪問到這個成員，但在對象外部可以通過“對象名._類名__xxx”這樣的特殊方式來訪問
注意：Python中不存在嚴(yán)格意義上的私有成員。
>>> class Fruit:def __init__(self):self.__color = 'Red'self.price = 1>>> apple = Fruit() >>> apple.price #顯示對象公開數(shù)據(jù)成員的值 1 >>> apple.price = 2 #修改對象公開數(shù)據(jù)成員的值 >>> apple.price 2 >>> print(apple.price, apple._Fruit__color) #顯示對象私有數(shù)據(jù)成員的值 2 Red >>> apple._Fruit__color = "Blue" #修改對象私有數(shù)據(jù)成員的值 >>> print(apple.price, apple._Fruit__color) 2 Blue >>> print(apple.__color) AttributeError: Fruit instance has no attribute '__color'類中的方法
在類中定義的方法可以粗略分為四大類：
公有方法、私有方法、靜態(tài)方法和類方法。
???私有方法的名字以兩個下劃線“__”開始，每個對象都有自己的公有方法和私有方法，在這兩類方法中可以訪問屬于類和對象的成員；
???公有方法通過對象名直接調(diào)用，私有方法不能通過對象名直接調(diào)用，只能在屬于對象的方法中通過self調(diào)用或在外部通過Python支持的特殊方式來調(diào)用。
???如果通過類名來調(diào)用屬于對象的公有方法，需要顯式為該方法的self參數(shù)傳遞一個對象名，用來明確指定訪問哪個對象的數(shù)據(jù)成員。
self.__value: 8
Root.__total: 1
self.__value: 5
Root.__total: 2
???Python中類的構(gòu)造函數(shù)是__init__()，一般用來為數(shù)據(jù)成員設(shè)置初值或進(jìn)行其他必要的初始化工作，在創(chuàng)建對象時被自動調(diào)用和執(zhí)行。如果用戶沒有設(shè)計構(gòu)造函數(shù)，Python將提供一個默認(rèn)的構(gòu)造函數(shù)用來進(jìn)行必要的初始化工作。
???Python中類的析構(gòu)函數(shù)是__del__()，一般用來釋放對象占用的資源，在Python刪除對象和收回對象空間時被自動調(diào)用和執(zhí)行。如果用戶沒有編寫析構(gòu)函數(shù)，Python將提供一個默認(rèn)的析構(gòu)函數(shù)進(jìn)行必要的清理工作。
屬性
類屬性是在類中方法（也就是類中的函數(shù)）之外但又在類之中定義的屬性；而實例屬性是在構(gòu)造函數(shù)中定義的（init）,定義時候以self作為前綴。類屬性在所有實例之間共享。在類內(nèi)部和類外部都可以通過“類.類屬性” 來訪問。
只讀屬性
可讀、可寫屬性
>>> class Test:def __init__(self, value):self.__value = value def __get(self):return self.__valuedef __set(self, v):self.__value = vvalue = property(__get, __set)def show(self):print(self.__value)繼承
構(gòu)造函數(shù)、私有方法以及普通公開方法的繼承原理。
父類：
繼承類1：
class B(A): #類B沒有構(gòu)造方法，會繼承基類的構(gòu)造方法def __private(self): #這不會覆蓋基類的私有方法print('__private() method in B')def public(self): #覆蓋了繼承自A類的公開方法publicprint('public() method in B')>>> b = B() #自動調(diào)用基類構(gòu)造方法 __private() method in A public() method in B>>> dir(b) #基類和派生類的私有方法訪問方式不一樣 ['_A__private', '_B__private', '__class__', ...]繼承類2：
class C(A):def __init__(self): #顯式定義構(gòu)造函數(shù)self.__private() #這里調(diào)用的是類C的私有方法self.public()def __private(self):print('__private() method in C')def public(self):print('public() method in C') >>> c = C() #調(diào)用類C的構(gòu)造方法 __private() method in C public() method in C>>> dir(c) ['_A__private', '_C__private', '__class__', ...]Python支持多繼承(Multiple Inheritance)
多繼承下的Method Resolution Order(MRO)：
如果父類中有相同的方法名，而在子類中使用時沒有指定父類名，則Python解釋器將從左向右按順序進(jìn)行搜索。
所謂多態(tài)（polymorphism），是指基類的同一個方法在不同派生類對象中具有不同的表現(xiàn)和行為。派生類繼承了基類行為和屬性之后，還會增加某些特定的行為和屬性，同時還可能會對繼承來的某些行為進(jìn)行一定的改變，這都是多態(tài)的表現(xiàn)形式。
Python大多數(shù)運算符可以作用于多種不同類型的操作數(shù)，并且對于不同類型的操作數(shù)往往有不同的表現(xiàn)，這本身就是多態(tài)，是通過特殊方法與運算符重載實現(xiàn)的。
總結(jié)
以上是生活随笔為你收集整理的合工大python期末复习知识点汇总的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： thumbnailator压缩图片并存至
- 下一篇： 解决LoggerFactory is n