python筆記

micryfotctf發表於2024-11-26
Python筆記

基礎語法

>>>

預設的python提示符，往往會顯示於能以互動方式在直譯器裡執行的樣例程式碼之前。

...

輸入特殊程式碼時預設的 Python 提示符，特殊程式碼包括縮排的程式碼塊，左右成對分隔符（圓括號、方括號、花括號或三重引號等）之內，或是在指定一個裝飾器之後。

字面量

在程式碼中，被寫下來的的固定的值，稱之為字面量

注：type()語句可以檢視變數儲存的資料型別

註釋

行註釋：以 # 開頭，直到該物理行結束。註釋可以在行開頭，或空白符與程式碼之後，但不能在字串裡面。字串中的 # 號就是 # 號。
多行註釋：以一對三個雙引號引起來""" """

資料轉換

語句(函式) 說明
int(x) 將x轉換為一個整數
float(x) 將x轉換為一個浮點數
str(x) 將物件 x 轉換為字串

python用作計算器

  • 直譯器像一個簡單的計算器：你可以輸入一個表示式，它將給出結果值。 表示式語法很直觀：運算子 +, -, * 和 / 可被用來執行算術運算；圓括號 (()) 可被用來進行分組。
>>>2 + 2
4
>>>50 - 5*6
20
>>>(50 - 5*6) / 4
5.0
>>>8 / 5  # 除法運算總是返回一個浮點數
1.6
  • 除法運算(/)總是返回浮點數。 如果要做 floor division （向下取整除法）得到一個整數結果你可以使用 // 運算子；要計算餘數你可以使用%
  • Python 用 ** 運算子計算乘方：2 ** 7 #2的7次方
  • 如果變數未定義（即，未賦值），使用該變數會提示錯誤
  • Python 全面支援浮點數；混合型別運算數的運算會把整數轉換為浮點數
  • 互動模式下，上次輸出的表示式會賦給變數_。最好把該變數當作只讀型別。不要為它顯式賦值，否則會建立一個同名獨立區域性變數，該變數會用它的魔法行為遮蔽內建變數。
  • 複合賦值運算子：+= -= /= *= %= **= //=

字串

  • 可以用成對的單引號（''）或雙引號（""）標示
  • 要標示引號等特殊符號，需要用到跳脫字元，加一個\
  • 這兩種引號唯一的區別是，不需要在單引號裡轉義雙引號 " （但此時必須把單引號轉義成 ' ），反之亦然
  • 如果不希望前置 \ 的字元轉義成特殊字元，可以使用 原始字串，在引號前新增 r 即可
    • 如print('C:\some\name')->print(r'C:\some\name')
    • 原始字串還有一個微妙的限制：一個原始字串不能以奇數個 \ 字元結束
  • 字串文字可以跨越多行。一種方法是使用三重引號："""...""" 或 '''...''' 。行尾會自動包含在字串中，但可以透過在行尾新增 \ 來避免這種情況。 在下面的示例中，不包含首行換行符
