Python初學者常用的函數總整理

圖翻拍自網路

常用的函數

一、數據類型相關的內置函數

1. int() 函數：將一個數轉換為整數。例如：int(3.14159) 的結果為 3。
2. float() 函數：將一個數轉換為浮點數。例如：float(3) 的結果為0。
3. str() 函數：將一個對象轉換為字符串。例如：str(3) 的結果為 “3”。
4. bool() 函數：將一個值轉換為布林值。如果值為 0、空字符串、空列表、空元組、空字典、None 等，則返回 False，否則返回 True。例如：bool(0) 的結果為 False，bool(1) 的結果為 True。
5. type() 函數：返回一個對象的類型。例如：type(3) 的結果為 <class ‘int’>，type(“hello”) 的結果為 <class ‘str’>。

二、字串相關函數

# 字串長度

len(“Hello”)        # 輸出 5

# 字串連接

“Hello” + “World”   # 輸出 “HelloWorld”

“Hello” “World”     # 輸出 “HelloWorld”

# 字串拆分

s = “Apple, Banana, Cherry”

s.split(“, “)       # 輸出 [‘Apple’, ‘Banana’, ‘Cherry’]

num = “11 22 33 44 55 66 77 88”

s.split()       # 輸出 [11 22 33 44 55 66 77 88]

# 字串取代

s.replace(“Banana”, “Orange”)   # 輸出 ‘Apple, Orange, Cherry’

# 字串大小寫轉換

s.upper()           # 輸出 ‘APPLE, BANANA, CHERRY’

s.lower()           # 輸出 ‘apple, banana, cherry’

 

三、字串格式化函數

# 格式化整數

x = 10

print(f”這是一個整數：{x:d}”)   # 輸出 “這是一個整數：10″

# 格式化浮點數

y = 3.1415926

print(f”這是一個浮點數：{y:.2f}”)   # 輸出 “這是一個浮點數：3.14”

# 格式化字串

name = “Alice”

print(f”我的名字是{name}”)   # 輸出 “我的名字是Alice”

四、數學計算函數：

1. sum() 函數：將一個可迭代對象中的所有元素相加。例如：sum([1, 2, 3, 4]) 的結果為 10。
2. abs() 函數：返回一個數的絕對值。例如：abs(-3) 的結果為 3。
3. pow() 函數：計算一個數的次方。例如：pow(2, 3) 的結果為 8。
4. round() 函數：將一個數四舍五入到指定的小數位數。例如：round(3.14159, 2) 的結果為14。
5. max() 函數：返回一個可迭代對象中最大的元素。例如：max([1, 2, 3, 4]) 的結果為 4。
6. min() 函數：返回一個可迭代對象中最小的元素。例如：min([1, 2, 3, 4]) 的結果為 1。

五、列表函數

列表操作函數

# 創建一個列表

fruits = [“apple”, “banana”, “cherry”]

# 獲取列表中的元素

print(fruits[0])   # 輸出 “apple”

# 增加元素

fruits.append(“orange”)

print(fruits)      # 輸出 [“apple”, “banana”, “cherry”, “orange”]

# 刪除元素

fruits.remove(“banana”)

print(fruits)      # 輸出 [“apple”, “cherry”, “orange”]

# 列表長度

len([1, 2, 3, 4])               # 輸出 4

# 列表連接

[1, 2, 3] + [4, 5, 6]           # 輸出 [1, 2, 3, 4, 5, 6]

# 列表取最大值和最小值

max([1, 2, 3, 4])               # 輸出 4

min([1, 2, 3, 4])               # 輸出 1

# 列表元素排序

sorted([3, 1, 4, 2])            # 輸出 [1, 2, 3, 4]

六、字典函數

# 創建一個字典

person = {“name”: “Alice”, “age”: 25, “city”: “Taipei”}

# 獲取字典中的鍵和值

print(person.keys())    # 輸出 [“name”, “age”, “city”]

print(person.values())  # 輸出 [“Alice”, 25, “Taipei”]

# 檢查字典中是否存在指定的鍵或值

print(“name” in person)   # 輸出 True

print(25 in person.values())   # 輸出 True

# 判斷鍵是否存在

d = {‘name’: ‘Tom’, ‘age’: 18}

‘name’ in d                     # 輸出 True

‘gender’ in d                   # 輸出 False

# 取值，若鍵不存在則返回默認值

d.get(‘name’, ‘default’)        # 輸出 ‘Tom’

