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

简介

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

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

内置函数详解（O-Z）

一、object()

object() 用于创建一个基本对象。它是所有其他类的基类，在 Python 中所有的类都是直接或间接地继承自该类。object() 函数创建的对象没有任何属性或方法，它是一个空对象。它通常用作其他类的基类，以便继承一些默认行为和功能。演示代码如下

class MyClass(object):
    pass

my_obj = MyClass()

二、oct()

oct() 用于将一个整数转换为八进制字符串。它的语法如下

oct(x)

参数：

x：整数

该函数将会返回对应的八进制表示形式。演示代码如下

num = 10
oct_num = oct(num)
print(oct_num)  # 输出: '0o12'

代码输出如下：

oct() 函数还可以用于将其他可兼容的数据类型转换为八进制字符串。例如，可以将一个字节字符串转换为八进制表示。演示代码如下

byte_str = b'\x41\x42\x43'
oct_str = oct(int.from_bytes(byte_str, 'big'))
print(oct_str)  # 输出: '0o101103'

代码输出如下：

三、open()

open() 用于打开文件，在进行文件操作时最为常用。它的语法如下

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数：

file：文件路径
mode：文件操作模式，有 r、w、a、r+、w+、a+、rb、wb、ab，默认为 r
encoding：编码模式，默认为 None，代表使用本机编码
errors：错误处理，用于编解码时发生错误时的处理，默认为 None，在字节模式下无法使用

该函数将会返回一个表示该文件的文件对象。演示代码如下

# 打开文件并写入内容
file = open('example.txt', 'w')
file.write('Hello, World!')
file.close()

# 打开文件并读取内容
file = open('example.txt', 'r')
content = file.read()
print(content)
file.close()

代码输出如下：

需要注意的是，在打开文件后，应该在不再使用文件时调用 close() 方法来关闭文件，以释放资源，否则知道程序关闭位置都会一直占用资源。

四、ord()

ord() 用于返回表示给定字符的 Unicode 码点。它的语法如下

ord(c)

参数：

c：字符，例如'a'、'b'、'!'、'@'、'中'之类的

演示代码如下

print(ord('A'))  # 输出：65
print(ord('a'))  # 输出：97
print(ord('中'))  # 输出：20013

代码输出如下：

需要注意的是，ord()函数只适用于单个字符。如果输入多个字符则会报 TypeError 错误，如下图所示

与之相对的是 chr() 函数，它接受一个整数值作为参数，并返回对应的字符。例如，chr(65) 会返回字符 'A'。

五、pow()

pow() 用于计算指定数的幂。它的语法如下

pow(x, y, mod)

参数：

x：底数
y：指数
mod：可选参数，表示计算结果的模数，默认为 None

pow() 函数的工作方式有两种不同的形式，如下所示

1、如果提供了两个参数 x 和 y，pow(x, y) 将返回 x 的 y 次幂。演示代码如下

print(pow(2, 3))  # 输出：8

代码输出如下：

2、如果提供了三个参数 x、y 和 mod，pow(x, y, mod) 将返回 x 的 y 次幂对 mod 取模的结果。演示代码如下

print(pow(2, 3, 5))  # 输出：3

代码输出如下：

需要注意的是，使用 ** 运算符也可以进行幂运算，例如 2** 3 将返回8，与 pow(2, 3) 等效。但是，pow() 函数的优势在于可以提供一个可选的模数参数，并且在某些情况下可以更快地进行计算。

六、print()

print() 用于将指定的内容输出到标准输出设备（通常是控制台）。它的语法如下

print(*objects, sep, end, file, flush)

参数：

*objects：一个或多个要打印的对象，可以是字符串、变量、表达式等
sep：要打印的对象之间的分隔符，默认是一个空格
end：表示打印结束后要追加的字符，默认是一个换行符 \n
file：表示输出的目标文件，默认是标准输出设备
flush：表示是否刷新输出缓冲区，默认是 False

演示代码如下

print("Hello, World!")  # 输出：Hello, World!
print(2 + 3)  # 输出：5
print("Hello", "World", sep=", ")  # 输出：Hello, World
print("Hello", end=" ")  # 输出：Hello，后面没有换行
print("World")  # 输出：World，与前面的输出在同一行

