公共交通公司网站建设方案,包头网站作风建设年自评材料,北京门户企业网站建设,上海网站开发一对一培训价格要获取Python解释器中所有当前可用的内置函数和变量的完整列表，您可以在Python解释器中使用dir(__builtins__)命令。这将返回一个包含所有内置函数、异常和其他内置对象的列表。 分为10类 数学运算（7）： abs 绝对值divmod 商和余数max 最大min最小pow 指数幂round 取整sum 求… 要获取Python解释器中所有当前可用的内置函数和变量的完整列表，您可以在Python解释器中使用dir(__builtins__)命令。这将返回一个包含所有内置函数、异常和其他内置对象的列表。 分为10类 数学运算（7）： abs 绝对值divmod 商和余数max 最大min最小pow 指数幂round 取整sum 求和 类型转换（24）： bool 布尔值int 整数float 浮点数complex 复数str 字符串bytearray 字节数组bytes 不可变字节对象momeryview 内存视图对象ord 返回Unicode码点chr 转为字符bin 二进制oct 八进制hex 十六进制tuple 元组list 列表dict 字典set 集合frozenset 不可变集合enumerate 枚举range 序列iter 迭代器slice 切片对象super 调用父类object 对象 序列操作（8）： all 都为True值any 有一个为True值filter 返回迭代对象符合指定条件的值map 返回迭代对象用指定函数处理后的值next 从迭代器获取下一个元素reversed 反转顺序soted 排序zip 按顺序聚合多个迭代器 对象操作（7）： help 帮助信息dir 属性和方法id 唯一标识符hash 哈希值type 类型len 长度ascii 字符串形式 反射操作（8）： __import__ 动态导入模块isinstance 判断对象类型issubclass 判断是否是某个类的子类hasattr 判断属性存在getattr 获取属性值setattr 设置属性值delattr 删除属性值callable 判断对象是否可调用 变量操作（2）： 1、globals 当前域全局变量及值 2、locals 当前域局部变量及值 交互操作（2）： 1、print 输出信息 2、input 获取用户输入 文件操作（1）： 1、open 打开并获取文件对象 编译执行（5）： compile 编译字符串为代码对象eval 执行字符串表达式exec 执行字符串代码块repr 返回对象字符串表示（调试用）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' 转换为十进制整数，根据前缀自动识别进制 需要注意的是
如果x是浮点数，int()函数会将其向零取整（即截断小数部分）。如果x是字符串，那么字符串必须符合整数的表示方式，否则会抛出ValueError异常。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 注意事项
当使用float()函数时，确保传入的字符串确实表示了一个有效的浮点数，否则将会引发ValueError异常。对于已经是浮点数或整数的参数，float()函数不会改变其值，但会返回一个新的浮点数对象。转换时，如果字符串表示的数值超出了浮点数能够表示的范围，将会引发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' 注意事项
bytes对象是不可变的，一旦创建就不能修改。如果你需要一个可以修改的字节序列，应该使用bytearray。bytes对象通常用于需要二进制数据表示的场合，如文件读写、网络通信等。当你需要将字符串转换为二进制数据时，必须指定一个编码方式（如'utf-8'），因为字符串本身是文本数据，而二进制数据是另一种表示方式。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 #