d.get(‘gender’, ‘unknown’)      # 輸出 ‘unknown’

# 取所有鍵和值

d.keys()                        # 輸出 [‘name’, ‘age’]

d.values()                      # 輸出 [‘Tom’, 18]

七、集合操作函數

# 創建一個集合

fruits = {“apple”, “banana”, “cherry”}

# 檢查集合中是否存在指定的元素

print(“apple” in fruits)   # 輸出 True

# 增加元素

fruits.add(“orange”)

print(fruits)             # 輸出 {“apple”, “banana”, “cherry”, “orange”}

# 刪除元素

fruits.remove(“banana”)

print(fruits)             # 輸出 {“apple”, “cherry”, “orange”}

八、由大到小或由小到大排序的函數

在 Python 中，我們可以使用內建函數 sorted() 來排序列表、元組、字串等可迭代物件。sorted() 函數的基本語法如下：

sorted(iterable, key=None, reverse=False)

其中，iterable 表示要排序的可迭代物件，可以是列表、元組、字串等；key 是一個可選的函數，用於指定排序時要使用的鍵，默認為 None；reverse 表示排序順序，如果設置為 True，則表示要按照遞減順序排序，否則按照遞增順序排序，默認為 False。

以下是一些示例：

1.從小到大排序：

nums = [5, 1, 3, 8, 2]

sorted_nums = sorted(nums)

print(sorted_nums)  # 輸出 [1, 2, 3, 5, 8]

2.從大到小排序：

nums = [5, 1, 3, 8, 2]

sorted_nums = sorted(nums, reverse=True)

print(sorted_nums)  # 輸出 [8, 5, 3, 2, 1]

3.根據元素的某個屬性排序

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __repr__(self):

return f”{self.name} ({self.age} 歲)”

people = [Person(“Amy”, 22), Person(“Bob”, 19), Person(“Charlie”, 25)]

sorted_people = sorted(people, key=lambda p: p.age)

print(sorted_people)  # 輸出 [Bob (19 歲), Amy (22 歲), Charlie (25 歲)]

在這個例子中，我們創建了一個 Person 類別，並創建了三個 Person 對象，每個對象都有一個名字和年齡屬性。然後，我們使用 sorted() 函數根據 Person 對象的 age 屬性進行排序。注意，這裡使用了 lambda 函數來指定排序時要使用的鍵。

九、隨機數函數

random 模塊：用於生成隨機數。需要使用 import random 來導入模塊。以下是一些常用的函數：

1. random()：返回一個位於 [0, 1) 之間的隨機小數。
2. randint(a, b)：返回一個位於 [a, b] 之間的隨機整數。
3. choice(seq)：從序列 seq 中隨機返回一個元素。
4. shuffle(lst)：將列表 lst 中的元素隨機排序。

# 隨機整數

import random

random.randint(0, 10)       # 輸出 0 到 10 之間的隨機整數

# 隨機浮點數

random.uniform(0, 1)        # 輸出 0 到 1 之間的隨機浮點數

# 隨機選取

random.choice([‘apple’, ‘banana’, ‘cherry’])   # 輸出三個中的一個隨機選取

 

 

其它補充

一、推導式（Comprehension）

Python 推導式（Comprehension）是一種簡潔的程式語法，可以用來從一個序列中創建另一個序列。

Python 推導式包含三種類型：列表推導式、字典推導式和集合推導式。

列表推導式：創建一個新的列表，其元素是通過操作現有列表中的元素得到的。

例如，下面的代碼可以創建一個新的列表，其中包含了原始列表中的每個元素的平方值：

1. 列表推導式

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

squares = [num**2 for num in numbers]

print(squares)

輸出：[1, 4, 9, 16, 25]

2.字典推導式：創建一個新的字典，其元素是通過操作現有字典中的鍵值對得到的。

例如，下面的代碼可以創建一個新的字典，其中包含原始字典中每個鍵值對的值的平方值：

original_dict = {‘a’: 1, ‘b’: 2, ‘c’: 3}

squared_dict = {key: value**2 for key, value in original_dict.items()}

print(squared_dict)

輸出：{‘a’: 1, ‘b’: 4, ‘c’: 9}

3.集合推導式：創建一個新的集合，其元素是通過操作現有集合中的元素得到的。

例如，下面的代碼可以創建一個新的集合，其中包含原始集合中每個元素的平方值：

original_set = {1, 2, 3, 4, 5}

