数据类型转换篇（二）

7.11 float()

float() 是 Python 的内置函数，用于将一个数值或数值表示的字符串转换成浮点数（floating point number）。如果转换失败，它会引发一个 ValueError。

以下是一些使用 float() 函数的例子：

# 将整数转换为浮点数
num = 10
float_num = float(num)
print(float_num)  # 输出: 10.0# 将字符串转换为浮点数
str_num = "3.14"
float_num = float(str_num)
print(float_num)  # 输出: 3.14# 尝试将非数值字符串转换为浮点数会引发 ValueError
try:float_num = float("hello")
except ValueError as e:print(e)  # 输出: could not convert string to float: 'hello'# 尝试将空字符串转换为浮点数也会引发 ValueError
try:float_num = float("")
except ValueError as e:print(e)  # 输出: could not convert string to float: ''# 尝试将非数字字符组成的字符串转换为浮点数也会失败
try:float_num = float("123abc")
except ValueError as e:print(e)  # 输出: could not convert string to float: '123abc'

在上面的例子中，float() 函数成功地将整数和表示浮点数的字符串转换成了浮点数。然而，当尝试将不能表示为浮点数的字符串（如包含非数字字符的字符串或空字符串）转换时，它会抛出 ValueError 异常。

在处理用户输入或从外部数据源获取数据时，通常需要先验证输入是否可以安全地转换为浮点数，以避免程序因异常而中断。这通常通过捕获 ValueError 异常来实现。

7.12 hex()

hex() 是 Python 的内置函数，用于将一个整数转换为其十六进制（hexadecimal）表示的字符串。十六进制是一种基数为 16 的数制系统，它使用 0-9 的十进制数字以及 A-F（或小写 a-f）来表示值。

hex() 函数返回一个字符串，其中包含输入整数的十六进制表示，前缀为 “0x”，以表明它是一个十六进制数。

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

# 将整数转换为十六进制字符串
num = 255
hex_num = hex(num)
print(hex_num)  # 输出: '0xff'# 负数也被转换为十六进制
neg_num = -42
hex_neg_num = hex(neg_num)
print(hex_neg_num)  # 输出: '-0x2a'# 尝试将非整数转换为十六进制会引发 TypeError
try:hex(3.14)
except TypeError as e:print(e)  # 输出: 'an integer is required (got type float instead)'

在这个例子中，hex() 函数成功地将整数 255 转换为了十六进制的表示 “0xff”，而负数 -42 也被转换成了 “-0x2a”。尝试将浮点数 3.14 转换为十六进制会引发 TypeError，因为 hex() 函数要求输入必须是一个整数。

在编程中，十六进制通常用于表示内存地址、机器码和其他需要紧凑表示的数字，因为十六进制比二进制更容易阅读和书写。

7.13 int()

int() 是 Python 的内置函数，用于将一个数值或数值表示的字符串转换成整数（integer）。如果转换失败，它会引发一个 ValueError。

以下是一些使用 int() 函数的例子：

# 将浮点数转换为整数（截断小数部分）
num = 3.14
int_num = int(num)
print(int_num)  # 输出: 3# 将字符串转换为整数
str_num = "123"
int_num = int(str_num)
print(int_num)  # 输出: 123# 字符串表示的负数也可以转换
str_neg_num = "-42"
int_neg_num = int(str_neg_num)
print(int_neg_num)  # 输出: -42# 尝试将非数值字符串转换为整数会引发 ValueError
try:int_num = int("hello")
except ValueError as e:print(e)  # 输出: invalid literal for int() with base 10: 'hello'# 尝试将空字符串转换为整数也会引发 ValueError
try:int_num = int("")
except ValueError as e:print(e)  # 输出: invalid literal for int() with base 10: ''# 使用不同的基数（base）转换字符串为整数
str_num = "1010"
int_num_binary = int(str_num, 2)  # 二进制转换为十进制
print(int_num_binary)  # 输出: 10str_num = "A"
int_num_hex = int(str_num, 16)  # 十六进制转换为十进制
print(int_num_hex)  # 输出: 10