print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")
  • 字串可以用+合併（粘到一起），也可以用*重複
  • 相鄰的兩個或多個 字串字面值 （引號標註的字元）會自動合併。如'py''thon'->'python'
    • 拼接分隔開的長字串時，這個功能特別實用
    • 不能用於變數或表示式
  • 字串支援== 索引 ==（下標訪問），第一個字元的索引是 0。單字元沒有專用的型別，就是長度為一的字串
    • 索引還支援負數，用負數索引時，從右邊開始計數
    • 注意，-0 和 0 一樣，因此，負數索引從 -1 開始。
  • 除了索引操作，還支援切片。 索引用來獲取單個字元，而切片允許你獲取子字串
    • 例如：word[0:2] # 從 0 號位 (含) 到 2 號位 (不含) 的字元
    • 切片索引的預設值很有用；省略開始索引時，預設值為 0，省略結束索引時，預設為到字串的結尾。如：`word[:2] word[4:]
    • 注意，輸出結果包含切片開始，但不包含切片結束。因此，s[:i] + s[i:]總是等於s
    • 索引越界會報錯，但是，切片會自動處理越界索引
    • Python 字串不能修改，是 immutable 的。因此，為字串中某個索引位置賦值會報錯
  • 內建函式 len() 返回字串的長度
    • s = 'supercalifragilisticexpialidocious' len(s)
字串格式化

透過%佔位符，完成字串和變數的快速拼接（和c差不多）

格式化的精度控制
  • 可以使用輔助符號"m.n"來控制資料的寬度和精度
    • m，控制寬度，要求是數字，如果設定的寬度小於數字自身，則不生效
    • .n，控制小數點精度，要求是數字，會進行小數的四捨五入
字串快速格式化

語法：f"內容{變數}"的格式來快速格式化
注：這種寫法不做精度控制，不理會型別

資料輸入

  • 使用input()語句可以從鍵盤獲取輸入
  • 注：無論鍵盤輸入什麼型別的資料，獲取到的資料永遠都是字串型別，記得進行型別轉換

多重賦值與迴圈體縮排

# 斐波那契數列：
# 前兩項之和即下一項的值
a, b = 0, 1
#變數 a 和 b 同時獲得新值 0 和 1 。
while a < 10:
    print(a)
    a, b = b, a+b
    #縮排是 Python 組織語句的方式。在互動式命令列裡，得為每個縮排的行輸入空格（或製表符）。使用文字編輯器可以實現更復雜的輸入方式；所有像樣的文字編輯器都支援自動縮排。互動式輸入複合語句時，要在最後輸入空白行表示完成（因為解析器不知道哪一行程式碼是程式碼塊的最後一行）。注意，同一塊語句的每一行的縮排相同。

i = 256*256
print('The value of i is', i)
The value of i is 65536

a, b = 0, 1
while a < 1000:
    print(a, end=',')#預設print語句輸出內容會自動換行，關鍵字引數 end 可以取消輸出後面的換行, 或用另一個字串結尾
    a, b = b, a+b
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

注：

  • print()輸出的字串不帶引號
  • ** 比 - 的優先順序更高, 所以 -3**2 會被解釋成 -(3**2)

控制流工具

while語句

if語句

  • 歸屬於if判斷的程式碼語句塊，需在前方填充4個空格縮排
  • Python透過縮排判斷程式碼塊的歸屬關係。
x = int(input("Please enter an integer: "))

if x < 0:
    x = 0
    print('Negative changed to zero')
elif x == 0:
    print('Zero')
elif x == 1:
    print('Single')
else:
    print('More')

for語句

Python 的 for 語句與 C 或 Pascal 中的不同。Python 的 for 語句不迭代算術遞增數值，或是給予使用者定義迭代步驟和結束條件的能力（如 C），而是在列表或字串等任意序列的元素上迭代，按它們在序列中出現的順序

  • 例如
# 度量一些字串：
words = ['cat', 'window', 'defenestrate']
for w in words:
    print(w, len(w))
  • for 迴圈遍歷列表中的每個元素，將其賦值給變數 w。
  • w 是一個變數，它持有一個指向字串物件的引用。（相當於指標）在迴圈中，w 的值（即它所指向的字串物件）並沒有被改變，而是 w 本身這個變數的引用被改變了，指向了列表中的下一個字串物件。
  • 變數 w 只是改變了它所指向的記憶體地址，即指向了列表中的下一個字串物件。這就是為什麼儘管字串是不可變的，w 的值（即它所指向的字串）在迴圈中看起來像是被改變了，實際上只是 w 這個變數的引用在改變。
    很難正確地在迭代多項集的同時修改多項集的內容。更簡單的方法是迭代多項集的副本或者建立新的多項集
  • 例如：
# 建立示例多項集
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

# 策略：迭代一個副本
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# 策略：建立一個新多項集
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

range()函式

  • 內建函式 range() 用於生成等差數列
  • 生成的序列絕不會包括給定的終止值；range(10) 生成 10 個值——長度為 10 的序列的所有合法索引。range 可以不從 0 開始，且可以按給定的步長遞增（即使是負數步長）
for i in range(5):
    print(i)
0
1
2
3
4

list(range(5, 10))
[5, 6, 7, 8, 9]
list(range(0, 10, 3))
[0, 3, 6, 9]
list(range(-10, -100, -30))
[-10, -40, -70]
  • 要按索引迭代序列，可以組合使用 range() 和 len()：
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print(i, a[i])
  • 也可以使用enumerate()函式
    • enumerate() 返回的迭代器的 next() 方法返回一個元組，裡面包含一個計數值（從 start 開始，預設為 0）和透過迭代 iterable 獲得的值。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  • range() 返回的物件在很多方面和列表的行為一樣，但其實它和列表不一樣。該物件只有在被迭代時才一個一個地返回所期望的列表項，並沒有真正生成過一個含有全部項的列表，從而節省了空間
  • 這種物件稱為可迭代物件 iterable，適合作為需要獲取一系列值的函式或程式構件的引數。for 語句就是這樣的程式構件；以可迭代物件作為引數的函式例如 sum()如sum(range(10))

break 和 continue 語句

  • break 語句將跳出最近的一層 for 或 while 迴圈
  • continue 語句將繼續執行迴圈的下一次迭代

迴圈的 else 子句

  • 在 for 或 while 迴圈中 break 語句可能對應一個 else 子句。 如果迴圈在未執行 break 的情況下結束，else 子句將會執行。
  • 在 for 迴圈中，else 子句會在迴圈結束其他最後一次迭代之後，即未執行 break 的情況下被執行。
  • 在 while 迴圈中，它會在迴圈條件變為假值後執行。
  • 在這兩類迴圈中，當在迴圈被 break 終結時 else 子句 不會 被執行。 當然，其他提前結束迴圈的方式，如 return 或是引發異常，也會跳過 else 子句的執行。
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        # 迴圈到底未找到一個因數
        print(n, 'is a prime number')

pass語句

#pass 語句不執行任何動作。語法上需要一個語句，但程式毋需執行任何動作時，可以使用該語句
while True:
    pass  # 無限等待鍵盤中斷 (Ctrl+C)

#常用於建立一個最小的類
class MyEmptyClass:
    pass

#pass 還可用作函式或條件語句體的佔位符，讓你保持在更抽象的層次進行思考。pass 會被默默地忽略
def initlog(*args):
    pass   # 記得實現這個！

match語句

match 語句接受一個表示式並把它的值與一個或多個 case 塊給出的一系列模式進行比較。這表面上像 C、Java 或 JavaScript（以及許多其他程式設計語言）中的 switch 語句，但其實它更像 Rust 或 Haskell 中的模式匹配。只有第一個匹配的模式會被執行，並且它還可以提取值的組成部分（序列的元素或物件的屬性）賦給變數。

  • 最簡單的形式是將一個主語值與一個或多個字面值進行比較
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"
  • 注意最後一個程式碼塊：“變數名”_被作為 萬用字元 並必定會匹配成功。如果沒有 case 匹配成功，則不會執行任何分支。
  • 可以用 | （“或”）將多個字面值組合到一個模式中
case 401 | 403 | 404:
    return "Not allowed"

函式

函式的定義：

def 函式名（傳入引數）
    函式體
    return 返回值

注：如果函式沒有使用return語句返回資料，會返回None這個字面量；在if判斷中，None等同於False；定義變數，但暫時不需要變數有具體值，可以用None來代替

  • 使用 global關鍵字 可以在函式內部宣告變數為全域性變數

python資料容器

一種可以容納多份資料的資料型別，容納的每一份資料稱之為1個元素。 每一個元素，可以是任意型別的資料

list（列表）

  • Python 支援多種複合資料型別，可將不同值組合在一起。最常用的列表是用方括號標註，逗號分隔的一組值。列表可以包含不同型別的元素，但一般情況下，各個元素的型別相同
  • 列表還支援合併操作
  • 列表是 mutable 型別，其內容可以改變，容納上限2**63-1
  • Python 中的簡單賦值絕不會複製資料。 當你將一個列表賦值給一個變數時，該變數將引用現有的列表。你透過一個變數對列表所做的任何更改都會被引用它的所有其他變數看到。
使用方式 作用
list.append(元素) 向列表的尾部追加一個元素
list.extend(容器) 向資料容器的內容（無結構）依次取出，追加到列表尾部
list.insert（下標、元素） 在指定下標處，插入指定的元素
del list[下標] 刪除列表指定下標元素
list.pop(下標) 刪除列表指定下標元素（能得到返回值）
list.remove(元素) 從前向後，刪除此元素第一個匹配項
list.clear() 清空列表
list.count(元素) 統計此元素在列表中出現的次數
list.index(元素) 查詢指定元素在列表的下標，找不到報錯ValueError
len(列表) 統計容器內有多少元素

例如：

# 字面量
[元素1，元素2，...]

# 定義變數
squares（變數名稱） = [1, 4, 9, 16, 25]
squares
[1, 4, 9, 16, 25]

# 定義空列表
變數名稱 = []
變數名稱 = list()

squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

sqares.append(216)
sqares
[1,4,9,16,25,216]

rgb = ["Red", "Green", "Blue"]
rgba = rgb
id(rgb) == id(rgba)  # 它們指向同一個物件
  • 切片操作返回包含請求元素的新列表。以下切片操作會返回列表的淺複製
correct_rgba = rgba[:]
correct_rgba[-1] = "Alpha"
correct_rgba
["Red", "Green", "Blue", "Alpha"]
rgba
["Red", "Green", "Blue", "Alph"]
  • 為切片賦值可以改變列表大小，甚至清空整個列表
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 替換一些值
letters[2:5] = ['C', 'D', 'E']
letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
# 現在移除它們
letters[2:5] = []
letters
['a', 'b', 'f', 'g']
# 透過用一個空列表替代所有元素來清空列表
letters[:] = []
letters
[]
* 為切片賦值可以改變列表大小，甚至清空整個列表
  • 內建函式 len() 也支援列表
  • 可以巢狀列表（建立包含其他列表的列表）
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
x
[['a', 'b', 'c'], [1, 2, 3]]
x[0]
['a', 'b', 'c']
x[0][1]
'b'
淺層複製與深層複製（還沒搞懂）
  • 淺層複製：構造一個新的複合物件，然後（在儘可能的範圍內）將原始物件中找到的物件的引用 插入其中
  • 深層複製：構造一個新的複合物件，然後，遞迴地將在原始物件裡找到的物件的副本插入其中

tuple（元組）

  • 基本語法：
# 定義元組字面量
(元素,元素,.......,元素)
# 定義元組變數
變數名稱 = (元素,元素,.......,元素)
# 定義空元組
變數名稱 = ()
變數名稱 = tuple()
# 定義一個元素的元組：注意：此時必須帶有逗號，否則不是元組型別
x = ('Hello', )
  • 元組的方法：
方法 作用
index() 查詢某個資料，如果資料存在返回對應的下標，否則報錯
count() 統計某個資料在當前元組出現的次數
len(元組) 統計元組內元素個數
  • 元組特點
# 不可以修改元組內容，否則會報錯
t1 = (1,2,3)
t1[0] = 5
#可以修改元組內list的內容（修改元素、增加、刪除、反轉等）
t1 = (1,2,['ijia','asda'])
t1[2][1] = 'best'

字串

  • 字串容器可以容納的型別是單一的，只能是字串型別
  • 字串不可以修改，如果必須要修改，只能得到一個新的字串，舊的字串是無法修改
  • 字串的方法
操作 說明
str[] 根據下標索引取出特定位置字元
str.index(str) 查詢給定字元的第一個匹配項的下標
str.replace(str1,str2) 將字串內的全部字串1，替換為字串2。不會修改原字串，而是得到一個新的
str.split(str) 按照給定字串，對字串進行分隔。不會修改原字串，而是得到一個新的列表
str.strip() 或 str.strip(str) 移除首尾的空格和換行符或指定字串
str.count(str) 統計字串內某字串的出現次數
len(str) 統計字串的字元個數

序列的切片

  • 序列是指：內容連續、有序，可使用下標索引的一類資料容器
  • 列表、元組、字串，均可以可以視為序列
  • 語法：序列[起始下標：結束下標：步長]
    • 表示從序列中，從指定位置開始，依次取出元素，到指定位置結束，得到一個新序列
    • 起始下標表示從何處開始，可以留空，留空視作從頭開始
    • 結束下標（不含）表示何處結束，可以留空，留空視作擷取到結尾
    • 步長表示，依次取元素的間隔
    • 步長為負數表示，反向取（注意，起始下標和結束下標也要反向標記）
  • 上面的列表有展示

set（集合）

  • 語法：
# 定義集合字面量
{element,element,......,element}
# 定義集合變數
變數名稱 = {element,element,......,element}
# 定義空集合
變數名稱 = set()
  • 集合的方法
操作 說明
set.add(element) 集合內新增一個元素
set.remove(element) 移除集合內指定的元素
set.pop() 從集合中隨機刪除一個元素並返回
set.clear() 將集合清空
set1.difference(set2) 得到一個新集合，內含2個集合的差集，原有的2個集合內容不變
set.difference_update(set2) 在集合1中，刪除集合2中存在的元素，集合1被修改，集合2不變
set1.union(set2) 得到1個新集合，內含2個集合的全部元素，原有的2個集合內容不變
len(set) 得到一個整數，記錄了集合的元素數量
  • 集合特點：相較於列表、元組、字串來說，不支援元素的重複（自帶去重功能）、並且內容無序

dict（字典）

  • 語法：
# 定義字典字面量
{key:value, key:value, ...... ,key:value}
# 定義字典變數
my_dict = {key:value, key:value, ...... ,key:value}
# 定義空字典
my_dict = {}
my_dict = dict()
  • 字典的方法
操作 說明
dict[key] 獲取指定Key對應的Value值
dict[key] = value 新增或更新鍵值對
dict.pop(key) 取出Key對應的Value並在字典內刪除此Key的鍵值對
dict.clear() 清空字典
dict.keys() 獲取字典的全部Key，可用於for迴圈遍歷字典
len(dict) 計算字典內的元素數量
  • 字典特點
    • 鍵值對的Key和Value可以是任意型別（Key不可為字典）
    • 字典內Key不允許重複，重複新增等同於覆蓋原有資料
    • 字典不可用下標索引，而是透過Key檢索Value

資料容器的通用操作

列表 元組 字串 集合 字典
元素數量 支援多個 支援多個 支援多個 支援多個 支援多個
元素型別 任意 任意 僅字元 任意 Key：Value
Key：除字典外任意型別
Value：任意型別
下標索引 支援 支援 支援 不支援 不支援
重複元素 支援 支援 支援 不支援 不支援
可修改性 支援 不支援 不支援 支援 支援
資料有序 是 是 是 否 否
使用場景 可修改、可重複的一批資料記錄場景 不可修改、可重複的一批資料記錄場景 一串字元的記錄場景 不可重複的資料記錄場景 以Key檢索Value的資料記錄場景

容器通用功能：

功能 描述
通用for迴圈 遍歷容器（字典是遍歷key）
max() 容器內最大元素
min() 容器內最小元素
len() 容器元素個數
list() 轉換為列表
tuple() 轉換為元組
str() 轉換為字串
set() 轉換為集合
sorted(序列,[reverse=Ture]) 排序，reverse=True表示降序
得到一個排好序的列表

函式進階

函式多返回值

def test_return():
    return 1,2

x, y = test_return()
print(x)  print(y)
# 按照返回值的順序，寫對應順序的多個變數接收即可 變數之間用逗號隔開

函式多種傳參方式

位置引數

呼叫時根據函式定義的引數位置傳參，傳遞的引數與定義的引數順序和個數必須一致

def user_info(name,age,gender):
    print(f'您的名字是{name},年齡是{age},性別是{gender}')

user_info('Tom',20,'男')
關鍵字引數

函式呼叫時透過“鍵=值”形式傳遞引數

def user_info(name,age,gender):
    print(f'您的名字是{name},年齡是{age},性別是{gender}')

# 關鍵字傳參：可以不按照固定順序
user_info(age=20,gender='男',name='Tom')
# 可以和位置引數混用，位置引數必須在前，且匹配引數順序
user_info('小明',age=20,gender='男')
預設引數
  • 預設引數也叫預設引數，用於定義函式，為引數提供預設值，呼叫函式時可不傳該預設引數的值
  • 函式呼叫時，如果為預設引數傳值則修改預設引數值, 否則使用這個預設值
    注：所有位置引數必須出現在預設引數前，包括函式定義和呼叫
def user_info(name,age,gender='男'):
    print(f'您的名字是{name},年齡是{age},性別是{gender}')

uesr_info('Tom',20)
uner_info('Tom',18,'女')
不定長引數

不定長引數也叫可變引數. 用於不確定呼叫的時候會傳遞多少個引數(不傳參也可以)的場景
不定長引數的型別：
1、位置傳遞

def user_info(*args)
    print(args)
# 傳進的所有引數都會被args變數收集，它會根據傳進引數的位置合併為一個元組(tuple)，args是元組型別，這就是位置傳遞
user_info('Tom')# ('Tom',)
user_info('Tom',18)# ('Tom',18)

2、關鍵字傳遞

def user_info(**args)
    print(args)
# 引數是“鍵=值”形式的形式的情況下, 所有的“鍵=值”都會被kwargs接受, 同時會根據“鍵=值”組成字典
user_info(name='Tom',age=18,id=110)# {'name':'Tom','age':18,'id':110}

匿名函式

  • 函式的定義中
    • def關鍵字，可以定義帶有名稱的函式
    • lambda關鍵字，可以定義匿名函式（無名稱）
      • 語法：`lambda 傳入引數：函式體（一行程式碼）
      • 傳入參數列示匿名函式的形式引數，如lambda x,y:...表示接收兩個形式引數
      • 函式體是函式的執行邏輯，只能寫一行，無法寫多行
  • 有名稱的函式，可以基於名稱重複使用。 無名稱的匿名函式，只可臨時使用一次
    使用示例：