squared_set = {num**2 for num in original_set}

print(squared_set)

輸出：{1, 4, 9, 16, 25}

需要注意的是，Python 推導式可以包含條件語句，以便對元素進行篩選。例如，下面的代碼可以創建一個新的列表，其中包含原始列表中的奇數值的平方：

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

squares_of_odds = [num**2 for num in numbers if num % 2 == 1]

print(squares_of_odds)

輸出：[1, 9, 25]

A.使用 for 迴圈的推導式：

例如，假設你想要創建一個包含從 0 到 9 的平方的列表，可以使用下面的推導式：

squares = [i**2 for i in range(10)]

print(squares)

輸出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

在上面的例子中，推導式內的 for 迴圈用於遍歷範圍從 0 到 9 的整數。迴圈變量 i 用於計算每個數字的平方，然後這些平方值被添加到新列表中。

1. 使用 for 迴圈和 if else 的推導式

使用 for 迴圈和 if else 的推導式可以根據條件創建不同的值。

下面是一個範例，使用 for 迴圈和 if else 的推導式創建一個列表，其中奇數被替換為其平方值，而偶數則被替換為其立方值：

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

new_numbers = [num**2 if num % 2 == 1 else num**3 for num in numbers]

print(new_numbers)

輸出：[1, 8, 9, 64, 25, 216]

在上面的例子中，推導式內的 for 迴圈用於遍歷列表中的每個元素。if else 條件語句用於決定要創建哪個新值。如果元素是奇數，則該元素的平方值被添加到新列表中；如果元素是偶數，則該元素的立方值被添加到新列表中。最終，創建的新列表被指定給變數 new_numbers。

再來看一個範例：

以下是一個示例，展示如何使用 for 迴圈和 if else 條件語句來創建一個包含正數和負數的新列表：

numbers = [1, 2, -3, -4, 5, -6, 7, -8, -9]

new_numbers = [num if num > 0 else -num for num in numbers]

print(new_numbers)

輸出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

在上面的例子中，推導式內的 if else 條件語句用於判斷列表中每個元素的正負性。如果元素是正數，則該元素會保留在新列表中；如果元素是負數，則使用 -num 來將其轉換為正數，並將其添加到新列表中。

注意，在這個例子中，if else 條件語句的位置是在推導式的前面部分，這是因為 if else 條件語句用於設置值，而推導式的後面部分用於迭代列表。另外，使用 if else 條件語句時，條件語句中的 if 和 else 之間必須有一個值被設置，否則會引發語法錯誤。

1. 使用 for 迴圈和 if else 的巢狀迴圈推導式

Python 推導式也可以包含迴圈，被稱為「帶有巢狀迴圈的推導式」。這種推導式可以從一個多維的序列中創建另一個多維的序列。

 

例如，假設你有一個包含多個列表的列表，你想將每個列表中的元素加 1，然後創建一個新的列表，其中包含所有修改後的列表。你可以使用帶有嵌套迴圈的推導式來實現：

original_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

new_lists = [[item + 1 for item in inner_list] for inner_list in original_lists]

print(new_lists)

輸出：[[2, 3, 4], [5, 6, 7], [8, 9, 10]]

在上面的例子中，內部的迴圈遍歷了每個子列表，將其中的每個元素加 1。外部的迴圈遍歷了原始列表中的每個子列表，將修改後的子列表添加到新的列表中。

需要注意的是，帶有嵌套迴圈的推導式可能會變得難以閱讀和理解。在進行編程時，要根據實際情況考慮使用哪種技術最為適合。

二、map 函數

map 函數可以將一個函數應用到一個可迭代對象的每個元素上，並返回一個迭代器。下面是一個示例：

# 將一個列表中的每個元素乘以 2

lst = [1, 2, 3, 4, 5]

result = map(lambda x: x * 2, lst)

print(list(result))    # 輸出 [2, 4, 6, 8, 10]

A.詳細介紹map()

當我們需要對一個可迭代對象中的每個元素應用同樣的操作時，可以使用 map 函數。

map 函數接受兩個參數：一個函數和一個可迭代對象。函數會應用到可迭代對象的每個元素上，返回一個迭代器，其中包含了應用過函數後的結果。

map 函數的基本語法如下：

map(function, iterable)

其中，function 是要應用到 iterable 中每個元素的函數，iterable 是一個可迭代對象，例如列表、元組或字典。

下面是一個示例，展示如何使用 map 函數將一個列表中的每個元素平方：

