Python内置函数67个语法、参数和用法详解

要获取Python解释器中所有当前可用的内置函数和变量的完整列表，您可以在Python解释器中使用dir(__builtins__)命令。这将返回一个包含所有内置函数、异常和其他内置对象的列表。

分为10类

数学运算（7）：

1. abs 绝对值
2. divmod 商和余数
3. max 最大
4. min最小
5. pow 指数幂
6. round 取整
7. sum 求和

类型转换（24）：

1. bool 布尔值
2. int 整数
3. float 浮点数
4. complex 复数
5. str 字符串
6. bytearray 字节数组
7. bytes 不可变字节对象
8. momeryview 内存视图对象
9. ord 返回Unicode码点
10. chr 转为字符
11. bin 二进制
12. oct 八进制
13. hex 十六进制
14. tuple 元组
15. list 列表
16. dict 字典
17. set 集合
18. frozenset 不可变集合
19. enumerate 枚举
20. range 序列
21. iter 迭代器
22. slice 切片对象
23. super 调用父类
24. object 对象

序列操作（8）：

1. all 都为True值
2. any 有一个为True值
3. filter 返回迭代对象符合指定条件的值
4. map 返回迭代对象用指定函数处理后的值
5. next 从迭代器获取下一个元素
6. reversed 反转顺序
7. soted 排序
8. zip 按顺序聚合多个迭代器

对象操作（7）：

1. help 帮助信息
2. dir 属性和方法
3. id 唯一标识符
4. hash 哈希值
5. type 类型
6. len 长度
7. ascii 字符串形式

反射操作（8）：

1. __import__ 动态导入模块
2. isinstance 判断对象类型
3. issubclass 判断是否是某个类的子类
4. hasattr 判断属性存在
5. getattr 获取属性值
6. setattr 设置属性值
7. delattr 删除属性值
8. callable 判断对象是否可调用

变量操作（2）：

1、globals 当前域全局变量及值

2、locals 当前域局部变量及值

交互操作（2）：

1、print 输出信息

2、input 获取用户输入

文件操作（1）：

1、open 打开并获取文件对象

编译执行（5）：

1. compile 编译字符串为代码对象
2. eval 执行字符串表达式
3. exec 执行字符串代码块
4. repr 返回对象字符串表示（调试用）
5. breakpoint 设置断点

装饰器（3）：

1、property 将方法转换为属性

2、classmethod 将方法转换为类方法

3、staticmethod 将方法转换为静态方法

操作环境：Python版本3.10.7、windows1

数学运算（7个）

1、abs(x)：返回一个数的绝对值

abs() 是一个内置函数，用于返回一个数的绝对值。绝对值是一个数不考虑其符号的大小，即一个数距离0的距离。对于正数和零，绝对值就是其本身；对于负数，绝对值是它的相反数。

参数

x -- 这是你想要求其绝对值的数字。

返回值

返回 x 的绝对值。

示例：

print(abs(-10))  # 输出: 10  

print(abs(10))   # 输出: 10  

print(abs(-3.14)) # 输出: 3.14

2、divmod(a,b)：返回a除以b的商和余数

divmod()是一个内置函数，用于返回商和余数，这是当两个数相除时的结果。这个函数接受两个参数：被除数和除数，并返回一个包含两个元素的元组，第一个元素是商，第二个元素是余数。

参数：

a：被除数

b：除数

返回值

返回一个包含两个元素的元组 (商, 余数)。

示列：

print(divmod(10, 3))  # 输出: (3, 1)，因为10除以3的商是3，余数是1  

print(divmod(7, 2))   # 输出: (3, 1)，因为7除以2的商是3，余数是1  

print(divmod(-10, 3)) # 输出: (-4, 2)，因为-10除以3的商是-3.333...,Ptyhon

注：

因为Python在处理负数的除法时，divmod()函数返回的是“地板除法”的结果，也就是向负无穷方向取整。（**如果算法是向上取整，结果就是（-3，-1）**）

