数学运算（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 &#