python入門教程（非常詳細！3w+ 文字）

先序: 學習編程語言要先學個輪廓，剛開始只用學核心的部分，一些細節、不常用的內容先放著，現用現查即可；把常用的東西弄熟練了在慢慢補充。 1、安裝 Python 解釋器為什麼需要安裝 Python Python 語言本身是由解釋器執行的，因此你需要在你的電腦上安裝 Python 解釋器。這個解釋 ...

先序: 學習編程語言要先學個輪廓，剛開始只用學核心的部分，一些細節、不常用的內容先放著，現用現查即可；把常用的東西弄熟練了在慢慢補充。

1、安裝 Python 解釋器

為什麼需要安裝 Python

Python 語言本身是由解釋器執行的，因此你需要在你的電腦上安裝 Python 解釋器。這個解釋器會將你編寫的 Python 代碼翻譯成電腦能夠理解和執行的機器碼。

1. 下載 Python 安裝包

打開 Python 官方網站 Python 下載頁面，選擇合適的版本（通常推薦最新的穩定版本）。
點擊下載按鈕，下載適合 Windows 系統的安裝包。

2. 安裝 Python

找到下載的安裝包，雙擊運行。
重要步驟：在安裝界面的底部勾選 "Add Python to PATH"（將 Python 添加到系統環境變數）。
選擇 "Customize installation"（自定義安裝），可以選擇預設設置或根據需要修改安裝選項。
安裝完成後，會彈出 "Setup was successful" 的提示。

3. 驗證安裝

打開命令提示符（按 Win+R 鍵，輸入 cmd，回車）。
輸入以下命令查看 Python 版本：
```
python --version
```
如果看到 Python 版本信息，說明安裝成功。

4.創建一個py項目

在這裡插入圖片描述

2、語法基礎

1. 變數

在 Python 中，變數可以存儲不同類型的數據。常見的數據類型如下：

類型	描述	舉例
int	整數	123
float	浮點數	1.23, 1.24e5
str	字元串	"python"
bool	布爾值	True, False
list	列表	[1, 2, 3]
tuple	元組	(1, 2, 3)
set	集合
dict	字典

變數的使用示例：

width = 20	
width = "none"	# 可以更改類型
height = 12.3
name = "yxc"
my_name = name
flag = True
a, b, c = 1, 'a', 3.0  # 同時給多個變數賦值
a, b = b, a  # 交換 a b 的值

註意：int 支持高精度，沒有大小限制。

2. 運算符

Python 支持多種運算符，用於執行各種運算操作。

示例：

A = 10
B = 20