代码输出如下：

在 Python3 中，print() 函数是一个函数而不是一个语句，这意味着可以将其用作表达式的一部分。

七、property()

property() 用于创建属性，这些属性可以像访问普通属性一样进行访问，但实际上是通过调用相应的 getter、setter 和 deleter 方法来实现的。它的语法如下

property(fget=None, fset=None, fdel=None, doc=None)

参数：

fget：获取属性值的函数
fset：设置属性值的函数
fdel：删除属性的函数
doc：属性的文档字符串

演示代码如下

class Person:
    def __init__(self, name):
        self._name = name
    
    def get_name(self):
        return self._name
    
    def set_name(self, value):
        if isinstance(value, str):
            self._name = value
        else:
            raise TypeError("Name must be a string")
    
    def del_name(self):
        del self._name
    
    name = property(get_name, set_name, del_name, "Person's name")

在上面的代码中，Person 类定义了一个私有属性 _name，并使用 property() 函数创建了一个名为 name 的属性，该属性可以像访问普通属性一样进行访问。get_name 是获取 name 属性值的函数，set_name 是设置 name 属性值的函数，del_name 是删除 name 属性的函数。当访问 name 属性时，会调用相应的 getter、setter 和 deleter 方法。

通过 property() 函数创建的属性还可以用作装饰器，以更简洁的方式定义属性。演示代码如下

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, value):
        if isinstance(value, str):
            self._name = value
        else:
            raise TypeError("Name must be a string")
    
    @name.deleter
    def name(self):
        del self._name

在上面的代码中，通过将 getter、setter 和 deleter 方法使用 @property、@name.setter 和 @name.deleter 装饰器修饰，实现了与之前示例相同的效果。

八、range()

range() 用于生成一个整数序列。它的语法如下

range(start, stop, step)

参数：

start：可选参数，起始值，默认为0
stop：结束值
step：可选参数，步长，默认为1

该函数将会返回一个迭代器（iterator），可以使用 list() 函数将其转换为列表，也可以使用 for 循环遍历它。演示代码如下

# 生成一个从0到4的整数序列
print(list(range(5)))  # 输出：[0, 1, 2, 3, 4]

# 生成一个从1到10的整数序列，步长为2
print(list(range(1, 11, 2)))  # 输出：[1, 3, 5, 7, 9]

# 生成一个从10到1的整数序列，步长为-1
print(list(range(10, 0, -1)))  # 输出：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 使用for循环遍历一个整数序列
for i in range(3):
    print(i)  # 输出：0, 1, 2

代码输出如下：

九、repr()

repr() 用于返回一个对象的“官方”字符串表示形式。它的语法如下

repr(object)

参数：

object：要获取其字符串表示形式的对象

repr() 函数会尝试返回一个能够用来重新创建该对象的字符串。它通常返回一个 Python 表达式，可以通过 eval() 函数进行求值以重新创建该对象。演示代码如下

x = 10
s = repr(x)
print(s,":",type(s))  # 输出："10"

# 使用eval()函数对repr()返回的字符串进行求值
lst_str = repr([1, 2, 3])
print(lst_str,":",type(lst_str))
new_lst = eval(lst_str)
print(new_lst,":",type(new_lst))  # 输出：[1, 2, 3]

代码输出如下：

repr() 函数对于调试和开发过程中获取对象的字符串表示非常有用，它提供了一种标准的方式来表示对象，以便于查看其内容和状态。

十、reversed()

reversed() 用于返回一个反向迭代器。它的语法如下

reversed(seq)

参数：

seq：要进行反向迭代的序列或可迭代对象

该函数将会返回一个新的反向迭代器对象，该对象可以用于遍历序列或可迭代对象的元素，但是以相反的顺序。演示代码如下

numbers = [1, 2, 3, 4, 5]
reversed_numbers = reversed(numbers)

for num in reversed_numbers:
    print(num)  # 输出：5 4 3 2 1

# 可以将反向迭代器转换为列表
reversed_list = list(reversed(numbers))
print(reversed_list)  # 输出：[5, 4, 3, 2, 1]

# 对字符串进行反向迭代
string = "Hello, World!"
reversed_string = reversed(string)

