for循環(huán)
在 Python 中，for 循環(huán)用于遍歷序列（list、tuple、range 對象等）或其他可迭代對象。for 循環(huán)的基本語法如下：
for 變量 in 可迭代對象:
# 循環(huán)體
其中，變量 表示每次循環(huán)中取出的一個元素，可迭代對象 表示被遍歷的對象。下面是一個 for 循環(huán)的例子：
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
輸出結(jié)果為：
apple
banana
cherry
代碼中，fruits 是一個列表，fruit 是當前循環(huán)中取出的元素。
除了用于遍歷序列外，for 循環(huán)還可以結(jié)合 range() 函數(shù)使用。range() 函數(shù)用于生成一個整數(shù)序列，它的基本語法如下：
range([start], stop[, step])
其中，start 為可選參數(shù)，表示序列的起始值；stop 是必需參數(shù)，表示序列的結(jié)束值（不包括該值）；step 為可選參數(shù)，表示步長，默認為 1。下面是一個 for 循環(huán)結(jié)合 range() 函數(shù)的例子：
for i in range(1, 5):
print(i)
輸出結(jié)果為：
1
2
3
4
上述代碼中，range(1, 5) 生成了一個包含整數(shù) 1、2、3、4 的序列。
除了常規(guī)使用外，for 循環(huán)還可以和 break 和 continue 語句一起使用。break 語句用于結(jié)束整個循環(huán)，而 continue 語句用于跳過本次循環(huán)。下面是一個包含 break 和 continue 的 for 循環(huán)例子：
fruits = ["apple", "banana", "cherry", "orange", "kiwi"]
for fruit in fruits:
if fruit == "orange":
break
elif fruit == "banana":
continue
print(fruit)
輸出結(jié)果為：
apple
cherry
代碼中，當循環(huán)到 “orange” 時，使用 break 語句結(jié)束循環(huán)；當循環(huán)到 “banana” 時，使用 continue 語句跳過本次循環(huán)。
while循環(huán)
Python 中，while 循環(huán)用于重復(fù)執(zhí)行一段代碼，直到滿足某個條件才停止循環(huán)。while 循環(huán)的基本語法如下：
while 條件:
# 循環(huán)體
其中，條件 表示一個表達式或變量，當該表達式或變量為 True 時，循環(huán)體會被執(zhí)行。下面是一個簡單的 while 循環(huán)的例子：
i = 1
while i <= 5:
print(i)
i += 1
輸出結(jié)果為：
1
2
3
4
5
代碼中，i 的初始值為 1，每次循環(huán) i 的值都會加 1，當 i 大于 5 時，循環(huán)停止。
需要注意的是，在使用 while 循環(huán)時要確保循環(huán)條件最終能夠變?yōu)?False，否則會導(dǎo)致死循環(huán)。下面是一個死循環(huán)的例子：
# 死循環(huán)，永遠不會停止
while True:
print("Hello, world!")
字符串操作
在 Python 中，字符串是一種不可變對象，即不能修改其內(nèi)容。但是我們可以通過字符串函數(shù)來操作字符串，例如訪問字符串中的字符、拼接字符串等。
訪問字符串中的字符
使用 [] 運算符可以訪問字符串中的單個字符。Python 中的字符串索引從 0 開始，也可以使用負數(shù)索引從右側(cè)開始計數(shù)。例如，字符串 “Hello, world!” 可以表示為以下索引：
+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | , | | w | o | r | l | d |
+---+---+---+---+---+---+---+---+---+---+---+---+
0 1 2 3 4 5 6 7 8 9 10 11
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
下面是一個字符串訪問的例子：
string = "Hello, world!"
print(string[0]) # H
print(string[-1]) # !
print(string[7:12]) # world
輸出結(jié)果為：
H
!
world
代碼中，我們使用 [] 運算符訪問字符串中的單個字符。例如 string[0] 返回字符串中的第一個字符，string[-1] 返回字符串中的最后一個字符。
還可以使用切片語法訪問字符串的子串。切片語法是指通過指定開始位置和結(jié)束位置來獲取字符串的子字符串，語法如下：
string[start:end]
其中，start 和 end 是可選參數(shù)，表示子字符串的開始位置和結(jié)束位置。如果不指定 start，則默認為 0；如果不指定 end，則默認為字符串的長度。下面是一個使用切片訪問字符串的例子：
string = "Hello, world!"
print(string[0:5]) # Hello
print(string[7:]) # world!
print(string[:5]) # Hello
print(string[:-1]) # Hello, world
輸出結(jié)果為：
Hello
world!
Hello
Hello, world
切片語法中還可以使用第三個參數(shù) step（步長）來指定從字符串中每隔多少個字符取一個字符。例如，當 step=2 時，表示每隔一個字符取一個字符，以此類推。需要注意的是，步長不能為 0，否則會拋出 ValueError 異常。
下面是一個使用步長訪問字符串的例子：
string = "Hello, world!"
print(string[::2]) # Hlo ol!
在這個例子中，[::2] 表示從字符串中每隔一個字符取一個字符，所以輸出結(jié)果為 Hlo ol!。
需要注意的是，如果要逆序遍歷字符串，我們可以先將步長設(shè)為 -1，然后再反向取子字符串。例如：
string = "Hello, world!"
print(string[::-1]) # !dlrow ,olleH
在這個例子中，[::-1] 表示從字符串的末尾開始，每隔一個字符取一個字符，所以輸出結(jié)果為 !dlrow ,olleH，即原字符串翻轉(zhuǎn)過來的字符串。
切片總結(jié)
s = "Hello, world!"
# 基本切片操作，獲取子字符串
print(s[0:5]) # 輸出 "Hello"，包含開頭位置，不包含結(jié)束位置
print(s[7:]) # 輸出 "world!"，從第 7 個字符開始，一直到字符串末尾
print(s[2:9]) # 輸出 "llo, wo"，包含開頭位置和結(jié)束位置之間的所有字符
print(s[:5]) # 輸出 "Hello"，從字符串開頭位置開始，一直到第 5 個字符（不包含）
print(s[:-1]) # 輸出 "Hello, world"，沒有指定結(jié)束位置，默認到字符串末尾
# 步長操作，獲取間隔多少個字符的子字符串
print(s[::2]) # 輸出 "Hlo,wr!d"，從第 0 個字符開始，每隔 2 個字符取一個字符
print(s[1::3]) # 輸出 "eood"，從第 1 個字符開始，每隔 3 個字符取一個字符
# 反轉(zhuǎn)字符串
print(s[::-1]) # 輸出 "!dlrow ,olleH"，步長為 -1 表示反轉(zhuǎn)字符串
字符串拼接
使用加號 + 可以將兩個或多個字符串拼接成一個新的字符串。下面是一個字符串拼接的例子：
string1 = "Hello"
string2 = "world"
string3 = string1 + ", " + string2 + "!"
print(string3) # Hello, world!
輸出結(jié)果為：
Hello, world!
除了加號 + 外，還可以使用 join() 方法來拼接字符串。join() 方法是一個字符串方法，它將一個可迭代對象中的字符串元素連接起來，并返回一個新的字符串。下面是一個使用 join() 方法拼接字符串的例子：
string1 = "Hello"
string2 = "world"
strings = [string1, string2, "!"]
string3 = "".join(strings)
print(string3) # Hello, world!
輸出結(jié)果與上一個例子相同。
文件讀寫
在 Python 中，可以使用內(nèi)置的 open() 函數(shù)來讀取和寫入文件。open() 函數(shù)的基本語法如下：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
其中，file 參數(shù)是必需的，表示要打開的文件路徑（相對或絕對），mode 參數(shù)是可選的，表示打開文件的模式，默認為 ‘r’（只讀）。下面是一個使用 open() 函數(shù)讀取文件的例子：
# 打開文件
f = open("example.txt", "r")
# 讀取文件內(nèi)容
content = f.read()
# 關(guān)閉文件
f.close()
# 輸出文件內(nèi)容
print(content)
代碼中，我們使用 open() 函數(shù)打開一個名為 example.txt 的文件，并使用 read() 方法讀取其內(nèi)容。最后，我們關(guān)閉了該文件。
如果要寫入文件，需要將 mode 參數(shù)設(shè)置為 ‘w’ 或 ‘a(chǎn)’?！畐’ 表示寫入模式，會覆蓋原有的內(nèi)容；‘a(chǎn)’ 表示追加模式，會在文件末尾添加新的內(nèi)容。下面是一個使用 open() 函數(shù)寫入文件的例子：
# 打開文件
f = open("example.txt", "a")
# 寫入文件內(nèi)容
f.write("\n 李白醉酒詩百篇")
# 關(guān)閉文件
f.close()
效果如圖:
代碼中，我們使用 open() 函數(shù)打開一個名為 example.txt 的文件，并使用 write() 方法在文件末尾添加了一行新的內(nèi)容。最后， 關(guān)閉了該文件。
需要注意的是，在打開文件后，必須要使用 close() 方法關(guān)閉文件。如果不關(guān)閉文件會導(dǎo)致資源泄漏，甚至可能會影響其他應(yīng)用程序讀取該文件。
使用 with 語句來自動關(guān)閉文件，例如：
with open("example.txt", "r") as f:
content = f.read()
print(content)
代碼中，使用 with 語句來打開一個文件，并使用 read() 方法讀取文件內(nèi)容。當 with 語句塊結(jié)束時，自動調(diào)用文件的 close() 方法關(guān)閉文件。這種寫法可以減少代碼量，并提高代碼的可讀性。
try…except 異常處理
在 Python 中，可以使用 try…except 語句來捕獲和處理異常。 try 語句用來執(zhí)行一段可能會拋出異常的代碼塊，如果代碼塊中發(fā)生了異常，就會跳轉(zhuǎn)到 except 語句塊中處理異常。
例子如下：
try:
# 嘗試執(zhí)行可能會拋出異常的代碼
result = 10 / 0
except ZeroDivisionError as e:
# 處理 ZeroDivisionError 異常
print("除數(shù)不能為0:", e)
代碼中，我們嘗試將 10 除以 0，這會拋出一個 ZeroDivisionError 異常。在 except 語句中，我們使用 as 關(guān)鍵字來給異常命名為 e，并打印錯誤信息。
在 except 塊中，還可以使用 else 語句處理未發(fā)生異常的情況。如果 try 塊中的代碼沒有拋出異常，就會執(zhí)行 else 塊中的代碼。下面是一個帶有 else 塊的 try…except 語句的例子：
try:
# 嘗試執(zhí)行可能會拋出異常的代碼
result = 10 / 2
except ZeroDivisionError as e:
# 處理 ZeroDivisionError 異常
print("除數(shù)不能為0:", e)
else:
# 處理未發(fā)生異常的情況
print("結(jié)果為:", result)
代碼中，我們嘗試將 10 除以 2，這不會拋出異常。因此，程序會執(zhí)行 else 塊中的代碼，打印計算結(jié)果。
除了使用 except 處理特定的異常類型外，還可以使用 except Exception 來處理所有類型的異常。
Exception 是所有異常類的基類，因此可以捕獲任何異常。
使用 except Exception 處理所有類型的異常的例子如下：
try:
# 嘗試執(zhí)行可能會拋出異常的代碼
result = 10 / 0
except Exception as e:
# 處理所有類型的異常
print("發(fā)生了異常:", e)
代碼中，我們使用 except Exception 處理任何類型的異常，并打印錯誤信息。
在 try…except 塊中，還可以使用 finally 語句來執(zhí)行一些清理工作。無論是否發(fā)生異常，都會執(zhí)行 finally 塊中的代碼。
下面是一個帶有 finally 塊的 try…except 語句的例子：
try:
# 嘗試執(zhí)行可能會拋出異常的代碼
f = open("example.txt", "r")
content = f.read()
except IOError:
# 處理 IOError 異常
print("無法打開文件")
else:
# 處理未發(fā)生異常的情況
print(content)
finally:
# 關(guān)閉文件
f.close()
代碼中，我們使用 try 塊嘗試打開一個文件并讀取其中的內(nèi)容。如果打開文件失敗會拋出 IOError 異常，在 except 塊中處理異常。如果打開文件成功，就會處理未發(fā)生異常的情況，在 else 塊中輸出文件內(nèi)容。無論是否發(fā)生異常，程序都要執(zhí)行 finally 塊中的代碼，以確保文件被關(guān)閉。
函數(shù)
在 Python 中，可以使用 def 語句來定義函數(shù)。 def 語句的基本語法如下：
def function_name(arguments):
# function body
return value
其中，function_name 是函數(shù)名，arguments 是傳遞給函數(shù)的參數(shù)列表。函數(shù)體是函數(shù)要執(zhí)行的一系列語句。如果函數(shù)需要返回值，可以使用 return 語句將結(jié)果返回。下面是一個定義函數(shù)和調(diào)用函數(shù)的例子：
def add(a, b):
"""求和函數(shù)"""
result = a + b
return result
# 調(diào)用函數(shù)
sum = add(3, 5)
print(sum)
代碼中，我們使用 def 關(guān)鍵字定義了一個名為 add 的函數(shù)，該函數(shù)接受兩個參數(shù)并返回它們的和。在程序的主體部分，我們調(diào)用了該函數(shù)，將 3 和 5 作為參數(shù)傳遞給它，并將其返回值賦給變量 sum。最后，我們打印出 sum 的值，結(jié)果為 8。
在 Python 中，還可以使用 *args 和 **kwargs 參數(shù)來接受可變數(shù)量的位置參數(shù)和關(guān)鍵字參數(shù)。*args 表示接受任意數(shù)量的位置參數(shù)，**kwargs 表示接受任意數(shù)量的關(guān)鍵字參數(shù)。下面是一個使用 *args 和 **kwargs 參數(shù)的例子：
def func(*args, **kwargs):
"""可變參數(shù)函數(shù)"""
print("位置參數(shù):", args)
print("關(guān)鍵字參數(shù):", kwargs)
# 調(diào)用函數(shù)
func(1, 2, 3, a=4, b=5)
代碼中，我們定義了一個名為 func 的函數(shù)，并使用 *args 和 **kwargs 參數(shù)來接受任意數(shù)量的位置和關(guān)鍵字參數(shù)。在函數(shù)體中，我們打印出這些參數(shù)的值。在程序的主體部分，我們調(diào)用該函數(shù)，傳遞了一組位置參數(shù)和關(guān)鍵字參數(shù)。
在 Python 中，還可以使用 lambda 表達式來定義匿名函數(shù)。lambda 表達式的語法如下：
lambda arguments: expression
其中，arguments 是傳入的參數(shù)列表，expression 是表達式，執(zhí)行該表達式并將結(jié)果返回。下面是一個使用 lambda 表達式的例子：
# 定義匿名函數(shù)
square = lambda x: x ** 2
# 調(diào)用函數(shù)
print(square(3)) # 9
上述代碼中，我們使用 lambda 表達式定義了一個名為 square 的匿名函數(shù)，該函數(shù)接受一個參數(shù)并返回該參數(shù)的平方。在程序的主體部分，我們使用該函數(shù)計算 3 的平方，并打印出結(jié)果。
模塊和包
在 Python 中，模塊是指一個包含 Python 代碼的文件。模塊可以包含函數(shù)、類、變量以及可執(zhí)行的代碼。在 Python 中，每一個文件都可以作為一個模塊來使用。要使用一個模塊，可以使用 import 語句導(dǎo)入該模塊。下面是一個導(dǎo)入模塊的例子：
import math
# 計算正弦值
x = math.sin(3.14 / 2)
print(x)
上述代碼中，我們使用 import 語句導(dǎo)入了 Python 的 math 模塊。在程序的主體部分，我們調(diào)用了 math 模塊中的 sin() 函數(shù)，并計算了 π/2 的正弦值，結(jié)果為 1.0。
在 Python 中，還可以使用 from…import 語句從模塊中導(dǎo)入部分內(nèi)容。這樣可以避免使用長名稱的標識符。下面是一個使用 from…import 語句導(dǎo)入部分內(nèi)容的例子：
from math import sin, pi
# 計算正弦值
x = sin(pi / 2)
print(x)
代碼中，我們使用 from…import 語句僅導(dǎo)入了 math 模塊中的 sin() 函數(shù)和 pi 變量。在程序的主體部分，我們調(diào)用了這些導(dǎo)入的函數(shù)和變量，并計算了 π/2 的正弦值，結(jié)果為 1.0。
在 Python 中，還可以使用包來組織模塊。包是指一個包含模塊和子包的文件夾，其中還包括一個名為 __init__.py 的空文件，該文件必須存在。要使用一個包中的模塊，可以使用 import 語句導(dǎo)入該模塊，格式為：
import package_name.module_name
下面是一個使用包的例子：
my_package/
__init__.py
module1.py
module2.py
我們可以使用以下語句來導(dǎo)入 my_package 包中的 module1 模塊：
import my_package.module1
# 調(diào)用函數(shù)
my_package.module1.my_function()
如果想從 my_package 包中導(dǎo)入多個模塊，可以使用以下語句：
from my_package import module1, module2
# 調(diào)用函數(shù)
module1.my_function()
module2.my_function()
代碼中，我們使用 from…import 語句從 my_package 包中導(dǎo)入了 module1 和 module2 兩個模塊，并分別調(diào)用了這兩個模塊中的函數(shù)。
類和面向?qū)ο缶幊?/h2>
在 Python 中，類是一種用于定義對象的模板。類包含數(shù)據(jù)屬性和方法，它們定義了對象的特征和行為。要定義一個類，可以使用 class 語句。下面是一個定義類的例子：
class MyClass:
"""一個簡單的類"""
def __init__(self, name):
self.name = name
def say_hello(self):
print(f"Hello, {self.name}")
# 創(chuàng)建對象
my_object = MyClass("World")
# 調(diào)用方法
my_object.say_hello()
代碼中，我們定義了一個名為 MyClass 的類，并使用 __init__() 方法創(chuàng)建了一個對象。這個方法會在對象創(chuàng)建時被自動調(diào)用，并將對象本身作為第一個參數(shù)傳入（通常被命名為 self）。在 __init__() 方法中，我們使用 self.name 來初始化對象的 name 屬性。
MyClass 類還包含一個 say_hello() 方法，該方法向控制臺打印出一條問候語，其中包含對象的 name 屬性。在程序的主體部分，我們使用 MyClass 創(chuàng)建了一個名為 my_object 的對象，并調(diào)用了該對象的 say_hello() 方法，輸出了一條問候語。
在 Python 中，還可以使用繼承來創(chuàng)建一個類。子類繼承父類的數(shù)據(jù)屬性和方法，并允許子類添加自己的數(shù)據(jù)屬性和方法。下面是一個使用繼承的例子：
class MyChildClass(MyClass):
"""一個簡單的子類"""
def say_goodbye(self):
print(f"Goodbye, {self.name}!")
# 創(chuàng)建對象
my_child_object = MyChildClass("World")
# 調(diào)用方法
my_child_object.say_hello()
my_child_object.say_goodbye()
代碼中，我們定義了一個名為 MyChildClass 的子類，并使用 MyClass 作為其父類。MyChildClass 子類包含一個 say_goodbye() 方法，該方法向控制臺打印出一條告別語，其中包含對象的 name 屬性。
在程序的主體部分，我們使用 MyChildClass 創(chuàng)建了一個名為 my_child_object 的對象，并調(diào)用了該對象的 say_hello() 和 say_goodbye() 方法，輸出了一條問候語和一條告別語。
在 Python 中，還可以使用裝飾器來擴展類和方法的功能。裝飾器可以在運行時修改、增強或包裝函數(shù)或類的功能。下面是一個使用裝飾器的例子：
def my_decorator(function):
def wrapper(*args, **kwargs):
print("Before function is called.")
result = function(*args, **kwargs)
print("After function is called.")
return result
return wrapper
@my_decorator
class MyDecoratedClass:
def __init__(self, name):
self.name = name
def say_hello(self):
print(f"Hello, {self.name}")
# 創(chuàng)建對象
my_decorated_object = MyDecoratedClass("World")
# 調(diào)用方法
my_decorated_object.say_hello()
代碼中，我們定義了一個名為 my_decorator 的裝飾器，并使用它來裝飾了 MyDecoratedClass 類。在程序的主體部分，我們創(chuàng)建了一個名為 my_decorated_object 的對象，并調(diào)用了該對象的 say_hello() 方法，輸出了一條問候語。在調(diào)用 MyDecoratedClass 類的構(gòu)造函數(shù)和 say_hello() 方法時，會自動調(diào)用 my_decorator 裝飾器中定義的代碼，輸出 Before function is called 和 After function is called。文章來源：http://www.zghlxwxcb.cn/news/detail-494727.html
完結(jié)
下一篇文章 Python網(wǎng)絡(luò)爬蟲 基礎(chǔ)進階到實戰(zhàn) , 如有興趣給個關(guān)注加訂閱文章來源地址http://www.zghlxwxcb.cn/news/detail-494727.html
到了這里，關(guān)于Python入門教程：掌握for循環(huán)、while循環(huán)、字符串操作、文件讀寫與異常處理等基礎(chǔ)知識的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
