[Python学习日记-36] Python 中的内置函数（中）

[Python学习日记-36] Python 中的内置函数（中）

简介

内置函数详解（F-N）

简介

         在 Python 中有很多内置函数，例如 len()，这些函数是 Python 解释器自带的，可以直接使用。本篇将介绍 F-N 的内置函数，下图是官方给出的所有 Python 解释器自带的函数

内置函数官方详解：Built-in Functions — Python 3.12.6 documentation

内置函数详解（F-N）

一、filter()

        filter() 用于过滤序列。它的语法如下

filter(function, iterable)

参数：

• function：代表一个函数，用于判断 iterable 中的每个元素是否符合条件，返回 True 或 False
• iterable：代表一个可以迭代的对象，例如列表、元组、字符串等

        filter() 函数会遍历 iterable 中的每个元素，将符合条件的元素组成一个新的迭代器（iterator）返回。

        以下例子，使用 filter() 函数从一个列表中过滤出所有的偶数，演示代码如下

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

def is_even(num):
    return num % 2 == 0

even_nums = list(filter(is_even, nums))
print(even_nums)  # 输出 [2, 4, 6, 8, 10]

代码输出如下：

        在上面的代码中，is_even() 是一个判断一个数是否为偶数的函数，filter(is_even, nums) 则表示将 nums 中的每个元素传入 is_even() 函数，将返回值为 True 的元素组成一个新的迭代器，并将其转换为列表。

二、float()

        float() 用于将一个数值或字符串转换为浮点数类型。它的语法如下

float(x)

参数：

• x：可以是一个数值、字符串或其他可以转换为浮点数的对象

演示代码如下

num1 = 3
num2 = "4.5"
num3 = "6.7"

result1 = float(num1)
result2 = float(num2)
result3 = float(num3)

print(type(result1), result1)  # 输出 <class 'float'> 3.0
print(type(result2), result2)  # 输出 <class 'float'> 4.5
print(type(result3), result3)  # 输出 <class 'float'> 6.7

代码输出如下：

        需要注意的是，如果 x 是一个无法转换为浮点数的对象，例如字符串中含有非数字字符，则会抛出 ValueError 异常，如下图所示

三、format()

        format() 用于对字符串进行格式化操作。它的语法如下

format(value, format_spec)

参数：

• value：要格式化的值
• format_spec：格式化规范，用来指定输出的格式

        format() 函数可以应用于不同类型的值，包括整数、浮点数、字符串等。演示代码如下

num = 3.14159
name = "John"

# 格式化浮点数
result1 = format(num, ".2f")
# 结果为 "3.14"

# 格式化整数，并指定宽度和填充字符
result2 = format(25, "0>5")
# 结果为 "00025"

# 格式化字符串
result3 = format(name, "^10")
# 结果为 "   John   "

print(result1)
print(result2)
print(result3)

代码输出如下：

        在上面的代码中，format(num, ".2f") 将浮点数 3.14159 格式化为保留两位小数的字符串 "3.14"。format(25, "0>5") 将整数 25 格式化为宽度为 5 的字符串，并在左侧填充零字符 "00025"。format(name, "^10") 将字符串 "John" 格式化为宽度为 10 的字符串，并在两侧填充空格字符 " John "。format_spec 参数中的格式规范可以是一些预定义的占位符，如 ".2f" 表示保留两位小数点的浮点数，"0>5" 表示宽度为 5 并在左侧填充零字符的整数，"^10" 表示宽度为 10 并在两侧填充空格字符的字符串。需要注意的是，format() 函数不会修改原始的值，而是返回一个新的格式化后的字符串。

四、frozenset()

        frozenset() 用于创建不可变的集合（frozen set）对象。与可变的集合（set）不同，不可变的集合（frozen set）是不可修改的，即一旦创建，就无法添加、删除或修改其中的元素。它的语法如下

frozenset(iterable) 

参数：

• iterable：可迭代对象，例如列表、元组、字符串等

演示代码如下

nums = [1, 2, 3, 4, 5]
names = ("Alice", "Bob", "Charlie")
myset = frozenset(nums)
yourset = frozenset(names)