# 常用運算符及其描述
print(A + B)  # 加法，結果為30,  字元串類型的相加是字元串拼接到一起
print(A - B)  # 減法，結果為-10
print(A * B)  # 乘法，結果為200
print(B / A)  # 除法，結果為2.0
print(B // A)  # 整除，結果為2
print(B % A)  # 取模，結果為0
print(A ** B)  # 乘方，結果為1e20

# 複合運算符
A += B  # 等價於 A = A + B
A -= B  # 等價於 A = A - B
A *= B  # 等價於 A = A * B
A /= B  # 等價於 A = A / B
A //= B  # 等價於 A = A // B
A %= B  # 等價於 A = A % B
A **= B  # 等價於 A = A ** B

註意：除法和取模運算中，當除以0時程式會報異常。

3. 表達式

Python 支持常見的四則運算，併在整數與浮點數混合運算時自動進行類型轉換。

示例：

x = 2 + 3
y = (x + 1.0) * 5

print(x + y)  # 輸出結果為30.0

# int()、float()、str()等函數強制轉換類型。
s = "123.0"
a = float(s)
b = int(a)
s2 = "The value is " + str(b)

print(s, a, b, s2)  # 輸出 '123.0 123.0 123 The value is 123'

4. 輸入

1. input

使用 input() 函數可以從用戶那裡獲得輸入。返回值類型為字元串，可以使用 split()、map()、int() 等函數進行處理。

示例：

a, b = map(int, input().split())  # 讀入兩個以空格隔開的字元, 並把它們轉換成 int 類型賦值給 a、b
print(a + b)  # 計算兩個數的和

stdin.readlines() 是 Python 中用於從標準輸入（通常是鍵盤輸入）讀取多行數據的函數。它一次性讀取所有輸入的行，並將其存儲在一個列表中，其中每一行作為列表中的一個元素。

2. readlines讀入

stdin.readlines() 會讀取用戶輸入的所有行，返回一個包含這些行的列表，每一行作為列表中的一個字元串元素，直到遇到文件結束符。

import sys

# 從標準輸入中讀取所有行
lines = sys.stdin.readlines()

# 列印每一行
for line in lines:
    print(line.strip())  # .strip() 用於去掉每行末尾的換行符

調用 strip() 是為了去掉行末的換行符，這樣輸出的內容就不會多出額外的空行。

適用場景

從文件中讀取多行數據：如果需要從文件或標準輸入讀取多行數據並存儲在列表中進行處理時，stdin.readlines() 非常有用。
處理批量輸入：當需要批量處理輸入數據時，可以使用 stdin.readlines() 讀取所有輸入，然後逐行處理。

5. 輸出

使用 print() 函數可以輸出多個變數，預設用空格隔開，且行末會預設添加回車。如果想自定義行末字元，可以添加 end 參數。

示例：

a, b, c = 1, 2, 'x'
print(a, b, c, end='!')  # 輸出 '1 2 x!'
print(a)	# 預設有換行  輸出 1 (後面有換行)
print(b, end=' ') # 輸出 2 (後面後一個空格)
print(c)	# 輸出 3

保留小數位數：

x = 12.34567
print("x = " + str(round(x, 1)))  # 保留1位小數，輸出 'x = 12.3'
print("x = " + str(round(x, 3)))  # 保留3位小數，輸出 'x = 12.346'

格式化輸出字元串：

x = 12.34567
y = 12

print("x = %.1f" % x)  # 保留1位小數，輸出 'x = 12.3'
print("x = %.3f" % (x * y))  # 保留3位小數，輸出 'x = 148.148'
print("x = %f, y = %d" % (x, y))  # 輸出 'x = 12.345670, y = 12'

%s ：字元串（`str`）
%d ：整數（`int`）
%f ：浮點數（`float`）
%x ：十六進位整數（`int`）

6. 其它函數

例如，使用 sqrt 函數計算平方根：

from math import sqrt  # 引入開根號函數
x = 2
y = sqrt(x)
print(y)  # 輸出 '1.4142135623730951'

3、判斷語句

在 Python 中，常見的判斷語句有 if、elif 和 else。這些語句允許我們根據條件的真假來執行不同的代碼塊。以下是 Python 判斷語句的基本用法和示例。

1. 基本語法

if condition:
    # 當條件為真時執行的代碼塊
elif another_condition:
    # 當另一個條件為真時執行的代碼塊
else:
    # 當以上所有條件都不滿足時執行的代碼塊

2. 示例

2.1 簡單的 `if` 語句

age = 18

if age >= 18:
    print("You are an adult.")

# 等價於上面那個
if not age < 18:
	print("You are an adult.")

2.2 `if` 和 `else` 語句

age = 16

if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

2.3 `if`、`elif` 和 `else` 語句

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80: # elif 相當於是 else if
    print("Grade: B")
else:
    print("Grade: F")

3. 條件表達式

除了使用 if 語句進行判斷，Python 還支持使用條件表達式（又稱三元運算符, 相當於 c ++ 的 ... : ... ? ... ）來簡化簡單的條件判斷。其語法如下：

value_if_true if condition else value_if_false

示例：

age = 18
status = "adult" if age >= 18 else "minor"
print(status)  # 輸出 "adult"

4. 使用布爾運算符

在條件判斷中，可以使用布爾運算符來組合多個條件。常見的布爾運算符有 and、or 和 not。

`not` 運算符示例：

is_student = False

if not is_student:
    print("You need to pay full price.")
else:
    print("You get a discount.")

5. 比較運算符

在條件判斷中，經常會使用比較運算符來比較數值或其他數據類型。常見的比較運算符有：

==：等於
!=：不等於
>：大於
<：小於
>=：大於等於
<=：小於等於

6. `match` 語句（Python 3.10 及以上版本）

Python 3.10 引入了新的 match 語句，用於模式匹配。它類似於其他語言中的 switch 語句，但功能更強大。match 語句允許你根據對象的結構和內容來進行匹配。

基本語法

match value:
    case pattern1:
        # 當 value 匹配 pattern1 時執行的代碼塊
    case pattern2:
        # 當 value 匹配 pattern2 時執行的代碼塊
    case _:
        # 預設情況下執行的代碼塊，相當於 'default' 或 'else'
        # 預設只匹配第一個滿足條件的case, 之後的case不再匹配, 相當於C++的switch case後加上break

示例

def http_status(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return "Unknown Status"

print(http_status(200))  # 輸出 "OK"
print(http_status(404))  # 輸出 "Not Found"
print(http_status(999))  # 輸出 "Unknown Status"

7. `pass` 語句

pass 語句是一個占位符，用於在語法上需要一個語句但實際上不做任何事情的地方。通常在定義空函數、類或迴圈時使用。

示例

if a > 5 :
	pass # 這裡什麼也不寫的話, 執行會報錯, 寫上 pass 的話不報錯
else 
	print("a <= 5")

4、迴圈語句

`for` 迴圈

for 迴圈用於遍歷序列（如列表、元組、字元串）或其他可迭代對象。在 Python 中，for 迴圈與其他語言的不同之處在於它遍歷的是可迭代對象的元素，而不是基於計數器的迴圈。

語法

for element in iterable:
    # do something with element

示例

# 遍歷列表
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number)

# 遍歷字元串
for letter in "Python":
    print(letter)

`for in range`

基本語法

for i in range(start, stop, step):
    # 代碼塊

start（可選）：迴圈的起始值，預設為 0。
stop：迴圈的結束值（不包括該值）。
step（可選）：步長，預設為 1。

示例

1. 基本用法

遍歷從 0 到 4 的數字：

for i in range(5):
    print(i)

2. 指定起始值

遍歷從 2 到 5 的數字：

for i in range(2, 6):
    print(i)

3. 指定步長

每次迴圈增加 2，遍歷從 1 到 9 的數字：

for i in range(1, 10, 2):
    print(i)

`while` 迴圈

while 迴圈在給定條件為真時重覆執行目標語句。迴圈會在條件為假時終止。

語法

while condition:
    # do something

示例

# 計數迴圈
count = 0
while count < 5:
    print(count)
    count += 1

迴圈控制語句

Python 提供了幾種控制迴圈行為的語句，包括 break，continue 和 else。

`break` 語句

break 語句用於終止迴圈。它會跳出當前的迴圈塊，不再執行迴圈剩餘的迭代。

for i in range(10):
    if i == 5:
        break
    print(i)

# 輸出: 0 1 2 3 4

`continue` 語句

continue 語句跳過當前代碼塊迭代的剩餘部分，並繼續下一次迭代。

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

# 輸出: 1 3 5 7 9

`else` 子句

在迴圈中，else 子句在迴圈正常結束時執行（即沒有被 break 終止）。

for i in range(5):
    print(i)
else:
    print("迴圈正常結束")

# 輸出: 
# 0
# 1
# 2
# 3
# 4
# 迴圈正常結束

如果迴圈被 break 終止，則 else 子句不會執行。

for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("迴圈正常結束")

# 輸出: 
# 0
# 1
# 2

嵌套迴圈

你可以在一個迴圈內部使用另一個迴圈，這就是嵌套迴圈。常見的使用場景包括遍歷二維數組或矩陣。

# 示例：列印乘法表
for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i} * {j} = {i * j}", end="\t")
    print()

`for` 迴圈中的 `enumerate` 和 `zip`

enumerate 函數可以在遍歷序列時同時得到索引和值。

names = ["Alice", "Bob", "Charlie"]
for index, name in enumerate(names):
    print(index, name)

# 輸出:
# 0 Alice
# 1 Bob
# 2 Charlie

zip 函數可以並行遍歷多個可迭代對象。

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name} scored {score}")

# 輸出:
# Alice scored 85
# Bob scored 92
# Charlie scored 78

5、列表

Python 列表（List）是最常用的數據結構之一。它是一個有序的、可變的序列，可以包含任意類型的元素。由於其靈活性，列表在日常編程中非常常見。

1. 列表的定義與創建

列表使用方括弧 [] 定義，元素之間用逗號 , 分隔。

# 創建一個空列表
empty_list = []

# 創建一個包含整數的列表
int_list = [1, 2, 3, 4, 5]