在上面的例子中，int() 函数成功地将浮点数和表示整数的字符串转换成了整数。它还允许你指定一个基数（base），用于将字符串表示的数值按照不同的进制转换为十进制整数。如果不指定基数，则默认使用十进制。

当尝试将不能表示为整数的字符串（如包含非数字字符的字符串或空字符串）转换时，int() 函数会抛出 ValueError 异常。

7.14 list()

list() 是 Python 的内置函数，用于将一个可迭代对象（如字符串、元组、集合或其他迭代器）转换成一个列表（list）。如果传递给 list() 的不是一个可迭代对象，它会引发一个 TypeError。

以下是一些使用 list() 函数的例子：

# 将字符串转换为列表，每个字符成为列表的一个元素
str_val = "hello"
list_val = list(str_val)
print(list_val)  # 输出: ['h', 'e', 'l', 'l', 'o']# 将元组转换为列表
tuple_val = (1, 2, 3)
list_val = list(tuple_val)
print(list_val)  # 输出: [1, 2, 3]# 将集合转换为列表
set_val = {1, 2, 3}
list_val = list(set_val)
print(list_val)  # 输出可能是 [1, 2, 3]，但顺序可能不同，因为集合是无序的# 将字典转换为列表，结果将只包含字典的键
dict_val = {'a': 1, 'b': 2, 'c': 3}
list_val = list(dict_val)
print(list_val)  # 输出: ['a', 'b', 'c']# 尝试将整数转换为列表会引发 TypeError
try:list_val = list(42)
except TypeError as e:print(e)  # 输出: 'int' object is not iterable# 使用 range 函数和 list 函数创建一个数字列表
list_val = list(range(5))
print(list_val)  # 输出: [0, 1, 2, 3, 4]

在上面的例子中，list() 函数将不同类型的可迭代对象转换成了列表。需要注意的是，字典转换为列表时，结果只包含字典的键，而不包含值。此外，尝试将不可迭代的对象（如整数）转换为列表会引发 TypeError。

list() 函数在需要将其他数据结构转换为列表时非常有用，因为它提供了一个简洁的方法来创建列表。

7.15 oct()

oct() 是 Python 的内置函数，用于将一个整数转换为其八进制（octal）表示的字符串。八进制是一种基数为 8 的数制系统，它使用 0-7 的数字来表示值。

oct() 函数返回一个字符串，其中包含输入整数的八进制表示，前缀为 “0o”，以表明它是一个八进制数。

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

# 将整数转换为八进制字符串
num = 255
oct_num = oct(num)
print(oct_num)  # 输出: '0o377'# 负数也被转换为八进制
neg_num = -42
oct_neg_num = oct(neg_num)
print(oct_neg_num)  # 输出: '-0o52'# 尝试将非整数转换为八进制会引发 TypeError
try:oct(3.14)
except TypeError as e:print(e)  # 输出: 'an integer is required (got type float instead)'# 使用 oct() 函数和 int() 函数进行八进制和十进制的转换
oct_str = "0o10"
int_num = int(oct_str, 8)
print(int_num)  # 输出: 8# 反向转换回八进制字符串
oct_num_again = oct(int_num)
print(oct_num_again)  # 输出: '0o10'

在这个例子中，oct() 函数成功地将整数 255 转换为了八进制的表示 “0o377”，而负数 -42 也被转换成了 “-0o52”。和 hex() 函数一样，oct() 函数也只接受整数作为输入。

八进制在编程中不如十六进制常见，但在某些情况下，如表示系统资源或文件权限时，八进制仍然是有用的。

7.16 ord()

ord() 是 Python 的内置函数，用于返回一个字符的 Unicode 码点（即其在 Unicode 表中的整数值）。这个函数只对单个字符有效，如果传递给它一个字符串（包含多个字符），它会引发 TypeError。

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