print(type(myset))       # <class 'frozenset'>
print(type(yourset))     # <class 'frozenset'>
print(myset)             # frozenset({1, 2, 3, 4, 5})
print(yourset)           # frozenset({'Alice', 'Bob', 'Charlie'})

代码输出如下：

        在上面的代码中，frozenset(nums) 创建了一个不可变的集合对象 myset，其中包含了列表 nums 中的元素。frozenset(names) 创建了另一个不可变的集合对象 yourset，其中包含了元组 names 中的元素。使用 type() 函数可以验证这两个对象的类型。最后，通过打印这两个对象，可以看到其内容。需要注意的是，不可变集合（frozen set）虽然无法修改，但仍然可以进行一些集合操作，比如并集、交集和差集等。这些操作将返回一个新的不可变集合对象，而不是修改原始的集合对象。

五、getattr()

        getattr() 用于获取对象的属性。对象可以拥有属性，属性可以是对象的变量、方法或特性。getattr() 函数可以通过属性名获取对象的属性值。它的语法如下

getattr(object, name, default)

参数：

• object： 要获取属性的对象
• name：属性的名称
• default：可选参数，表示当属性不存在时返回的默认值

演示代码如下

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 25)

name = getattr(person, "name")
print(name)  # Alice

age = getattr(person, "age")
print(age)  # 25

# 获取不存在的属性，指定默认值
gender = getattr(person, "gender", "unknown")
print(gender)  # unknown

代码输出如下：

         如果不提供 default 参数，则在属性不存在时会引发 AttributeError 异常。代码如下

# 获取不存在的属性，未指定默认值
address = getattr(person, "address")
# AttributeError: 'Person' object has no attribute 'address'

代码输出错误如下：

        在上面的代码中，我们定义了一个 Person 类，包含 name 和 age 两个属性。我们创建了一个 person 对象，并使用 getattr() 函数获取其属性值。通过指定属性名，我们可以获取 person 对象的 name 属性和 age 属性，并打印出来。在此演示中，属性存在，所以没有使用默认值。接下来，我们使用 getattr() 函数获取 person 对象的不存在的属性 gender，并指定了默认值为 "unknown"。由于 gender 属性不存在，所以返回了指定的默认值。最后，我们再次使用 getattr() 函数获取 person 对象的不存在的属性 address，但未指定默认值。由于 address 属性不存在，所以引发了 AttributeError 异常。

六、globals()

        globals() 用于返回当前全局命名空间的字典。它返回一个包含全局作用域中所有可用对象的字典，其中键是对象的名称，值是对象本身。在Python中，全局命名空间是指在文件级别定义的变量、函数和类所在的命名空间。当我们在全局范围内定义了变量、函数或类时，它们都会成为全局命名空间的一部分。

演示代码如下

x = 10

def greet():
    print("Hello, World!")

class Person:
    def __init__(self, name):
        self.name = name

print(globals())

代码输出如下：

        输出结果中包含了一些 Python 解释器自动添加的特殊变量，如 __name__、__doc__ 和 __builtins__ 等。此外，还包括我们在全局作用域中定义的变量 x、函数 greet 和类 Person。我们可以通过 key 值对的方式访问全局命名空间中的对象。例如，globals()['x'] 将返回变量 x 的值， globals()['greet'] 将返回函数 greet 的引用。

        值得注意的是，globals() 返回的是一个字典对象，因此可以使用字典的各种方法来对全局命名空间进行操作，比如添加新的对象或删除已有的对象。除此之外，globals() 函数可以让我们访问和操作全局命名空间中的对象，方便在程序中进行动态编程或元编程。

七、hasattr()

        hasattr() 用于检查一个对象是否具有指定的属性。它的语法如下

hasattr(object, name)

参数：

• object：要检查的对象
• name：属性的名称

        如果对象具有指定的属性，即对象的命名空间中存在该属性，hasattr() 将返回 True；否则，将返回 False。

演示代码如下

class Person:
    def __init__(self, name):
        self.name = name

person = Person("John")

print(hasattr(person, "name"))  # True
print(hasattr(person, "age"))   # False