for char in reversed_string:
    print(char)  # 输出：! d l r o W   , o l l e H

代码输出如下：

十一、round()

round() 用于对浮点数进行四舍五入。它的语法如下

round(number, ndigits=None)

参数：

number：要进行四舍五入的数值
ndigits：可选参数，表示保留的小数位数，默认为None，如果省略 ndigits 参数，则返回最接近的整数

演示代码如下

x = 3.14159
rounded = round(x)
print(rounded)  # 输出：3

y = 4.56789123
rounded_2 = round(y, 2)
print(rounded_2)  # 输出：4.57

z = 2.345
rounded_0 = round(z, 0)
print(rounded_0)  # 输出：2.0

代码输出如下：

十二、set()

set() 用于创建一个可变的集合对象。它的语法如下

set(iterable)

参数：

iterable：可选参数，表示一个可迭代的对象，如列表、元组、字符串等。如果省略iterable参数，则创建一个空的集合

演示代码如下

numbers = [1, 2, 3, 4, 4, 5, 5]
numbers_set = set(numbers)
print(numbers_set)  # 输出：{1, 2, 3, 4, 5}

string = "hello"
string_set = set(string)
print(string_set)  # 输出：{'e', 'h', 'o', 'l'}

代码输出如下：

十三、setattr()

setattr() 用于动态设置对象的属性。它的语法如下

setattr(obj, name, value)

参数：

obj：要设置属性的对象
name：属性的名称
value：要设置的属性值

该函数会将对象 obj 的属性 name 设置为值 value。如果属性已经存在，那么该属性的值会被替换；如果属性不存在，那么将会创建一个新的属性，并将其设置为指定的值。演示代码如下

class Person:
    pass

person = Person()  # 创建一个Person对象

setattr(person, 'name', 'John')  # 设置person对象的name属性为'John'
setattr(person, 'age', 25)  # 设置person对象的age属性为25

print(person.name)  # 输出：John
print(person.age)  # 输出：25

代码输出如下：

需要注意的是，setattr() 函数是一个通用函数，可以用于任意对象的属性设置，不仅限于类的实例对象。

十四、slice()

slice() 用于创建切片对象。切片对象可以用于对序列（例如字符串、列表、元组等）进行切片操。它的语法如下

slice(start, stop, step)

参数：

start：表示起始位置，默认为0
stop：表示终止位置
step：表示步长，默认为1

该函数将会返回一个切片对象，该对象可以传递给序列对象的切片操作符[]，从而实现对序列的切片操作。演示代码如下

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

# 使用切片对象对列表进行切片操作
s = slice(2, 7, 2)  # 与 numbers[2:7:2] 相同
result = numbers[s]
print(result)  # 输出：[3, 5, 7]

代码输出如下：

十五、sorted()

sorted() 用于对可迭代对象进行排序操作。它的语法如下

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

参数：

iterable：表示要排序的可迭代对象，例如列表、元组等
key：可选参数，用于指定一个函数，该函数将作用于每个元素，并根据返回值进行排序，默认为None
reverse：可选参数，用于指定排序顺序，默认为 False（升序），如果设置为 True，则会按照降序进行排序

该函数将会返回一个新的已排序的列表，并且不会修改原始的可迭代对象。演示代码如下

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

# 对列表进行升序排序
result = sorted(numbers)
print(result)  # 输出：[1, 2, 3, 5, 6, 8, 9]

# 对列表进行降序排序
result_reverse = sorted(numbers, reverse=True)
print(result_reverse)  # 输出：[9, 8, 6, 5, 3, 2, 1]

代码输出如下：

十六、staticmethod()

staticmethod() 用于将一个方法转换为静态方法。静态方法是属于类的方法，与类的实例无关，可以直接通过类名进行调用，而不需要创建类的实例。它的语法如下

staticmethod(function)

参数：

function：要转换为静态方法的函数或方法

演示代码如下

class MyClass:
    def __init__(self, name):
        self.name = name
    
    @staticmethod
    def static_method():
        print("This is a static method.")
    
    def instance_method(self):
        print("This is an instance method. My name is", self.name)

# 调用静态方法
MyClass.static_method()  # 输出：This is a static method.

# 创建类的实例并调用实例方法
my_instance = MyClass("John")
my_instance.instance_method()  # 输出：This is an instance method. My name is John