-10/3的结果是-3.3333，向下取整即取比-3.3333更小的最大整数即-4，而2是满足商为-4时的余数（-4*3+2=10）

3、max(iterable,*[,key,default]) / max(arg1,arg2,*args[,key])：找到给定参数中的最大值

当只有一个参数时，它应该是一个可迭代对象（例如列表、元组、集合、字符串等），max() 返回该可迭代对象中的最大值。

当有两个或多个参数时，max() 返回这些参数中的最大值。

max() 函数还可以接受关键字参数：

key：用于指定一个函数，该函数将应用于可迭代对象的每个元素，并根据函数的返回值进行比较。

default：可选参数，指定在可迭代对象为空时返回的默认值。

例1：找到列表中的最大值

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

print(max(numbers))  # 输出: 9

例2：找到多个参数中的最大值

print(max(3, 1, 4, 1, 5, 9, 2, 6))  # 输出: 9

例3：使用key参数来指定比较的方式

words = ["apple", "banana", "cherry", "date"]

print(max(words, key=len))  # 输出: "banana"，根据字符串长度比较

例4：使用default参数来设置默认值

empty_list = []

print(max(empty_list, default="列表为空"))  # 输出: "列表为空"

例5：自定义比较

如果默认的比较不满足你的需求，你可以通过提供 key 参数来定义自己的比较函数。这个比较函数应该接受一个参数并返回一个可以用于比较的值。

例如，如果我们有一个数字列表，并且我们想要找出其中绝对值最大的数字，我们可以这样做：

numbers = [-10, -5, 0, 5, 10]  

  

def abs_value(num):  

    return abs(num)  

  

print(max(numbers, key=abs_value))  # 输出: -10

注意事项

• 如果可迭代对象为空，max() 函数会引发 ValueError 异常。
• 如果提供了多个参数并且其中一个是可迭代对象，那么会引发 TypeError 异常。例如，max(3, [1, 2]) 会引发异常。

• key 参数应该是一个函数，它接受一个参数并返回一个用于比较的值。如果 key 不是函数，会引发 TypeError 异常。
• max() 函数在进行比较时会遵循正常的比较规则，这意味着它可以用于不同类型的可迭代对象，只要其中的元素支持比较操作。

4、min(iterable, *[, key, default]) / min(arg1, arg2, *args[, key])：找到给定参数中的最小值

min() 函数与 max() 函数类似。min是minimum的缩写，即最小值或最小量。

5、pow(x, y, [z])：计算一个数的指数幂

x：底数

y：指数

返回x的y次幂的值。与x**y运算的结果相同。

z[可选]：当指定了这个参数时，计算的结果为：(x**y)%z。这对于大数幂运算取模很有用。

例1：2的3次方

result = pow(2, 3)

print(result)  # 输出: 8

例2：2的3次方再除5后的余数

result = pow(2, 3, 5)

print(result)  # 输出: 3，因为 (2 ** 3) % 5 = 8 % 5 = 3

例3：求平方根

print(pow(3, 0.5))    # 输出: 1.7320508075688772，即 3 的平方根

6、round(number[, ndigits])：将浮点数四舍五入为指定的小数位数或最接近的整数

number：要四舍五入的数字。

ndigits：可选参数，表示要保留的小数位数。默认为 0，表示将 number 四舍五入为最接近的整数。当 ndigits 为正数时，将 number 四舍五入到小数点右侧指定的位数；当 ndigits 为负数时，将 number 四舍五入到小数点左侧指定的位数（即指定精度）。

例1：

result = round(3.1415926)

print(result)  # 输出: 3，将 3.1415926 四舍五入为整数

result = round(3.1415926, 2)

print(result)  # 输出: 3.14，将 3.1415926 四舍五入为小数点后两位

result = round(12345.6789, -2)

print(result)  # 输出: 12300.0，将 12345.6789 四舍五入到千位

例2：小数为0.5边界值时只向偶数向上取整

round(0.5) 结果为 0，

round(1.5) 结果为 2。

round(2.5) 结果为 2。

round(3.5) 结果为 4。