代码输出如下：

        在上面的代码中，我们定义了一个 Person 类，该类具有 name 属性。然后，我们实例化了一个 Person 对象，并使用 hasattr() 函数检查该对象是否具有 name 和 age 属性。hasattr() 函数在编写动态程序或元编程时非常有用，它可以帮助我们在运行时检查对象是否具有特定的属性，从而根据属性的存在与否进行相应的处理。

八、hash()

        hash() 用于生成对象的哈希值。它的语法如下

hash(object)

参数：

• object：要计算哈希值的对象

 演示代码如下

print(hash(42))
print(hash("Hello, World!"))
print(hash(("apple", "banana")))

代码输出如下：

        对于可哈希的对象（例如数字、字符串、元组等），hash()将返回唯一的哈希值；而对于不可哈希的对象（例如列表、字典等），hash()将引发TypeError异常。代码如下

print(hash([1, 2, 3]))            # TypeError: unhashable type: 'list'
print(hash({"name": "John"}))     # TypeError: unhashable type: 'dict'

代码输出如下：

九、help()

        help() 用于获取对象的帮助信息。它可以用于查看函数、类、模块等对象的详细描述和使用方法。它的语法如下

help(request)

参数：

• request： 要获取帮助信息的对象

演示代码如下

import math,random

help(print)            # 查看内置print函数的帮助信息
help(list)             # 查看内置列表类的帮助信息
help(str.split)        # 查看字符串split()方法的帮助信息
help(math.sin)         # 查看math模块的sin()函数的帮助信息
help(random.choice)    # 查看random模块的choice()函数的帮助信息

代码输出如下：

        当调用 help() 函数时，将在控制台中显示对象的帮助文档。帮助文档通常包含有关对象的描述、参数的说明、返回值的说明以及示例用法。需要注意的是，对于某些对象，可能没有可用的帮助信息。在这种情况下，help() 函数可能会显示一个简短的默认消息，或者什么都不显示。代码如下

help("Hello, World!")  # 没有关于字符串对象的帮助信息

代码输出如下：

十、hex()

        hex() 用于将整数转换为十六进制字符串。它的语法如下

hex(x)

参数：

• x： 整数

        将会返回一个十六进制字符串。十六进制字符串的前缀为"0x"，后跟表示整数值的十六进制数字。演示代码如下

print(hex(10))    # 返回 '0xa'，将十进制数10转换为十六进制字符串
print(hex(255))   # 返回 '0xff'，将十进制数255转换为十六进制字符串
print(hex(16))    # 返回 '0x10'，将十进制数16转换为十六进制字符串
print(hex(0))     # 返回 '0x0'，将十进制数0转换为十六进制字符串

代码输出如下：

        需要注意的是，hex() 函数的返回值始终是字符串类型。如果传入的参数不是整数，则会引发 TypeError 异常。代码如下

hex(3.14)  # TypeError: 'float' object cannot be interpreted as an integer
hex("10")  # TypeError: 'str' object cannot be interpreted as an integer

代码输出错误如下：

十一、id()

        id() 用于获取对象的唯一标识符（即对象的内存地址）。它的语法如下

id(object)

参数：

• object：需查看内存地址的对象

        将会返回一个整数，该整数表示该对象在内存中的唯一标识符。每个对象在内存中都有一个唯一的ID，该ID在对象的生命周期内保持不变。演示代码如下

x = 10
print(id(x))  # 输出对象x的唯一标识符，如 140732974627544

y = "hello"
print(id(y))  # 输出对象y的唯一标识符，如 2458843961104

z = [1, 2, 3]
print(id(z))  # 输出对象z的唯一标识符，如 2458841305472

代码输出如下：

        需要注意的是，id()函数返回的标识符并不一定是连续的或按顺序分配的。它们是由Python解释器在运行时分配的，具体的分配策略取决于底层的内存管理实现。另外，当对象被垃圾回收时，其唯一标识符可能会被重新使用，因此在对象被删除后，不应再使用该对象的唯一标识符。

十二、input()

        input() 用于从用户处获取输入。它的语法如下

input(prompt)

参数：