# 創建一個包含字元串的列表
str_list = ["apple", "banana", "cherry"]

# 創建一個混合類型的列表
mixed_list = [1, "apple", 3.14, True]

2. 訪問列表元素

列表中的元素通過索引訪問，索引從 0 開始。也可以使用負索引從列表末尾訪問元素。

fruits = ["apple", "banana", "cherry"]

# 訪問第一個元素
first_fruit = fruits[0]  # 輸出: apple

# 訪問最後一個元素
last_fruit = fruits[-1]  # 輸出: cherry

3. 修改列表元素

列表是可變的，因此可以直接修改列表中的元素。

fruits = ["apple", "banana", "cherry"]

# 修改第二個元素
fruits[1] = "blueberry"
print(fruits)  # 輸出: ['apple', 'blueberry', 'cherry']

4. 列表的遍歷

可以使用 for 迴圈來遍歷列表中的元素。

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

for i in range(0, 3)
	print(fruit[i])

輸出：

apple
banana
cherry

5. 常用方法

Python 提供了多種方法向列表中添加元素。

append()：在列表末尾添加元素。

fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits)  # 輸出: ['apple', 'banana', 'cherry']

insert()：在指定位置插入元素。

fruits = ["apple", "banana"]
fruits.insert(1, "blueberry")
print(fruits)  # 輸出: ['apple', 'blueberry', 'banana']

extend()：將另一個列表的所有元素添加到當前列表中。

fruits = ["apple", "banana"]
more_fruits = ["cherry", "date"]
fruits.extend(more_fruits)
print(fruits)  # 輸出: ['apple', 'banana', 'cherry', 'date']

remove()：刪除指定值的第一個匹配項。

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
print(fruits)  # 輸出: ['apple', 'cherry']

pop()：刪除指定索引位置的元素，並返回該元素。若不指定索引，則預設刪除最後一個元素。

fruits = ["apple", "banana", "cherry"]
last_fruit = fruits.pop()
print(last_fruit)  # 輸出: cherry
print(fruits)      # 輸出: ['apple', 'banana']

clear()：清空列表，保留列表對象但刪除所有元素。

fruits = ["apple", "banana", "cherry"]
fruits.clear()
print(fruits)  # 輸出: []

reverse()：反轉列表。

fruits = ["apple", "banana", "cherry"]
fruits.reverse()
print(fruits)  # 輸出: ["cherry", "banana", "apple"]

del 語句：可以刪除特定索引處的元素或整個列表。

fruits = ["apple", "banana", "cherry"]
del fruits[1]
print(fruits)  # 輸出: ['apple', 'cherry']

6. 列表的切片

切片允許你獲取列表的一個子集或修改列表中的部分元素。

[startIndex] : [endIndex] : [step] : 從起始下標到結束下表截取, 步長是 step

numbers = [0, 1, 2, 3, 4, 5, 6]

# 獲取索引 2 到 4 的元素（不包括索引 5）
subset = numbers[2:5]
print(subset)  # 輸出: [2, 3, 4]

# 修改索引 3 到 5 的元素
numbers[3:6] = [7, 8, 9]
print(numbers)  # 輸出: [0, 1, 2, 7, 8, 9, 6]

# 將列表倒序
b = a[::-1]

7. 列表的排序

在 Python 中，列表排序是一項非常常用的操作。Python 提供了幾種方法來對列表進行排序，主要包括 sort() 方法和 sorted() 函數。這兩者都有各自的特點和適用場景。

1. 使用 `sort()` 方法

sort() 方法會直接對原列表進行排序（就地排序），不會生成新的列表。這個方法有兩個常用參數：

key：用於指定一個函數，該函數用於提取元素的排序鍵。
reverse：布爾值，若為 True，則列表將按降序排序，預設值為 False（升序排序）。

示例

# 簡單的升序排序
numbers = [5, 2, 9, 1, 5, 6]
numbers.sort()
print(numbers)  # 輸出: [1, 2, 5, 5, 6, 9]

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # 輸出: [9, 6, 5, 5, 2, 1]

# 使用 key 參數按字元串長度排序
words = ["apple", "banana", "cherry", "date"]
words.sort(key=len)
print(words)  # 輸出: ['date', 'apple', 'banana', 'cherry']

2. 使用 `sorted()` 函數

sorted() 函數不會改變原列表，而是返回一個新列表，原列表保持不變。它的參數和 sort() 方法相同，也可以指定 key 和 reverse 參數。

示例

# 使用 sorted() 函數進行排序
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 輸出: [1, 1, 3, 4, 5, 9]
print(numbers)  # 原列表不變: [3, 1, 4, 1, 5, 9]

# 按照字母的倒序排序
sorted_words = sorted(words, reverse=True)
print(sorted_words)  # 輸出: ['date', 'cherry', 'banana', 'apple']

3. 自定義排序規則

可以通過 key 參數自定義排序規則。key 參數接收一個函數，這個函數對每個列表元素進行處理，並返回一個用於比較的值。可以結合 lambda 函數使用。

示例：按字元串的最後一個字母排序

words = ["grape", "apple", "banana", "cherry"]

# 按照最後一個字母排序
sorted_words = sorted(words, key=lambda word: word[-1])
print(sorted_words)  # 輸出: ['banana', 'grape', 'apple', 'cherry']

8. 列表的其他常用操作

len()：獲取列表長度（元素個數）。

fruits = ["apple", "banana", "cherry"]
print(len(fruits))  # 輸出: 3

in 和 not in：檢查列表中是否包含某個元素。

fruits = ["apple", "banana", "cherry"]
print("banana" in fruits)  # 輸出: True
print("grape" not in fruits)  # 輸出: True

列表拼接：可以使用 + 操作符將兩個列表拼接成一個新列表。

fruits = ["apple", "banana"]
more_fruits = ["cherry", "date"]
all_fruits = fruits + more_fruits
print(all_fruits)  # 輸出: ['apple', 'banana', 'cherry', 'date']

列表複製：使用 copy() 方法或切片語法。

fruits = ["apple", "banana", "cherry"]
copy_fruits = fruits.copy()  # 或者 fruits[:]
print(copy_fruits)  # 輸出: ['apple', 'banana', 'cherry']

9、Python 列表推導式

列表推導式（List Comprehension）是一種簡潔且強大的語法，用於生成新的列表。它讓你可以用一行代碼來創建一個基於已有列表的過濾、變換後的新列表，語法上非常簡潔且易讀。