注意：

对于在中间值上的舍入，round() 函数会向最接近的偶数舍入，这与数学中的 "银行家舍入规则" 相符。

7、sum(iterable, start=0)：计算可迭代对象中所有元素的总和

sum()函数接受一个必需的参数，即要计算总和的可迭代对象。这个可迭代对象可以是列表（list）、元组（tuple）或其他任何可迭代的数据结构。

iterable：要计算总和的可迭代对象。

start：可选参数，用于指定总和的初始值。默认为 0。如果指定了 start，则会将 start 与可迭代对象中的元素逐个相加。

例 1：计算列表中元素的和

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

total = sum(numbers)  

print(total)  # 输出：15

例 2：计算元组中元素的和

numbers = (1, 2, 3, 4, 5)  

total = sum(numbers)  

print(total)  # 输出：15

例3：附上初始值

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

result = sum(numbers, 10)

print(result) # 输出: 25，计算列表中所有元素的总和，并加上初始值 10

注意事项

• sum()函数只能用于数值类型的数据。如果可迭代对象中包含非数值类型的数据（如字符串、列表等），将会引发TypeError异常。

• 对于空的可迭代对象，sum()函数返回0。

• sum()函数在内部使用循环来计算总和，因此对于大型数据集，使用sum()可能比手动循环遍历元素求和更高效。

类型转换（24个）

1、bool([value])：将给定的值转换为布尔值

bool() 函数接受一个参数，这个参数可以是任何数据类型，包括整数、浮点数、字符串、列表、元组、字典、集合等。

value：

可选参数，要转换为布尔值的值。如果省略 value 参数，则返回 False。否则，根据 value 的值进行转换：

如果 value 是假值（如 None、空容器（空列表、空元组、空字典、空集合）、数字 0、布尔值 False 等），则返回 False。

如果 value 是真值（除了上述假值之外的其他值），则返回 True。

例：

print(bool())       # 输出: False，未提供参数，返回 False

print(bool(0))      # 输出: False，0 是假值

print(bool([]))     # 输出: False，空列表是假值

print(bool("hello"))# 输出: True，非空字符串是真值

print(bool(42))     # 输出: True，非零数字是真值

需要注意的是

虽然 bool() 函数可以用于将任何值转换为布尔值，但在 Python 中的条件表达式中，会隐式调用 bool() 函数来判断条件的真假。例如，在 if 语句中，如果条件为真，则执行 if 语句块中的代码；否则，执行 else 语句块中的代码。

通过 bool() 函数，你可以轻松地将任何数据类型转换为一个布尔值，这在编写条件逻辑时非常有用。

2、int([x], base=10)：将一个数值或字符串转换为十进制整数

x：要转换为整数的值。可以是数值型（如整数、浮点数）或字符串型。

base：可选参数，用于指定转换的进制。默认为 10。如果 x 是字符串，那么 base 表示字符串所表示的进制。

参数为空时输出0。

例：

print(int('10'))           # 输出: 10，将字符串 '10' 转换为十进制整数

print(int('10', 2))        # 输出: 2，将二进制字符串 '10' 转换为十进制整数

print(int('10', 16))       # 输出: 16，将十六进制字符串 '10' 转换为十进制整数

print(int(3.14))           # 输出: 3，将浮点数 3.14 转换为整数，截断小数部分

print(int(-3.14))          # 输出: -3，将负浮点数 -3.14 转换为整数，截断小数部分

print(int('10', 8))        # 输出: 8，将八进制字符串 '10' 转换为十进制整数

print(int('0b10', 0))      # 输出: 2，将二进制字符串 '0b10' 转换为十进制整数，根据前缀自动识别进制

需要注意的是

1. 如果 x 是浮点数，int() 函数会将其向零取整（即截断小数部分）。
2. 如果 x 是字符串，那么字符串必须符合整数的表示方式，否则会抛出 ValueError 异常。
3. x不能是复数，如complex_num = 3 + 4j，否则引发TypeError异常。

3、float([x])：将一个数值或字符串转换为浮点数