代码输出如下：

十七、str()

str() 用于将一个对象转换为字符串表示形式。它的语法如下

str(object)

参数：

object：要转换为字符串的对象

演示代码如下

number = 123
string = str(number)
print(string)  # 输出: "123"
print(type(string))  # 输出: <class 'str'>

boolean = True
string = str(boolean)
print(string)  # 输出: "True"
print(type(string))  # 输出: <class 'str'>

lst = [1, 2, 3]
string = str(lst)
print(string)  # 输出: "[1, 2, 3]"
print(type(string))  # 输出: <class 'str'>

dict_obj = {"name": "John", "age": 30}
string = str(dict_obj)
print(string)  # 输出: "{'name': 'John', 'age': 30}"
print(type(string))  # 输出: <class 'str'>

代码输出如下：

十八、sum()

sum() 用于计算可迭代对象中元素的总和。它的语法如下

sum(iterable, start)

参数：

iterable：表示可迭代对象，如列表、元组或集合等
start：可选参数，表示起始值，默认为0

演示代码如下

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # 输出: 15

numbers = [1.5, 2.5, 3.5]
total = sum(numbers)
print(total)  # 输出: 7.5

numbers = (1, 2, 3)
total = sum(numbers)
print(total)  # 输出: 6

numbers = {1, 2, 3, 4, 5}
total = sum(numbers)
print(total)  # 输出: 15

numbers = [1, 2, 3, 4, 5]
total = sum(numbers, 10)  # 指定起始值为10
print(total)  # 输出: 25

代码输出如下：

十九、super()

super() 用于调用父类的方法。它常常在子类的方法内部使用，以便在子类中扩展或重写父类的功能，同时保留父类的行为。它的语法如下

super(type, object_or_type)

参数：

type：类对象
object_or_type：类对象或对象实例

演示代码如下

class Parent:
    def __init__(self, name):
        self.name = name
        
    def greet(self):
        print(f"Hello, {self.name}!")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # 调用父类的__init__方法
        self.age = age
    
    def greet(self):
        super().greet()  # 调用父类的greet方法
        print(f"I am {self.age} years old.")

child = Child("Jove", 10)
child.greet()

代码输出如下：

二十、tuple()

tuple() 用于创建元组（tuple）。它的语法如下

tuple(iterable)

参数：

iterable：可迭代对象，如列表、字符串、字典等

演示代码如下

# 创建一个空元组
empty_tuple = tuple()
print(empty_tuple)  # ()

# 创建一个包含多个元素的元组
numbers_tuple = tuple([1, 2, 3, 4, 5])
print(numbers_tuple)  # (1, 2, 3, 4, 5)

# 通过字符串创建元组
string_tuple = tuple("Hello")
print(string_tuple)  # ('H', 'e', 'l', 'l', 'o')

# 将字典转换为元组
dict_tuple = tuple({"name": "Alice", "age": 20})
print(dict_tuple)  # ('name', 'age')

# 在元组中包含其他元组
nested_tuple = (("a", "b"), (1, 2, 3), ("x", "y", "z"))
print(nested_tuple)  # (('a', 'b'), (1, 2, 3), ('x', 'y', 'z'))

代码输出如下：

二十一、type()

type() 用于获取一个对象的类型。它的语法如下

type(object)

参数：

object：要获取类型的对象

演示代码如下

# 获取整数的类型
num = 10
print(type(num))  # <class 'int'>

# 获取浮点数的类型
pi = 3.14
print(type(pi))  # <class 'float'>

# 获取字符串的类型
message = "Hello, World!"
print(type(message))  # <class 'str'>

# 获取列表的类型
numbers = [1, 2, 3, 4, 5]
print(type(numbers))  # <class 'list'>

# 获取字典的类型
person = {"name": "Alice", "age": 20}
print(type(person))  # <class 'dict'>

# 获取函数的类型
def say_hello():
    print("Hello!")

print(type(say_hello))  # <class 'function'>

代码输出如下：

该函数能够帮助我们了解对象的类型，以正确地处理和操作对象。

二十二、vars()

vars() 用于返回对象的 __dict__ 属性。它的语法如下

vars(object)

