数据类型转换篇（一）

7.1 ascii()

ascii() 是 Python 的内置函数，用于将一个对象转换为其“ASCII”表示形式。具体来说，它返回一个字符串，该字符串包含对象的可打印表示形式，其中非ASCII字符被转义。

这个函数通常用于调试和日志记录，因为它提供了一种方式来查看对象的文本表示形式，即使该对象包含非ASCII字符。

下面是一些使用 ascii() 函数的示例：

# 字符串的ASCII表示
print(ascii('Hello, 世界!'))  # 输出: 'Hello, \\u4e16\\u754c!'

# 数字的ASCII表示
print(ascii(123))  # 输出: '123'

# 列表的ASCII表示
print(ascii([1, 'a', 2.3]))  # 输出: '[1, \\'a\\', 2.3]'

# 元组的ASCII表示
print(ascii((1, 'a', 2.3)))  # 输出: '(1, \\'a\\', 2.3)'

# 字典的ASCII表示
print(ascii({'name': 'Alice', 'age': 30}))  # 输出: "{'name': 'Alice', 'age': 30}"

在上面的例子中，你可以看到 ascii() 函数将非ASCII字符（如中文字符）转换为它们的Unicode转义序列（例如，\u4e16\u754c）。这对于在文本环境中表示非ASCII字符非常有用，尤其是当这些环境不支持直接显示这些字符时。

需要注意的是，ascii() 函数并不尝试将对象转换为有效的Python表达式，而是提供一个可读的、可打印的字符串表示。如果你需要得到一个可以重新评估为原始对象的表示，应该使用 repr() 函数。

7.2 bin()

bin() 是 Python 的内置函数，用于将一个整数转换为其二进制表示的字符串形式。这个函数返回一个字符串，其中包含表示给定整数的二进制数。

以下是 bin() 函数的一些使用示例：

# 将整数转换为二进制字符串
binary_representation = bin(10)
print(binary_representation)  # 输出: '0b1010'

# 带有更多位的整数
larger_binary = bin(123456)
print(larger_binary)  # 输出: '0b11110010000100000'

# 负数也被转换为二进制补码形式
negative_binary = bin(-15)
print(negative_binary)  # 输出: '-0b11110001'

# 尝试对非整数使用 bin() 会引发 TypeError
try:
    not_integer = bin(3.14)
    print(not_integer)
except TypeError as e:
    print("Error:", e)  # 输出: Error: 'bin() arg 1 must be an integer'

在上面的例子中，bin(10) 将整数 10 转换为其二进制表示，即 ‘0b1010’。注意返回的字符串以 ‘0b’ 开头，这表示它是一个二进制数。对于负数，bin() 函数返回的是该数的二进制补码形式。

二进制补码是一种表示负整数的方法，在计算机科学中非常常见。对于给定的负整数，其补码是通过将该整数的绝对值的二进制表示取反（即每位上的 0 变为 1，1 变为 0），然后加 1 来计算的。

需要注意的是，bin() 函数只能用于整数。如果你尝试对非整数使用它，将会引发 TypeError 异常。

7.3 bool()

bool() 是 Python 的内置函数，用于将给定的对象转换为一个布尔值（True 或 False）。在 Python 中，布尔值是两种可能的状态之一，通常用于条件判断、循环控制和其他逻辑操作。

bool() 函数的行为取决于传递给它的参数的类型和值：

• 数字类型：非零数值被转换为 True，0（零）被转换为 False。
• 字符串类型：非空字符串被转换为 True，空字符串 ‘’ 被转换为 False。
• 列表、元组、字典等容器类型：非空容器被转换为 True，空容器（如 [], (), {}）被转换为 False。
• 对于自定义对象，如果定义了 bool() 方法，则调用该方法来确定对象的布尔值。如果没有定义 bool() 方法，但定义了 len() 方法，则对象被视为容器类型，并根据其长度来确定布尔值。如果既没有 bool() 也没有 len()，则引发 TypeError。

下面是一些使用 bool() 函数的例子：

