第2章 Python基礎語法¶
前言¶
Python是一種簡潔、優雅且功能強大的編程語言，其語法設計注重可讀性和簡潔性，使得編寫和維護代碼變得更加容易。本章將介紹Python的基礎語法，包括變量、數據類型、運算符、輸入輸出函數以及代碼規範等內容，爲後續章節打下堅實的基礎。
本系列文章所使用到的示例源碼：Python從入門到精通示例代碼
2.1 變量與標識符¶
2.1.1 變量的概念與作用¶
變量是計算機程序中用於存儲數據的命名存儲位置。在Python中，變量實際上是對內存中存儲的數據的引用或指針。變量的主要作用包括：
- 存儲和管理數據
- 提高代碼的可讀性和可維護性
- 方便數據的重複使用和修改
在Python中創建變量非常簡單，只需要爲變量賦值即可：
# 創建變量並賦值
name = "Python"
age = 30
is_programming_language = True
# 使用變量
print(name) # 輸出: Python
print(age) # 輸出: 30
2.1.2 變量的命名規則¶
標識符的組成¶
標識符是用來命名變量、函數、類、模塊或其他對象的名稱。Python中的標識符需要遵循以下規則：
- 由字母、數字和下劃線組成
- 不能以數字開頭
- 區分大小寫
- 不能使用Python的關鍵字
# 有效的標識符
name = "Alice"
age_1 = 25
_private = "私有變量"
UserName = "用戶名"
# 無效的標識符
# 1name = "Bob" # 不能以數字開頭
# my-var = 10 # 不能包含連字符
# class = "Python" # 不能使用關鍵字
命名約定（PEP 8規範）¶
PEP 8是Python官方的代碼風格指南，它提供了一些命名約定：
- 變量和函數名使用小寫字母，單詞之間用下劃線連接（snake_case）
- 類名使用駝峯命名法（CamelCase）
- 常量使用全大寫字母，單詞之間用下劃線連接
- 模塊名使用簡短的全小寫名稱
# 變量和函數名
user_name = "Alice"
max_retry_count = 3
def calculate_average(numbers):
return sum(numbers) / len(numbers)
# 類名
class UserProfile:
pass
# 常量
MAX_CONNECTIONS = 100
PI = 3.14159
關鍵字與保留字¶
Python有一組保留的關鍵字，這些關鍵字不能用作變量名或其他標識符名稱。可以使用以下代碼查看所有關鍵字：
import keyword
print(keyword.kwlist)
輸出結果：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
2.1.3 變量的賦值與引用¶
Python中的變量賦值非常直觀：
# 基本賦值
x = 10
# 多重賦值
a, b, c = 1, 2, 3
# 交換變量值
x, y = 10, 20
x, y = y, x # 交換後 x=20, y=10
# 增強賦值
counter = 0
counter += 1 # 等同於 counter = counter + 1
在Python中，變量實際上是對象的引用。當我們將一個變量賦值給另一個變量時，兩個變量實際上引用同一個對象：
a = [1, 2, 3] # 創建列表對象
b = a # b引用同一個列表對象
b.append(4) # 修改列表對象
print(a) # 輸出: [1, 2, 3, 4]
2.1.4 變量的作用域簡介¶
Python中的變量有不同的作用域，決定了變量在哪些部分的代碼中可見：
- 局部作用域：在函數內部定義的變量
- 全局作用域：在模塊級別定義的變量
- 嵌套作用域：在嵌套函數中定義的變量
- 內置作用域：Python預定義的變量
# 全局變量
global_var = "我是全局變量"
def my_function():
# 局部變量
local_var = "我是局部變量"
print(local_var)
print(global_var) # 可以訪問全局變量
def nested_function():
# 嵌套作用域變量
nested_var = "我是嵌套變量"
print(nested_var)
print(local_var) # 可以訪問外層函數的局部變量
print(global_var) # 可以訪問全局變量
my_function()
# print(local_var) # 錯誤：局部變量在函數外不可見
2.1.5 常量的概念¶
常量是指在程序執行過程中值不應該改變的變量。Python沒有內置的常量類型，但按照慣例，使用全大寫字母命名的變量被視爲常量：
PI = 3.14159
MAX_USERS = 100
DATABASE_URL = "mongodb://localhost:27017"
# 雖然可以修改，但按照慣例不應該這樣做
# PI = 3.14 # 不推薦
2.2 數據類型概述¶
2.2.1 Python數據類型分類¶
Python是一種動態類型語言，提供了多種內置數據類型。這些數據類型可以分爲兩大類：
基本數據類型¶
- 數字類型：int（整數）、float（浮點數）、complex（複數）
- 字符串（str）：文本序列
- 布爾類型（bool）：True或False
- None類型：表示空值或不存在
# 數字類型
int_num = 42
float_num = 3.14
complex_num = 1 + 2j
# 字符串
text = "Hello, Python!"
# 布爾類型
is_active = True
is_completed = False
# None類型
result = None
複合數據類型¶
- 列表（list）：有序可變序列
- 元組（tuple）：有序不可變序列
- 字典（dict）：鍵值對集合
- 集合（set）：無序不重複元素集合
- 凍結集合（frozenset）：不可變的集合
# 列表
fruits = ["apple", "banana", "cherry"]
# 元組
coordinates = (10, 20)
# 字典
person = {"name": "Alice", "age": 30, "city": "Beijing"}
# 集合
unique_numbers = {1, 2, 3, 4, 5}
# 凍結集合
immutable_set = frozenset([1, 2, 3])
2.2.2 動態類型系統¶
Python是一種動態類型語言，這意味着變量的類型是在運行時確定的，而不是在編譯時。同一個變量可以在不同時刻引用不同類型的對象：
x = 10 # x引用整數對象
print(type(x)) # 輸出: <class 'int'>
x = "hello" # x現在引用字符串對象
print(type(x)) # 輸出: <class 'str'>
x = [1, 2, 3] # x現在引用列表對象
print(type(x)) # 輸出: <class 'list'>
2.2.3 type()函數的使用¶
type()函數用於獲取對象的類型：
print(type(42)) # 輸出: <class 'int'>
print(type(3.14)) # 輸出: <class 'float'>
print(type("hello")) # 輸出: <class 'str'>
print(type([1, 2, 3])) # 輸出: <class 'list'>
print(type({"a": 1})) # 輸出: <class 'dict'>
print(type(True)) # 輸出: <class 'bool'>
2.2.4 isinstance()函數的使用¶
isinstance()函數用於檢查對象是否是指定類型的實例：
x = 42
print(isinstance(x, int)) # 輸出: True
print(isinstance(x, float)) # 輸出: False
print(isinstance(x, (int, float))) # 輸出: True，檢查多種類型
y = "hello"
print(isinstance(y, str)) # 輸出: True
2.2.5 類型轉換（顯式與隱式）¶
Python支持兩種類型轉換：
顯式類型轉換（類型轉換函數）¶
# 整數轉換
print(int(3.14)) # 輸出: 3
print(int("42")) # 輸出: 42
# 浮點數轉換
print(float(42)) # 輸出: 42.0
print(float("3.14")) # 輸出: 3.14
# 字符串轉換
print(str(42)) # 輸出: "42"
print(str(3.14)) # 輸出: "3.14"
# 布爾值轉換
print(bool(0)) # 輸出: False
print(bool(42)) # 輸出: True
print(bool("")) # 輸出: False
print(bool("hello")) # 輸出: True
隱式類型轉換¶
Python在某些情況下會自動進行類型轉換：
x = 10 + 3.14 # 整數和浮點數相加，整數被轉換爲浮點數
print(x) # 輸出: 13.14
print(type(x)) # 輸出: <class 'float'>
y = "Hello, " + "World!" # 字符串連接
print(y) # 輸出: Hello, World!
2.3 數字類型（int、float、complex）¶
2.3.1 整數類型（int）¶
Python中的整數可以是任意大小，不受限制：
# 十進制表示
decimal = 42
print(decimal) # 輸出: 42
# 二進制表示（以0b開頭）
binary = 0b101010
print(binary) # 輸出: 42
# 八進制表示（以0o開頭）
octal = 0o52
print(octal) # 輸出: 42
# 十六進制表示（以0x開頭）
hexadecimal = 0x2A
print(hexadecimal) # 輸出: 42
大整數處理¶
Python可以處理任意大小的整數，不會溢出：
# 大整數計算
big_number = 10**100 # 10的100次方
print(big_number)
# 輸出: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
factorial = 1
for i in range(1, 51):
factorial *= i
print("50的階乘是:", factorial)
# 輸出一個非常大的數字，不會溢出
2.3.2 浮點數類型（float）¶
浮點數用於表示實數：
# 浮點數表示
x = 3.14
y = -0.001
z = 2.0
# 科學計數法
scientific = 3.14e2 # 3.14 × 10²
print(scientific) # 輸出: 314.0
small = 1.23e-4 # 1.23 × 10⁻⁴
print(small) # 輸出: 0.000123
浮點數精度問題¶
由於二進制浮點數的表示方式，某些小數在計算機中無法精確表示：
# 浮點數精度問題
print(0.1 + 0.2) # 輸出: 0.30000000000000004
print(0.1 + 0.2 == 0.3) # 輸出: False
# 解決方法：使用decimal模塊
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2')) # 輸出: 0.3
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3')) # 輸出: True
2.3.3 複數類型（complex）¶
複數由實部和虛部組成，虛部以j或J結尾：
# 複數表示
z1 = 2 + 3j
z2 = complex(2, 3) # 另一種創建方式
print(z1) # 輸出: (2+3j)
print(z1 == z2) # 輸出: True
# 獲取實部和虛部
print(z1.real) # 輸出: 2.0
print(z1.imag) # 輸出: 3.0
複數的基本操作¶
# 複數運算
z1 = 2 + 3j
z2 = 1 - 2j
print(z1 + z2) # 輸出: (3+1j)
print(z1 - z2) # 輸出: (1+5j)
print(z1 * z2) # 輸出: (8-1j)
print(z1 / z2) # 輸出: (-0.8+1.4j)
# 複數的共軛
print(z1.conjugate()) # 輸出: (2-3j)
# 複數的模
import math
print(abs(z1)) # 輸出: 3.605551275463989
2.3.4 數字類型之間的轉換¶
# 整數轉浮點數
print(float(42)) # 輸出: 42.0
# 浮點數轉整數（截斷小數部分）
print(int(3.14)) # 輸出: 3
print(int(-3.14)) # 輸出: -3
# 整數或浮點數轉複數
print(complex(2)) # 輸出: (2+0j)
print(complex(2, 3)) # 輸出: (2+3j)
print(complex(2.5, 1.5)) # 輸出: (2.5+1.5j)
2.4 運算符與表達式¶
2.4.1 算術運算符¶
基本算術運算（+、-、*、/）¶
a = 10
b = 3
print(a + b) # 加法，輸出: 13
print(a - b) # 減法，輸出: 7
print(a * b) # 乘法，輸出: 30
print(a / b) # 除法，輸出: 3.3333333333333335（返回浮點數）
整除運算符（//）¶
整除運算符返回商的整數部分（向下取整）：
print(10 // 3) # 輸出: 3
print(-10 // 3) # 輸出: -4（向下取整）
取模運算符（%）¶
取模運算符返回除法的餘數：
print(10 % 3) # 輸出: 1
print(15 % 4) # 輸出: 3
# 判斷奇偶性
print(10 % 2) # 輸出: 0（偶數）
print(11 % 2) # 輸出: 1（奇數）
冪運算符（**）¶
print(2 ** 3) # 2的3次方，輸出: 8
print(10 ** 2) # 10的2次方，輸出: 100
print(4 ** 0.5) # 4的平方根，輸出: 2.0
2.4.2 比較運算符¶
比較運算符用於比較兩個值，返回布爾值（True或False）：
x = 10
y = 20
print(x == y) # 等於，輸出: False
print(x != y) # 不等於，輸出: True
print(x > y) # 大於，輸出: False
print(x < y) # 小於，輸出: True
print(x >= y) # 大於等於，輸出: False
print(x <= y) # 小於等於，輸出: True
2.4.3 邏輯運算符¶
and、or、not運算符¶
x = True
y = False
print(x and y) # 邏輯與，輸出: False
print(x or y) # 邏輯或，輸出: True
print(not x) # 邏輯非，輸出: False
# 在條件語句中使用
age = 25
income = 50000
if age > 18 and income > 30000:
print("符合貸款條件")
if age < 18 or income < 10000:
print("不符合貸款條件")
短路求值¶
Python的邏輯運算符使用短路求值，即如果第一個操作數已經能夠確定結果，就不會計算第二個操作數：
# and的短路求值：如果第一個操作數爲False，則不計算第二個操作數
x = False
y = print("計算y") or True # 如果計算y，會打印"計算y"
result = x and y # 由於x爲False，y不會被計算
print(result) # 輸出: False
# or的短路求值：如果第一個操作數爲True，則不計算第二個操作數
x = True
y = print("計算y") or False # 如果計算y，會打印"計算y"
result = x or y # 由於x爲True，y不會被計算
print(result) # 輸出: True
2.4.4 位運算符¶
位運算符對整數的二進制表示進行操作：
a = 60 # 二進制: 0011 1100
b = 13 # 二進制: 0000 1101
# 按位與（&）：對應位都爲1時結果爲1，否則爲0
print(a & b) # 輸出: 12 (二進制: 0000 1100)
# 按位或（|）：對應位有一個爲1時結果爲1，否則爲0
print(a | b) # 輸出: 61 (二進制: 0011 1101)
# 按位異或（^）：對應位不同時結果爲1，相同爲0
print(a ^ b) # 輸出: 49 (二進制: 0011 0001)
# 按位取反（~）：0變1，1變0
print(~a) # 輸出: -61 (二進制: 1100 0011，帶符號位)
# 左移（<<）：所有位向左移動指定位數，右側補0
print(a << 2) # 輸出: 240 (二進制: 1111 0000)
# 右移（>>）：所有位向右移動指定位數，左側補0（無符號數）或補符號位（有符號數）
print(a >> 2) # 輸出: 15 (二進制: 0000 1111)
2.4.5 賦值運算符¶
基本賦值（=）¶
x = 10 # 將10賦值給變量x
複合賦值（+=、-=、*=等）¶
x = 10
x += 5 # 等同於 x = x + 5，結果: 15
x -= 3 # 等同於 x = x - 3，結果: 12
x *= 2 # 等同於 x = x * 2，結果: 24
x /= 4 # 等同於 x = x / 4，結果: 6.0
x //= 2 # 等同於 x = x // 2，結果: 3.0
x %= 2 # 等同於 x = x % 2，結果: 1.0
x **= 3 # 等同於 x = x ** 3，結果: 1.0
# 位運算的複合賦值
y = 5
y &= 3 # 等同於 y = y & 3，結果: 1
y |= 4 # 等同於 y = y | 4，結果: 5
y ^= 2 # 等同於 y = y ^ 2，結果: 7
y <<= 1 # 等同於 y = y << 1，結果: 14
y >>= 2 # 等同於 y = y >> 2，結果: 3
2.4.6 成員運算符（in、not in）¶
成員運算符用於檢查序列中是否存在指定的值：
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits) # 輸出: True
print("orange" in fruits) # 輸出: False
print("orange" not in fruits) # 輸出: True
text = "Hello, Python!"
print("Python" in text) # 輸出: True
print("Java" in text) # 輸出: False
2.4.7 身份運算符（is、is not）¶
身份運算符用於比較兩個對象是否是同一個對象（是否有相同的內存地址）：
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a is b) # 輸出: False（a和b是不同的對象）
print(a is c) # 輸出: True（a和c引用同一個對象）
print(a == b) # 輸出: True（a和b的值相等）
# None的比較應該使用is
x = None
print(x is None) # 輸出: True（推薦的寫法）
print(x == None) # 輸出: True（不推薦的寫法）
2.4.8 運算符優先級¶
Python中的運算符有不同的優先級，決定了表達式中運算的執行順序：
# 優先級示例
result = 2 + 3 * 4 # 乘法優先級高於加法
print(result) # 輸出: 14，而不是20
# 使用括號改變優先級
result = (2 + 3) * 4
print(result) # 輸出: 20
以下是Python運算符的優先級，從高到低排列：
- 括號
() - 冪運算
** - 正負號
+x,-x - 乘、除、整除、取模
*,/,//,% - 加減
+,- - 位移
<<,>> - 按位與
& - 按位異或
^ - 按位或
| - 比較運算符
==,!=,>,>=,<,<=,is,is not,in,not in - 邏輯非
not - 邏輯與
and - 邏輯或
or - 條件表達式
if-else - 賦值運算符
=,+=,-=等
2.5 輸入輸出函數¶
2.5.1 print()函數詳解¶
基本用法¶
# 打印單個值
print("Hello, Python!")
# 打印多個值
print("Name:", "Alice", "Age:", 30)
# 打印變量
name = "Bob"
age = 25
print(name, age)
參數詳解（sep、end、file、flush）¶
# sep參數：指定值之間的分隔符，默認爲空格
print("apple", "banana", "cherry", sep=", ")
# 輸出: apple, banana, cherry
# end參數：指定輸出結束後的字符，默認爲換行符\n
print("Hello", end=" ")
print("World!")
# 輸出: Hello World!
# file參數：指定輸出的文件對象，默認爲sys.stdout
with open("output.txt", "w") as f:
print("This will be written to the file", file=f)
# flush參數：是否立即刷新輸出緩衝區，默認爲False
import time
for i in range(5):
print(i, end=" ", flush=True) # 立即顯示，不等待緩衝區填滿
time.sleep(0.5)
格式化輸出¶
# 使用%運算符格式化
name = "Alice"
age = 30
print("%s is %d years old." % (name, age))
# 輸出: Alice is 30 years old.
# 使用str.format()方法
print("{} is {} years old.".format(name, age))
# 輸出: Alice is 30 years old.
# 使用f-string（Python 3.6+）
print(f"{name} is {age} years old.")
# 輸出: Alice is 30 years old.
2.5.2 input()函數詳解¶
用戶輸入獲取¶
# 基本用法
name = input("請輸入您的名字: ")
print(f"您好，{name}!")
# 輸入提示：請輸入您的名字: Alice
# 輸出: 您好，Alice!
輸入數據的類型轉換¶
input()函數始終返回字符串，需要根據需要進行類型轉換：
# 獲取整數輸入
age = int(input("請輸入您的年齡: "))
print(f"明年您將是{age + 1}歲")
# 獲取浮點數輸入
height = float(input("請輸入您的身高(米): "))
print(f"您的身高是{height}米")
輸入驗證¶
# 簡單的輸入驗證
while True:
try:
age = int(input("請輸入您的年齡(1-120): "))
if 1 <= age <= 120:
break
else:
print("年齡必須在1到120之間，請重新輸入")
except ValueError:
print("請輸入有效的數字")
print(f"您的年齡是{age}歲")
2.5.3 格式化字符串¶
Python提供了多種字符串格式化方法：
%格式化¶
name = "Alice"
age = 30
salary = 50000.75
# 字符串格式化
print("%s is %d years old." % (name, age))
# 輸出: Alice is 30 years old.
# 數字格式化
print("Salary: $%.2f" % salary)
# 輸出: Salary: $50000.75
# 寬度和對齊
print("%10s" % name) # 右對齊，寬度爲10
# 輸出: ' Alice'
print("%-10s" % name) # 左對齊，寬度爲10
# 輸出: 'Alice '
# 零填充
print("%05d" % age)
# 輸出: 00030
str.format()方法¶
name = "Bob"
age = 25
salary = 45000.50
# 基本用法
print("{} is {} years old.".format(name, age))
# 輸出: Bob is 25 years old.
# 使用索引
print("{1} is {0} years old.".format(age, name))
# 輸出: Bob is 25 years old.
# 使用命名參數
print("{name} is {age} years old.".format(name=name, age=age))
# 輸出: Bob is 25 years old.
# 數字格式化
print("Salary: ${:.2f}".format(salary))
# 輸出: Salary: $45000.50
# 寬度和對齊
print("{:10}".format(name)) # 右對齊，寬度爲10
# 輸出: ' Bob'
print("{:<10}".format(name)) # 左對齊，寬度爲10
# 輸出: 'Bob '
print("{:^10}".format(name)) # 居中對齊，寬度爲10
# 輸出: ' Bob '
# 零填充
print("{:05d}".format(age))
# 輸出: 00025
f-string（格式化字符串字面值）¶
f-string是Python 3.6引入的一種字符串格式化方法，語法簡潔且性能更好：
name = "Charlie"
age = 35
salary = 60000.25
# 基本用法
print(f"{name} is {age} years old.")
# 輸出: Charlie is 35 years old.
# 表達式計算
print(f"Next year, {name} will be {age + 1} years old.")
# 輸出: Next year, Charlie will be 36 years old.
# 數字格式化
print(f"Salary: ${salary:.2f}")
# 輸出: Salary: $60000.25
# 寬度和對齊
print(f"{name:10}") # 右對齊，寬度爲10
# 輸出: ' Charlie'
print(f"{name:<10}") # 左對齊，寬度爲10
# 輸出: 'Charlie '
print(f"{name:^10}") # 居中對齊，寬度爲10
# 輸出: ' Charlie '
# 零填充
print(f"{age:05d}")
# 輸出: 00035
# 千位分隔符
print(f"{1000000:,}")
# 輸出: 1,000,000
2.6 註釋與代碼規範¶
2.6.1 註釋的重要性¶
註釋是程序中的非執行文本，用於解釋代碼的功能、邏輯和目的。良好的註釋可以：
- 提高代碼的可讀性和可維護性
- 幫助其他開發者理解代碼
- 記錄代碼的設計決策和注意事項
- 方便未來的代碼修改和調試
2.6.2 單行註釋（#）¶
# 這是一個單行註釋
x = 10 # 這是行尾註釋
# 多行單行註釋
# 第一行
# 第二行
# 第三行
2.6.3 多行註釋（三引號）¶
Python沒有專門的多行註釋語法，但可以使用三引號字符串作爲多行註釋：
"""
這是一個多行註釋
可以跨越多行
不會被執行
"""
'''
這也是一個多行註釋
使用單引號也可以
'''
2.6.4 文檔字符串（docstring）¶
文檔字符串是特殊的多行註釋，用於爲模塊、類、函數等提供文檔：
def calculate_area(radius):
"""
計算圓的面積
參數:
radius (float): 圓的半徑
返回:
float: 圓的面積
"""
import math
return math.pi * radius ** 2
# 訪問文檔字符串
print(calculate_area.__doc__)
2.6.5 代碼規範（PEP 8）¶
PEP 8是Python官方的代碼風格指南，提供了編寫Python代碼的規範。以下是一些重要的規範：
縮進規範¶
# 使用4個空格進行縮進（不要使用製表符）
def function():
if True:
print("正確的縮進")
命名規範¶
# 變量和函數名使用小寫字母，單詞之間用下劃線連接
user_name = "Alice"
def calculate_average(numbers):
return sum(numbers) / len(numbers)
# 類名使用駝峯命名法
class UserProfile:
pass
# 常量使用全大寫字母
MAX_CONNECTIONS = 100
空行使用¶
# 頂級函數和類定義之間空兩行
def function1():
pass
class MyClass:
pass
# 方法定義之間空一行
class AnotherClass:
def method1(self):
pass
def method2(self):
pass
行長度限制¶
PEP 8建議每行代碼不超過79個字符：
# 長字符串的換行
long_string = (
"這是一個很長的字符串，需要跨越多行，"
"可以使用括號來連接多個字符串。"
)
# 長表達式的換行
result = (value1 + value2 + value3 +
value4 + value5 + value6)
# 長函數調用的換行
function_call(argument1, argument2,
argument3, argument4)
2.6.6 代碼可讀性最佳實踐¶
# 使用有意義的變量名
user_age = 25 # 好的命名
a = 25 # 不好的命名
# 避免魔法數字，使用命名常量
MAX_ATTEMPTS = 3
for attempt in range(MAX_ATTEMPTS):
# 處理邏輯
pass
# 使用空格增加可讀性
x = (a + b) * (c + d) # 好的寫法
x=(a+b)*(c+d) # 不好的寫法
# 使用空行分隔邏輯塊
def process_data(data):
# 數據驗證
if not data:
return None
# 數據處理
result = []
for item in data:
result.append(item * 2)
# 返回結果
return result
總結¶
本章介紹了Python的基礎語法，包括變量與標識符、數據類型、運算符與表達式、輸入輸出函數以及註釋與代碼規範。掌握這些基礎知識對於學習Python編程至關重要，它們是構建更復雜程序的基石。在接下來的章節中，我們將在這些基礎上，進一步學習Python的控制流程、數據結構和函數等更高級的概念。