1. 基本語法

[expression for item in iterable if condition]

expression：要執行的表達式，決定了每個元素在新列表中的形式。
item：從可迭代對象中取出的元素。
iterable：一個可迭代對象，如列表、元組、字元串等。
condition（可選）：一個可選的條件過濾器。只有滿足此條件的元素才會包含在生成的列表中。

示例

生成一個包含 0 到 9 的列表：

numbers = [x for x in range(10)]
print(numbers)
# 輸出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

6、Python 字元串詳解

1. 字元串的定義與創建

Python 中的字元串可以用單引號 ' 或雙引號 " 來定義。三引號 ''' 或 """ 可以用於定義多行字元串。

# 使用單引號
single_quote_str = 'Hello, World!'

# 使用雙引號
double_quote_str = "Hello, World!"

# 使用三引號定義多行字元串
multi_line_str = '''This is a
multi-line string.'''

2. 字元串的基本操作

2.1 連接

使用 + 操作符可以連接多個字元串。

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"
print(message)  # 輸出: Hello, Alice!

2.2 重覆

使用 * 操作符可以重覆字元串。

repeated_str = "Ha" * 3
print(repeated_str)  # 輸出: HaHaHa

2.3 索引

可以使用索引訪問字元串中的單個字元。索引從 0 開始，也可以使用負索引從末尾訪問字元。

text = "Python"
first_char = text[0]      # 輸出: 'P'
last_char = text[-1]      # 輸出: 'n'

2.4 切片

通過切片可以獲取字元串的子字元串。

text = "Python"
substring = text[1:4]     # 輸出: 'yth'

2.5 長度

使用 len() 函數可以獲取字元串的長度。

text = "Python"
length = len(text)        # 輸出: 6

2.6 查看字元的ascll碼

使用 ord() 函數可以獲取字元的 ASCII 碼。
使用 chr() 函數可以獲取 ASCII 碼對應的字元。

3. 字元串的常用方法

Python 提供了豐富的字元串方法來操作和處理字元串。

3.1 `lower()` 和 `upper()`

轉換字元串的大小寫。

text = "Hello, World!"
lower_text = text.lower()  # 輸出: 'hello, world!'
upper_text = text.upper()  # 輸出: 'HELLO, WORLD!'

3.2 `strip()`

去除字元串兩端的空白字元（或其他指定字元）。

text = "  Hello, World!  "
stripped_text = text.strip()  # 輸出: 'Hello, World!'

3.3 `split()`

將字元串拆分成一個列表，預設按空格拆分。

text = "Hello, World!"
words = text.split()  # 輸出: ['Hello,', 'World!']

可以指定分隔符：

text = "apple,banana,cherry"
fruits = text.split(',')  # 輸出: ['apple', 'banana', 'cherry']

3.4 `join()`

將列表中的元素連接成一個字元串。

words = ['Hello', 'World']
joined_text = ' '.join(words)  # 輸出: 'Hello World'

3.5 `find()` 和 `replace()`

find() 返回子字元串在字元串中第一次出現的索引，如果未找到則返回 -1。
```
text = "Hello, World!"
index = text.find('World')  # 輸出: 7
```
rfind() 返回子字元串在字元串中最後一次出現的索引，如果未找到則返回 -1。
```
text = "Hello, World!"
index = text.find('World')  # 輸出: 7
```

replace() 用新字元串替換字元串中的舊子字元串。

text = "Hello, World!"
new_text = text.replace('World', 'Python')  # 輸出: 'Hello, Python!'

3.6 `startswith()` 和 `endswith()`

檢查字元串是否以指定的首碼或尾碼開頭或結尾。

text = "Hello, World!"
print(text.startswith("Hello"))  # 輸出: True
print(text.endswith("!"))        # 輸出: True

4. 字元串的格式化

在 Python 中，格式化字元串允許你在字元串中插入變數的值。有幾種方法可以實現格式化，其中常見的有：

百分號格式化 (%)
str.format() 方法
f-strings (格式化字元串字面量)

1. 百分號格式化 (`%`)

使用 % 運算符來格式化字元串，是 Python 的老式方法。常見的占位符包括：

%s：字元串（str）
%d：整數（int）
%f：浮點數（float）
%x：十六進位整數（int）

示例

name = "Alice"
age = 30
height = 5.6

# 使用 % 格式化字元串
formatted_str = "Name: %s, Age: %d, Height: %.1f" % (name, age, height)
print(formatted_str)  # 輸出: Name: Alice, Age: 30, Height: 5.6

2. `str.format()` 方法

使用 str.format() 方法來格式化字元串，比 % 更靈活，支持更複雜的格式化選項。

常見的占位符

{}：預設插入位置
{0}：按索引插入
{name}：按變數名插入
{:.2f}：控制浮點數的顯示精度

示例

name = "Bob"
age = 25
height = 6.1

# 使用 str.format() 格式化字元串
formatted_str = "Name: {}, Age: {}, Height: {:.1f}".format(name, age, height)
print(formatted_str)  # 輸出: Name: Bob, Age: 25, Height: 6.1

3. f-strings (格式化字元串字面量)

f-strings 是 Python 3.6 引入的功能，它提供了更簡潔的格式化方式。通過在字元串前加 f，你可以直接在字元串中嵌入變數表達式。

示例

name = "Carol"
age = 28
height = 5.9

# 使用 f-strings 格式化字元串
formatted_str = f"Name: {name}, Age: {age}, Height: {height:.1f}"
print(formatted_str)  # 輸出: Name: Carol, Age: 28, Height: 5.9

5. 字元串的不可變性

字元串是不可變的，這意味著一旦創建，就不能修改其內容。任何試圖修改字元串的操作，實際上都會創建一個新的字元串。

text = "Hello"
text[0] = "h"  # 這會導致錯誤，因為字元串是不可變的

要“修改”字元串，可以通過切片和連接的方式創建一個新的字元串。

text = "Hello"
new_text = "h" + text[1:]  # 輸出: 'hello'

6. 字元串的常見操作與技巧

6.1 反轉字元串

使用切片反轉字元串。

text = "Python"
reversed_text = text[::-1]
print(reversed_text)  # 輸出: 'nohtyP'

6.2 檢查字元串是否為數字

使用 isdigit() 方法。

text = "12345"
print(text.isdigit())  # 輸出: True

text = "123a5"
print(text.isdigit())  # 輸出: False

6.3 去除字元串中的特定字元

可以使用 str.replace() 方法。

text = "Hello, World!"
new_text = text.replace(",", "")
print(new_text)  # 輸出: 'Hello World!'

7. 字元串跟列表的不同之一

字元串賦值是深拷貝, 列表賦值時淺拷貝

a = [1, 2]
b = a
b[0] = 99
print(a, b) # 輸出 [99, 2] [99, 2]

a = "hello"
b = a
b = "world"
print(a, b) # 輸出 hello world

7、函數

在 Python 中，函數是組織代碼的基本單元，它將一段可復用的代碼封裝起來，可以通過函數名來調用。Python 的函數可以帶參數，也可以返回值，函數的定義和調用都非常靈活。

1. 函數的定義

Python 使用 def 關鍵字定義函數，語法如下：

def function_name(parameters):
    """docstring (optional): 函數的文檔字元串，用於描述函數功能"""
    # 函數體
    return value  # 可選的返回值

示例：

def greet(name):
    """輸出問候語"""
    print(f"Hello, {name}!")

greet("Alice")  # 輸出: Hello, Alice!

函數相當於變數, 可以重新賦值
b = greet
greet = "change"
b("World") # 輸出：Hello, World!
print(greet) # 輸出 change

2. 函數的調用

定義函數後，可以通過函數名加上圓括弧來調用函數。如果函數有參數，需要在調用時傳遞參數。

greet("Bob")  # 調用 greet 函數，輸出: Hello, Bob!

3. 函數的參數

3.1 位置參數

函數參數根據位置傳遞，順序很重要。

def add(a, b):
    return a + b

result = add(3, 5)  # 位置參數調用
print(result)  # 輸出: 8

3.2 關鍵字參數

在調用函數時，可以通過參數名來指定參數，這樣順序就不重要了。

result = add(b=3, a=5)  # 關鍵字參數調用
print(result)  # 輸出: 8

3.3 預設參數

在定義函數時，可以為參數指定預設值。如果調用時不傳遞該參數，則使用預設值。

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()  # 使用預設參數，輸出: Hello, Guest!
greet("Carol")  # 輸出: Hello, Carol!

3.4 可變參數 (`*args` 和 `**kwargs`)

*args 用於接收任意數量的位置參數，類型為元組。
**kwargs 用於接收任意數量的關鍵字參數，類型為字典。

def func(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

func(1, 2, 3, a=10, b=20)
# 輸出:
# args: (1, 2, 3)
# kwargs: {'a': 10, 'b': 20}

4. 返回值

函數可以返回值，使用 return 語句。如果不使用 return，函數會返回 None。

def square(x):
    return x * x

result = square(4)  # 返回值賦給變數
print(result)  # 輸出: 16

5. 作用域

局部變數：在函數內部定義的變數，只在函數內有效。
全局變數：在函數外部定義的變數，在整個腳本中有效。

x = 10  # 全局變數

def func():
    x = 5  # 局部變數
    print(x)  # 輸出: 5

func()
print(x)  # 輸出: 10

使用 global 關鍵字可以在函數內修改全局變數。

def func():
    global x
    x = 5

func()
print(x)  # 輸出: 5

6. Lambda 函數

Lambda 函數是匿名函數，用於定義簡單的、一次性使用的函數。

# 定義一個複雜的 lambda 函數，接受三個參數，並根據條件返回最大值
max_value = lambda a, b, c: a if a > b else b if b > c else c

# 調用 lambda 函數
result = max_value(10, 20, 15)
print(result)  # 輸出: 20

7. 函數的文檔字元串

使用三引號（"""）可以為函數添加文檔字元串（docstring），描述函數的功能。