float() 是一个内置函数，用于将一个数值或数值表示的字符串转换为一个浮点数。

如果参数已经是一个浮点数或整数，那么float() 函数将返回相同的数值，只是类型变为浮点数。

如果参数是一个字符串，那么该字符串必须表示一个有效的浮点数，否则将引发 ValueError 异常。

参数：

x：要转换为浮点数的值。

x可以是数值型（如整数、浮点数）或字符串型。这个字符串可以包含小数点、指数符号（e 或 E）以及正负号。

例1：将数值转换为浮点数

# 将整数转换为浮点数  

num_int = 10  

num_float = float(num_int)  

print(num_float)  # 输出: 10.0  

print(type(num_float))  # 输出: <class 'float'>  

  

# 将浮点数转换为浮点数（实际上不会改变数值，但会改变类型）  

num_float_original = 3.14  

num_float_converted = float(num_float_original)  

print(num_float_converted)  # 输出: 3.14  

print(type(num_float_converted))  # 输出: <class 'float'>

例2：将字符串转换为浮点数

# 字符串转换为浮点数  

str_num = "3.14"  

float_num = float(str_num)  

print(float_num)  # 输出: 3.14  

  

# 带有正负号的字符串也可以转换  

positive_str = "+42.0"  

negative_str = "-100.5"  

  

positive_float = float(positive_str)  

negative_float = float(negative_str)  

  

print(positive_float)  # 输出: 42.0  

print(negative_float)  # 输出: -100.5  

  

# 带有指数的字符串也可以转换  

exponential_str = "1.23e-4"  

exponential_float = float(exponential_str)  

print(exponential_float)  # 输出: 0.000123

注意事项

1. 当使用 float() 函数时，确保传入的字符串确实表示了一个有效的浮点数，否则将会引发 ValueError 异常。
2. 对于已经是浮点数或整数的参数，float() 函数不会改变其值，但会返回一个新的浮点数对象。
3. 转换时，如果字符串表示的数值超出了浮点数能够表示的范围，将会引发 OverflowError 异常。

4、complex([a=0],[b=0j])：创建一个复数

函数用于创建一个复数。它可以接受两个参数，分别是实部和虚部，也可以接受一个字符串参数，表示复数的表达式。

两个参数：

a：第一个参数是复数的实部。

b：第二个参数是复数的虚部。

示例：

# 创建一个复数对象，实部为3，虚部为0

c1 = complex(3)

print(c1)  # 输出: (3+0j)

# 创建一个复数对象，实部为1，虚部为2

c2 = complex(1, 2)

print(c2)  # 输出: (1+2j)

# 也可以通过字符串创建复数对象

c3 = complex('5-6j')

print(c3)  # 输出: (5-6j)

# 创建一个复数，实部为1，虚部为0

c3 = complex(1+0j)  

print(c3)  # 输出：(1+0j)

复数操作

创建复数后，你可以像操作其他数值类型一样对其进行操作。例如，可以进行加法、减法、乘法、除法等。

例：

c1 = complex(1, 2)  

c2 = complex(3, 4)  

  

print(c1 + c2)       # 输出: (4+6j)  

print(c1 - c2)       # 输出: (-2-2j)  

print(c1 * c2)       # 输出: (-5+10j)  

print(c1 / c2)       # 输出: (0.44+0.08j)

print(c1 ** 2)       # 输出: (-3+4j)

此外，Python的复数还支持一些特殊方法，如共轭（conjugate()）、模（abs() 或 magnitude()）、角度（angle() 或 phase()）等。

例：

c = complex(1, 2)  

print(c.conjugate())    # 输出: (1-2j)  

print(abs(c))           # 输出: 2.23606797749979  

print(c.real)           # 输出: 1.0  

print(c.imag)           # 输出: 2.0

5、str(object='')：将对象转换为字符串

str()函数接受一个可选的参数object，该参数可以是任何对象。如果不提供参数，则返回一个空字符串。

