爆肝2w字????????????
還愁要自己總結(jié)知識點？有這一篇就足夠??????
干貨滿滿不看后悔??????
??個人主頁→數(shù)據(jù)挖掘博主ZTLJQ的主頁
?
個人推薦python學(xué)習(xí)系列：
??爬蟲JS逆向系列專欄?-?爬蟲逆向教學(xué)
??python系列專欄?-?從零開始學(xué)python
?
目錄
數(shù)據(jù)類型和變量
??1、數(shù)字類型（int）
1.浮點數(shù)類型（float）
2.復(fù)數(shù)類型（complex）
3.字符串類型（str）
4.浮點數(shù)類型（float）
??2、字符串類型及其操作
1、字符串的創(chuàng)建和基本操作
2、字符串的切片操作
3、字符串的常用方法
4、格式化字符串
??3、列表、元組和字典的使用
1、列表(List)的使用
2、元組(Tuple)的使用
3、字典(Dictionary)的使用
??4、變量的定義和命名規(guī)范
1、變量的定義
2、變量的命名規(guī)范
3、變量的使用注意事項
條件和循環(huán)語句
??1、if語句及其嵌套
1、if語句的基本使用
2、if-else語句的使用
3、if-elif-else語句的使用
4、if語句的嵌套使用
??2、for循環(huán)和while循環(huán)
1、for循環(huán)的使用
2、遍歷字符串
3、遍歷字典
4、while循環(huán)
5、用戶輸入循環(huán)
6、條件控制循環(huán)
??3、break和continue語句的使用
1、break語句
2、跳出循環(huán)
3、結(jié)合條件判斷
4、continue語句
5、結(jié)合條件判斷
函數(shù)和模塊
??1、函數(shù)的定義和調(diào)用
1、函數(shù)的定義
2、無參數(shù)函數(shù)
3、帶參數(shù)函數(shù)
4、返回值函數(shù)
5、函數(shù)的調(diào)用
6、調(diào)用帶參數(shù)函數(shù)
7、使用返回值
??2、函數(shù)參數(shù)和返回值
1、位置參數(shù)
2、默認參數(shù)
3、可變長參數(shù)：
4、返回值的多樣化應(yīng)用
??3、模塊的導(dǎo)入和使用
1、導(dǎo)入標(biāo)準(zhǔn)庫模
2、導(dǎo)入第三方模塊
3、自定義模塊的導(dǎo)入和使用
4、使用別名導(dǎo)入模塊
?文章來源地址http://www.zghlxwxcb.cn/news/detail-778002.html
文件操作
??1、打開、讀取和寫入文件
1、文件的打開
2、文件的讀取
3、文件的寫入
4、使用上下文管理器
??2、文件指針和文件的關(guān)閉
1、文件指針的定位
2、文件指針的移動
3、文件的自動關(guān)閉
??3、異常處理和文件操作的錯誤處理
1、異常的捕獲與處理
2、文件操作錯誤處理
3、異常處理與文件操作的結(jié)合
4、自定義異常
面向?qū)ο缶幊?/p>
??1、類和對象的概念
1、類的定義與實例化
2、對象屬性與方法的訪問
3、錯誤處理與類的結(jié)合
??2、屬性和方法的定義
1、屬性的定義與訪問
2、方法的定義與調(diào)用：
3、錯誤處理與屬性方法的結(jié)合
??3、繼承和多態(tài)的實現(xiàn)
1、類的繼承與重寫
2、多態(tài)的實現(xiàn)
3、繼承和多態(tài)的應(yīng)用場景
?
數(shù)據(jù)類型和變量
??1、數(shù)字類型（int）
整數(shù)類型表示整數(shù)，可以進行基本的數(shù)學(xué)運算
代碼案例：
# 整數(shù)類型定義和操作
num1 = 10
num2 = 5
print(num1 + num2) # 輸出：15
print(num1 - num2) # 輸出：5
print(num1 * num2) # 輸出：50
print(num1 / num2) # 輸出：2.0（注意：整數(shù)相除得到的是浮點數(shù)）
print(num1 // num2) # 輸出：2（地板除法，得到整數(shù)結(jié)果）
print(num1 % num2) # 輸出：0（取余數(shù)）
print(num1 ** num2) # 輸出：100000（冪運算）
1.浮點數(shù)類型（float）
浮點數(shù)類型表示帶有小數(shù)部分的數(shù)，支持浮點數(shù)運算。
代碼案例：
# 浮點數(shù)類型定義和操作
num1 = 3.14
num2 = 2.7
print(num1 + num2) # 輸出：5.84
print(num1 - num2) # 輸出：0.44
print(num1 * num2) # 輸出：8.478
print(num1 / num2) # 輸出：1.162962962962963
print(num1 ** num2) # 輸出：13.815511826682914（冪運算）
2.復(fù)數(shù)類型（complex）
復(fù)數(shù)類型表示實部和虛部組成的復(fù)數(shù)，可以進行復(fù)數(shù)運算。
代碼案例：
# 復(fù)數(shù)類型定義和操作
num1 = 2 + 3j
num2 = 4 + 2j
print(num1 + num2) # 輸出：(6+5j)
print(num1 - num2) # 輸出：(-2+1j)
print(num1 * num2) # 輸出：(8+14j)
print(num1 / num2) # 輸出：(0.7+0.4j)
print(num1.real) # 輸出：2.0（獲取實部）
print(num1.imag) # 輸出：3.0（獲取虛部）
print(num1.conjugate()) # 輸出：(2-3j)（求共軛復(fù)數(shù)）
3.字符串類型（str）
字符串類型表示文本數(shù)據(jù)，由字符組成，可以進行字符串操作和處理。
# 整數(shù)類型定義和操作
num1 = 10
num2 = 5
print(num1 + num2) # 輸出：15
print(num1 - num2) # 輸出：5
print(num1 * num2) # 輸出：50
print(num1 / num2) # 輸出：2.0（注意：整數(shù)相除得到的是浮點數(shù)）
print(num1 // num2) # 輸出：2（地板除法，得到整數(shù)結(jié)果）
print(num1 % num2) # 輸出：0（取余數(shù)）
print(num1 ** num2) # 輸出：100000（冪運算）
4.浮點數(shù)類型（float）
浮點數(shù)類型表示帶有小數(shù)部分的數(shù)，支持浮點數(shù)運算。
# 浮點數(shù)類型定義和操作
num1 = 3.14
num2 = 2.7
print(num1 + num2) # 輸出：5.84
print(num1 - num2) # 輸出：0.44
print(num1 * num2) # 輸出：8.478
print(num1 / num2) # 輸出：1.162962962962963
print(num1 ** num2) # 輸出：13.815511826682914（冪運算）
??2、字符串類型及其操作
1、字符串的創(chuàng)建和基本操作
可以使用單引號或雙引號創(chuàng)建字符串。下面是一些基本的字符串操作示例：
# 創(chuàng)建字符串
str1 = 'Hello, World!'
str2 = "Python Programming"
# 訪問字符串中的字符
print(str1[0]) # 輸出：H
print(str2[7]) # 輸出：P
# 字符串長度
print(len(str1)) # 輸出：13
print(len(str2)) # 輸出：18
# 字符串拼接
str3 = str1 + " " + str2
print(str3) # 輸出：Hello, World! Python Programming
# 字符串重復(fù)
str4 = str1 * 3
print(str4) # 輸出：Hello, World!Hello, World!Hello, World!
2、字符串的切片操作
切片是指從字符串中獲取部分字符子串的操作。通過指定起始位置和結(jié)束位置的索引，可以截取需要的子串。
str5 = "Python Programming"
# 切片操作
print(str5[0:6]) # 輸出：Python
print(str5[7:]) # 輸出：Programming
print(str5[:6]) # 輸出：Python
print(str5[-11:-1]) # 輸出：Programmin
# 步長切片
print(str5[0:10:2]) # 輸出：Pto rg
3、字符串的常用方法
Python提供了許多有用的字符串方法，用于處理字符串。以下是一些常用的方法示例：
str6 = " Hello, World! "
# 去除字符串兩端的空格
print(str6.strip()) # 輸出：Hello, World!
# 大小寫轉(zhuǎn)換
print(str6.lower()) # 輸出： hello, world!
print(str6.upper()) # 輸出： HELLO, WORLD!
# 查找子串的位置
print(str6.find("World")) # 輸出：9
print(str6.find("Python")) # 輸出：-1
# 替換子串
print(str6.replace("World", "Python")) # 輸出： Hello, Python!
# 字符串分割
print(str6.split(",")) # 輸出：[' Hello', ' World! ']
4、格式化字符串
Python提供了多種字符串格式化的方法，用于將變量的值插入到字符串中。
name = "Alice"
age = 20
# 使用占位符
print("My name is %s and I am %d years old." % (name, age))
# 使用f-string
print(f"My name is {name} and I am {age} years old.")
??3、列表、元組和字典的使用
1、列表(List)的使用
列表是一個有序的可變數(shù)據(jù)類型，可以存儲多個元素，并且允許元素重復(fù)。下面是一些基本的列表操作示例：
# 創(chuàng)建列表
list1 = [1, 2, 3, 4, 5]
list2 = ['apple', 'banana', 'orange']
# 訪問列表中的元素
print(list1[0]) # 輸出：1
print(list2[2]) # 輸出：orange
# 列表長度
print(len(list1)) # 輸出：5
print(len(list2)) # 輸出：3
# 列表的切片操作
print(list1[1:4]) # 輸出：[2, 3, 4]
print(list2[:2]) # 輸出：['apple', 'banana']
# 列表的修改和添加
list1[0] = 10
list2.append('grape')
print(list1) # 輸出：[10, 2, 3, 4, 5]
print(list2) # 輸出：['apple', 'banana', 'orange', 'grape']
# 列表的刪除
del list1[2]
list2.remove('banana')
print(list1) # 輸出：[10, 2, 4, 5]
print(list2) # 輸出：['apple', 'orange', 'grape']
2、元組(Tuple)的使用
元組是一個有序的不可變數(shù)據(jù)類型，類似于列表，但元組的元素不能修改。下面是一些基本的元組操作示例：
# 創(chuàng)建元組
tuple1 = (1, 2, 3, 4, 5)
tuple2 = ('apple', 'banana', 'orange')
# 訪問元組中的元素
print(tuple1[0]) # 輸出：1
print(tuple2[2]) # 輸出：orange
# 元組長度
print(len(tuple1)) # 輸出：5
print(len(tuple2)) # 輸出：3
# 元組的切片操作
print(tuple1[1:4]) # 輸出：(2, 3, 4)
print(tuple2[:2]) # 輸出：('apple', 'banana')
# 元組的拼接
tuple3 = tuple1 + tuple2
print(tuple3) # 輸出：(1, 2, 3, 4, 5, 'apple', 'banana', 'orange')
3、字典(Dictionary)的使用
字典是一個無序的可變數(shù)據(jù)類型，由鍵-值對(key-value)組成，用于存儲和查找數(shù)據(jù)。下面是一些基本的字典操作示例：
# 創(chuàng)建字典
dict1 = {'name': 'Alice', 'age': 20, 'country': 'USA'}
dict2 = {'apple': 1.0, 'banana': 0.5, 'orange': 0.8}
# 訪問字典中的元素
print(dict1['name']) # 輸出：Alice
print(dict2['apple']) # 輸出：1.0
# 字典長度
print(len(dict1)) # 輸出：3
print(len(dict2)) # 輸出：3
# 修改字典中的元素
dict1['age'] = 21
dict2['orange'] = 1.0
print(dict1) # 輸出：{'name': 'Alice', 'age': 21, 'country': 'USA'}
print(dict2) # 輸出：{'apple': 1.0, 'banana': 0.5, 'orange': 1.0}
# 添加新的鍵-值對
dict1['gender'] = 'female'
dict2['grape'] = 0.7
print(dict1) # 輸出：{'name': 'Alice', 'age': 21, 'country': 'USA', 'gender': 'female'}
print(dict2) # 輸出：{'apple': 1.0, 'banana': 0.5, 'orange': 1.0, 'grape': 0.7}
# 刪除字典中的元素
del dict1['age']
dict2.pop('banana')
print(dict1) # 輸出：{'name': 'Alice', 'country': 'USA', 'gender': 'female'}
print(dict2) # 輸出：{'apple': 1.0, 'orange': 1.0, 'grape': 0.7}
??4、變量的定義和命名規(guī)范
1、變量的定義
在Python中，變量的定義是通過給變量名賦予一個值來創(chuàng)建變量。下面是一些基本的變量定義示例：
# 定義整數(shù)變量
x = 5
y = 10
# 定義浮點數(shù)變量
pi = 3.14159
radius = 5.0
# 定義字符串變量
name = "Alice"
greeting = "Hello, world!"
# 定義列表變量
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']
# 定義字典變量
student = {'name': 'Alice', 'age': 20, 'country': 'USA'}
prices = {'apple': 1.0, 'banana': 0.5, 'orange': 0.8}
2、變量的命名規(guī)范
在命名變量時，需要遵循一定的規(guī)范，以保證代碼的可讀性和可維護性。以下是Python中變量命名的一些規(guī)范：
變量名只能包含字母、數(shù)字和下劃線，不能包含空格和特殊字符。
變量名不能以數(shù)字開頭，可以以字母或下劃線開頭。
變量名區(qū)分大小寫，例如count和Count是不同的變量。
變量名應(yīng)具有描述性，能夠清晰表達變量所表示的含義。
變量名通常使用小寫字母，多個單詞之間可以用下劃線分隔，例如first_name。
避免使用Python的關(guān)鍵字作為變量名，例如if、for等。
下面是一些符合命名規(guī)范的變量示例：
# 定義變量并遵循命名規(guī)范
first_name = "Alice"
age = 20
num_students = 100
# 使用多個單詞并用下劃線分隔
total_sales = 5000.0
student_count = 50
# 避免使用關(guān)鍵字作為變量名
my_list = [1, 2, 3]
for item in my_list:
print(item)
3、變量的使用注意事項
在使用變量時，需要注意以下幾點：
變量在使用之前需要進行定義，即給變量賦予一個值。
變量可以被重新賦值，新的值會覆蓋舊的值。
變量的作用域是在其被定義的塊內(nèi)有效，超出該塊的范圍無法訪問該變量。
# 變量的重新賦值
x = 5
print(x) # 輸出：5
x = 10
print(x) # 輸出：10
# 變量作用域的示例
def my_function():
y = 20
print(y) # 輸出：20
my_function()
print(y) # 報錯，無法訪問函數(shù)內(nèi)部的變量y
?
條件和循環(huán)語句
??1、if語句及其嵌套
1、if語句的基本使用
if語句用于在滿足條件時執(zhí)行特定的代碼塊。下面是一個基本的if語句示例：
# 基本的if語句
x = 10
if x > 5:
print("x大于5")
# 在上述示例中，當(dāng)變量x的值大于5時，if語句的條件為真，執(zhí)行打印語句。否則，不執(zhí)行任何操作。2、if-else語句的使用
if-else語句允許根據(jù)條件的真假執(zhí)行不同的代碼塊。下面是一個if-else語句的示例：
# if-else語句
x = 3
if x > 5:
print("x大于5")
else:
print("x小于等于5")
# 在上述示例中，如果變量x的值大于5，則執(zhí)行第一個代碼塊；否則，執(zhí)行第二個代碼塊。3、if-elif-else語句的使用
if-elif-else語句允許根據(jù)多個條件的真假執(zhí)行不同的代碼塊。elif是"else if"的縮寫，用于檢查額外的條件。下面是一個if-elif-else語句的示例：
# if-elif-else語句
x = 7
if x > 10:
print("x大于10")
elif x > 5:
print("x大于5，小于等于10")
else:
print("x小于等于5")
# 在上述示例中，首先檢查變量x是否大于10，如果是，則執(zhí)行第一個代碼塊；
# 如果不滿足第一個條件，那么檢查是否大于5，如果是，則執(zhí)行第二個代碼塊；否則，執(zhí)行第三個代碼塊。4、if語句的嵌套使用
在Python中，if語句可以相互嵌套，以構(gòu)建更復(fù)雜的條件判斷邏輯。下面是一個if語句的嵌套示例：
# if語句的嵌套使用
x = 15
if x > 10:
print("x大于10")
if x > 15:
print("x大于15")
else:
print("x小于等于15")
else:
print("x小于等于10")
# 在上述示例中，首先檢查變量x是否大于10，如果是，則執(zhí)行第一個代碼塊；
# 在第一個代碼塊中，又嵌套了一個if語句，檢查變量x是否大于15，根據(jù)條件的真假執(zhí)行相應(yīng)的代碼塊。?
??2、for循環(huán)和while循環(huán)
1、for循環(huán)的使用
for循環(huán)用于遍歷序列（如列表、字符串等）或其他可迭代對象，并按順序執(zhí)行特定的代碼塊。下面是一個for循環(huán)的示例：
# for循環(huán)遍歷列表
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
# 在上述示例中，for循環(huán)遍歷了列表fruits中的每一個元素，并將其賦值給變量fruit，然后執(zhí)行打印語句。
# 循環(huán)會一直執(zhí)行，直到遍歷完所有的元素。2、遍歷字符串
我們也可以使用for循環(huán)遍歷字符串中的每個字符。
message = "Hello, World!"
for char in message:
print(char)
3、遍歷字典
在遍歷字典時，我們可以使用items()方法來獲取鍵值對，并使用for循環(huán)遍歷它們。
student_scores = {"Alice": 85, "Bob": 72, "Charlie": 90}
for name, score in student_scores.items():
print(name, score)
4、while循環(huán)
while循環(huán)用于在滿足特定條件時重復(fù)執(zhí)行一段代碼。它會在每次迭代之前檢查條件，只要條件為真，就會繼續(xù)執(zhí)行循環(huán)。
以下是while循環(huán)的基本語法：
while 條件:
# 執(zhí)行的代碼塊
# 更新條件
計數(shù)器循環(huán)
while循環(huán)常用于實現(xiàn)計數(shù)器循環(huán)，即在一定條件下重復(fù)執(zhí)行固定次數(shù)的操作。
count = 0
while count < 5:
print("Count:", count)
count += 1
5、用戶輸入循環(huán)
我們可以使用while循環(huán)和條件語句來實現(xiàn)根據(jù)用戶輸入進行循環(huán)的功能。
user_input = ""
while user_input != "quit":
user_input = input("請輸入內(nèi)容（輸入'quit'退出）：")
print("輸入內(nèi)容：", user_input)
6、條件控制循環(huán)
while循環(huán)還可以通過條件控制來靈活地實現(xiàn)各種不同的需求。
num = 1
sum = 0
while num <= 10:
sum += num
num += 1
print("Sum:", sum)
?
??3、break和continue語句的使用
1、break語句
break語句用于終止循環(huán)，并跳出循環(huán)體執(zhí)行循環(huán)之后的代碼。當(dāng)某個條件滿足時，我們可以使用break語句立即退出循環(huán)，無論循環(huán)還有多少次迭代。
以下是break語句的基本語法：
for 變量 in 可迭代對象:
if 條件:
break
# 執(zhí)行的代碼塊
2、跳出循環(huán)
我們可以使用break語句來跳出for循環(huán)或while循環(huán)。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
if fruit == "banana":
break
print(fruit)
3、結(jié)合條件判斷
break語句通常與條件判斷結(jié)合使用，以滿足特定條件時跳出循環(huán)。
count = 0
while True:
print("Count:", count)
count += 1
if count == 5:
break
4、continue語句
continue語句用于跳過當(dāng)前迭代，并繼續(xù)執(zhí)行下一次迭代。當(dāng)某個條件滿足時，我們可以使用continue語句跳過當(dāng)前循環(huán)體的剩余代碼，直接進入下一次循環(huán)。
以下是continue語句的基本語法：
for 變量 in 可迭代對象:
if 條件:
continue
# 執(zhí)行的代碼塊
跳過特定迭代
我們可以使用continue語句來跳過特定的迭代。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
if fruit == "banana":
continue
print(fruit)
5、結(jié)合條件判斷
continue語句通常與條件判斷結(jié)合使用，以滿足特定條件時跳過當(dāng)前迭代。
count = 0
while count < 5:
count += 1
if count == 3:
continue
print("Count:", count)
?
函數(shù)和模塊
??1、函數(shù)的定義和調(diào)用
1、函數(shù)的定義
函數(shù)是一段完成特定任務(wù)的代碼塊，它可以接收輸入?yún)?shù)并返回輸出結(jié)果。通過定義函數(shù)，我們可以將一段代碼封裝成一個獨立的邏輯單元，供程序的其他部分重復(fù)使用。
以下是函數(shù)的基本定義語法：
def 函數(shù)名(參數(shù)1, 參數(shù)2, ...):
# 函數(shù)體
# 執(zhí)行的代碼塊
return 返回值
2、無參數(shù)函數(shù)
我們可以定義一個不接收任何參數(shù)的函數(shù)。
def say_hello():
print("Hello, World!")
# 調(diào)用函數(shù)
say_hello()
3、帶參數(shù)函數(shù)
我們可以定義一個接收參數(shù)的函數(shù)，并在函數(shù)體內(nèi)使用這些參數(shù)。
def greet(name):
print("Hello, " + name + "!")
# 調(diào)用函數(shù)
greet("Alice")
4、返回值函數(shù)
?
def add_numbers(a, b):
return a + b
# 調(diào)用函數(shù)并打印返回值
result = add_numbers(3, 5)
print("Sum:", result)
5、函數(shù)的調(diào)用
函數(shù)的調(diào)用是指使用函數(shù)名稱和適當(dāng)?shù)膮?shù)來執(zhí)行函數(shù)體內(nèi)的代碼。
調(diào)用無參數(shù)函數(shù)
我們可以直接調(diào)用不接收任何參數(shù)的函數(shù)。
def say_hello():
print("Hello, World!")
# 調(diào)用函數(shù)
say_hello()
6、調(diào)用帶參數(shù)函數(shù)
在調(diào)用帶參數(shù)的函數(shù)時，我們需要提供相應(yīng)的參數(shù)值。
def greet(name):
print("Hello, " + name + "!")
# 調(diào)用函數(shù)
greet("Alice")
7、使用返回值
在調(diào)用返回值函數(shù)時，我們可以將返回值賦給一個變量，并在后續(xù)代碼中使用。
def add_numbers(a, b):
return a + b
# 調(diào)用函數(shù)并打印返回值
result = add_numbers(3, 5)
print("Sum:", result)
??2、函數(shù)參數(shù)和返回值
1、位置參數(shù)
位置參數(shù)是最常見的函數(shù)參數(shù)類型。它們按照函數(shù)定義中的參數(shù)順序進行傳遞，并且在調(diào)用函數(shù)時必須提供相應(yīng)的參數(shù)值。下面是一個計算兩個數(shù)之和的函數(shù)示例：
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)
print(result) # 輸出：8
2、默認參數(shù)
默認參數(shù)在函數(shù)定義時給參數(shù)賦予一個默認值，如果調(diào)用函數(shù)時沒有提供該參數(shù)的值，則使用默認值。默認參數(shù)可以減少函數(shù)調(diào)用時的必要參數(shù)個數(shù)。以下是一個帶有默認參數(shù)的函數(shù)示例：
def greet(name, message="Hello"):
print(message, name)
greet("Alice") # 輸出：Hello Alice
greet("Bob", "Hi") # 輸出：Hi Bob
3、可變長參數(shù)：
有時候我們無法確定函數(shù)需要接收多少個參數(shù)，這時候可變長參數(shù)非常有用。在Python中，有兩種類型的可變長參數(shù)：*args和kwargs。*args用于接收任意數(shù)量的位置參數(shù)，而kwargs用于接收任意數(shù)量的關(guān)鍵字參數(shù)。下面是一個使用可變長參數(shù)的函數(shù)示例：
def calculate_total(*args):
total = 0
for num in args:
total += num
return total
result = calculate_total(1, 2, 3, 4, 5)
print(result) # 輸出：15
4、返回值的多樣化應(yīng)用
函數(shù)可以返回不同類型的值，包括單個值、多個值和空值。返回值可以被存儲、傳遞給其他函數(shù)或用于進行進一步的計算。以下是幾個返回值多樣化應(yīng)用的示例：
返回單個值：
def square(number):
return number * number
result = square(5)
print(result) # 輸出：25
返回多個值：
def calculate_sum_and_average(numbers):
total = sum(numbers)
average = total / len(numbers)
return total, average
result = calculate_sum_and_average([1, 2, 3, 4, 5])
print(result) # 輸出：(15, 3.0)
返回空值
def print_message():
print("Hello, World!")
result = print_message()
print(result) # 輸出：None
??3、模塊的導(dǎo)入和使用
1、導(dǎo)入標(biāo)準(zhǔn)庫模
Python標(biāo)準(zhǔn)庫是Python安裝時默認包含的一組模塊，它們提供了各種常用的功能和工具。通過導(dǎo)入標(biāo)準(zhǔn)庫模塊，我們可以直接使用這些功能。下面是一個使用math模塊計算圓的面積的示例：
import math
radius = 5
area = math.pi * math.pow(radius, 2)
print(area) # 輸出：78.53981633974483
2、導(dǎo)入第三方模塊
除了標(biāo)準(zhǔn)庫模塊外，Python還有一個龐大的第三方模塊生態(tài)系統(tǒng)，可以通過pip等工具進行安裝和使用。導(dǎo)入第三方模塊需要先安裝該模塊，然后使用import語句導(dǎo)入。以下是一個使用requests模塊發(fā)送HTTP請求的示例：
import requests
response = requests.get("https://www.example.com")
print(response.status_code) # 輸出：200
3、自定義模塊的導(dǎo)入和使用
除了使用現(xiàn)有的模塊，我們還可以自己編寫模塊來組織和重用代碼。自定義模塊通常由一個.py文件組成，其中包含函數(shù)、類和變量等。下面是一個自定義模塊的示例：
calculation.py 文件內(nèi)容：
def add_numbers(a, b):
return a + b
def multiply_numbers(a, b):
return a * b
主程序文件中導(dǎo)入自定義模塊并使用其中的函數(shù)
import calculation
result = calculation.add_numbers(3, 5)
print(result) # 輸出：8
result = calculation.multiply_numbers(3, 5)
print(result) # 輸出：15
4、使用別名導(dǎo)入模塊
在導(dǎo)入模塊時，我們可以使用別名來簡化模塊名的使用。這在模塊名過長或存在沖突時特別有用。以下是使用別名導(dǎo)入模塊的示例：
import math as m
radius = 5
area = m.pi * m.pow(radius, 2)
print(area) # 輸出：78.53981633974483
?
文件操作
??1、打開、讀取和寫入文件
1、文件的打開
在Python中，我們使用open()函數(shù)來打開文件，并返回一個文件對象，以便后續(xù)操作。在打開文件時，我們需要指定文件的路徑和打開模式。以下是幾種常見的文件打開模式：
"r"：只讀模式，用于讀取文件內(nèi)容。
"w"：寫入模式，用于清空文件并寫入新內(nèi)容。
"a"：追加模式，用于在文件末尾追加新內(nèi)容。
"x"：創(chuàng)建模式，用于創(chuàng)建新文件并寫入內(nèi)容。
下面是打開文件并讀取其中內(nèi)容的示例：
file = open("data.txt", "r")
content = file.read()
print(content)
file.close()
2、文件的讀取
一旦文件被打開，我們可以使用不同的方法來讀取文件中的內(nèi)容。常見的方法包括：
read()：讀取整個文件內(nèi)容。
readline()：逐行讀取文件內(nèi)容。
readlines()：將文件內(nèi)容按行讀取并返回一個列表。
以下是使用不同方法讀取文件內(nèi)容的示例：
# read()
file = open("data.txt", "r")
content = file.read()
print(content)
file.close()
# readline()
file = open("data.txt", "r")
line = file.readline()
while line:
print(line)
line = file.readline()
file.close()
# readlines()
file = open("data.txt", "r")
lines = file.readlines()
for line in lines:
print(line)
file.close()
3、文件的寫入
除了讀取文件內(nèi)容，我們還可以將數(shù)據(jù)寫入文件中。在打開文件時，我們需要使用寫入模式（"w"）或追加模式（"a"）來寫入數(shù)據(jù)。以下是將數(shù)據(jù)寫入文件的示例：
# 寫入模式（"w"）
file = open("data.txt", "w")
file.write("Hello, World!")
file.close()
# 追加模式（"a"）
file = open("data.txt", "a")
file.write("\nWelcome to Python!")
file.close()
4、使用上下文管理器
為了更加方便和安全地操作文件，我們可以使用上下文管理器來自動管理文件的打開和關(guān)閉。通過使用with語句，可以確保文件在使用完畢后自動關(guān)閉，而無需手動調(diào)用close()方法。以下是使用上下文管理器進行文件讀取的示例：
with open("data.txt", "r") as file:
content = file.read()
print(content)
?
??2、文件指針和文件的關(guān)閉
1、文件指針的定位
在文件中，文件指針是一個標(biāo)記，指示當(dāng)前讀取或?qū)懭氲奈恢?。文件指針默認指向文件開頭。我們可以使用seek()函數(shù)將文件指針定位到指定位置。以下是一個將文件指針定位到文件開頭的示例：
file = open("data.txt", "r")
file.seek(0)
content = file.read()
print(content)
file.close()
2、文件指針的移動
文件指針不僅可以定位到文件的開頭，還可以根據(jù)需要進行移動。使用seek()函數(shù)和偏移量（以字節(jié)為單位），我們可以將文件指針相對于當(dāng)前位置進行前進或后退。以下是一個將文件指針后退一行的示例：
file = open("data.txt", "r")
file.readline() # 讀取并忽略第一行
file.seek(-len(file.readline()), 1) # 后退一行
content = file.read()
print(content)
file.close()
3、文件的自動關(guān)閉
在文件操作完成后，我們需要確保正確關(guān)閉文件，以釋放系統(tǒng)資源。為了避免忘記關(guān)閉文件，可以使用上下文管理器的方式操作文件。通過使用with語句，文件在使用完畢后會自動關(guān)閉，無需手動調(diào)用close()方法。以下是使用上下文管理器進行文件操作的示例：
with open("data.txt", "r") as file:
content = file.read()
print(content)
??3、異常處理和文件操作的錯誤處理
1、異常的捕獲與處理
在Python中，我們可以使用try-except語句來捕獲和處理異常。try塊中的代碼嘗試執(zhí)行，如果出現(xiàn)異常，則會跳轉(zhuǎn)到對應(yīng)的except塊，并執(zhí)行相應(yīng)的異常處理代碼。以下是一個捕獲除零錯誤的示例：
try:
x = 10 / 0
except ZeroDivisionError:
print("除零錯誤發(fā)生！")
2、文件操作錯誤處理
在文件操作中，可能會出現(xiàn)諸如文件不存在、權(quán)限錯誤等錯誤情況。為了處理這些錯誤，我們可以使用try-except語句捕獲相應(yīng)的異常，并執(zhí)行適當(dāng)?shù)腻e誤處理代碼。以下是一個處理文件打開錯誤的示例：
try:
file = open("data.txt", "r")
except FileNotFoundError:
print("文件不存在！")
3、異常處理與文件操作的結(jié)合
在文件操作中，我們可以結(jié)合異常處理來處理文件的讀取和寫入操作。通過捕獲文件操作可能出現(xiàn)的異常，我們可以在發(fā)生錯誤時進行適當(dāng)?shù)奶幚?，避免程序崩潰或?shù)據(jù)丟失。以下是一個讀取文件并處理文件不存在異常的示例：
try:
with open("data.txt", "r") as file:
content = file.read()
print(content)
except FileNotFoundError:
print("文件不存在！")
4、自定義異常
除了內(nèi)置的異常類型，我們還可以自定義異常類型來滿足特定的錯誤處理需求。通過繼承Python的Exception類，我們可以定義自己的異常類，并在需要時引發(fā)自定義異常。以下是一個自定義異常的示例：
class MyCustomException(Exception):
pass
try:
raise MyCustomException("自定義異常被引發(fā)！")
except MyCustomException as e:
print(e)
面向?qū)ο缶幊?/h2>
??1、類和對象的概念
1、類的定義與實例化
在Python中，我們使用class關(guān)鍵字來定義類，類中包含屬性和方法。通過實例化類，我們可以創(chuàng)建對象，并訪問對象的屬性和調(diào)用對象的方法。以下是一個簡單的人類（Person）類的定義和實例化示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
person1.greet()
?
2、對象屬性與方法的訪問
在Python中，我們可以通過點運算符來訪問對象的屬性和調(diào)用對象的方法。對象屬性存儲對象的狀態(tài)信息，而對象方法用于定義對象的行為。以下是訪問對象屬性和調(diào)用對象方法的示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
print(person1.name) # 訪問對象屬性
person1.greet() # 調(diào)用對象方法
3、錯誤處理與類的結(jié)合
在類和對象的使用過程中，可能會出現(xiàn)各種錯誤情況。為了保證程序的健壯性，我們可以結(jié)合錯誤處理來捕獲和處理可能發(fā)生的異常。以下是一個在類方法中使用錯誤處理的示例：
class Calculator:
def divide(self, num1, num2):
try:
result = num1 / num2
print("結(jié)果：", result)
except ZeroDivisionError:
print("除零錯誤發(fā)生！")
calculator = Calculator()
calculator.divide(10, 0)
??2、屬性和方法的定義
1、屬性的定義與訪問
在Python類中，我們可以使用__init__方法初始化對象的屬性，并使用self關(guān)鍵字來訪問和設(shè)置屬性的值。以下是一個簡單的人類（Person）類的屬性定義和訪問示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("Alice", 20)
print(person1.name) # 訪問屬性值
person1.age = 25 # 設(shè)置屬性值
print(person1.age)
2、方法的定義與調(diào)用：
在Python類中，我們可以定義方法來實現(xiàn)對象的行為。方法可以訪問對象的屬性，并在需要時進行相應(yīng)的操作。以下是一個簡單的人類（Person）類的方法定義和調(diào)用示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
person1.greet() # 調(diào)用方法
3、錯誤處理與屬性方法的結(jié)合
在屬性和方法的使用過程中，可能會出現(xiàn)各種錯誤情況。為了保證程序的健壯性，我們可以結(jié)合錯誤處理來捕獲和處理可能發(fā)生的異常。以下是一個在方法中使用錯誤處理的示例：
class Calculator:
def divide(self, num1, num2):
try:
result = num1 / num2
print("結(jié)果：", result)
except ZeroDivisionError:
print("除零錯誤發(fā)生！")
calculator = Calculator()
calculator.divide(10, 0)
??3、繼承和多態(tài)的實現(xiàn)
1、類的繼承與重寫
在Python中，我們可以通過繼承來創(chuàng)建一個新類，該新類繼承了父類的屬性和方法。子類可以使用父類的屬性和方法，并可以重寫父類的方法以實現(xiàn)自己的行為。以下是一個簡單的動物（Animal）類和狗（Dog）類的繼承與重寫示例：
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("動物發(fā)出叫聲...")
class Dog(Animal):
def __init__(self, name):
super().__init__(name)
def speak(self):
print("狗發(fā)出汪汪叫聲！")
dog = Dog("旺財")
dog.speak() # 輸出："狗發(fā)出汪汪叫聲！"
2、多態(tài)的實現(xiàn)
在Python中，多態(tài)可以通過方法的重寫和對象的動態(tài)綁定來實現(xiàn)。不同的子類對象可以對相同的方法進行不同的實現(xiàn)。以下是一個簡單的形狀（Shape）類和矩形（Rectangle）類的多態(tài)實現(xiàn)示例：
class Shape:
def calculate_area(self):
pass
class Rectangle(Shape):
def __init__(self, length, width):
self.length = length
self.width = width
def calculate_area(self):
return self.length * self.width
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def calculate_area(self):
return 3.14 * self.radius * self.radius
shapes = [Rectangle(5, 10), Circle(3)]
for shape in shapes:
area = shape.calculate_area()
print("面積：", area)
3、繼承和多態(tài)的應(yīng)用場景
繼承和多態(tài)在實際開發(fā)中有廣泛的應(yīng)用。通過繼承，我們可以從現(xiàn)有的類構(gòu)建出更具體的子類，以實現(xiàn)代碼的重用和擴展。而多態(tài)則使得我們可以針對不同的對象類型使用相同的方法名，從而簡化了代碼的編寫和維護。這種靈活性使得我們能夠更好地應(yīng)對不同的業(yè)務(wù)需求。文章來源：http://www.zghlxwxcb.cn/news/detail-778002.html
?
到了這里，關(guān)于大學(xué)生Python期末復(fù)習(xí)沖刺（有這一篇足夠）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