def add(a, b):
    """返回兩個數的和"""
    return a + b

print(add.__doc__)  # 輸出: 返回兩個數的和

8、Python 元組概述

元組（Tuple）是 Python 中的一種內置數據結構，用於存儲多個元素。與列表類似，元組也可以存儲不同類型的數據，但與列表不同的是，元組一旦創建後就不能修改，這意味著元組是不可變的。

元組與列表的區別

可變性：元組不可變，列表可變。
性能：由於不可變性，元組在使用中比列表更為高效，特別是在需要頻繁讀操作的場景下。
用途：元組常用於作為函數參數、返回值、數據結構的鍵等場景，而列表更多用於需要修改數據的場景。

1. 元組的定義與創建

1.1. 使用圓括弧創建元組

元組使用圓括弧 () 來定義，元素之間用逗號分隔。即使元組只有一個元素，也要在元素後面加上逗號，否則不會被識別為元組。

# 創建一個包含多個元素的元組
my_tuple = (1, 2, 3, "hello")

# 創建一個空元組
empty_tuple = ()

# 創建一個只有一個元素的元組，註意逗號
single_element_tuple = (5,)

1.2. 省略圓括弧

Python 允許在定義元組時省略圓括弧，直接用逗號分隔元素即可。

my_tuple = 1, 2, 3, "hello"

2. 元組的訪問與操作

2.1. 訪問元組元素

可以使用索引來訪問元組中的元素，索引從 0 開始。負索引可以從末尾開始訪問元素。

my_tuple = (10, 20, 30, 40)

# 訪問第一個元素
print(my_tuple[0])  # 輸出: 10

# 訪問最後一個元素
print(my_tuple[-1])  # 輸出: 40

2.2. 元組的切片操作

元組支持切片操作，用於訪問子元組。切片語法為 start:end:step，其中 start 是起始索引，end 是結束索引（不包括 end），step 是步長（可選）。

my_tuple = (0, 1, 2, 3, 4, 5)

# 訪問從索引 1 到 3 的元素
print(my_tuple[1:4])  # 輸出: (1, 2, 3)

# 訪問從索引 2 開始的所有元素
print(my_tuple[2:])  # 輸出: (2, 3, 4, 5)

# 以步長 2 訪問元素
print(my_tuple[::2])  # 輸出: (0, 2, 4)

3. 元組的不可變性

元組是不可變的，這意味著一旦創建了元組，其元素不能被修改、添加或刪除。

my_tuple = (10, 20, 30)

# 嘗試修改元組中的元素會導致錯誤
# my_tuple[0] = 100  # 會引發 TypeError

# 嘗試刪除元組中的元素也會導致錯誤
# del my_tuple[0]  # 會引發 TypeError