这个函数可以接受多种类型的参数，包括数字、列表、元组、字典、其他对象等，并将它们转换为它们的字符串表示形式。

如果参数是其他对象，str() 函数会尝试调用该对象的 __str__() 方法来获取其字符串表示。

例1：将数字转换为字符串类型

num = 123  

str_num = str(num)  

print(str_num)  # 输出: '123'  

  

float_num = 3.14  

str_float_num = str(float_num)  

print(str_float_num)  # 输出: '3.14'  

  

complex_num = complex(1, 2)  

str_complex_num = str(complex_num)  

print(str_complex_num)  # 输出: '(1+2j)'

另外，如果对象具有__str__()方法，则str()函数将调用该方法以生成其字符串表示形式。这在自定义类中很有用，可以自定义对象的字符串表示形式。

例2：将列表转换为字符串

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

str_list = str(my_list)  

print(type(str_list),str_list)  # 输出:<class 'str'> [1, 2, 3, 4, 5]

例3：将元组转换为字符串

my_tuple = (1, 2, 3, 4, 5)  

str_tuple = str(my_tuple)  

print(type(str_tuple),str_tuple)  # 输出: <class 'str'> (1, 2, 3, 4, 5)

例4：将字典转换为字符串

my_dict = {'a': 1, 'b': 2, 'c': 3}  

str_dict = str(my_dict)  

print(str_dict)  # 输出: "{'a': 1, 'b': 2, 'c': 3}"

例5：将自定义对象转换为字符串

如果你有一个自定义的对象，并且你想定义它如何转换为字符串，你可以在你的类中实现 __str__() 方法。

class Person:  

    def __init__(self, name, age):  

        self.name = name  

        self.age = age  

  

    def __str__(self):  

        return f"Person(name={self.name}, age={self.age})"  

  

person = Person("Alice", 30)  

str_person = str(person)  

print(str_person)  # 输出: Person(name=Alice, age=30)

注意事项

当使用 str() 函数转换对象时，它通常调用该对象的 __str__() 方法。这意味着如果你尝试转换一个没有实现 __str__() 方法的对象，Python会提供一个默认的字符串表示，但这可能不是你想要的。

对于复杂的数据结构，如嵌套列表或字典，str() 函数会递归地转换每个元素，生成一个易于阅读的字符串表示。

如果你想控制如何将对象转换为字符串，你应该在你的类中实现 __str__() 方法。这个方法应该返回一个字符串，描述了你的对象的状态。

6、bytearray([source[, encoding[, errors]]])：创建一个可变的字节数组

bytearray() 是 Python 的内置函数，用于创建一个可变的字节数组。字节数组是一个序列，其中包含范围在 0 <= x < 256 的整数，这些整数表示字节。

参数

source：可选参数，可以是以下几种类型之一：

一个字节对象，例如从文件或网络读取的原始字节。

一个字节数组。

一个字符串，此时需要指定 encoding 参数来指定字符串的编码方式。

一个可迭代的整数序列，其中每个整数都在 0-255 范围内。

encoding：可选参数，当 source 是字符串时，此参数指定了字符串的编码方式。默认是 'utf-8'。

errors：可选参数，当 source 是字符串且编码/解码过程中遇到错误时，此参数定义了错误处理方式。默认是 'strict'，表示抛出异常。

bytearray()函数返回一个新的可变字节数组对象，可以像列表一样进行修改，包括修改元素值、添加元素、删除元素等操作。这使得它在需要动态修改字节数据时非常有用。

用法

1：不带参数，创建一个空的数组

ba = bytearray()  

print(ba)  # 输出: bytearray(b'')

2：从字节对象创建

b = b'hello'  

ba = bytearray(b)  

print(ba)  # 输出: bytearray(b'hello')

3：从字符串创建

s = 'hello'  

ba = bytearray(s, 'utf-8')  

print(ba)  # 输出: bytearray(b'hello')

4：从整数序列创建

numbers = [72, 101, 108, 108, 111]  # ASCII values for 'hello'  

ba = bytearray(numbers)  

