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