4. 元組的常見操作

儘管元組是不可變的，但有一些常見操作可以應用於元組。

4.1. 連接與重覆

連接：可以使用 + 操作符連接兩個元組，生成一個新的元組。
重覆：可以使用 * 操作符重覆元組中的元素。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# 連接元組
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 輸出: (1, 2, 3, 4, 5, 6)

# 重覆元組
repeated_tuple = tuple1 * 2
print(repeated_tuple)  # 輸出: (1, 2, 3, 1, 2, 3)

4.2. 成員檢查

可以使用 in 和 not in 操作符檢查某個元素是否在元組中。

my_tuple = (1, 2, 3, 4)

print(2 in my_tuple)  # 輸出: True
print(5 not in my_tuple)  # 輸出: True

4.3. 元組的遍歷

可以使用 for 迴圈遍歷元組中的所有元素。

my_tuple = ("apple", "banana", "cherry")

for item in my_tuple:
    print(item)
# 輸出:
# apple
# banana
# cherry

5. 元組的解包

元組可以進行解包操作，將元組中的元素賦值給對應數量的變數。

my_tuple = (1, 2, 3)

# 解包元組
a, b, c = my_tuple
print(a, b, c)  # 輸出: 1 2 3

# 結合*操作符進行部分解包
a, *b = my_tuple
print(a, b)  # 輸出: 1 [2, 3]

6. 元組的內置函數

Python 提供了一些內置函數來操作元組：

len()：返回元組的長度（元素個數）。
max() 和 min()：返回元組中的最大值和最小值（元素必須是可比較的）。
sum()：對元組中的元素求和（元素必須是數字）。
index()：返回某個元素在元組中的索引。
count()：返回某個元素在元組中出現的次數。

my_tuple = (1, 2, 3, 2, 1)

print(len(my_tuple))  # 輸出: 5
print(max(my_tuple))  # 輸出: 3
print(min(my_tuple))  # 輸出: 1
print(sum(my_tuple))  # 輸出: 9
print(my_tuple.index(2))  # 輸出: 1
print(my_tuple.count(1))  # 輸出: 2

9、集合

集合（Set）是 Python 中的一種內置數據類型，用於存儲多個元素。與列表和元組不同，集合中的元素是無序且不重覆的。集合主要用於去重和集合運算，如並集、交集和差集等。

1. 集合的定義與創建

1.1. 使用花括弧創建集合

可以使用花括弧 {} 創建集合，元素之間用逗號分隔。

# 創建一個包含多個元素的集合
my_set = {1, 2, 3, "hello"}

# 創建一個空集合
empty_set = set()  # 註意：不能使用 {} 創建空集合，那是創建空字典的語法

1.2. 使用 `set()` 函數創建集合

可以使用 set() 函數將其他可迭代對象（如 列表、元組 ）轉換為集合。

# 從列表創建集合
my_set = set([1, 2, 3, 3, 4])
print(my_set)  # 輸出: {1, 2, 3, 4}，去除了重覆元素

2. 集合的基本操作

2.1. 添加與刪除元素

add()：向集合添加單個元素。
update()：向集合添加多個元素，可以傳入可迭代對象。
remove() 和 discard()：從集合中刪除指定元素。remove() 在元素不存在時會引發 KeyError，而 discard() 不會。
pop()：隨機刪除並返回集合中的一個元素。
clear()：清空集合中的所有元素。

my_set = {1, 2, 3}

# 添加元素
my_set.add(4)
print(my_set)  # 輸出: {1, 2, 3, 4}

# 添加多個元素
my_set.update([5, 6])
print(my_set)  # 輸出: {1, 2, 3, 4, 5, 6}

# 刪除元素
my_set.remove(2)
print(my_set)  # 輸出: {1, 3, 4, 5, 6}

# 刪除不存在的元素不會引發錯誤
my_set.discard(10)
print(my_set)  # 輸出: {1, 3, 4, 5, 6}

# 隨機刪除元素
removed_element = my_set.pop()
print(removed_element)  # 輸出: 被刪除的元素
print(my_set)  # 輸出: 剩餘的集合元素

# 清空集合
my_set.clear()
print(my_set)  # 輸出: set()，空集合

3. 集合的集合運算

集合支持多種常見的集合運算，如並集、交集、差集和對稱差集。

3.1. 並集

union() 或 |：返回兩個集合的並集，即所有元素的集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 並集
print(set1.union(set2))  # 輸出: {1, 2, 3, 4, 5}
print(set1 | set2)       # 輸出: {1, 2, 3, 4, 5}

3.2. 交集

intersection() 或 &：返回兩個集合的交集，即共有元素的集合。

# 交集
print(set1.intersection(set2))  # 輸出: {3}
print(set1 & set2)              # 輸出: {3}

3.3. 差集

difference() 或 -：返回一個集合中有而另一個集合中沒有的元素。

# 差集
print(set1.difference(set2))  # 輸出: {1, 2}
print(set1 - set2)            # 輸出: {1, 2}

3.4. 對稱差集

symmetric_difference() 或 ^：返回兩個集合中不相同的元素組成的集合。

# 對稱差集
print(set1.symmetric_difference(set2))  # 輸出: {1, 2, 4, 5}
print(set1 ^ set2)                      # 輸出: {1, 2, 4, 5}

4. 集合的其他操作

4.1. 判斷子集與超集

子集和超集是互為對稱的概念，但它們之間的區別在於關註的方向不同。

子集關註的是“較小”集合相對於“較大”集合的包含關係：如果集合 (B) 的所有元素都在集合 (A) 中，那麼 (B) 是 (A) 的子集。
超集關註的是“較大”集合相對於“較小”集合的包含關係：如果集合 (A) 包含了集合 (B) 的所有元素，那麼 (A) 是 (B) 的超集。
issubset()：判斷一個集合是否為另一個集合的子集。
issuperset()：判斷一個集合是否為另一個集合的超集。

set1 = {1, 2, 3}
set2 = {1, 2}

print(set2.issubset(set1))  # 輸出: True，set2 是 set1 的子集
print(set1.issuperset(set2))  # 輸出: True，set1 是 set2 的超集

4.2. 判斷集合相等

可以使用 == 判斷兩個集合是否相等，即它們的元素是否完全一致。

set1 = {1, 2, 3}
set2 = {3, 2, 1}

print(set1 == set2)  # 輸出: True

4.3. 成員檢查

