python 常用內建函式

len()

len(iterable)：返回給定序列（可迭代物件）的長度或元素個數。

list1 = [1, 2, 3, 4, 5]
print("列表長度:", len(list1))

issubclass()

issubclass(class, classinfo)：檢查一個類是否是另一個類的子類，返回 True 或 False。

class Base:
    pass

class Derived(Base):
    pass

print(issubclass(Derived, Base))  # 輸出: True

abs()

返回一個數的絕對值。

print(abs(-5))  # 輸出: 5

round()

round(number, ndigits)：返回浮點數 number 的四捨五入值，可以指定保留的小數位數 ndigits。

print(round(3.14159, 2))  # 輸出: 3.14

pow()

pow(x, y, z=None)：計算 x 的 y 次方，如果提供 z 引數，則計算結果取模。(x**y) % z

print(pow(2, 3))  # 輸出: 8
print(pow(2, 3, 3))  # 輸出: 2

range()

range([start,] stop[, step])：成一個從 start 到 stop 的整數序列，間隔為 step。

for i in range(0, 5):
    print(i)  # 輸出: 0, 1, 2, 3, 4

divmod()

divmod(a, b)：以元組 (a // b, a % b) 的形式返回兩個數的商和餘數。

print(divmod(8, 3))  # 輸出: (2, 2)

sum()

sum(iterable[, start]): 計算 iterable 的所有項的總和，如果提供了 start，則從這個值開始累加。

print(sum([1, 2, 3]))  # 輸出: 6
print(sum([1, 2, 3], 10))  # 輸出: 16

sorted()

功能：sorted() 函式用於對可迭代物件進行排序，並返回一個新的已排序列表。
語法：sorted(iterable, key=None, reverse=False)
        iterable：待排序的可迭代物件。
        key：可選引數，用於指定排序的規則函式。
        reverse：可選引數，為 True 時按降序排列，預設為 False。

# 基本排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 輸出: [1, 1, 2, 3, 4, 5, 6, 9]

# 按字串長度排序
words = ["banana", "apple", "cherry"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 輸出: ['apple', 'banana', 'cherry']

# 逆序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 輸出: [9, 6, 5, 4, 3, 2, 1, 1]

# 使用 key 引數按絕對值排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
sorted_numbers_abs = sorted(numbers, key=abs)
print("按絕對值排序:", sorted_numbers_abs)

reversed()

功能：reversed() 函式用於反轉序列中的元素，返回一個逆序的迭代器。
語法：reversed(sequence)

# 反轉列表
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(reversed_numbers)  # 輸出: [5, 4, 3, 2, 1]

# 反轉字串
hello = "hello"
reversed_hello = ''.join(reversed(hello))
print(reversed_hello)  # 輸出: 'olleh'

enumerate()

功能：enumerate() 函式用於將可迭代物件組合為一個索引序列，同時列出資料和資料下標。
語法：enumerate(iterable, start=0)
        iterable：待列舉的可迭代物件。
        start：可選引數，指定下標起始值，預設為 0。

# 列舉列表
names = ["Alice", "Bob", "Charlie"]
for index, name in enumerate(names):
    print(f"{index}: {name}")
# 輸出:
# 0: Alice
# 1: Bob
# 2: Charlie

# 從指定索引開始列舉
for index, name in enumerate(names, start=1):
    print(f"{index}: {name}")
# 輸出:
# 1: Alice
# 2: Bob
# 3: Charlie

id()

id(object)：返回物件的唯一識別符號，即物件在記憶體中的地址。每個物件在記憶體中都有一個唯一的識別符號。

# 使用 id() 獲取物件的記憶體地址
num = 10
print("物件 num 的記憶體地址:", id(num))   # 輸出: 物件 num 的記憶體地址: 140732046623816

hash()

hash(object)：返回物件的雜湊值，如果物件是可雜湊的（即不可變的），則返回其雜湊值。雜湊值是一種用於快速比較物件的值是否相同的機制。

num = 10
hash_num = hash(num)
print("物件 num 的雜湊值:", hash_num)   # 輸出: 物件 num 的雜湊值: 10

input()

input(prompt)：從標準輸入（通常是鍵盤）獲取使用者輸入，並返回使用者輸入的字串。

name = input("請輸入你的名字：")
print("你好，" + name + "!")

type()

type() 函式用於返回物件的型別。

其語法如下：

type(object)   
  object：要獲取其型別的物件
  
type(name, bases, dict, **kwds)

type() 函式返回物件的型別。如果只傳入一個引數，則返回該物件的型別；如果傳入三個引數，則返回一個新的型別物件。

# 獲取物件的型別
num = 10
print(type(num))  # <class 'int'>，num 是整數型別

# 獲取函式的型別
def greet():
    print("Hello!")

print(type(greet))  # <class 'function'>，greet 是函式型別

# 獲取類的型別
class Person:
    pass

print(type(Person))  # <class 'type'>，Person 是類型別

# 獲取例項的型別
class Dog:
    pass

my_dog = Dog()
print(type(my_dog))  # <class '__main__.Dog'>，my_dog 是 Dog 類的例項

# 獲取型別的型別
print(type(int))  # <class 'type'>，int 是型別物件
print(type(str))  # <class 'type'>，str 是型別物件

# 使用三個引數建立新的型別物件
NewClass = type('NewClass', (object,), {'attr': 10})
print(type(NewClass))  # <class 'type'>，NewClass 是新的型別物件


# 返回字串物件的型別
string = "hello"
type_str = type(string)
print(type_str)  # 輸出：<class 'str'>

# 返回列表物件的型別
list1 = [1, 2, 3]
type_list = type(list1)
print(type_list)  # 輸出：<class 'list'>

# 隱式轉換
print(type(1+True))     # 輸出：<class 'int'>
print(type(1+True+2.0)) # 輸出：<class 'float'>

# 獲取自定義類的例項的型別
class MyClass:
    pass

obj = MyClass()
print(type(obj))  # 輸出：<class '__main__.MyClass'>

isinstance()

isinstance() 是 Python 內建函式，用於檢查一個物件是否是指定類或型別中的一個。

其語法如下：
isinstance(object, classinfo)

object：要檢查的物件
classinfo：要檢查的類、型別或元組

如果 object 是 classinfo 類或型別的例項，或者是其子類的例項，則返回 True；否則返回 False。

# 檢查物件是否是指定類的例項
num = 10
print(isinstance(num, int))  # True，num 是整數型別
print(isinstance(num, str))  # False，num 不是字串型別

# 檢查物件是否是多個類或型別中的一個
num = 10
print(isinstance(num, (int, float)))  # True，num 是整數或浮點數型別中的一個
print(isinstance(num, (str, float)))  # False，num 不是字串或浮點數型別中的一個

# 結合繼承關係進行檢查
class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()
print(isinstance(my_dog, Animal))  # True，my_dog 是 Animal 類的例項
print(isinstance(my_dog, Dog))     # True，my_dog 是 Dog 類的例項

callable()

callable() 是 Python 內建函式，用於檢查物件是否可呼叫（callable）。可呼叫的物件包括函式、方法、類和某些類的例項等。

其語法如下：

callable(object)

object：要檢查的物件

如果 object 可以呼叫，則返回 True；否則返回 False。

# 檢查函式是否可呼叫
def greet():
    print("Hello!")

print(callable(greet))  # True，函式 greet 可呼叫

# 檢查方法是否可呼叫
class Person:
    def greet(self):
        print("Hello!")

p = Person()
print(callable(p.greet))  # True，方法 greet 可呼叫

# 檢查類是否可呼叫
class Dog:
    pass

print(callable(Dog))  # True，類 Dog 可呼叫，建立類例項

# 檢查例項是否可呼叫
class Calculator:
    def calculate(self, x, y):
        return x + y

c = Calculator()
print(callable(c.calculate))  # True，例項 c 的方法 calculate 可呼叫

# 檢查不可呼叫的物件
num = 10
print(callable(num))  # False，整數物件 num 不可呼叫

iter()

iter() 是 Python 內建函式，用於獲取可迭代物件的迭代器。

其語法如下：
iter(object, sentinel)

object：要建立迭代器的可迭代物件
sentinel：可選引數，指定在迭代器到達特定值時停止迭代

iter() 函式返回一個迭代器物件，該物件可以用於遍歷可迭代物件的元素。

# 獲取列表的迭代器
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

print(next(my_iter))  # 1，獲取迭代器的下一個元素
print(next(my_iter))  # 2
print(next(my_iter))  # 3

# 獲取字串的迭代器
my_string = "Hello"
my_iter = iter(my_string)

print(next(my_iter))  # 'H'，獲取迭代器的下一個字元
print(next(my_iter))  # 'e'
print(next(my_iter))  # 'l'

# 使用 sentinel 引數建立迭代器
def my_generator():
    yield 1
    yield 2
    yield 3

gen_iter = iter(my_generator(), 2)  # 當迭代器產生值為2時停止迭代

for value in gen_iter:
    print(value)  # 1，迭代器產生值為2時停止

# 迭代字典的鍵
my_dict = {'a': 1, 'b': 2, 'c': 3}
key_iter = iter(my_dict)

print(next(key_iter))  # 'a'，獲取字典鍵的迭代器
print(next(key_iter))  # 'b'
print(next(key_iter))  # 'c'

hasattr()

hasattr() 是 Python 內建函式，用於檢查物件是否具有指定屬性。

其語法如下：
hasattr(object, name)

object：要檢查的物件
name：要檢查的屬性名稱

如果物件具有指定屬性，則返回 True；否則返回 False。

# 檢查物件是否具有屬性
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(hasattr(person, "name"))  # True，person 物件具有屬性 "name"
print(hasattr(person, "gender"))  # False，person 物件不具有屬性 "gender"

# 檢查模組是否具有屬性
import math
print(hasattr(math, "pi"))  # True，math 模組具有屬性 "pi"
print(hasattr(math, "sin"))  # True，math 模組具有屬性 "sin"

# 檢查內建型別是否具有屬性
print(hasattr(int, "bit_length"))  # True，整數型別具有屬性 "bit_length"
print(hasattr(float, "real"))  # True，浮點數型別具有屬性 "real"

# 檢查例項方法是否具有屬性
class Car:
    def drive(self):
        print("Driving the car")

car = Car()
print(hasattr(car.drive, "__call__"))  # True，例項方法 "drive" 可呼叫

# 檢查字串是否具有屬性
my_string = "Hello"
print(hasattr(my_string, "upper"))  # True，字串具有屬性 "upper"
print(hasattr(my_string, "split"))  # True，字串具有屬性 "split"

getattr()

getattr() 是 Python 內建函式，用於獲取物件的屬性值。

其語法如下：
getattr(object, name, default)

object：要獲取屬性的物件
name：要獲取的屬性名稱
default：可選引數，如果屬性不存在，則返回預設值

如果物件具有指定屬性，則返回該屬性的值；如果屬性不存在且未提供預設值，則引發 AttributeError 異常。

# 獲取物件的屬性值
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(getattr(person, "name"))  # 'Alice'，獲取物件 person 的屬性 "name" 的值
print(getattr(person, "age"))   # 30，獲取物件 person 的屬性 "age" 的值

# 獲取模組的屬性值
import math
print(getattr(math, "pi"))  # 3.141592653589793，獲取 math 模組的屬性 "pi" 的值
print(getattr(math, "sin"))  # <built-in function sin>，獲取 math 模組的屬性 "sin"，為函式物件

# 提供預設值
class Person:
    pass

person = Person()
print(getattr(person, "name", "Unknown"))  # 'Unknown'，屬性 "name" 不存在，返回預設值

# 處理不存在的屬性
class Person:
    def __init__(self, name):
        self.name = name

person = Person("Alice")
print(getattr(person, "age", None))  # None，屬性 "age" 不存在，返回 None

# 獲取內建型別的屬性值
print(getattr(str, "upper"))  # <method 'upper' of 'str' objects>，獲取字串型別的屬性 "upper"
print(getattr(int, "bit_length"))  # <method 'bit_length' of 'int' objects>，獲取整數型別的屬性 "bit_length"

issubclass()

issubclass() 是 Python 內建函式，用於檢查一個類是否是另一個類的子類。

其語法如下：
issubclass(class, classinfo)

class：要檢查的類
classinfo：要檢查的類或類的元組

如果 class 是 classinfo 類或其子類，則返回 True；否則返回 False。

# 檢查類是否是另一個類的子類
class Animal:
    pass

class Dog(Animal):
    pass

print(issubclass(Dog, Animal))  # True，Dog 是 Animal 的子類

# 檢查內建型別是否是指定型別的子類
print(issubclass(bool, int))  # True，布林型別是整數型別的子類
print(issubclass(float, int))  # False，浮點數型別不是整數型別的子類

# 檢查類是否是元組中任一類的子類
class Shape:
    pass

class Circle(Shape):
    pass

class Square(Shape):
    pass

print(issubclass(Circle, (Shape, int)))  # True，Circle 是 Shape 或 int 的子類
print(issubclass(Square, (Shape, int)))  # False，Square 不是 Shape 或 int 的子類

# 檢查類是否是自身的子類
class Parent:
    pass

class Child(Parent):
    pass

print(issubclass(Child, Child))  # True，Child 是自身的子類

# 檢查內建型別是否是基本型別的子類
print(issubclass(str, object))  # True，字串型別是基本型別 object 的子類
print(issubclass(list, object))  # True，列表型別是基本型別 object 的子類

map()

map() 函式是Python內建的高階函式，用於對可迭代物件中的每個元素應用一個指定的函式，然後返回一個包含所有函式返回值的新的可迭代物件。

功能：map 函式是一個內建函式，它將一個函式應用於一個序列（比如列表、元組等）或迭代器的每個元素，並返回一個迭代器。使用 map 函式可以實現對序列中每個元素進行操作的目標，而無需顯式地編寫迴圈。這樣不僅程式碼更簡潔，而且提高了程式碼的可讀性和效率。
語法： map(function, iterable, *iterables)
        function：要對每個元素應用的函式。
        iterable：一個或多個可迭代物件，如列表、元組、集合等。map 將逐個從提供的序列中取出元素，並將它們作為引數傳遞給函式。
返回值：map 函式返回一個迭代器，迭代器中的元素是應用函式後的結果。

# 基礎示例
# 定義一個函式，用於計算數字的平方
def square(x):
    return x * x

# 建立一個數字列表
numbers = [1, 2, 3, 4, 5]

# 使用 map 函式應用 square 函式到 numbers 的每個元素
squared = map(square, numbers)

# 將結果轉換為列表，並列印
print(list(squared))   # 輸出: [1, 4, 9, 16, 25]

# 多個序列
# 定義一個函式，用於計算兩個數的和
def add(x, y):
    return x + y

# 建立兩個數字列表
a = [1, 2, 3]
b = [4, 5, 6]

# 使用 map 函式將兩個列表對應位置的元素相加
result = map(add, a, b)

print(list(result))   # 輸出： [5, 7, 9]

zip()

zip() 函式用於將多個可迭代物件中對應位置的元素打包成一個元組，然後返回一個包含這些元組的迭代器。
預設情況下，zip() 在最短的迭代完成後停止。較長可迭代物件中的剩餘項將被忽略，結果會裁切至最短可迭代物件的長度。
zip() 與 * 運算子相結合可以用來拆解一個列表。

zip()函式的語法如下：
zip(iterable1, iterable2, ...,strict=False)
  iterable1, iterable2, ...：多個可迭代物件，可以是列表、元組、集合等。
  strict：如果設定strict=True，則會在長度不匹配時引發ValueError異常。

# 將兩個列表中對應位置的元素打包成元組
list1 = [1, 2, 3]
list2 = ['d', 'e', 'f', 'g']
zipped = list(zip(list1, list2))
print(zipped)      # 輸出：[(1, 'd'), (2, 'e'), (3, 'f')]

# 使用zip()函式同時遍歷多個列表
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for num, letter in zip(list1, list2):
    print(num, letter)
# 輸出：
# 1 a
# 2 b
# 3 c

# 將字典的鍵和值分別打包成元組
my_dict = {'a': 1, 'b': 2, 'c': 3}
zipped = list(zip(my_dict.keys(), my_dict.values()))
print(zipped)
# 輸出：[('a', 1), ('b', 2), ('c', 3)]

# 使用zip()函式合併多個列表成為一個字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(my_dict)
# 輸出：{'a': 1, 'b': 2, 'c': 3}

# 解壓縮元組列表
data = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*data)
print(numbers)
print(letters)
# 輸出：
# (1, 2, 3)
# ('a', 'b', 'c')

# 解壓縮字典的鍵和值
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys, values = zip(*my_dict.items())
print(keys)
print(values)
# 輸出：
# ('a', 'b', 'c')
# (1, 2, 3)

max()

用於從一組引數中返回最大值。這些引數可以是數字、字串或者可迭代物件（如列表、元組等）。

語法: max(arg1, arg2, *args, key=None, default=None)
引數： 
    arg1, arg2, *args: 用於比較大小的引數，可以是數字、字串或者可迭代物件。
    key (可選): 用於指定一個函式，該函式將應用於每個引數以進行比較。
    default (可選): 如果引數為空，則返回該預設值，否則引發 ValueError。
返回值：返回引數中的最大值。

# 作為獨立函式使用
max(3, 6, 1, 8, 4)  # 輸出: 8

# 透過指定 key 函式來進行比較
words = ['apple', 'banana', 'cherry', 'dragonfruit']
max_word = max(words, key=len)  # 輸出: 'dragonfruit'

chr()

描述：chr(i) 方法將一個 Unicode 編碼點轉換為對應的字元。
用法：chr(i)  i 必須是一個整數，表示 Unicode 編碼點。
返回值：返回表示該編碼點的字元。

print(chr(65))      # 輸出: 'A'
print(chr(8364))    # 輸出: '€'
print(chr(128516))  # 輸出: '😄'

ord()

描述：用於返回表示給定字元的 Unicode 碼點的整數。該函式接受一個表示單個字元的字串作為引數，並返回該字元的 Unicode 碼點（整數）
用法：ord(character)。character 是要獲取 Unicode 碼點的字元（必須是長度為 1 的字串）。
返回值：返回表示給定字元的 Unicode 碼點的整數值。

print(ord('A'))     # 輸出: 65
print(ord('€'))     # 輸出: 8364
print(ord('😄'))    # 輸出: 128516

isprintable()

描述：用於檢查字串是否包含可列印字元。即該字元是否在螢幕上可見，而不是控制字元或不可見字元。
返回值：如果一個字元是可列印的，isprintable()將返回True；否則，將返回False。

print('A'.isprintable())    # 輸出: True
print('€'.isprintable())    # 輸出: True
print('😄'.isprintable())   # 輸出: True
print('\n'.isprintable())   # 輸出: False
print('\t'.isprintable())   # 輸出: False
print('\r'.isprintable())   # 輸出: False
print(' '.isprintable())    # 輸出: True
print(''.isprintable())     # 輸出: True
print(chr(8).isprintable()) # ASCII. 輸出: False
print(chr(127).isprintable()) # ASCII. 輸出: False

iter()

功能：iter() 函式用於生成一個迭代器物件，返回一個迭代器，可用於逐個訪問某個可迭代物件的元素。
語法：iter(object, sentinel)
        object：要轉換為迭代器的物件（如列表、元組、字典等）。
        sentinel：可選引數，用於指定終止條件。如果提供了 sentinel 引數，object 必須是一個可呼叫的物件，在每次呼叫時返回結果直到等於 sentinel 為止，並且不會輸出哨兵值本身。

# 使用 iter() 獲取列表的迭代器
my_list = [1, 2, 3, 4]
my_iter = iter(my_list)

# 使用迭代器遍歷列表
for number in my_iter:
    print(number)
# 輸出:
# 1
# 2
# 3
# 4

# 使用 iter() 建立一個以哨兵值停止的迭代器
import random

# 生成隨機數直到生成5為止
random_iter = iter(lambda: random.randint(1, 10), 5)

# 迭代並列印隨機數直到生成的數是5
for num in random_iter:
    print(num)
# 輸出: 當 5 被生成時，迭代會立即終止，因此不會有機會列印 5。所以輸出將包括 1 到 10 之間的隨機數，但不包括 5。

next()

描述：next() 是 Python 中的一個內建函式，用於從迭代器中獲取下一個專案。如果迭代器已經耗盡（沒有更多的元素可供返回），則根據是否提供了預設值，next() 函式會丟擲一個 StopIteration 異常或返回一個指定的預設值。
用法：next(iterator, default=None)
        iterator：要從中獲取元素的迭代器。
        default（可選）：如果迭代器耗盡（沒有更多元素可返回時），返回的預設值。如果未提供此引數且迭代器耗盡，則會丟擲 StopIteration。

# 在沒有預設值的情況下使用 next()，當迭代器耗盡時會丟擲 StopIteration 異常。
numbers = iter([1, 2, 3])

# 使用 next() 逐個獲取元素
print(next(numbers))  # 輸出 1
print(next(numbers))  # 輸出 2
print(next(numbers))  # 輸出 3

# 再次嘗試獲取元素將丟擲 StopIteration 異常
try:
    print(next(numbers))
except StopIteration:
    print("迭代器已耗盡")

# 使用預設值
# 建立一個簡單的迭代器
numbers = iter([1, 2, 3])

# 使用 next() 逐個獲取元素，提供預設值
print(next(numbers, '結束'))  # 輸出 1
print(next(numbers, '結束'))  # 輸出 2
print(next(numbers, '結束'))  # 輸出 3
print(next(numbers, '結束'))  # 輸出 '結束'（因為迭代器已耗盡）

# 在迴圈中使用 next()
# 建立一個迭代器
import random
random_iter = iter(lambda: random.randint(1, 10), 5)

# 迴圈使用 next()，直到迭代器耗盡
while True:
    try:
        number = next(random_iter)
        print(number)
    except StopIteration:
        print("隨機數生成器達到哨兵值，迭代終止")
        break

參考文件

https://docs.python.org/zh-cn/3.12/library/functions.html