告別冗余代碼！這 20 個 Python 內置函數讓你的編程更優雅高效
Python自帶許多內置函數，這些函數無需導入任何模塊即可直接使用，極大地提高了開發效率。掌握這些常用內置函數是精通 Python 的基礎。本文將詳細介紹 20 個在日常編程中極為常用的 Python 內置函數。
1. print()
將指定對象輸出到標準輸出設備（通常是控制臺）。這是調試和顯示信息最常用的函數。
name = "Alice"
age = 30
print("Hello, world!") # 輸出字符串
print("Name:", name, "Age:", age) # 輸出多個對象，默認以空格分隔
print(f"User {name} is {age} years old.") # 使用 f-string 格式化輸出
print("第一行", end=" | ") # 自定義行尾結束符
print("第二行") # 默認 end='\n' (換行)print() 可以接受一個或多個參數，并將它們轉換成字符串后輸出。sep 參數控制分隔符（默認空格），end 參數控制行尾符（默認換行）。
2. input()
從標準輸入（通常是鍵盤）讀取一行文本，并將其作為字符串返回（末尾的換行符會被剝離）。
user_name = input("請輸入您的名字: ")
user_age_str = input("請輸入您的年齡: ")
print(f"您好, {user_name}! 您輸入的年齡是: {user_age_str}")
print(f"名字的數據類型: {type(user_name)}") # 輸出: <class 'str'>
print(f"年齡的數據類型: {type(user_age_str)}") # 輸出: <class 'str'>input() 會暫停程序執行，等待用戶輸入。無論用戶輸入什么，input() 總是返回一個字符串。如果需要數字，需要后續使用 int() 或 float() 進行轉換。
3. len()
返回對象的“長度”（其中包含的項數）。適用于序列（如字符串、列表、元組）和集合（如字典、集合）。
my_string = "Python"
my_list = [1, 2, 3, 4, 5]
my_dict = {'a': 1, 'b': 2}
print(f"字符串 '{my_string}' 的長度: {len(my_string)}") # 輸出: 6
print(f"列表 my_list 的長度: {len(my_list)}") # 輸出: 5
print(f"字典 my_dict 的鍵值對數量: {len(my_dict)}") # 輸出: 2len() 是獲取容器或序列大小的基本方法。
4. type()
返回對象的類型（類）。對于調試和理解代碼中變量的性質非常有用。
x = 10
y = 3.14
z = "hello"
l = [1, 2]
print(f"變量 x 的類型是: {type(x)}") # 輸出: <class 'int'>
print(f"變量 y 的類型是: {type(y)}") # 輸出: <class 'float'>
print(f"變量 z 的類型是: {type(z)}") # 輸出: <class 'str'>
print(f"變量 l 的類型是: {type(l)}") # 輸出: <class 'list'>type() 返回對象的類對象，可以據此判斷變量屬于哪種數據類型。
5. int()
將一個數字或字符串轉換為整數。如果字符串不能表示一個有效的整數，會引發 ValueError。
float_num = 9.8
str_num = "123"
str_invalid = "abc"
print(f"{float_num} 轉換為整數: {int(float_num)}") # 輸出: 9 (向零取整)
print(f"字符串 '{str_num}' 轉換為整數: {int(str_num)}") # 輸出: 123
try:
int(str_invalid)
except ValueError as e:
print(f"轉換 '{str_invalid}' 失敗: {e}") # 輸出: invalid literal for int() with base 10: 'abc'
# 也可以指定基數進行轉換 (例如二進制)
binary_str = "1011"
print(f"二進制字符串 '{binary_str}' 轉換為十進制整數: {int(binary_str, 2)}") # 輸出: 11int() 常用于處理用戶輸入或文件讀取的字符串數據，將其轉換為可進行數學運算的整數。
6. float()
將一個數字或字符串轉換為浮點數。如果字符串不能表示一個有效的數字，會引發 ValueError。
int_num = 100
str_num = "3.14159"
str_int = "42"
str_invalid = "pi"
print(f"{int_num} 轉換為浮點數: {float(int_num)}") # 輸出: 100.0
print(f"字符串 '{str_num}' 轉換為浮點數: {float(str_num)}") # 輸出: 3.14159
print(f"字符串 '{str_int}' 轉換為浮點數: {float(str_int)}") # 輸出: 42.0
try:
float(str_invalid)
except ValueError as e:
print(f"轉換 '{str_invalid}' 失敗: {e}") # 輸出: could not convert string to float: 'pi'float() 用于需要小數精度計算的場景，同樣常用于轉換輸入數據。
7. str()
將對象轉換為其字符串表示形式。幾乎所有 Python 對象都可以被 str() 轉換。
number = 42
pi = 3.14
my_list = [1, 'a', True]
is_valid = False
print(f"整數 {number} 轉為字符串: '{str(number)}'") # 輸出: '42'
print(f"浮點數 {pi} 轉為字符串: '{str(pi)}'") # 輸出: '3.14'
print(f"列表 {my_list} 轉為字符串: '{str(my_list)}'") # 輸出: '[1, 'a', True]'
print(f"布爾值 {is_valid} 轉為字符串: '{str(is_valid)}'") # 輸出: 'False'str() 在需要將非字符串數據（如數字、列表）嵌入到字符串中（尤其是在舊式 % 格式化或 + 拼接時）或寫入文件時非常有用。
8. list()
將一個可迭代對象（如字符串、元組、集合、字典的鍵/值/項）轉換為列表。也可以創建一個空列表。
my_string = "abc"
my_tuple = (10, 20, 30)
my_set = {1, 2, 3}
my_dict = {'x': 1, 'y': 2}
print(f"字符串 '{my_string}' 轉為列表: {list(my_string)}") # 輸出: ['a', 'b', 'c']
print(f"元組 {my_tuple} 轉為列表: {list(my_tuple)}") # 輸出: [10, 20, 30]
print(f"集合 {my_set} 轉為列表: {list(my_set)}") # 輸出: [1, 2, 3] (順序可能變化)
print(f"字典的鍵轉為列表: {list(my_dict)}") # 輸出: ['x', 'y'] (Python 3.7+ 保證順序)
print(f"字典的值轉為列表: {list(my_dict.values())}") # 輸出: [1, 2]
print(f"字典的項轉為列表: {list(my_dict.items())}") # 輸出: [('x', 1), ('y', 2)]
print(f"創建一個空列表: {list()}") # 輸出: []list() 是創建新列表或從其他可迭代類型復制/轉換元素到列表的常用方法。列表是可變的，因此轉換后可以修改。
9. tuple()
將一個可迭代對象轉換為元組。元組是不可變的序列。
my_string = "xyz"
my_list = [4, 5, 6]
print(f"字符串 '{my_string}' 轉為元組: {tuple(my_string)}") # 輸出: ('x', 'y', 'z')
print(f"列表 {my_list} 轉為元組: {tuple(my_list)}") # 輸出: (4, 5, 6)
print(f"創建一個空元組: {tuple()}") # 輸出: ()tuple() 用于需要不可變序列的場景，或者希望將可迭代對象轉換為元組形式。
10. dict()
創建 一個新的字典。可以通過關鍵字參數、映射對象或鍵值對的可迭代對象來初始化。
# 創建空字典
empty_dict = dict()
print(f"空字典: {empty_dict}") # 輸出: {}
# 使用關鍵字參數創建
kw_dict = dict(name="Bob", age=25, city="Paris")
print(f"關鍵字參數創建: {kw_dict}") # 輸出: {'name': 'Bob', 'age': 25, 'city': 'Paris'}
# 從鍵值對列表創建
pairs = [('a', 1), ('b', 2), ('c', 3)]
pairs_dict = dict(pairs)
print(f"鍵值對列表創建: {pairs_dict}") # 輸出: {'a': 1, 'b': 2, 'c': 3}
# 從另一個字典創建 (淺拷貝)
copy_dict = dict(kw_dict)
print(f"從字典拷貝創建: {copy_dict}")dict() 是創建和初始化字典的靈活方式，比 {} 字面量提供了更多選項。
11. set()
創建一個新的集合。集合是無序的、不包含重復元素的集合。可以從可迭代對象創建。
my_string = "programming"
my_list = [1, 2, 2, 3, 1, 4]
print(f"從字符串創建集合: {set(my_string)}") # 輸出: {'r', 'o', 'g', 'a', 'm', 'i', 'n', 'p'} (順序不定)
print(f"從列表創建集合: {set(my_list)}") # 輸出: {1, 2, 3, 4} (去重)
print(f"創建空集合: {set()}") # 輸出: set()set() 主要用于去重和執行數學上的集合運算（如并集、交集、差集）。
12. abs()
返回數字的絕對值（其大小，不考慮符號）。
positive_num = 10
negative_num = -5.5
zero = 0
print(f"{positive_num} 的絕對值: {abs(positive_num)}") # 輸出: 10
print(f"{negative_num} 的絕對值: {abs(negative_num)}") # 輸出: 5.5
print(f"{zero} 的絕對值: {abs(zero)}") # 輸出: 0abs() 在數學計算和需要忽略數值符號的場景中使用。
13. max()
返回可迭代對象中最大的項，或者返回兩個或多個參數中最大的一個。
numbers = [3, 1, 4, 1, 5, 9, 2]
strings = ["apple", "banana", "cherry"]
print(f"列表 {numbers} 中的最大值: {max(numbers)}") # 輸出: 9
print(f"字符串列表 {strings} 中的最大值 (字典序): {max(strings)}") # 輸出: 'cherry'
print(f"參數 10, 25, 18 中的最大值: {max(10, 25, 18)}") # 輸出: 25
# 可以提供 key 函數進行自定義比較
words = ["go", "pyth?n", "is", "fun"]
print(f"按長度比較的最大單詞: {max(words, key=len)}") # 輸出: 'pyth?n' (長度為6)max() 對于尋找序列極值非常方便。key 參數允許基于元素的某個屬性或計算結果來比較。
14. min()
返回可迭代對象中最小的項，或者返回兩個或多個參數中最小的一個。用法與 max() 類似。
numbers = [3, 1, 4, 1, 5, 9, 2]
strings = ["apple", "banana", "cherry"]
print(f"列表 {numbers} 中的最小值: {min(numbers)}") # 輸出: 1
print(f"字符串列表 {strings} 中的最小值 (字典序): {min(strings)}") # 輸出: 'apple'
print(f"參數 10, 25, 18 中的最小值: {min(10, 25, 18)}") # 輸出: 10
# 使用 key 函數
words = ["go", "pyth?n", "is", "fun"]
print(f"按長度比較的最小單詞: {min(words, key=len)}") # 輸出: 'go' (或 'is', 長度為2)min() 用于尋找序列的最小值，同樣支持 key 參數進行自定義比較。
15. sum()
對可迭代對象（通常是數字列表、元組）中的所有項求和。可以提供一個可選的 start 參數作為初始值。
numbers = [1, 2, 3, 4, 5]
print(f"列表 {numbers} 的和: {sum(numbers)}") # 輸出: 15
# 添加起始值
print(f"列表 {numbers} 的和加上起始值 10: {sum(numbers, 10)}") # 輸出: 25
# 對空列表求和 (默認 start=0)
print(f"空列表的和: {sum([])}") # 輸出: 0sum() 是對數字序列進行求和的快捷方式。注意它不能直接用于對非數字（如字符串）列表求和。
16. range()
返回一個表示算術級數序列的對象。常用于 for 循環中迭代指定的次數。它本身不創建列表，而是一個惰性序列。
print("迭代 0 到 4:")
for i in range(5): # range(stop) - 從 0 到 stop-1
print(i, end=" ") # 輸出: 0 1 2 3 4
print("\n")
print("迭代 2 到 5:")
for i in range(2, 6): # range(start, stop) - 從 start 到 stop-1
print(i, end=" ") # 輸出: 2 3 4 5
print("\n")
print("以步長 2 迭代 1 到 9:")
for i in range(1, 10, 2): # range(start, stop, step)
print(i, end=" ") # 輸出: 1 3 5 7 9
print("\n")
# 將 range 對象轉換為列表 (以便查看)
range_list = list(range(3))
print(f"range(3) 轉為列表: {range_list}") # 輸出: [0, 1, 2]range() 是控制循環次數的標準方式，它比手動創建數字列表更高效（尤其是對于大范圍）。
17. enumerate()
返回一個枚舉對象。它接收一個可迭代對象作為參數，并生成一系列包含索引和對應值的元組。
fruits = ["apple", "banana", "cherry"]
print("使用 enumerate 迭代列表:")
for index, fruit in enumerate(fruits):
print(f"索引 {index}: {fruit}")
# 輸出:
# 索引 0: apple
# 索引 1: banana
# 索引 2: cherry
print("\n使用 enumerate 并指定起始索引:")
for i, fruit in enumerate(fruits, start=1): # 從索引 1 開始
print(f"編號 {i}: {fruit}")
# 輸出:
# 編號 1: apple
# 編號 2: banana
# 編號 3: cherry當循環中既需要元素的值也需要其索引時，enumerate() 是最 Pythonic（符合 Python 風格）且最高效的方式，避免了手動維護計數器。
18. zip()
接收任意多個可迭代對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的迭代器。如果可迭代對象的長度不同，zip 會在最短的對象耗盡后停止。
names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
cities = ["New York", "Paris", "London"]
print("使用 zip 組合三個列表:")
zipped_data = zip(names, ages, cities)
print(f"zip 對象類型: {type(zipped_data)}") # 輸出: <class 'zip'>
# 迭代 zip 對象
for name, age, city in zipped_data:
print(f"{name} is {age} years old and lives in {city}.")
# 輸出:
# Alice is 30 years old and lives in New York.
# Bob is 25 years old and lives in Paris.
# Charlie is 35 years old and lives in London.
# 注意: zip 對象是一次性的迭代器，迭代過后就空了
# print(list(zipped_data)) # 會輸出 []
# 如果長度不同
ids = [101, 102]
items = ["Laptop", "Mouse", "Keyboard"]
print("\n組合不同長度的列表:")
for id_val, item_val in zip(ids, items):
print(f"ID: {id_val}, Item: {item_val}")
# 輸出: (只到最短的 ids 結束)
# ID: 101, Item: Laptop
# ID: 102, Item: Mousezip() 非常適合并行處理多個序列，例如同時迭代鍵和值，或合并來自不同來源的相關數據。
19. sorted()
返回一個新的、根據可迭代對象中的項排序后的列表。原始的可迭代對象保持不變。
numbers = [3, 1, 4, 1, 5, 9, 2]
print(f"原始列表: {numbers}")
sorted_numbers = sorted(numbers)
print(f"排序后列表 (升序): {sorted_numbers}") # 輸出: [1, 1, 2, 3, 4, 5, 9]
print(f"原始列表仍未改變: {numbers}")
# 降序排序
desc_sorted_numbers = sorted(numbers, reverse=True)
print(f"降序排序后列表: {desc_sorted_numbers}") # 輸出: [9, 5, 4, 3, 2, 1, 1]
# 對字符串列表排序 (字典序)
words = ["banana", "Apple", "cherry"] # 注意大小寫影響排序
sorted_words = sorted(words)
print(f"字符串列表排序: {sorted_words}") # 輸出: ['Apple', 'banana', 'cherry']
# 使用 key 函數自定義排序規則 (例如按長度)
sorted_words_by_length = sorted(words, key=len)
print(f"按長度排序: {sorted_words_by_length}") # 輸出: ['Apple', 'banana', 'cherry'] (長度相同則保持原相對順序)
# 對字典按值排序 (得到鍵的列表)
my_dict = {'a': 3, 'c': 1, 'b': 2}
sorted_keys_by_value = sorted(my_dict, key=my_dict.get)
print(f"字典按值排序 (得到鍵): {sorted_keys_by_value}") # 輸出: ['c', 'b', 'a']sorted() 是通用的排序工具，適用于任何可迭代對象，并返回一個新的排序后的列表。key 參數和 reverse 參數提供了強大的自定義排序能力。它與列表的 .sort() 方法不同，后者是原地修改列表且只適用于列表。
20. open()
打開一個文件，并返回一個文件對象（也稱為文件句柄）。這是進行文件讀取、寫入等操作的基礎。
file_path = 'example.txt'
# --- 寫入文件 ('w' 模式會覆蓋舊內容) ---
try:
# 使用 'with' 語句確保文件無論如何都會被關閉
with open(file_path, 'w', encoding='utf-8') as writer:
writer.write("這是第一行內容。\n")
writer.write(f"Python 版本: 3.x\n") # 可以寫入變量
print(f"成功寫入到文件 '{file_path}'")
except IOError as e:
print(f"寫入文件時發生錯誤: {e}")
# --- 讀取文件 ('r' 模式) ---
try:
with open(file_path, 'r', encoding='utf-8') as reader:
# 讀取整個文件內容
# content = reader.read()
# print(f"\n文件 '{file_path}' 的全部內容:\n{content}")
# 或者逐行讀取
print(f"\n逐行讀取文件 '{file_path}':")
for line in reader:
print(line.strip()) # strip() 去除行尾換行符
except FileNotFoundError:
print(f"錯誤: 文件 '{file_path}' 未找到。")
except IOError as e:
print(f"讀取文件時發生錯誤: {e}")
# --- 追加內容到文件 ('a' 模式) ---
try:
with open(file_path, 'a', encoding='utf-8') as appender:
appender.write("這是追加的一行。\n")
print(f"\n成功追加內容到文件 '{file_path}'")
except IOError as e:
print(f"追加文件時發生錯誤: {e}")open() 函數是文件操作的入口。第一個參數是文件路徑，第二個參數是模式（'r'讀, 'w'寫, 'a'追加, 'b'二進制模式等）。encoding='utf-8' 對于處理文本文件至關重要。強烈推薦使用 with open(...) 語法，它能自動管理文件的關閉，即使發生錯誤也能保證關閉，防止資源泄漏。
Python 的內置函數遠不止這些，大家可以進一步探索Python官方文檔，了解更多內置函數和標準庫模塊。