def test(com)
    re=com(1,2)
    print(re)
test(lambda x,y:x+y)

python檔案操作

檔案讀取

mode常用的三種基礎訪問模式：

模式 描述
r 以只讀方式開啟檔案。檔案的指標將會放在檔案的開頭。這是預設模式。
w 開啟一個檔案只用於寫入。如果該檔案已存在則開啟檔案，並從開頭開始編輯，原有內容會被刪除。如果該檔案不存在，建立新檔案。
a 開啟一個檔案用於追加。如果該檔案已存在，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。
操作 功能
檔案物件 = open(file, mode, encoding) 開啟檔案獲得檔案物件
檔案物件.read(num) 讀取指定長度位元組。不指定num讀取檔案全部
檔案物件.readline() 讀取一行
檔案物件.readlines() 讀取全部行，得到列表
for line in 檔案物件 for迴圈檔案行，一次迴圈得到一行資料
檔案物件.close() 關閉檔案物件
with open() as f 透過with open語法開啟檔案，可以自動關閉

檔案寫入

# 開啟檔案
f = open('python.txt','w')
# 檔案寫入
f.wirte('Hello World')
# 內容重新整理
f.flush
  • 直接呼叫write，內容並未真正寫入檔案，而是會積攢在程式的記憶體中，稱之為緩衝區
  • 當呼叫flush的時候，內容會真正寫入檔案
  • 這樣做會頻繁的操作硬碟，導致效率下降