可以使用 in 和 not in 檢查某個元素是否在集合中。

my_set = {1, 2, 3}

print(1 in my_set)  # 輸出: True
print(4 not in my_set)  # 輸出: True

5. 集合的應用場景

去重：集合最常見的用途是去除重覆元素。
集合運算：集合提供了強大的集合運算功能，適用於需要計算交集、並集、差集的場景。
元素檢查：集合查找元素的時間複雜度為 O(1)，適合用於大量元素的快速查找。

10、字典

字典（Dictionary）是 Python 中一種內置的數據類型，用於存儲鍵值對（key-value pairs）。字典是一種可變的、無序的集合，主要用於根據鍵快速查找對應的值。

1. 字典的定義與創建

1.1. 使用花括弧創建字典

可以使用花括弧 {} 創建字典，鍵值對之間用冒號 : 分隔，多個鍵值對之間用逗號分隔。

# 創建一個包含多個鍵值對的字典
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# 創建一個空字典
empty_dict = {}

1.2. 使用 `dict()` 函數創建字典

可以使用 dict() 函數通過其他可迭代對象（如列表的元組）創建字典。

# 從鍵值對的元組列表創建字典
my_dict = dict([("name", "Alice"), ("age", 30), ("city", "New York")])

# 從關鍵字參數創建字典
my_dict = dict(name="Alice", age=30, city="New York")

2. 字典的基本操作

2.1. 訪問字典中的值

通過鍵訪問字典中的值。如果鍵不存在，會引發 KeyError 異常。

my_dict = {"name": "Alice", "age": 30}

# 訪問字典中的值
print(my_dict["name"])  # 輸出: Alice

# 訪問不存在的鍵會引發 KeyError
# print(my_dict["gender"])  # 引發 KeyError

可以使用 get() 方法訪問字典中的值，如果鍵不存在，則返回 None 或指定的預設值。

# 使用 get() 方法訪問字典中的值
print(my_dict.get("name"))  # 輸出: Alice
print(my_dict.get("gender", "Not Found"))  # 輸出: Not Found

2.2. 添加與修改鍵值對

可以通過賦值操作添加新的鍵值對或修改已有的鍵值對。

my_dict = {"name": "Alice", "age": 30}

# 添加新的鍵值對
my_dict["city"] = "New York"

# 修改已有的鍵值對
my_dict["age"] = 31

print(my_dict)  # 輸出: {'name': 'Alice', 'age': 31, 'city': 'New York'}

2.3. 刪除鍵值對

使用 del 關鍵字或 pop() 方法刪除鍵值對。pop() 方法返回被刪除的值。

可以用 in 或 not in 判斷是否含有該 key, del 刪除不存在的 key 會報錯

my_dict = {"name": "Alice", "age": 30, "city": "New York"}

# 使用 del 刪除鍵值對
del my_dict["city"]

# 使用 pop() 刪除鍵值對並獲取其值
age = my_dict.pop("age")

print(my_dict)  # 輸出: {'name': 'Alice'}
print(age)      # 輸出: 30

2.4. 清空字典

使用 clear() 方法清空字典中的所有鍵值對。

my_dict = {"name": "Alice", "age": 30}
my_dict.clear()
print(my_dict)  # 輸出: {}

3. 字典的常用方法

keys(): 返回字典中所有鍵的視圖對象。
values(): 返回字典中所有值的視圖對象。
items(): 返回字典中所有鍵值對的視圖對象。
update(): 用另一個字典或鍵值對更新當前字典。

my_dict = {"name": "Alice", "age": 30}

# 獲取所有鍵
print(my_dict.keys())  # 輸出: dict_keys(['name', 'age'])

# 獲取所有值
print(my_dict.values())  # 輸出: dict_values(['Alice', 30])

# 獲取所有鍵值對
print(my_dict.items())  # 輸出: dict_items([('name', 'Alice'), ('age', 30)])

# 更新字典
my_dict.update({"city": "New York", "age": 31})
print(my_dict)  # 輸出: {'name': 'Alice', 'age': 31, 'city': 'New York'}

4. 字典的遍歷

可以使用 for 迴圈遍歷字典的鍵、值或鍵值對。

my_dict = {"name": "Alice", "age": 30}

# 遍歷字典的鍵
for key in my_dict:
    print(key)

# 遍歷字典的值
for value in my_dict.values():
    print(value)

# 遍歷字典的鍵值對
for key, value in my_dict.items():
    print(f"{key}: {value}")

5. 字典的特性

無序：字典中的鍵值對沒有順序。在 Python 3.7 及更高版本中，字典保持插入順序。
鍵的唯一性：字典中的鍵是唯一的，不能重覆。如果重覆插入相同的鍵，後插入的值會覆蓋之前的值。
鍵的不可變性：字典的鍵必須是不可變的數據類型，例如字元串、整數、元組等。列表和其他可變類型不能作為字典的鍵。

6. 應用場景

快速查找：字典提供 O(1) 時間複雜度的查找操作，適用於需要快速檢索數據的場景。
存儲關聯數據：字典非常適合用於存儲關聯數據，例如資料庫的記錄、配置項等。

11、類

Python中的類（Class）是面向對象編程的核心概念之一。類定義了一個對象的結構和行為，允許我們創建具有相同屬性和方法的多個實例（對象）。

1. 類的定義

在Python中，使用class關鍵字來定義一個類。類的名字通常遵循大駝峰命名法（每個單詞的首字母大寫），以便與函數名或變數名區分開來。以下是一個簡單的類定義示例：

class Animal:
    pass  # 空類，暫不定義任何屬性或方法

2. 類的構造函數

類的構造函數是指在創建對象時自動調用的特殊方法。在Python中，構造函數使用__init__方法定義。構造函數通常用於初始化對象的屬性。下麵是一個包含構造函數的類定義示例：

class Animal:
    def __init__(self, name, species):
        self.name = name  # 實例屬性
        self.species = species  # 實例屬性

在上面的例子中，__init__方法接受name和species兩個參數，並將它們賦值給對象的實例屬性self.name和self.species。

3. 創建對象（實例化）

類定義完成後，可以通過調用類的名稱來創建對象。這個過程稱為實例化。實例化時會自動調用類的構造函數，並返回一個類的實例：

dog = Animal("Buddy", "Dog")
print(dog.name)  # 輸出: Buddy
print(dog.species)  # 輸出: Dog

4. 類的方法