# 定義一個函數，將一個數字平方

def square(x):

return x ** 2

# 將一個列表中的每個元素平方

lst = [1, 2, 3, 4, 5]

result = map(square, lst)

print(list(result))    # 輸出 [1, 4, 9, 16, 25]

在這個示例中，square 函數會應用到 lst 列表中的每個元素上，返回一個迭代器，其中包含了應用過 square 函數後的結果。

B.map 函數也可以使用 lambda 函數來簡化代碼：

# 將一個列表中的每個元素平方

lst = [1, 2, 3, 4, 5]

result = map(lambda x: x ** 2, lst)

print(list(result))    # 輸出 [1, 4, 9, 16, 25]

這樣就不需要再定義一個 square 函數了，直接使用 lambda 函數即可。

三、lambda 函數介紹

lambda 函數也被稱為匿名函數，它是一種用於創建簡單函數的快捷方式。它的語法簡單，通常由一個 lambda 關鍵字，一個或多個參數以及冒號和一個表達式組成。

lambda 函數的基本語法如下：

# 使用 lambda 函數計算兩個數字的和

add = lambda x, y: x + y

result = add(3, 5)

print(result)    # 輸出 8

在這個示例中，我們使用 lambda 函數定義了一個 add 函數，這個函數接受兩個參數 x 和 y，並返回它們的和。

lambda 函數通常用於需要簡單函數的場合，例如在 map 和 filter 函數中使用。使用 lambda 函數可以簡化代碼，使得代碼更簡潔易讀。例如，下面是一個使用 lambda 函數過濾一個列表中的偶數的示例：

# 使用 lambda 函數過濾一個列表中的偶數

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

result = filter(lambda x: x % 2 == 0, lst)

print(list(result))    # 輸出 [2, 4, 6, 8]

在這個示例中，我們使用 lambda 函數定義了一個判斷奇偶的函數，然後將這個函數應用到 lst 列表中的每個元素上，返回一個迭代器，其中包含了滿足條件的元素。

 

需要注意的是，lambda 函數通常用於簡單的操作，如果需要進行較複雜的操作，還是建議使用 def 關鍵字定義一個正式的函數。

四、filter 函數

filter 函數可以根據指定的函數對可迭代對象進行篩選，返回一個迭代器，其中包含符合條件的元素。下面是一個示例：

# 篩選一個列表中的奇數元素

lst = [1, 2, 3, 4, 5]

result = filter(lambda x: x % 2 != 0, lst)

print(list(result))    # 輸出 [1, 3, 5]

五、reduce 函數

reduce 函數可以將一個函數應用到一個可迭代對象的所有元素上，並返回一個單一的結果值。下面是一個示例：

# 計算一個列表中所有元素的和

lst = [1, 2, 3, 4, 5]

from functools import reduce

result = reduce(lambda x, y: x + y, lst)

print(result)    # 輸出 15

六、檔案操作函數

# 開啟檔案

f = open(“file.txt”, “r”)

# 讀取檔案內容

content = f.read()

# 關閉檔案

f.close()

七、錯誤處理函數

# try-except

try:

a = 10 / 0

except ZeroDivisionError:

print(“除數不能為零”)

八、進階數學計算相關函數

math 模塊：包含了許多數學計算中常用的函數，例如三角函數、指數函數、對數函數等等。需要使用 import math 來導入模塊。以下是一些常用的函數：

math.tan(x)：返回 x 的正切值。

math.log(x)：返回 x 的自然對數。

math.log10(x)：返回 x 的以 10 為底的對數。

math.ceil() 函數：返回大於等於輸入參數的最小整數。例如：math.ceil(3.14159) 的結果為 4。

math.floor() 函數：返回小於等於輸入參數的最大整數。例如：math.floor(3.14159) 的結果為 3。

math.sqrt() 函數：返回一個數的平方根。例如：math.sqrt(4) 的結果為 2.0。

math.exp() 函數：返回 e 的 x 次方。例如：math.exp(1) 的結果為 2.718281828459045。

math.log() 函數：返回一個數的自然對數。例如：math.log(10) 的結果為 2.302585092994046。

math.sin() 函數：返回一個角度的正弦值。例如：math.sin(math.pi/2) 的結果為 1.0。

math.cos() 函數：返回一個角度的余弦值。例如：math.cos(math.pi/2) 的結果為 6.123233995736766e-17。

到訪人數：(48)