• prompt：等待用户输入数据时显示的字符串

        input() 函数会在程序运行时暂停，并等待用户输入数据。用户可以在命令行界面输入任意内容，按下回车键确认输入。然后，input() 函数会将用户输入的内容作为字符串返回。演示代码如下

name = input("请输入您的姓名：")
print("您好，" + name + "！")

代码输出如下：

        需要注意的是，input() 函数将所有用户输入的内容都作为字符串返回。如果需要将输入转换为其他类型（整数或浮点数），可以使用适当的类型转换函数（int() 或 float()）进行转换。在使用 input() 函数时要显示清晰的提示信息，以便用户知道应该输入什么。这样可以提高用户体验和程序的交互性。

十三、int()

        int() 用于将一个数字或字符串转换为整数。它的语法如下

int(x, base)

参数：

• x： 可以接受不同类型的参数，如整数、浮点数、字符串等，如果参数是一个字符串，那么该字符串必须表示一个有效的整数
• base：默认情况下将字符串解析为十进制整数，可以通过提供可选的 base 参数来指定基数。base 参数可以是一个整数，范围在2到36之间（包括2和36）

演示代码如下

num1 = int(3.14)         # 将浮点数3.14转换为整数类型，结果为3
num2 = int("20")         # 将字符串"20"转换为整数类型
num3 = int("100", 2)     # 将二进制字符串"100"转换为整数类型，使用二进制表示，结果为4

print(num1)
print(num2)
print(num3)

代码输出如下：

        如果字符串参数无法转换为整数，将会抛出 ValueError 异常。

十四、isinstance()

        isinstance() 用于检查一个对象是否是指定类或类型的实例。它的语法如下

isinstance(object, classinfo)

参数：

• object：要检查的对象
• classinfo：要检查的类或类型

        该内置函数将会返回一个布尔值，如果对象是指定类或类型的实例，则返回 True，否则返回 False。演示代码如下

x = 5
y = "hello"
z = [1, 2, 3]

print(isinstance(x, int))   # True，x是整数类型的实例
print(isinstance(y, str))   # True，y是字符串类型的实例
print(isinstance(z, list))  # True，z是列表类型的实例

print(isinstance(x, str))   # False，x不是字符串类型的实例
print(isinstance(y, list))  # False，y不是列表类型的实例
print(isinstance(z, dict))  # False，z不是字典类型的实例

代码输出如下：

        该内置函数除了可以用于检查 Python 内置类型（如int、str、list等）以及自定义的类。它还可以用于检查一个对象是否是指定类的派生类的实例。

十五、issubclass()

        issubclass() 用于检查一个类是否是另一个类的直接子类（即直接继承），或者是间接子类（即通过继承链的其他类派生而来）。它的语法如下

issubclass(class, classinfo)

参数：

•  class：类的名称
• classinfo：类或元组的名称

        该内置函数将会返回一个布尔值，如果第一个类是第二个类的子类（或元组中的任意一个类），则返回 True，否则返回 False。演示代码如下

class A:
    pass

class B(A):
    pass

class C:
    pass

print(issubclass(B, A))      # True，B是A的子类
print(issubclass(B, object)) # True，B是object的子类

print(issubclass(C, A))      # False，C不是A的子类
print(issubclass(C, object)) # True，C是object的子类

print(issubclass(A, B))      # False，A不是B的子类
print(issubclass(object, B)) # False，object不是B的子类

代码输出如下：

十六、iter()

        iter() 用于返回一个可迭代对象的迭代器（可以使用 next() 函数来逐个获取迭代器中的元素）。可迭代对象是指具有 __iter__() 方法的对象，而迭代器是指具有 __next__() 方法的对象。它的语法如下

iter(object)

参数：

• 要获取迭代器的可迭代对象 

        将该内置函数会返回一个迭代器对象，该对象可以用于在循环中逐个访问可迭代对象中的元素。演示代码如下

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
print(next(my_iter))  # 4
print(next(my_iter))  # 5

my_string = "Hello"
my_iter = iter(my_string)