類的方法是定義在類內部的函數。方法的第一個參數通常是self，它指向類的實例本身，從而允許方法訪問和修改實例屬性。以下是一個帶有方法的類示例：

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def speak(self):
        return f"{self.name} says hello!"

你可以通過類的實例來調用方法：

dog = Animal("Buddy", "Dog")
print(dog.speak())  # 輸出: Buddy says hello!

5. 類屬性與實例屬性

實例屬性：定義在__init__方法中的屬性，每個實例獨有。
類屬性：定義在類體內部但不在__init__方法中的屬性，所有實例共用。

class Animal:
    kingdom = "Animalia"  # 類屬性

    def __init__(self, name, species):
        self.name = name  # 實例屬性
        self.species = species  # 實例屬性

可以通過類名或實例來訪問類屬性：

print(Animal.kingdom)  # 輸出: Animalia
dog = Animal("Buddy", "Dog")
print(dog.kingdom)  # 輸出: Animalia

6. 繼承

Python支持類的繼承機制，即一個類可以繼承另一個類的屬性和方法。繼承允許我們重用代碼並構建層次化的類結構。以下是繼承的示例：

class Dog(Animal):  # Dog類繼承Animal類
    def __init__(self, name, breed):
        super().__init__(name, "Dog")  # 調用父類的構造函數
        self.breed = breed  # 新增屬性

    def speak(self):
        return f"{self.name} says woof!"

在這個例子中，Dog類繼承了Animal類，並重寫了speak方法。super().__init__(name, "Dog")調用父類的構造函數來初始化name和species屬性。

7. 多態

多態是指同一方法在不同對象上表現出不同的行為。通過繼承和方法重寫，多態在Python中得以實現。例如：

class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"

animals = [Dog("Buddy", "Golden Retriever"), Cat("Whiskers")]
for animal in animals:
    print(animal.speak())

輸出將分別調用Dog和Cat的speak方法：

Buddy says woof!
Whiskers says meow!

8. 封裝與私有化

封裝是將對象的狀態（屬性）和行為（方法）隱藏在類內部，外部不能直接訪問類的內部狀態。Python通過在屬性名前加上雙下劃線__來實現屬性的私有化：

class Animal:
    def __init__(self, name, species):
        self.__name = name  # 私有屬性

    def get_name(self):
        return self.__name  # 通過方法訪問私有屬性

在外部代碼中，無法直接訪問私有屬性：

dog = Animal("Buddy", "Dog")
print(dog.__name)  # 拋出 AttributeError 錯誤
print(dog.get_name())  # 輸出: Buddy

9. 類與靜態方法

類方法：使用@classmethod裝飾器定義，第一個參數為cls，表示類本身。
靜態方法：使用@staticmethod裝飾器定義，不需要傳入self或cls。

class Animal:
    population = 0

    def __init__(self, name, species):
        self.name = name
        self.species = species
        Animal.population += 1

    @classmethod
    def get_population(cls):
        return cls.population

    @staticmethod
    def is_animal(thing):
        return isinstance(thing, Animal)

調用類方法和靜態方法：

dog = Animal("Buddy", "Dog")
cat = Animal("Whiskers", "Cat")

print(Animal.get_population())  # 輸出: 2
print(Animal.is_animal(dog))  # 輸出: True

10. 魔法方法

Python的類中有一些特殊方法被稱為魔法方法（Magic Methods），它們以雙下劃線開頭和結尾，提供了一種定製類行為的方式。常見的魔法方法有：

__str__：定義對象的字元串表示。

示例：

class Animal:
    def __str__(self):
        return f"{self.name} the {self.species}"

# str(dog) 時會調用上面的方法

12、異常

1. 什麼是異常？

異常（Exception）是指程式在運行時遇到的錯誤情況，這些錯

python入門教程（非常詳細！3w+ 文字）

1、 安裝 Python 解釋器

為什麼需要安裝 Python

1. 下載 Python 安裝包

2. 安裝 Python

3. 驗證安裝

4.創建一個py項目

2、語法基礎

1. 變數

變數的使用示例：

2. 運算符

示例：

3. 表達式

示例：

4. 輸入

1. input

示例：

2. readlines讀入

適用場景

5. 輸出

示例：

保留小數位數：

格式化輸出字元串：

6. 其它函數

3、判斷語句

1. 基本語法

2. 示例

2.1 簡單的 if 語句

2.2 if 和 else 語句

2.3 if、elif 和 else 語句

3. 條件表達式

示例：

4. 使用布爾運算符

not 運算符示例：

5. 比較運算符

6. match 語句（Python 3.10 及以上版本）

基本語法

示例

7. pass 語句

示例

4、迴圈語句

for 迴圈

語法

示例

for in range

基本語法

示例

1. 基本用法

2. 指定起始值

3. 指定步長

while 迴圈

語法

示例

迴圈控制語句

break 語句

continue 語句

else 子句

嵌套迴圈

for 迴圈中的 enumerate 和 zip

5、列表

1. 列表的定義與創建

2. 訪問列表元素

3. 修改列表元素

4. 列表的遍歷

5. 常用方法

6. 列表的切片

7. 列表的排序

1. 使用 sort() 方法

示例

2. 使用 sorted() 函數

示例

3. 自定義排序規則

示例：按字元串的最後一個字母排序

8. 列表的其他常用操作

9、Python 列表推導式

1. 基本語法

示例

6、Python 字元串詳解

1. 字元串的定義與創建

2. 字元串的基本操作

1、安裝 Python 解釋器

2.1 簡單的 `if` 語句

2.2 `if` 和 `else` 語句

2.3 `if`、`elif` 和 `else` 語句

`not` 運算符示例：

6. `match` 語句（Python 3.10 及以上版本）

7. `pass` 語句

`for` 迴圈

`for in range`

`while` 迴圈

`break` 語句

`continue` 語句

`else` 子句

`for` 迴圈中的 `enumerate` 和 `zip`

1. 使用 `sort()` 方法

2. 使用 `sorted()` 函數

3.1 `lower()` 和 `upper()`

3.2 `strip()`

3.3 `split()`

3.4 `join()`

3.5 `find()` 和 `replace()`

3.6 `startswith()` 和 `endswith()`

1. 百分號格式化 (`%`)

2. `str.format()` 方法

3.4 可變參數 (`*args` 和 `**kwargs`)

1.2. 使用 `set()` 函數創建集合