python異常、模組與包

異常的捕獲

在可能發生異常的地方，進行捕獲。當異常出現的時候，提供解決方式，而不是任由其導致程式無法執行。

try:
    可能要發生異常的語句
except[異常 as 別名:]
    出現異常的準備手段
[else:]
    未出現異常應做的事
[finally:]
    不管出不出現異常都會做的事
# 異常的種類多種多樣，如果想要不管什麼型別的異常都能捕獲到，那麼使用：except Exception as e:

python模組

模組(Module)，是一個 Python 檔案，以 .py 結尾. 模組能定義函式，類和變數，模組裡也能包含可執行的程式碼
模組的匯入方式：

[from 模組名] import [模組 | 類 | 變數 | 函式 | *] [as 別名]

常用的組合形式如：

  • import 模組名
  • from 模組名 import 類、變數、方法等
  • from 模組名 import *
  • import 模組名 as 別名
  • from 模組名 import 功能名 as 別名
    每個Python檔案都可以作為一個模組，模組的名字就是檔案的名字
    在實際開發中，當一個開發人員編寫完一個模組後，為了讓模組能夠在專案中達到想要的效果， 這個開發人員會自行在py檔案中新增一些測試資訊，但是在模組匯入的時候都會自動執行test函式的呼叫
  • 解決方案：