print(next(my_iter))  # 'H'
print(next(my_iter))  # 'e'
print(next(my_iter))  # 'l'
print(next(my_iter))  # 'l'
print(next(my_iter))  # 'o'

代码输出如下：

        需要注意的是，当迭代器达到末尾时，再次调用 next() 函数将引发 StopIteration 异常。

        因此，在使用迭代器时，需要小心处理此异常或使用循环结构来遍历所有元素。

十七、len()

        len() 用于返回一个对象的长度或元素个数。可以使用 len() 函数来获取字符串、列表、元组、集合、字典等对象的长度或元素个数。它的语法如下

len(s)

参数：

•  要获取长度的对象

        将该内置函数会返回一个整数。演示代码如下

my_string = "Hello"
print(len(my_string))  # 5

my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 5

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # 5

my_set = {1, 2, 3, 4, 5}
print(len(my_set))  # 5

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))  # 3

代码输出如下：

        需要注意的是，len() 函数返回的是对象中元素的个数，而不是对象占用的内存大小或字节数。而对于字符串来说，返回的是字符串中字符的个数。

十八、list()

        list() 用于创建一个新的列表对象。可以将一个可迭代对象（如字符串、元组、集合、字典、range 对象等）转换为一个新的列表对象。它的语法如下

list(iterable)

参数：

• iterable：需要转换为列表的可迭代对象 

演示代码如下

my_string = "Hello"
my_list = list(my_string)
print(my_list)  # ['H', 'e', 'l', 'l', 'o']

my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3, 4, 5]

my_set = {1, 2, 3, 4, 5}
my_list = list(my_set)
print(my_list)  # [1, 2, 3, 4, 5]

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict)
print(my_list)  # ['a', 'b', 'c']

my_range = range(5)
my_list = list(my_range)
print(my_list)  # [0, 1, 2, 3, 4]

代码输出如下：

        需要注意的是，list() 函数会将可迭代对象中的每个元素作为列表的元素，并按照原始顺序排列。对于字典来说，list() 函数会将字典的键作为列表的元素。

十九、locals()

        locals() 用于返回当前作用域中的局部变量和它们的值的字典。在 Python 中，每个函数、方法或类都有自己的作用域。locals() 函数可以在函数、方法或类的作用域内调用，返回一个包含局部变量及其值的字典。这个字典可以用于查看和操作当前作用域中的局部变量。演示代码如下

def my_function():
    x = 10
    y = 20
    local_variables = locals()
    print(local_variables)

my_function()

代码输出如下：

        需要注意的是，在全局作用域中调用 locals() 函数会返回全局命名空间中的变量和它们的值。如果需要获取全局作用域中的变量和它们的值，可以使用 globals() 函数。

二十、map()

        map() 用于将一个函数应用于一个或多个可迭代对象的对应元素上，并返回一个包含结果的迭代器。它的语法如下

map(function, iterable, *iterable)

参数：

• function：用于处理可迭代对象中元素的函数，可以是普通函数、匿名函数等
• iterable：可迭代对象是要处理的数据
• *iterable：代表其他可迭代对象

        将该内置函数将会依次将 function 应用于 iterable、*iterable 等可迭代对象的对应元素上，并返回一个迭代器，其中包含了处理结果。演示代码如下

# 定义一个函数，用于将字符串转换为大写
def to_uppercase(string):
    return string.upper()

# 使用map()函数将to_uppercase函数应用于一个列表中的所有元素
result = map(to_uppercase, ["hello", "world", "python"])

# 打印结果
print(list(result))

代码输出如下：

        需要注意的是，map() 函数可以接受多个可迭代对象作为参数。当提供了多个可迭代对象时，function 函数的参数列表需要与可迭代对象个数一致。

二十一、max( )

        max()  用于获取可迭代对象或一组值中的最大值。它的语法如下

max(iterable,*iterable, key, default)
max(arg, *arg, key)

参数：

• iterable：可迭代对象，例如列表、元组、集合等
• *iterable：可选参数，表示其他可迭代对象
• key：指定一个函数应用于每一个元素上，默认使用元素的值进行比较
• default：可选的参数，用于指定当可迭代对象为空时返回的默认值。如果不提供该参数，并且可迭代对象为空，那么将会抛出一个 ValueError 异常
• arg, *arg：一组具体的值，例如85, 90, 77, 92

        将该内置函数将会返回可迭代对象中的最大值，或者一组给定值中的最大值。演示代码如下

