Python 語言 30 個核心必知語法細節
1. 變量與數據類型
Python 是一種動態類型語言，這意味著你不需要聲明變量的數據類型。你可以直接給變量賦值。
示例：
# 定義一個整型變量
age = 25
print("年齡:", age) # 輸出 年齡: 25
# 定義一個字符串變量
name = "Alice"
print("名字:", name) # 輸出 名字: Alice
# 定義一個浮點型變量
salary = 5000.50
print("工資:", salary) # 輸出 工資: 5000.5解釋：
age 是一個整型變量。
name 是一個字符串變量。
salary 是一個浮點型變量。
2. 字符串操作
字符串是 Python 中最常用的數據類型之一。你可以使用多種方法來操作字符串。
示例：
# 字符串拼接
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print("全名:", full_name) # 輸出 全名: John Doe
# 字符串重復
greeting = "Hello" * 3
print("問候:", greeting) # 輸出 問候: HelloHelloHello
# 字符串索引
word = "Python"
print("首字母:", word[0]) # 輸出 首字母: P
print("尾字母:", word[-1]) # 輸出 尾字母: n
# 字符串切片
print("子字符串:", word[1:4]) # 輸出 子字符串: yth解釋：
+ 操作符用于拼接字符串。
* 操作符用于重復字符串。
索引和切片可以用來獲取字符串中的特定字符或子字符串。
3. 列表 (List)
列表是一種常用的有序集合，可以包含不同類型的元素。
示例：
# 創建一個列表
fruits = ["apple", "banana", "cherry"]
print("水果:", fruits) # 輸出 水果: ['apple', 'banana', 'cherry']
# 訪問列表元素
print("第一個水果:", fruits[0]) # 輸出 第一個水果: apple
print("最后一個水果:", fruits[-1]) # 輸出 最后一個水果: cherry
# 修改列表元素
fruits[1] = "orange"
print("更新后的水果:", fruits) # 輸出 更新后的水果: ['apple', 'orange', 'cherry']
# 添加元素
fruits.append("grape")
print("添加后的水果:", fruits) # 輸出 添加后的水果: ['apple', 'orange', 'cherry', 'grape']
# 刪除元素
fruits.remove("cherry")
print("刪除后的水果:", fruits) # 輸出 刪除后的水果: ['apple', 'orange', 'grape']解釋：
使用方括號 [] 來創建列表。
使用索引來訪問或修改列表中的元素。
append() 方法用于在列表末尾添加元素。
remove() 方法用于刪除指定元素。
4. 元組 (Tuple)
元組與列表類似，但它是不可變的，一旦定義就不能修改。
示例：
# 創建一個元組
colors = ("red", "green", "blue")
print("顏色:", colors) # 輸出 顏色: ('red', 'green', 'blue')
# 訪問元組元素
print("第一個顏色:", colors[0]) # 輸出 第一個顏色: red
# 元組切片
print("切片:", colors[1:]) # 輸出 切片: ('green', 'blue')解釋：
使用圓括號 () 來創建元組。
元組中的元素不能被修改。
可以使用索引和切片來訪問元組中的元素。
5. 字典 (Dictionary)
字典是一種鍵值對集合，常用于存儲和檢索數據。
示例：
# 創建一個字典
person = {"name": "Alice", "age": 25, "city": "New York"}
print("個人信息:", person) # 輸出 個人信息: {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 訪問字典元素
print("名字:", person["name"]) # 輸出 名字: Alice
# 修改字典元素
person["age"] = 26
print("更新后的個人信息:", person) # 輸出 更新后的個人信息: {'name': 'Alice', 'age': 26, 'city': 'New York'}
# 添加新元素
person["job"] = "Engineer"
print("添加后的個人信息:", person) # 輸出 添加后的個人信息: {'name': 'Alice', 'age': 26, 'city': 'New York', 'job': 'Engineer'}
# 刪除元素
del person["city"]
print("刪除后的個人信息:", person) # 輸出 刪除后的個人信息: {'name': 'Alice', 'age': 26, 'job': 'Engineer'}解釋：
使用花括號 {} 來創建字典。
使用鍵來訪問或修改字典中的元素。
可以使用 del 關鍵字來刪除字典中的元素。
6. 控制結構 - if 語句
條件語句用于根據不同的條件執行不同的代碼塊。
示例：
# if 語句
age = 18
if age >= 18:
print("你是成年人。") # 輸出 你是成年人。
# if-else 語句
if age < 18:
print("你是未成年人。")
else:
print("你是成年人。") # 輸出 你是成年人。
# if-elif-else 語句
if age < 13:
print("你是兒童。")
elif age < 18:
print("你是青少年。")
else:
print("你是成年人。") # 輸出 你是成年人。解釋：
if 語句用于檢查條件是否為真。
if-else 語句用于在條件為真時執行一個代碼塊，在條件為假時執行另一個代碼塊。
if-elif-else 語句用于檢查多個條件，并執行第一個為真的條件對應的代碼塊。
7. 控制結構 - for 循環
循環語句用于重復執行一段代碼塊。
示例：
# 遍歷列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
# 輸出
# apple
# banana
# cherry
# 遍歷字符串
word = "Python"
for char in word:
print(char)
# 輸出
# P
# y
# t
# h
# o
# n
# 使用 range() 函數
for i in range(5):
print(i)
# 輸出
# 0
# 1
# 2
# 3
# 4解釋：
for 循環可以遍歷任何序列的項目，如列表或字符串。
range() 函數生成一系列數字，通常用于控制循環次數。
8. 控制結構 - while 循環
while 循環用于在條件為真時重復執行代碼塊。
示例：
# 基本 while 循環
count = 0
while count < 5:
print(count)
count += 1
# 輸出
# 0
# 1
# 2
# 3
# 4
# 使用 break 和 continue
i = 0
while i < 10:
if i == 5:
break
if i % 2 == 0:
i += 1
continue
print(i)
i += 1
# 輸出
# 1
# 3解釋：
while 循環會在每次迭代前檢查條件。
break 語句用于提前退出循環。
continue 語句用于跳過當前迭代并繼續下一次迭代。
9. 函數
函數是一段可重用的代碼塊，可以接收參數并返回值。
示例：
# 定義一個函數
def greet(name):
print(f"你好, {name}!")
# 調用函數
greet("Alice") # 輸出 你好, Alice!
# 返回值的函數
def add(a, b):
return a + b
result = add(5, 3)
print("結果:", result) # 輸出 結果: 8解釋：
使用 def 關鍵字定義函數。
函數可以有參數。
使用 return 語句返回值。
10. 參數傳遞方式
Python 中函數可以使用位置參數、關鍵字參數、默認參數等多種方式傳遞參數。
示例：
# 位置參數
def print_info(name, age):
print(f"名字: {name}, 年齡: {age}")
print_info("Alice", 25) # 輸出 名字: Alice, 年齡: 25
# 關鍵字參數
print_info(age=25, name="Alice") # 輸出 名字: Alice, 年齡: 25
# 默認參數
def print_info(name, age=25):
print(f"名字: {name}, 年齡: {age}")
print_info("Alice") # 輸出 名字: Alice, 年齡: 25解釋：
位置參數按照參數順序傳遞。
關鍵字參數使用參數名稱傳遞。
默認參數可以在定義函數時指定默認值。
11. 變量作用域
變量的作用域決定了變量在程序中哪些地方可以被訪問。
示例：
# 全局變量
x = 10
def test():
global x
x = 20
print(x) # 輸出 20
test()
print(x) # 輸出 20
# 局部變量
def test():
y = 5
print(y) # 輸出 5
test()
# print(y) # 報錯，y 是局部變量解釋：
全局變量在整個程序范圍內都可以訪問。
局部變量只能在定義它的函數內部訪問。
使用 global 關鍵字可以在函數內部修改全局變量。
12. 異常處理
異常處理可以幫助程序更好地應對錯誤情況，避免程序崩潰。
示例：
# try-except 語句
try:
num = int(input("請輸入一個數字: "))
result = 10 / num
print("結果:", result)
except ZeroDivisionError:
print("不能除以零。")
except ValueError:
print("無效輸入。")
# try-except-else 語句
try:
num = int(input("請輸入一個數字: "))
result = 10 / num
except ZeroDivisionError:
print("不能除以零。")
else:
print("結果:", result)
# try-except-finally 語句
try:
num = int(input("請輸入一個數字: "))
result = 10 / num
except ZeroDivisionError:
print("不能除以零。")
finally:
print("程序結束。")解釋：
try 塊用于嘗試可能引發異常的代碼。
except 塊用于捕獲并處理異常。
else 塊在沒有異常發生時執行。
finally 塊無論是否有異常都會執行。
13. 類和對象
類是面向對象編程的基礎，它定義了一組屬性和方法。
示例：
# 定義一個簡單的類
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print(f"我的名字是 {self.name}，我今年 {self.age} 歲。")
# 創建一個對象
alice = Person("Alice", 25)
alice.introduce() # 輸出 我的名字是 Alice，我今年 25 歲。
# 創建另一個對象
bob = Person("Bob", 30)
bob.introduce() # 輸出 我的名字是 Bob，我今年 30 歲。解釋：
使用 class 關鍵字定義類。
__init__ 方法是一個特殊的方法，用于初始化對象的屬性。
類中的方法可以通過對象調用。
14. 繼承
繼承允許一個類繼承另一個類的屬性和方法。
示例：
# 定義父類
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("動物發出聲音。")
# 定義子類
class Dog(Animal):
def speak(self):
print("狗說汪汪。")
# 創建對象
animal = Animal("普通動物")
animal.speak() # 輸出 動物發出聲音。
dog = Dog("Buddy")
dog.speak() # 輸出 狗說汪汪。解釋：
子類 Dog 繼承自父類 Animal。
子類可以覆蓋父類的方法，實現多態性。
15. 多態
多態是指同一個方法在不同的對象上表現出不同的行為。
示例：
# 定義父類
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("動物發出聲音。")
# 定義子類
class Dog(Animal):
def speak(self):
print("狗說汪汪。")
class Cat(Animal):
def speak(self):
print("貓說喵喵。")
# 創建對象
animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:
animal.speak()
# 輸出
# 狗說汪汪。
# 貓說喵喵。解釋：
子類覆蓋了父類的方法 speak。
在循環中，根據對象的實際類型調用相應的 speak 方法。
16. 類方法和靜態方法
類方法和靜態方法是類級別的方法，它們不依賴于具體的對象實例。
示例：
# 定義類方法
class MathUtils:
@classmethod
def add(cls, a, b):
return a + b
# 使用類方法
result = MathUtils.add(5, 3)
print("結果:", result) # 輸出 結果: 8
# 定義靜態方法
class MathUtils:
@staticmethod
def multiply(a, b):
return a * b
# 使用靜態方法
result = MathUtils.multiply(5, 3)
print("結果:", result) # 輸出 結果: 15解釋：
類方法通過 @classmethod 裝飾器定義，第一個參數通常是 cls，代表類本身。
靜態方法通過 @staticmethod 裝飾器定義，不依賴于類或對象實例。
17. 內置函數
Python 提供了許多內置函數，用于處理各種常見的編程任務。
示例：
# len() 函數
fruits = ["apple", "banana", "cherry"]
print("長度:", len(fruits)) # 輸出 長度: 3
# type() 函數
num = 5
print("類型:", type(num)) # 輸出 類型:
# sum() 函數
numbers = [1, 2, 3, 4, 5]
print("總和:", sum(numbers)) # 輸出 總和: 15
# sorted() 函數
fruits = ["banana", "apple", "cherry"]
sorted_fruits = sorted(fruits)
print("排序后:", sorted_fruits) # 輸出 排序后: ['apple', 'banana', 'cherry']解釋：
len() 函數用于獲取序列的長度。
type() 函數用于獲取變量的數據類型。
sum() 函數用于計算數值列表的總和。
sorted() 函數用于對列表進行排序。
18. 生成器
生成器是一種特殊的迭代器，可以節省內存。
示例：
# 定義一個生成器函數
def fibonacci(n):
a, b = 0, 1
while a < n:
yield a
a, b = b, a + b
# 使用生成器
for num in fibonacci(10):
print(num)
# 輸出
# 0
# 1
# 1
# 2
# 3
# 5
# 8解釋：
使用 yield 關鍵字定義生成器函數。
生成器函數每次調用時返回一個值，并保留狀態。
19. Lambda 函數
Lambda 函數是一種簡潔的匿名函數定義方式。
示例：
# 定義 lambda 函數
add = lambda x, y: x + y
print("加法結果:", add(5, 3)) # 輸出 加法結果: 8
# 使用 lambda 函數
numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("偶數:", even_numbers) # 輸出 偶數: [2, 4]解釋：
lambda 關鍵字用于定義匿名函數。
Lambda 函數可以作為參數傳遞給其他函數，如 filter()。
20. 列表推導式
列表推導式是一種簡潔的創建列表的方式。
示例：
# 基本列表推導式
squares = [x ** 2 for x in range(5)]
print("平方數:", squares) # 輸出 平方數: [0, 1, 4, 9, 16]
# 帶條件的列表推導式
even_squares = [x ** 2 for x in range(5) if x % 2 == 0]
print("偶數平方數:", even_squares) # 輸出 偶數平方數: [0, 4, 16]解釋：
列表推導式使用 [expression for item in iterable] 的形式。
可以在列表推導式中加入條件表達式。
21. 字典推導式
字典推導式是一種簡潔的創建字典的方式。
示例：
# 基本字典推導式
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
age_dict = {name: age for name, age in zip(names, ages)}
print("年齡字典:", age_dict) # 輸出 年齡字典: {'Alice': 25, 'Bob': 30, 'Charlie': 35}
# 帶條件的字典推導式
even_age_dict = {name: age for name, age in zip(names, ages) if age % 2 == 0}
print("偶數年齡字典:", even_age_dict) # 輸出 偶數年齡字典: {}解釋：
字典推導式使用 {key_expression: value_expression for item in iterable} 的形式。
可以在字典推導式中加入條件表達式。
22. 裝飾器
裝飾器是一種函數，可以修改其他函數的行為。
示例：
# 定義一個裝飾器
def my_decorator(func):
def wrapper():
print("在函數調用之前做一些事情。")
func()
print("在函數調用之后做一些事情。")
return wrapper
# 應用裝飾器
@my_decorator
def say_hello():
print("你好！")
say_hello()
# 輸出
# 在函數調用之前做一些事情。
# 你好！
# 在函數調用之后做一些事情。解釋：
使用 def 關鍵字定義裝飾器函數。
裝飾器函數返回一個包裝函數 wrapper，該函數在調用原函數前后執行額外的操作。
使用 @ 符號將裝飾器應用到目標函數上。
23. 文件操作
文件操作是 Python 中常見的任務，包括讀取、寫入和追加文件內容。
示例：
# 寫入文件
with open('example.txt', 'w', encoding='utf-8') as file:
file.write('你好，世界！')
# 讀取文件
with open('example.txt', 'r', encoding='utf-8') as file:
content = file.read()
print("文件內容:", content) # 輸出 文件內容: 你好，世界！
# 追加文件
with open('example.txt', 'a', encoding='utf-8') as file:
file.write('\n再見，世界！')
# 重新讀取文件
with open('example.txt', 'r', encoding='utf-8') as file:
content = file.read()
print("更新后的文件內容:", content) # 輸出 更新后的文件內容: 你好，世界！\n再見，世界！解釋：
使用 with 語句打開文件，確保文件在操作完成后自動關閉。
'w' 模式用于寫入文件，會清空原有內容。
'r' 模式用于讀取文件。
'a' 模式用于追加文件，不會清空原有內容。
24. 列表切片
列表切片是 Python 中一種強大的特性，用于訪問和操作列表的子部分。
示例：
# 獲取列表的前 n 個元素
lst = [0, 1, 2, 3, 4, 5]
n = 3
print("前3個元素:", lst[:n]) # 輸出 前3個元素: [0, 1, 2]
# 獲取列表的后 n 個元素
print("后3個元素:", lst[-n:]) # 輸出 后3個元素: [3, 4, 5]
# 獲取列表的中間 n 個元素
print("中間部分元素:", lst[n:-n]) # 輸出 中間部分元素: [3, 4]
# 獲取列表的第一個元素
print("第一個元素:", lst[0]) # 輸出 第一個元素: 0
# 獲取列表的最后一個元素
print("最后一個元素:", lst[-1]) # 輸出 最后一個元素: 5
# 獲取列表的倒數第二個元素
print("倒數第二個元素:", lst[-2]) # 輸出 倒數第二個元素: 4
# 反轉列表
print("反轉后的列表:", lst[::-1]) # 輸出 反轉后的列表: [5, 4, 3, 2, 1, 0]
# 獲取列表的奇數索引元素
print("奇數索引元素:", lst[1::2]) # 輸出 奇數索引元素: [1, 3, 5]
# 獲取列表的偶數索引元素
print("偶數索引元素:", lst[0::2]) # 輸出 偶數索引元素: [0, 2, 4]
# 獲取列表的步長為 2 的元素
print("步長為2的元素:", lst[::2]) # 輸出 步長為2的元素: [0, 2, 4]解釋：
切片操作使用 : 分隔符來指定起始和結束索引。
負索引從列表末尾開始計數。
可以使用步長來指定切片的間隔。
25. 字符串格式化
字符串格式化用于將變量插入到字符串中。
示例：
# 使用 % 操作符
name = "Alice"
age = 25
print("我的名字是 %s，我今年 %d 歲。" % (name, age)) # 輸出 我的名字是 Alice，我今年 25 歲。
# 使用 format() 方法
print("我的名字是 {}, 我今年 {} 歲。".format(name, age)) # 輸出 我的名字是 Alice，我今年 25 歲。
# 使用 f-string
print(f"我的名字是 {name}，我今年 {age} 歲。") # 輸出 我的名字是 Alice，我今年 25 歲。解釋：
% 操作符是最傳統的字符串格式化方式。
format() 方法提供更靈活的格式化選項。
f-string 是 Python 3.6 以后引入的新特性，更簡潔易讀。
26. 列表排序
列表排序可以按升序或降序排列列表元素。
示例：
# 升序排序
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print("升序排序:", sorted_numbers) # 輸出 升序排序: [1, 1, 3, 4, 5, 9]
# 降序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print("降序排序:", sorted_numbers_desc) # 輸出 降序排序: [9, 5, 4, 3, 1, 1]
# 原地排序
numbers.sort()
print("原地排序:", numbers) # 輸出 原地排序: [1, 1, 3, 4, 5, 9]解釋：
sorted() 函數返回一個新的排序后的列表。
reverse=True 參數用于降序排序。
sort() 方法在原列表上進行排序。
27. 列表去重
列表去重可以去除列表中的重復元素。
示例：
# 使用 set 去重
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
print("去重后的列表:", unique_numbers) # 輸出 去重后的列表: [1, 2, 3, 4, 5]
# 使用列表推導式去重
unique_numbers = []
for num in numbers:
if num not in unique_numbers:
unique_numbers.append(num)
print("去重后的列表:", unique_numbers) # 輸出 去重后的列表: [1, 2, 3, 4, 5]解釋：
set 是一種無序不重復的集合，可以快速去重。
列表推導式可以手動去重，保持元素的原始順序。
28. 列表反轉
列表反轉可以將列表中的元素順序顛倒。
示例：
# 使用 reversed() 函數
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print("反轉后的列表:", reversed_numbers) # 輸出 反轉后的列表: [5, 4, 3, 2, 1]
# 使用切片反轉
reversed_numbers = numbers[::-1]
print("反轉后的列表:", reversed_numbers) # 輸出 反轉后的列表: [5, 4, 3, 2, 1]解釋：
reversed() 函數返回一個反向迭代器，需要轉換為列表。
切片操作 [::-1] 可以直接反轉列表。
29. 列表合并
列表合并可以將多個列表合并為一個列表。
示例：
# 使用 + 操作符
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2
print("合并后的列表:", merged_list) # 輸出 合并后的列表: [1, 2, 3, 4, 5, 6]
# 使用 extend() 方法
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print("合并后的列表:", list1) # 輸出 合并后的列表: [1, 2, 3, 4, 5, 6]解釋：
+ 操作符可以將兩個列表合并為一個新的列表。
extend() 方法在原列表上添加另一個列表的元素。
30. 列表索引
列表索引用于查找列表中元素的位置。
示例：
# 查找元素的索引
fruits = ["apple", "banana", "cherry"]
index = fruits.index("banana")
print("香蕉的索引:", index) # 輸出 香蕉的索引: 1
# 查找不存在的元素會拋出 ValueError
try:
index = fruits.index("grape")
except ValueError:
print("葡萄不在列表中。") # 輸出 葡萄不在列表中。解釋：
index() 方法返回指定元素在列表中的第一個匹配項的索引。
如果元素不存在，會拋出 ValueError。
總結
以上是Python 語言的核心語法細節，涵蓋了從基本的變量和數據類型、字符串操作、列表和元組、字典和集合，到控制結構、函數、類和對象、異常處理、文件操作、列表切片、字符串格式化、列表排序、去重、反轉、合并和索引等各個方面。熟悉這些語法細節可以大大提高你在編程中的效率和代碼的可讀性。