print(ba)  # 输出: bytearray(b'hello')

注意事项

字节数组通常用于低级别的数据处理，例如网络通信或文件处理，其中直接操作字节是必要的。

与字节数组相对的是不可变的 bytes 类型，你不能修改 bytes 对象的内容。如果你需要一个可以修改的字节序列，应该使用 bytearray。

bytearray 实现了序列协议（例如，它支持索引和切片操作），因此你可以像处理列表或字符串那样处理它。

7、bytes([source[, encoding[, errors]]])：创建一个不可变的字节对象

字节对象是一个“字节数组”，它用 8 位二进制数字来表示数据。与 bytearray 不同，bytes 对象是不可变的，一旦创建就不能修改。

参数

source：可选参数，可以是以下几种类型之一：

一个整数，表示要创建的字节对象的长度。

一个字节对象，用于复制。

一个字节数组，用于复制。

一个可迭代的整数序列，其中每个整数都在 0-255 范围内，用于初始化字节对象。

一个字符串，此时需要指定 encoding 参数来指定字符串的编码方式。

encoding：可选参数，当 source 是字符串时，此参数指定了字符串的编码方式。默认是 'utf-8'。

errors：可选参数，当 source 是字符串且编码/解码过程中遇到错误时，此参数定义了错误处理方式。默认是 'strict'。

用法

1. 从整数创建

创建一个指定长度的字节对象，所有字节的初始值都是 0。

b = bytes(5)  

print(b)  # 输出: b'\x00\x00\x00\x00\x00'

2. 从字节对象或字节数组复制

original_bytes = b'hello'  

copied_bytes = bytes(original_bytes)  

print(copied_bytes)  # 输出: b'hello'

3. 从整数序列创建

numbers = [72, 101, 108, 108, 111]  # ASCII values for 'hello'  

bytes_obj = bytes(numbers)  

print(bytes_obj)  # 输出: b'hello'

4. 从字符串创建

s = 'hello'  

bytes_obj = bytes(s, 'utf-8')  

print(bytes_obj)  # 输出: b'hello'

5.尝试修改一个 bytes 对象会导致 TypeError  

# b3[0] = 87  # 这将引发错误:TypeError: 'bytes' object does not support item assignment

  

6.可以通过索引和切片访问 bytes 对象的内容  

print(b3[0])  # 输出: 119，这是 'w' 的 ASCII 值  

print(b3[1:4])  # 输出: b'orl'

注意事项

1. bytes 对象是不可变的，一旦创建就不能修改。如果你需要一个可以修改的字节序列，应该使用 bytearray。
2. bytes 对象通常用于需要二进制数据表示的场合，如文件读写、网络通信等。
3. 当你需要将字符串转换为二进制数据时，必须指定一个编码方式（如 'utf-8'），因为字符串本身是文本数据，而二进制数据是另一种表示方式。
4. bytes 对象支持常见的序列操作，如索引、切片等，但不支持修改操作，如赋值。

8、memoryview(obj)：创建内存视图对象

在Python中，memoryview 是一个内置类，它提供了一个对底层字节数据的低级别、高效的视图。使用 memoryview 可以让你在不复制数据的情况下访问和修改原始字节序列。这对于处理大型数据块（如数组、图像或网络数据）特别有用，因为它可以减少内存使用和复制操作。

参数

obj：可以是任何实现了缓冲区协议的对象，如字节串（bytes）、字节数组（bytearray）、数组（array）等可缓冲类型对象。

返回值：

返回一个内存视图对象，可以访问 obj 对象的内存，但不复制数据。

用法

1、创建 memoryview 对象

# 从字节串创建  

mv_bytes = memoryview(b'hello')  

  

# 从字节数组创建  

ba = bytearray(b'world')  

mv_bytearray = memoryview(ba)  

  

# 从数组创建  

import array  

arr = array.array('i', [1, 2, 3, 4])  

mv_array = memoryview(arr)

2、访问和修改数据

memoryview 支持切片操作，可以像列表或数组一样访问和修改元素。

# 访问元素  