def test(a,b)
    print(a+b)
# 只在當前檔案呼叫該函式，其他匯入的檔案不符合該條件，則不執行test函式
if __name__ == '__main__':
    test(1,1)
  • 如果一個模組檔案中有__all__變數，當使用from xxx import *匯入時，只能匯入這個列表中的元素
__all__ = ['test_A']
def test_A():
    print('A')
def test_B():
    print('B')
# 只能傳輸test_A函式

python包

從物理上看，包就是一個資料夾，在該資料夾下自動建立了一個 _ init _.py 檔案，該資料夾可用於包含多個模組檔案 從邏輯上看，包的本質依然是模組
~
當我們的模組檔案越來越多時,包可以幫助我們管理這些模組, 包的作用就是包含多個模組，但包的本質依然是模組
匯入包：
1.import 包名.模組名 呼叫：包名.模組名.目標
2.from 包名 import * 必須在__init__.py檔案中新增__all__ = []，控制允許匯入的模組列表

物件導向

成員方法

  • 在Python中，如果將函式定義為class（類）的成員，那麼函式會稱之為：方法
# 函式
def add(x,y):
    return x+y
# 方法
class Student:
    def add(self,x,y):
        return x+y
  • self關鍵字 ，它是成員方法定義的時候，必須填寫的，但是傳參的時候可以忽略它
    • 它用來表示類物件自身的意思
    • 當我們使用類物件呼叫方法的是，self會自動被python傳入
    • 在方法內部，想要訪問類的成員變數，必須使用self
  • 方法和函式功能一樣， 有傳入引數，有返回值，只是方法的使用格式不同：