# 数字的布尔值
print(bool(42))     # 输出: True
print(bool(0))      # 输出: False

# 字符串的布尔值
print(bool("hello")) # 输出: True
print(bool(""))      # 输出: False

# 容器的布尔值
print(bool([1, 2, 3]))   # 输出: True
print(bool([]))          # 输出: False
print(bool({"key": "value"})) # 输出: True
print(bool({}))          # 输出: False

# 自定义对象的布尔值（需要定义 __bool__ 方法）
class MyClass:
    def __bool__(self):
        return True

obj = MyClass()
print(bool(obj))  # 输出: True

# 没有定义 __bool__ 方法的自定义对象
class AnotherClass:
    pass

another_obj = AnotherClass()
try:
    print(bool(another_obj))
except TypeError as e:
    print("Error:", e)  # 输出: Error: <__main__.AnotherClass object at 0x...> is not callable

在这个例子中，我们展示了不同类型的对象如何被 bool() 函数转换为布尔值。需要注意的是，对于自定义对象，如果没有定义适当的魔术方法（如 bool() 或 len()），则不能直接使用 bool() 函数。

7.4 bytearray()

bytearray() 是 Python 的内置函数，用于创建一个可变的字节数组对象。字节数组是一个序列类型，它包含范围为 0 <= x < 256 的整数，这些整数表示 8 位字节。字节数组在内部使用数组存储，因此它可以比普通的字节字符串（bytes）更高效地进行修改。

以下是 bytearray() 函数的一些使用示例：

# 创建一个空的字节数组
ba = bytearray()
print(ba)  # 输出: bytearray(b'')

# 创建一个包含一些字节的字节数组
ba = bytearray([65, 66, 67])
print(ba)  # 输出: bytearray(b'ABC')

# 从字节字符串创建字节数组
bs = b'Hello'
ba = bytearray(bs)
print(ba)  # 输出: bytearray(b'Hello')

# 从字符串创建字节数组（需要指定编码）
s = 'Hello'
ba = bytearray(s, 'utf-8')
print(ba)  # 输出: bytearray(b'Hello')

# 通过迭代来创建字节数组
ba = bytearray(iter([65, 66, 67]))
print(ba)  # 输出: bytearray(b'ABC')

# 修改字节数组的内容
ba = bytearray(b'Hello')
ba[0] = ord('X')  # 使用 ord 函数将字符转换为 ASCII 值
print(ba)  # 输出: bytearray(b'Xello')

# 在字节数组中添加新内容
ba.append(ord('!'))
print(ba)  # 输出: bytearray(b'Xello!')

# 从字节数组中删除内容
del ba[1]
print(ba)  # 输出: bytearray(b'Xello')

在上面的例子中，bytearray() 函数可以接受多种参数类型来创建字节数组，包括一个整数列表、一个字节字符串、一个可迭代对象（产生整数的），或者一个字符串和字符编码。

一旦创建了字节数组，就可以像处理列表一样处理它，包括索引、切片、追加、删除等操作。这使得 bytearray 在需要频繁修改字节数据的情况下比 bytes 类型更加灵活和高效。

7.5 bytes()

bytes() 是 Python 的内置函数，用于创建字节对象。字节是不可变的序列，通常用于表示二进制数据。与字节数组 (bytearray) 不同，字节对象一旦创建就不能被修改。

bytes() 函数可以接受几种不同类型的参数来创建字节对象：

• 一个整数，表示要创建的字节对象的长度，并且生成包含空字节 (\x00) 的序列。
• 一个整数序列，其中的每个整数都在 0 到 255 的范围内，表示字节的值。
• 一个字节字符串，它将被复制到一个新的字节对象中。
• 一个可迭代的对象，产生在 0 到 255 范围内的整数，用于创建字节对象。

下面是一些使用 bytes() 函数的例子：

# 创建一个长度为 5 的字节对象，包含空字节
b = bytes(5)
print(b)  # 输出可能是: b'\x00\x00\x00\x00\x00'