print(mv_bytes[0])  # 输出: 104 (ASCII码中'h'的值)  

  

# 修改元素  

mv_bytearray[0] = ord('H')  

print(ba)  # 输出: bytearray(b'Hello')  

  

# 切片操作  

print(mv_array[1:3])  # 输出: <memory at 0x000001A7D25DEC80>

3、将内存视图对象转换为字节序列并打印

# 创建一个字节对象

data = b'Hello, world!'

# 创建内存视图对象

mv = memoryview(data)

# 将内存视图对象转换为字节序列并打印

print(mv[1:6].tobytes())  # 输出：b'ello,'

4、属性

cast(type, new_flags=0): 创建一个新的 memoryview，其元素类型已更改。

readonly: 一个只读属性，指示 memoryview 是否是只读的。

shape（只读）: 如果数据具有形状（如多维数组），则返回形状。

strides（只读）: 如果数据具有步幅（如多维数组），则返回步幅。

suboffsets: 如果数据具有子偏移（如嵌套数组），则返回子偏移。

9、ord(c)：返回一个字符的Unicode码点

Unicode 是一种字符编码标准，它允许你为每一个字符（不仅仅是字母，还包括符号、数字等）分配一个唯一的数字，这个数字就是码点。

参数：

c：一个字符（长度为1的字符串）

返回值：

返回一个整数，表示字符 c 的 Unicode 码点。

用法详解

ord() 函数非常简单，只需要传入一个字符（长度为 1 的字符串），它就会返回这个字符的 Unicode 码点。

# 示例  

  

# 获取字符 'A' 的 Unicode 码点  

code_point = ord('A')  

print(code_point)  # 输出：65  

  

# 获取字符 '中' 的 Unicode 码点  

code_point_zh = ord('中')  

print(code_point_zh)  # 输出：20013

注意

ord() 函数只能接受长度为 1 的字符串作为参数。如果你尝试传入一个长度不为 1 的字符串，Python 会抛出一个 TypeError。

另外，ord() 函数返回的码点是基于 Unicode 的，所以不同的字符集（如 ASCII、UTF-8 等）可能会有不同的码点值。例如，在 ASCII 中，大写字母 'A' 的码点是 65，而在 Unicode 中也是 65。但对于一些只在 Unicode 中存在的字符（如中文字符），它们的码点在 ASCII 中是没有对应的值的。

10、chr(i)：将Unicode码点转换为对应的字符。

chr() 函数接受一个整数（即 Unicode 码点）作为参数，并返回与该整数对应的字符。

参数

i：一个介于 0 和 1,114,111（包含）之间的整数，代表 Unicode 码点。超出这个范围的整数会导致 ValueError 异常。

返回值

返回一个字符，该字符的 Unicode 码点等于传入的整数 i。

用法详解

chr() 函数非常直接，只需要传入一个有效的 Unicode 码点，它就会返回对应的字符。

# 示例  

  

# 获取 Unicode 码点 65 对应的字符  

character = chr(65)  

print(character)  # 输出：A  

  

# 获取 Unicode 码点 20013 对应的字符  

character_zh = chr(20013)  

print(character_zh)  # 输出：中

注意：

如果传入的整数不在有效的 Unicode 码点范围内，chr() 函数会抛出一个 ValueError 异常。

11、bin(x)：将整数转换为其二进制字符串表示形式

这个函数返回一个字符串，表示该整数的二进制表示。

参数

x：一个整数，可以是正数、负数或零。

返回值

返回一个字符串，表示整数 x 的二进制表示。这个字符串以 "0b" 或 "0B" 开头，以指示它是一个二进制字面量。

用法详解

bin() 函数将整数转换为二进制字符串。对于正数，它返回该数的二进制表示形式；对于负数，它返回该数的补码形式的二进制表示。

# 示例  

  

# 将正整数转换为二进制字符串  

binary_representation = bin(10)  

print(binary_representation)  # 输出：0b1010  

  

# 将负整数转换为二进制字符串（补码形式）  