# 获取字符 'a' 的 Unicode 码点
code_a = ord('a')
print(code_a)  # 输出: 97# 获取字符 '中' 的 Unicode 码点（这是一个中文字符）
code_zhong = ord('中')
print(code_zhong)  # 输出: 20013# 获取数字字符 '0' 的 Unicode 码点
code_zero = ord('0')
print(code_zero)  # 输出: 48# 尝试传递一个字符串给 ord() 会引发 TypeError
try:code_string = ord('hello')
except TypeError as e:print(e)  # 输出: 'ord() expected a character, but string of length 5 found'# 使用 ord() 和 chr() 函数进行字符和码点之间的转换
char = chr(97)
print(char)  # 输出: 'a'code = ord(char)
print(code)  # 输出: 97

在这个例子中，ord(‘a’) 返回 97，因为 a 在 ASCII 表中的位置是 97。对于非 ASCII 字符（如中文字符），ord() 返回的是该字符在 Unicode 表中的位置。

ord() 函数在处理字符编码时非常有用，尤其是在处理涉及多种字符集（如 ASCII、Unicode）的文本时。了解字符的 Unicode 码点可以帮助你理解文本在不同编码方式下的表示。

7.17 repr()

repr() 是 Python 的内置函数，用于返回一个对象的“官方”字符串表示。这个字符串表示通常可以作为一个有效的 Python 表达式，当使用 eval() 函数时，可以重新创建该对象。

repr() 的主要目的是提供一个明确且无歧义的对象的表示形式，以便于调试和记录。

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

# 对于简单的数据类型
num = 42
print(repr(num))  # 输出: '42'# 对于字符串
str_val = "hello"
print(repr(str_val))  # 输出: "'hello'"# 对于列表
list_val = [1, 2, 3]
print(repr(list_val))  # 输出: '[1, 2, 3]'# 对于元组
tuple_val = (1, 2, 3)
print(repr(tuple_val))  # 输出: '(1, 2, 3)'# 对于自定义对象
class MyClass:def __repr__(self):return "MyClass object"obj = MyClass()
print(repr(obj))  # 输出: 'MyClass object'# 使用 repr() 和 eval() 重新创建对象
expr = repr(list_val)
new_list = eval(expr)
print(new_list)  # 输出: [1, 2, 3]# 注意：eval() 的使用应当谨慎，因为它可以执行任何有效的 Python 代码，
# 这可能导致安全问题。

在这个例子中，repr() 函数返回了每个对象的字符串表示。对于简单数据类型（如整数、字符串），返回的字符串可以直接作为 Python 代码使用。对于复杂的数据类型（如列表、元组），返回的字符串包含数据结构的信息。

此外，对于自定义对象，可以通过定义 repr() 方法来指定其 repr() 的输出。这通常涉及到返回对象的类名和主要属性的字符串表示。

repr() 在调试和日志记录时非常有用，因为它提供了一个明确的方式来表示对象的状态。然而，请注意，repr() 的输出并不总是人类可读的，它主要是为了让 Python 能够理解并重新创建对象。

7.18 set()

set() 是 Python 的内置函数，用于创建一个无序且不包含重复元素的集合（set）。集合是一个数学上的概念，它表示一组对象的集合，其中的对象被称为集合的元素。在 Python 中，集合是一种可变的数据类型，它支持集合运算，如并集、交集、差集等。

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

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出: set()# 创建一个包含不同元素的集合
simple_set = set([1, 2, 2, 3, 4, 4, 5])
print(simple_set)  # 输出: {1, 2, 3, 4, 5}# 集合中的元素是唯一的，所以重复的元素会被自动去除# 使用花括号 {} 也可以创建集合
another_set = {6, 7, 8, 9}
print(another_set)  # 输出: {6, 7, 8, 9}# 从其他序列类型创建集合
list_to_set = set([1, 'a', 3.14])
print(list_to_set)  # 输出: {1, 'a', 3.14}# 集合支持集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}# 并集
union_set = set1.union(set2)
print(union_set)  # 输出: {1, 2, 3, 4, 5}# 交集
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {3}# 差集
difference_set = set1.difference(set2)
print(difference_set)  # 输出: {1, 2}

set() 函数可以接受一个可迭代对象（如列表、元组、字符串等）作为参数，并创建一个包含该可迭代对象中所有元素的集合。如果可迭代对象中包含重复的元素，set() 函数会自动去除它们，因为集合不允许有重复元素。