# 创建一个包含特定值的字节对象
b = bytes([65, 66, 67])
print(b)  # 输出: b'ABC'

# 从字节字符串创建字节对象
s = b'Hello'
b = bytes(s)
print(b)  # 输出: b'Hello'

# 从整数序列创建字节对象
b = bytes([72, 101, 108, 108, 111])
print(b)  # 输出: b'Hello'

# 从可迭代对象创建字节对象
b = bytes(iter([72, 101, 108, 108, 111]))
print(b)  # 输出: b'Hello'

# 创建一个空字节对象
b = bytes()
print(b)  # 输出: b''

在上面的例子中，bytes() 函数被用来创建不同类型的字节对象。值得注意的是，当你传递一个整数给 bytes() 时，你创建的是一个包含该数量的空字节的字节对象。当你传递一个整数列表或其他可迭代对象时，列表中的每个整数都被视为一个字节，并用于创建字节对象。

由于字节是不可变的，所以一旦创建了一个字节对象，你就不能修改它包含的数据。如果你需要一个可以修改的字节序列，你应该使用 bytearray() 函数来创建一个字节数组对象。

7.6 chr()

chr() 是 Python 的内置函数，用于将整数（在 0 到 255 的范围内）转换为其对应的 ASCII 字符。ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是一种字符编码标准，它用 7 位或 8 位二进制数表示 128 或 256 种可能的字符。

下面是一些使用 chr() 函数的例子：

# 将 ASCII 值转换为对应的字符
char = chr(65)
print(char)  # 输出: A

# 转换其他 ASCII 值
print(chr(97))  # 输出: a
print(chr(32))  # 输出: 空格
print(chr(10))  # 输出: 换行符（在控制台可能不显示为可见字符）

# 超出范围的整数值会引发 ValueError
try:
    print(chr(256))
except ValueError as e:
    print("Error:", e)  # 输出: Error: chr() arg not in range(256)

# 使用 ord() 函数和 chr() 函数进行转换
original_char = 'A'
ascii_value = ord(original_char)
converted_char = chr(ascii_value)
print(converted_char)  # 输出: A

在这个例子中，chr(65) 将整数 65 转换为 ASCII 字符 ‘A’。类似地，chr(97) 将返回 ‘a’，因为 97 是小写字母 ‘a’ 的 ASCII 值。

值得注意的是，chr() 函数仅适用于 ASCII 字符集。对于更广泛的 Unicode 字符集，可以使用 chr() 的 Unicode 版本 unichr()（在 Python 2 中）或简单地使用 chr()（在 Python 3 中，因为 Python 3 默认支持 Unicode）。

此外，ord() 函数是 chr() 的逆操作，它接受一个字符并返回其对应的 ASCII 值。

7.8 complex()

complex() 是 Python 的内置函数，用于创建复数。复数是一个数学概念，可以表示为 a + bj，其中 a 和 b 是实数，j（或 i 在某些上下文中）是虚数单位，满足 j**2 = -1。

complex() 函数可以接受不同数量和类型的参数，以创建复数。以下是一些使用 complex() 的例子：

# 创建一个实数部分为 0，虚数部分为 1 的复数
c = complex(0, 1)
print(c)  # 输出: (0+1j)

# 创建一个实数部分为 4，虚数部分为 3 的复数
c = complex(4, 3)
print(c)  # 输出: (4+3j)

# 只传递一个参数时，该参数被视为复数的实数部分，虚数部分为 0
c = complex(4)
print(c)  # 输出: (4+0j)

# 从字符串创建复数，格式应为 'real+imagj' 或 'real+imagI'
c = complex('4+3j')
print(c)  # 输出: (4+3j)

# 从字符串创建复数，使用 'I' 作为虚数单位
c = complex('4+3I')
print(c)  # 输出: (4+3j)

# 使用两个字符串分别表示实部和虚部
c = complex('4', '3')
print(c)  # 输出: (4+3j)

# 复数也可以作为参数传递给 complex() 函数，它将返回相同的复数
c = complex(4+3j)
print(c)  # 输出: (4+3j)