参数：

object：要获取属性的对象

该函数对于普通的对象，vars() 返回对象的属性和属性值的字典。对于模块、类和实例，vars() 返回它们的名称空间，如果没有提供object参数，则vars()返回当前作用域的名称空间。下演示代码如下

# 获取当前作用域的名称空间
print(vars())  # 返回当前作用域的名称空间的字典

# 获取模块的名称空间
import math
print(vars(math))  # 返回math模块的名称空间的字典

# 获取类的名称空间
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 20)
print(vars(Person))  # 返回Person类的名称空间的字典

# 获取实例的属性字典
print(vars(p))  # 返回实例p的属性字典

代码输出如下：

需要注意的是，vars() 仅适用于具有 __dict__ 属性的对象。如果对象没有 __dict__ 属性，调用 vars() 会引发 TypeError 异常。

二十三、zip()

zip() 用于将一系列可迭代对象（例如列表、元组或字符串）作为参数，返回一个由元组组成的迭代器，其中的每个元组包含源可迭代对象中相同位置的元素。它的语法如下

zip(*iterables)

参数：

*iterables：一个或多个可迭代对象

该函数可以传递多个可迭代对象作为参数，将它们的对应元素打包成元组（以短的为准）。将会返回一个迭代器，每次迭代都会返回一个元组，其中的元素分别来自于每个可迭代对象相同位置的元素。当最短的可迭代对象被遍历完时，迭代将停止，超出部分将会被忽略。演示代码如下

# 将两个列表打包成元组
letters = ['a', 'b', 'c', 'd']
numbers = [1, 2, 3, 4]
result = zip(letters, numbers)  # 返回一个迭代器

# 遍历迭代器并打印每个元组
for item in result:
    print(item)  # 打印每个元组

# 将多个列表打包成元组
names = ['Jove', 'Bob', 'Charlie']
ages = [25, 30, 35]
countries = ['USA', 'Canada', 'UK']
result = zip(names, ages, countries)  # 返回一个迭代器

# 将元组解压缩为单独的列表
unzipped = zip(*result)  # 对迭代器中的每个元组进行解压缩
name_list, age_list, country_list = list(unzipped)  # 将解压后的元组分别赋值给不同的列表

print(name_list)  # 打印姓名列表
print(age_list)  # 打印年龄列表
print(country_list)  # 打印国家列表

代码输出如下：

zip() 函数返回的是一个迭代器，如果需要重复使用结果，建议将返回值转换为列表或其他可迭代对象保存起来。

二十四、import()

__import__() 用于动态地导入模块。它的语法如下

__import__(name, globals=None, locals=None, fromlist=(), level=0)

参数：

name：要导入的模块名，可以是一个字符串
globals：可选参数，用于指定模块的全局命名空间
locals：可选参数，用于指定模块的局部命名空间
fromlist：可选参数，用于指定要从模块中导入的对象，可以是一个列表或元组
level：输入的是整数，用于指定相对导入时的层级

该函数会根据给定的模块名，动态地导入相应的模块，并返回导入的模块对象。如果模块不存在，则会抛出ImportError异常。演示代码如下

# 导入内置模块
math_module = __import__('math')
print(math_module.pi)  # 打印数学模块中的π值

# 导入自定义模块
my_module = __import__('my_module')
my_module.my_function()  # 调用自定义模块中的函数

# 导入模块的某个对象
random_module = __import__('random', fromlist=['randrange'])
random_number = random_module.randrange(1, 10)
print(random_number)  # 打印随机数

# 导入相对路径的模块
relative_module = __import__('..my_module', fromlist=['my_function'], level=1)
relative_module.my_function()  # 调用相对路径模块中的函数

在上面的代码中，我们使用 __import__() 函数动态地导入模块，并使用导入的模块对象进行相应的操作。我们可以导入内置模块、自定义模块，以及导入模块的特定对象。还可以通过 fromlist 参数指定要从模块中导入的对象，以及通过 level 参数指定相对导入的层级。

需要注意的是，虽然可以使用 __import__() 函数动态导入模块，但通常更推荐使用 import 语句来导入模块。__import__() 函数主要在特定的动态导入场景中使用，例如根据用户输入或配置文件中的动态模块名进行导入。