binary_representation_negative = bin(-10)  

print(binary_representation_negative)  # 输出：-0b1010  

  

# 将零转换为二进制字符串  

binary_representation_zero = bin(0)  

print(binary_representation_zero)  # 输出：0b0

注意：

bin() 函数只能接受整数作为参数。如果你尝试传入一个浮点数或非整数类型，Python 会抛出一个 TypeError 异常。

12、oct(x)：将整数转换为其八进制字符串表示形式

这个函数返回一个字符串，表示该整数的八进制（octal）表示。

参数

x：一个整数，可以是正数、负数或零。

返回值

返回一个字符串，表示整数 x 的八进制表示。这个字符串以 "0o" 或 "0O" 开头，以指示它是一个八进制字面量。

用法详解

oct() 函数将整数转换为八进制字符串。对于正数，它返回该数的八进制表示形式；对于负数，它返回该数的补码形式的八进制表示。

# 示例  

  

# 将正整数转换为八进制字符串  

octal_representation = oct(10)  

print(octal_representation)  # 输出：0o12  

  

# 将负整数转换为八进制字符串（补码形式）  

octal_representation_negative = oct(-10)  

print(octal_representation_negative)  # 输出：-0o12  

  

# 将零转换为八进制字符串  

octal_representation_zero = oct(0)  

print(octal_representation_zero)  # 输出：0o0

注意：

oct() 函数只能接受整数作为参数。如果你尝试传入一个浮点数或非整数类型，Python 会抛出一个 TypeError 异常。

13、hex(x)：将整数转换为16进制

hex() 函数是 Python 的内置函数，用于将整数转换为其十六进制（hexadecimal）字符串表示形式。这个函数返回一个字符串，表示该整数的十六进制表示。

参数

x：一个整数，可以是正数、负数或零。

返回值

返回一个字符串，表示整数 x 的十六进制表示。这个字符串以 "0x" 或 "0X" 开头，以指示它是一个十六进制字面量。

用法详解

hex() 函数将整数转换为十六进制字符串。对于正数，它返回该数的十六进制表示形式；对于负数，它返回该数的补码形式的十六进制表示。

# 示例  

  

# 将正整数转换为十六进制字符串  

hexadecimal_representation = hex(255)  

print(hexadecimal_representation)  # 输出：0xff  

  

# 将负整数转换为十六进制字符串（补码形式）  

hexadecimal_representation_negative = hex(-255)  

print(hexadecimal_representation_negative)  # 输出：-0xff  

  

# 将零转换为十六进制字符串  

hexadecimal_representation_zero = hex(0)  

print(hexadecimal_representation_zero)  # 输出：0x0

hex() 函数只能接受整数作为参数。如果你尝试传入一个浮点数或非整数类型，Python 会抛出一个 TypeError 异常。

14、tuple(iterable)：创建元组或将其他可迭代对象转换为元组。

元组也可以使用圆括号包围元素，元素之间用逗号分隔的方式创建。如a=(1,2,3,'a','b')。

用圆括号创建元组时，如元组只有一个元素，需要在该元素后面添加一个逗号，如b=(1,)。

参数：

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

返回值：

返回一个新的元组，包含可迭代对象中的元素。

访问元组元素

可以通过索引来访问元组中的元素，索引从 0 开始。

例：

# 创建元组

t1 = tuple([1, 2, 3])

print(t1)  # 输出: (1, 2, 3)

# 将字符串转换为元组

t2 = tuple("hello")

print(t2)  # 输出: ('h', 'e', 'l', 'l', 'o')

# 使用 tuple() 函数复制其他可迭代对象

t3 = tuple(range(5))

print(t3)  # 输出: (0, 1, 2, 3, 4)

# 使用索引输出元素

print(t3[1])    # 输出：1

元组操作

由于元组是不可变的，因此不能对元组进行增加、删除或修改元素的操作。但可以进行一些其他操作，如连接、重复、切片等。

# 连接两个元组  

t1 = (1, 2, 3)  

t2 = (4, 5, 6)  

t3 &#