# 函式的使用
num = add(1,2)
# 方法的使用
student = Student()
num = student.add(1,2)

構造方法

  • 基於類建立物件的語法：物件名 = 類名稱()
  • python類可以使用：__init__()方法，稱之為構造方法
  • 在建立類物件（構造類）的時候，會自動執行，並將傳入引數自動傳遞給__init__方法使用
class student:
    name = None
    age = None
    tel = None
def __init__(self,name,age,tel):
    self.name = name
    self.age = age
    self.tel = tel
    print("Student類創造了一個物件")
stu = student("Tom",31,16554665460)

封裝

  • 物件導向程式設計，是基於模板（類）去建立實體（物件），使用物件完成功能開發
  • 物件導向包含3大主要特性：封裝 繼承 多型
  • 將現實世界事物在類中描述為屬性和方法，即為封裝
  • 現實事物有部分屬性和行為是不公開對使用者開放的。同樣在類中描述屬性和方法的時候也需要達到這個要求，就需要定義私有成員了
    • 成員變數和成員方法的命名均以__作為開頭即可
class phone:
    i=None
    p=None
    __curr = None  # 私有成員變數
    def __keep(...):  # 私有成員方法
        ...
# 私有成員無法被類物件使用，但可以被其他成員使用
    def call(self)
        if self.__curr>=1:
            self.__keep()

繼承

  • 將從父類那裡繼承（複製）來成員變數和成員方法（不含私有）
    • 單繼承
    • 多繼承
      • 多個父類中，如果有同名的成員，那麼預設以繼承順序（從左到右）為優先順序
      • pass是佔位語句，用來保證函式（方法）或類定義的完整性，表示無內容，空的意思
    • 複寫：子類繼承父類的成員屬性和成員方法後，如果對其“不滿意”，那麼可以進行復寫。即在子類中重新定義同名的屬性或方法即可
      • 一旦複寫父類成員，那麼類物件呼叫成員的時候，就會呼叫複寫後的新成員 如果需要使用被複寫的父類的成員，需要特殊的呼叫方式:

多型

  • 指的是完成某個行為時，使用不同的物件會得到不同的狀態，多型常作用在繼承關係上
  • 抽象類（介面）：含有抽象方法的類稱之為抽象類
  • 抽象方法：方法體是空實現的（pass）稱之為抽象方法
  • 抽象類多用於做頂層設計（設計標準），以便子類做具體實現，要求子類必須複寫（實現）父類的一些方法

相關文章