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