除了直接调用 set() 函数，还可以使用花括号 {} 来创建集合，但这仅适用于直接列出集合元素的情况，不能用于从其他可迭代对象创建集合。

集合是一种非常有用的数据结构，特别是在需要快速查找、删除或检查元素是否存在的情况下。由于集合是无序的，它们不支持索引操作，但支持成员资格测试（使用 in 关键字）以及集合运算（如并集、交集、差集等）。

7.19 str()

str() 是 Python 的内置函数，用于将给定的对象转换为字符串（string）表示形式。如果对象已经是一个字符串，那么 str() 将返回该对象本身。对于其他对象类型，str() 会尝试返回一个“人类可读”的字符串表示。

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

# 将整数转换为字符串
num = 123
str_num = str(num)
print(str_num)  # 输出: '123'# 将浮点数转换为字符串
float_num = 3.14159
str_float_num = str(float_num)
print(str_float_num)  # 输出: '3.14159'# 将布尔值转换为字符串
bool_val = True
str_bool = str(bool_val)
print(str_bool)  # 输出: 'True'# 将列表转换为字符串
list_val = [1, 2, 3]
str_list = str(list_val)
print(str_list)  # 输出: '[1, 2, 3]'# 将元组转换为字符串
tuple_val = (1, 2, 3)
str_tuple = str(tuple_val)
print(str_tuple)  # 输出: '(1, 2, 3)'# 将自定义对象转换为字符串
class MyClass:def __str__(self):return "MyClass object"obj = MyClass()
str_obj = str(obj)
print(str_obj)  # 输出: 'MyClass object'# 注意：如果自定义对象没有定义 __str__ 方法，str() 将调用 __repr__ 方法。

对于自定义对象，通常建议定义 str() 方法来提供一个人类可读的字符串表示。如果没有定义 str() 方法，str() 函数将回退到使用 repr() 方法来生成字符串表示，这通常是一个更精确但可能不易读的表示形式。

str() 函数在需要将非字符串对象用于字符串操作（如拼接、格式化）或输出到控制台时非常有用。它允许你以一种统一的方式处理不同类型的对象，并将它们转换为字符串以进行进一步处理。

7.20 tuple()

tuple() 是 Python 的内置函数，用于创建一个元组（tuple）。元组是一种不可变（immutable）的序列类型，它允许你存储一个有序的集合，但这个集合在创建后不能被修改（即不能添加、删除或更改元素）。

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

# 创建一个空元组
empty_tuple = tuple()
print(empty_Tuple)  # 输出: ()# 创建一个包含元素的元组
simple_Tuple = tuple([1, 2, 3, 4])
print(simple_Tuple)  # 输出: (1, 2, 3, 4)# 直接使用圆括号也可以创建元组
another_Tuple = (1, 2, 3, 4)
print(another_Tuple)  # 输出: (1, 2, 3, 4)# 元组可以包含不同类型的元素
mixed_Tuple = (1, 'a', 3.14)
print(mixed_Tuple)  # 输出: (1, 'a', 3.14)# 创建一个只有一个元素的元组时，需要加上逗号
singleton_Tuple = (42,)
print(singleton_Tuple)  # 输出: (42,)# 尝试修改元组会导致TypeError
# 这是因为元组是不可变的
try:simple_Tuple[0] = 5
except TypeError as e:print(e)  # 输出: 'tuple' object does not support item assignment

Tuple() 函数可以接受一个可迭代对象（如列表、字符串等）作为参数，并返回一个包含该可迭代对象中所有元素的元组。如果传入的参数本身就是一个元组，那么它会被原样返回。

由于元组是不可变的，所以它们在用于存储不应更改的数据集时非常有用。元组还常常被用作字典的键和集合的元素，因为它们的不可变性保证了唯一性和不变性。

需要注意的是，尽管元组是不可变的，但它们可以包含可变对象（如列表）作为元素。不过，即使这样，元组本身仍然是不可变的，意味着你不能添加、删除或更改元组中的元素，即使这些元素是可变的。