除了创建复数，complex() 函数还可以用来将其他数据类型（如字符串、整数、浮点数等）转换为复数。当传递一个字符串给 complex() 时，该字符串应该遵循 ‘real[+imagj|imagI]’ 的格式，其中 real 是实部，imag 是虚部，[+imagj|imagI] 表示虚部可以带有符号，并且可以使用 j 或 I 作为虚数单位。

复数在数学、物理、工程和其他科学领域中有广泛应用，特别是在处理波动、交流电、量子力学等复杂问题时。Python 的 complex 类型提供了对这些复杂计算的支持。

7.9 dict()

dict() 是 Python 的内置函数，用于创建字典对象。字典是一种无序的键值对集合，其中每个键都是唯一的，并且与一个值相关联。

dict() 函数可以接受多种类型的参数来创建字典：

• 无参数调用 dict() 会创建一个空字典。
• 一个可迭代对象，如另一个字典、键值对的序列（例如列表的列表或元组的元组）或键值对的集合，其中每个元素都是一个包含两个元素的序列（例如列表或元组），第一个元素是键，第二个元素是值。
• 一系列关键字参数，其中每个参数名成为字典的键，参数值成为对应的值。

下面是一些使用 dict() 函数的例子：

# 创建一个空字典
d = dict()
print(d)  # 输出: {}

# 使用可迭代对象创建字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
print(d)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用键值对的序列创建字典
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用键值对的集合创建字典
d = dict({('a', 1), ('b', 2), ('c', 3)})
print(d)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用关键字参数创建字典
d = dict(a=1, b=2, c=3)
print(d)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 字典推导式也可以用来创建字典
d = {x: x**2 for x in range(3)}
print(d)  # 输出: {0: 0, 1: 1, 2: 4}

在上面的例子中，dict() 函数通过不同的方式创建了包含相同键值对的字典。

字典在 Python 中是一种非常有用的数据结构，因为它们允许你通过键快速查找、添加和删除值。字典的键必须是不可变的类型（如整数、浮点数、字符串或元组），而值可以是任何类型的数据。

7.10 eval()

eval() 是 Python 的内置函数，用于执行一个字符串表达式，并返回表达式的值。它基本上是一个内置的 Python 解释器，能够解析并执行传递给它的字符串。

使用 eval() 时要小心，因为它可以执行任何 Python 代码，这可能导致安全问题，特别是当执行的字符串来自不可信的来源（如用户输入或网络）时。恶意用户可能会尝试注入恶意代码来执行系统命令、访问敏感数据等。

下面是一些使用 eval() 的例子：

# 计算数学表达式
result = eval('3 + 4 * 2')
print(result)  # 输出: 11 (因为乘法优先级高于加法)

# 执行简单的变量赋值
x = 10
eval('y = x + 5')
print(y)  # 输出: 15

# 使用变量
x = 10
eval('print(x)')  # 输出: 10

# 执行更复杂的逻辑
eval('if 1 > 0: print("True")')  # 输出: True

尽管 eval() 在某些情况下很有用，但通常最好避免使用它，特别是当处理来自用户或不可信的输入时。更安全的方法是使用其他方法，如 ast.literal_eval()，它只能评估 Python 字面量结构（如列表、元组、数字、字符串和字典），而不能执行任意代码。

例如，使用 ast.literal_eval() 来安全地评估字符串表示的字典：

import ast

# 安全地评估一个字符串表示的字典
s = '{"key": "value"}'
dictionary = ast.literal_eval(s)
print(dictionary)  # 输出: {'key': 'value'}

# 尝试评估恶意输入时会引发异常
s = '__import__("os").system("rm -rf /")'
try:
    ast.literal_eval(s)
except (ValueError, SyntaxError):
    print("Invalid or malicious input detected.")  # 输出: Invalid or malicious input detected.

在这个例子中，ast.literal_eval() 尝试评估一个字符串表示的字典，但如果字符串包含恶意代码，它会引发异常，从而防止执行恶意代码。