numbers = [2, 4, 6, 8, 10]
max_number = max(numbers)
print(max_number)  # 输出 10

names = ["Alice", "Bob", "Charlie", "Dave"]
longest_name = max(names, key=len)
print(longest_name)  # 输出 "Charlie"

highest_score = max(85, 90, 77, 92)
print(highest_score)  # 输出 92

代码输出如下：

        需要注意的是，在 Python3 中列表应该全是相同类型的元素，否则会报错，但在 Python2 当中则不会报错。

二十二、memoryview()

        memoryview()  用于创建一个内存视图对象，它可以让你以不同的方式查看底层数据的内存，而无需创建新的副本。它适用于对大量数据进行高效处理，例如快速访问、修改和切片操作。它的语法如下

memoryview(object)

参数：

• object： 可以被转换为内存视图的对象，比如字节数组、字节对象、数组等

演示代码如下

data = bytearray(b"Hello, World!")
mv = memoryview(data)

for byte in mv:
    print(byte)

print(mv[7])  # 输出 87，对应字符 "W" 的 ASCII 值

mv[0] = 104    # 一定要先将字节组使用 bytearray() 使字节组可编辑，否则会报 TypeError: cannot modify read-only memory
print(data)  # 输出 b"Hallo, World!"，首字母 "H" 被修改为 "h"

代码输出如下：

        需要注意的是，memoryview() 函数只能用于支持缓冲区协议的对象。这意味着它只能用于字节类型的对象，如字节数组、字节对象，以及其他一些支持缓冲区接口的对象。它提供了一种高效访问和操作底层数据内存的方式，特别适用于处理大型数据集。通过使用内存视图，我们可以避免不必要的数据复制，从而提高性能和节省内存使用。

二十三、min()

        min() 用于返回给定可迭代对象中的最小值。它的语法如下

min(iterable, *iterables, key, default)

min(arg, *arg, key)

参数：

• iterable：表示一个可迭代对象，如列表、元组、字符串等
• *iterables：可选参数，表示其他可迭代对象
• key：可选的参数，指定一个函数应用于每一个元素上，默认使用元素的值进行比较
• default：可选的参数，用于指定当可迭代对象为空时返回的默认值。如果不提供该参数，并且可迭代对象为空，那么将会抛出一个 ValueError 异常
• arg, *arg：一组具体的值，例如85, 90, 77, 92

演示代码如下

numbers = [5, 2, 9, 1, 7]

# 找到列表中的最小值
print(min(numbers))  # 输出 1

# 找到两个列表中的最小值
more_numbers = [3, 8, 4]
print(min(numbers, more_numbers))  # 输出 1

# 找到字符串中的最小字符
text = "hello"
print(min(text))  # 输出 'e'

代码输出如下：

二十四、next()

        next() 用于从迭代器（iterator）中获取下一个元素，配合 iter() 函数使用。它的语法如下

next(iterator, default)

参数：

• iterator：表示一个迭代器对象，可以是一个列表、元组、字符串等
• default：可选参数，表示当迭代器耗尽时，返回的默认值

        如果迭代器已经耗尽，即没有更多的元素可供获取，它会抛出一个 StopIteration 异常，除非提供了 default 参数。如果提供了 default 参数，则在迭代器耗尽时，返回该值。演示代码如下

numbers = [1, 2, 3, 4, 5]
iter_numbers = iter(numbers)

# 逐个获取迭代器中的元素
print(next(iter_numbers))  # 输出 1
print(next(iter_numbers))  # 输出 2
print(next(iter_numbers))  # 输出 3

# 使用默认值处理迭代器耗尽的情况
print(next(iter_numbers, "No more elements"))  # 输出 4
print(next(iter_numbers, "No more elements"))  # 输出 5
print(next(iter_numbers, "No more elements"))  # 输出 "No more elements"

代码输出如下：