隐式类型转换#

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

显式类型转换#

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int() 强制转换为整型：

一、知识回顾（读完直接做下面的实践题）#

1. 隐式类型转换：Python 自动完成——两种类型运算时往”更宽”的类型上靠（int + float → float），避免数据丢失；数字直接加字符串则会报 TypeError，Python 不会偷偷替你转
2. 显式类型转换：把类型名当函数用，写法是 目标类型(值)，常用的有 int()、float()、str()、bool()
3. 转整数 int(x)：int(2.8) 得 2（小数部分直接截断，不是四舍五入）、int("123") 得 123；但 int("3.14") 会报 ValueError——字符串得是纯整数写法，带小数点要先 float() 再 int()
4. 转浮点 float(x)：float(1) 得 1.0、float("3.14") 得 3.14、float("100") 得 100.0，整数字符串也能直接转
5. 转字符串 str(x)：任何类型都能转（str(123)、str(3.14)、str(True)）；只有转成字符串之后，才能用 + 和别的字符串拼接
6. 转布尔 bool(x)：0、0.0、""、[]、{}、None 这些”空/零”的值都是 False，其余为 True；注意非空字符串 "0"、"False" 也是 True
7. 序列互转：list(s) 转列表、tuple(s) 转元组、set(s) 转集合；字符串会被拆成一个个字符，集合本身无序，转成列表/元组的顺序不保证
8. 转集合 set() 顺带去重：set([1, 2, 2, 3, 3, 3]) 得 {1, 2, 3}，set("aabbbccc") 得 {'a', 'b', 'c'}
9. 转字典 dict()：用键值对序列创建，如 dict([("name", "小明"), ("age", 18)]) 得 {'name': '小明', 'age': 18}
10. 字符与数值、进制互转：chr(65) 得 'A'、ord('A') 得 65；hex(255) 得 '0xff'、oct(8) 得 '0o10'、bin() 同理；另外 eval("3 + 5 * 2") 得 13（把字符串当表达式算），repr(3.14) 得 '3.14'

二、裸写题#

• 2-1 隐式类型转换 创建文件 test_implicit.py，完成以下操作：

  • 创建变量 a = 10（整数）和 b = 3.14（浮点数）
  • 计算 c = a + b
  • 用 type() 打印 a、b、c 的类型
  • 观察结果，解释为什么 c 是浮点数

  批改（2026-09-28）：✅ 正确（a、b、c 类型实测 <class 'int'> <class 'float'> <class 'float'>；注释里也答出了”自动把整数转成浮点数，避免数据丢失”）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：两种不同类型直接相加时，Python 会自动往更宽的类型上靠，这一步不需要你写任何转换代码；用查看类型的函数逐个验证就行 二级 · 方法：两个变量直接用 + 相加；查看类型用内置函数 type(x) 三级 · 骨架：c = a ____ b / print(f"c = {c}, 类型: {____(c)}")

  参考答案（做完再点开）

  1
  # 2-1
  2
  a = 10
  3
  b = 3.14
  4
  c = a + b
  5
  
  6
  print(f"a = {a}, 类型: {type(a)}")
  7
  print(f"b = {b}, 类型: {type(b)}")
  8
  print(f"c = {c}, 类型: {type(c)}")
  9
  # 输出：
  10
  # a = 10, 类型: <class 'int'>
  11
  # b = 3.14, 类型: <class 'float'>
  12
  # c = 13.14, 类型: <class 'float'>
  13
  # 解释：Python 会自动将整数转换为浮点数，避免数据丢失

• 2-2 整数转换 创建文件 test_int.py，完成以下操作：

  • 将浮点数 3.14 转换为整数
  • 将字符串 "123" 转换为整数
  • 将字符串 "3.14" 转换为整数（观察是否报错）
  • 打印每个结果及其类型

  批改（2026-09-28）：⚠️ int(3.14)=3、int("123")=123、int(float("3.14"))=3 都对；但 int("3.14") 那行被注释掉了，没有实际跑出报错（去掉注释会得到 ValueError: invalid literal for int() with base 10: '3.14'），另外 print(a,b,d) 只打了值、没打印类型（题面要求”打印每个结果及其类型”）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：转整数就是把值交给”整数类型函数”；小数会直接被切掉小数部分，字符串里带小数点这个函数不认，会报错 二级 · 方法：int(x) 转整数；int(2.8) 截断成 2；字符串要先 float("3.14") 转成 3.14 再 int() 三级 · 骨架：a = ____(3.14) / b = int("____") / c = int(____("3.14"))

  参考答案（做完再点开）

  1
  # 2-2
  2
  a = int(3.14)
  3
  b = int("123")
  4
  # c = int("3.14")  # 这行会报错，因为不能直接将小数字符串转为整数
  5
  
  6
  print(f"int(3.14) = {a}, 类型: {type(a)}")  # 3, <class 'int'>
  7
  print(f"int('123') = {b}, 类型: {type(b)}")  # 123, <class 'int'>
  8
  # 如果要转换 "3.14"，需要先转为 float 再转 int：
  9
  c = int(float("3.14"))
  10
  print(f"int(float('3.14')) = {c}")  # 3

• 2-3 浮点数转换 创建文件 test_float.py，完成以下操作：

  • 将整数 100 转换为浮点数
  • 将字符串 "3.14" 转换为浮点数
  • 将字符串 "100" 转换为浮点数
  • 打印每个结果及其类型

  批改（2026-09-28）：⚠️ 第 3 项题面是 float("100")（字符串），你写成了 c = float(100)（整数），虽然结果都是 100.0，但没测到”字符串转浮点”这个点；另外 print(a, b, c) 只打印了值、没有打印类型（题面要求”打印每个结果及其类型”）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：转浮点也是”类型函数”套路，整数和小数字符串都能收；整数转出来会补上 .0 二级 · 方法：float(x)；float(100) → 100.0、float("3.14") → 3.14、float("100") → 100.0 三级 · 骨架：a = ____(100) / b = float("3.14") / c = float("____")

  参考答案（做完再点开）

  1
  # 2-3
  2
  a = float(100)
  3
  b = float("3.14")
  4
  c = float("100")
  5
  
  6
  print(f"float(100) = {a}, 类型: {type(a)}")    # 100.0, <class 'float'>
  7
  print(f"float('3.14') = {b}, 类型: {type(b)}")  # 3.14, <class 'float'>
  8
  print(f"float('100') = {c}, 类型: {type(c)}")   # 100.0, <class 'float'>

• 2-4 字符串转换 创建文件 test_str.py，完成以下操作：

  • 将整数 123 转换为字符串
  • 将浮点数 3.14 转换为字符串
  • 将布尔值 True 转换为字符串
  • 打印每个结果及其类型，并用 + 拼接字符串

  批改（2026-09-28）：✅ 正确（输出 123 <class 'str'> 3.14 <class 'str'> True <class 'str'>，用 + 拼接得到 1233.14True）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：任何类型都能变成字符串，转完类型都是字符串；只有都变成字符串之后，才能用加号拼接 二级 · 方法：str(x) 转字符串；转换后 a + b 得到拼接结果 三级 · 骨架：a = ____(123) / print(f"拼接: 数字是 {____}")

  参考答案（做完再点开）

  1
  # 2-4
  2
  a = str(123)
  3
  b = str(3.14)
  4
  c = str(True)
  5
  
  6
  print(f"str(123) = '{a}', 类型: {type(a)}")      # '123', <class 'str'>
  7
  print(f"str(3.14) = '{b}', 类型: {type(b)}")      # '3.14', <class 'str'>
  8
  print(f"str(True) = '{c}', 类型: {type(c)}")      # 'True', <class 'str'>
  9
  print(f"拼接: 数字是 {a}")  # 拼接: 数字是 123

• 2-5 布尔值转换 创建文件 test_bool.py，测试下列值的真假，记录哪些是 True，哪些是 False：

  • 0、1、-1
  • ""、"0"、"False"
  • []、[0]
  • None

  批改（2026-09-28）：⚠️ 缺 bool("0")、bool("False")、bool([0]) 三个测试点，而且第 2 项写的是 bool(False)（测的是布尔值 False，不是字符串 "False"）；已测的 0/1/-1/""/[]/None 输出 False True True False False False 都对，补上的三项应都是 True。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：“空”和”零”一律是假，有内容一律是真；字符串要看有没有字符，容器要看有没有元素——哪怕里面装的是 0 或 False，只要非空就是真 二级 · 方法：bool(x) 转布尔；数字看是否为 0、字符串看是否为空串、列表看是否为空 三级 · 骨架：print(f"bool('') = {____('')}") / print(f"bool([0]) = {bool([____])}")

  参考答案（做完再点开）

  1
  # 2-5
  2
  print(f"bool(0) = {bool(0)}")       # False
  3
  print(f"bool(1) = {bool(1)}")       # True
  4
  print(f"bool(-1) = {bool(-1)}")     # True
  5
  print(f"bool('') = {bool('')}")     # False
  6
  print(f"bool('0') = {bool('0')}")   # True（非空字符串）
  7
  print(f"bool('False') = {bool('False')}")  # True（非空字符串）
  8
  print(f"bool([]) = {bool([])}")     # False
  9
  print(f"bool([0]) = {bool([0])}")   # True（非空列表）
  10
  print(f"bool(None) = {bool(None)}") # False

• 2-6 转列表 创建文件 test_list.py，完成以下操作：

  • 将字符串 "hello" 转换为列表
  • 将元组 (1, 2, 3) 转换为列表
  • 将集合 {3, 1, 2} 转换为列表（观察顺序）
  • 打印每个结果

  批改（2026-09-28）：✅ 正确（['h', 'e', 'l', 'l', 'o']、[1, 2, 3]、[1, 2, 3]；集合是无序的，本次正好按 1、2、3 输出）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：把别的可迭代对象整个搬进列表；字符串会被拆成一个个字符，集合本来无序、顺序看运气 二级 · 方法：list(s)；list("hello") → ['h', 'e', 'l', 'l', 'o']、list((1, 2, 3)) → [1, 2, 3] 三级 · 骨架：a = ____("hello") / b = list((1, 2, 3)) / c = list({3, 1, 2})

  参考答案（做完再点开）

  1
  # 2-6
  2
  a = list("hello")
  3
  b = list((1, 2, 3))
  4
  c = list({3, 1, 2})
  5
  
  6
  print(f"list('hello') = {a}")        # ['h', 'e', 'l', 'l', 'o']
  7
  print(f"list((1,2,3)) = {b}")        # [1, 2, 3]
  8
  print(f"list({3,1,2}) = {c}")        # 顺序可能不同，因为集合是无序的

• 2-7 转元组 创建文件 test_tuple.py，完成以下操作：

  • 将字符串 "Python" 转换为元组
  • 将列表 [10, 20, 30] 转换为元组
  • 打印每个结果及其类型

  批改（2026-09-28）：⚠️ 题面是字符串 "Python"，你写成了小写 "python"，输出首字母变成 'p'（('p', 'y', 't', 'h', 'o', 'n')）；tuple([10, 20, 30]) 得 (10, 20, 30)、类型 <class 'tuple'> 都对。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：跟转列表一个套路，只是换了个目标类型；字符串照样会被拆成一个个字符 二级 · 方法：tuple(s)；tuple("Python") → ('P', 'y', 't', 'h', 'o', 'n') 三级 · 骨架：a = ____("Python") / b = tuple([10, 20, ____])

  参考答案（做完再点开）

  1
  # 2-7
  2
  a = tuple("Python")
  3
  b = tuple([10, 20, 30])
  4
  
  5
  print(f"tuple('Python') = {a}")       # ('P', 'y', 't', 'h', 'o', 'n')
  6
  print(f"tuple([10,20,30]) = {b}")     # (10, 20, 30)
  7
  print(f"类型: {type(b)}")             # <class 'tuple'>

• 2-8 转集合 创建文件 test_set.py，完成以下操作：

  • 将列表 [1, 2, 2, 3, 3, 3] 转换为集合（观察去重效果）
  • 将字符串 "aabbbccc" 转换为集合
  • 打印每个结果

  批改（2026-09-28）：⚠️ 第 1 项题面是 [1, 2, 2, 3, 3, 3]，你写成了 [1, 2, 4, 2, 3, 3, 3]（多一个 4），输出 {1, 2, 3, 4}（应为 {1, 2, 3}）；第 2 项字符串也写成 "aaabbbccc"（多一个 a），去重结果 {'a', 'b', 'c'} 不受影响。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：转成集合会自动去掉重复元素，转换过程本身就是一次去重 二级 · 方法：set(s)；set([1, 2, 2, 3, 3, 3]) → {1, 2, 3}、set("aabbbccc") → {'a', 'b', 'c'} 三级 · 骨架：a = ____([1, 2, 2, 3, 3, 3]) / b = set("____")

  参考答案（做完再点开）

  1
  # 2-8
  2
  a = set([1, 2, 2, 3, 3, 3])
  3
  b = set("aabbbccc")
  4
  
  5
  print(f"set([1,2,2,3,3,3]) = {a}")   # {1, 2, 3}（自动去重）
  6
  print(f"set('aabbbccc') = {b}")      # {'a', 'b', 'c'}（自动去重）

• 2-9 转字典 创建文件 test_dict.py，完成以下操作：

  • 用键值对列表创建字典：[("name", "小明"), ("age", 18)]
  • 用字典推导式创建字典：{x: x**2 for x in range(1, 5)}
  • 打印每个结果

  批改（2026-09-28）：✅ 正确（dict() 创建 {'name': '小明', 'age': 18}、推导式得 {1: 1, 2: 4, 3: 9, 4: 16}）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：从”键值对”出发建字典——要么给一串 (键, 值) 小元组，要么用字典推导式一行生成 二级 · 方法：dict([("name", "小明"), ("age", 18)])；推导式 {x: x**2 for x in range(1, 5)} 三级 · 骨架：a = ____([("name", "小明"), ("age", 18)]) / b = {x: x**2 for x in ____(1, 5)}

  参考答案（做完再点开）

  1
  # 2-9
  2
  a = dict([("name", "小明"), ("age", 18)])
  3
  b = {x: x**2 for x in range(1, 5)}
  4
  
  5
  print(f"dict() 创建: {a}")    # {'name': '小明', 'age': 18}
  6
  print(f"推导式创建: {b}")      # {1: 1, 2: 4, 3: 9, 4: 16}

• 2-10 表达式求值与字符串表示 创建文件 test_eval.py，完成以下操作：

  • 把字符串 "3 + 5 * 2" 当作表达式计算，得到它的结果
  • 把浮点数 3.14 转成它的表达式字符串形式
  • 打印每个结果及其类型

  批改（2026-09-28）：✅ 正确（eval("3+5*2") 得 13 <class 'int'>，repr(3.14) 得 3.14 <class 'str'>，值和类型都对）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：一个是”把字符串当代码算”，一个是”把值变成能写进代码的字符串”；后者转出来的类型是字符串 二级 · 方法：eval("3 + 5 * 2") → 13；repr(3.14) → '3.14' 三级 · 骨架：a = ____("3 + 5 * 2") / b = ____(3.14)

  参考答案（做完再点开）

  1
  # 2-10
  2
  a = eval("3 + 5 * 2")
  3
  b = repr(3.14)
  4
  
  5
  print(f"eval('3 + 5 * 2') = {a}")   # 13
  6
  print(f"类型: {type(a)}")            # <class 'int'>
  7
  print(f"repr(3.14) = {b}")           # '3.14'
  8
  print(f"类型: {type(b)}")            # <class 'str'>

• 2-11 数字与字符互转 创建文件 test_char.py，完成以下操作：

  • 把数字 65、97、48 转换成对应的字符
  • 把字符 'A'、'a'、'0' 转换成对应的数字
  • 打印每个结果

  批改（2026-09-28）：✅ 正确（chr(65/97/48) 输出 A/a/0，ord("a"/"A"/"0") 输出 97/65/48，六项都对）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：字符和它的编码数字是一一对应的，两个方向各有一个函数；65 是 'A'、97 是 'a'、48 是 '0' 二级 · 方法：数字转字符 chr(65) → 'A'；字符转数字 ord('A') → 65 三级 · 骨架：print(f"chr(65) = {____(65)}") / print(f"ord('A') = {____('A')}")

  参考答案（做完再点开）

  1
  # 2-11
  2
  print(f"chr(65) = {chr(65)}")   # A
  3
  print(f"chr(97) = {chr(97)}")   # a
  4
  print(f"chr(48) = {chr(48)}")   # 0
  5
  
  6
  print(f"ord('A') = {ord('A')}")  # 65
  7
  print(f"ord('a') = {ord('a')}")  # 97
  8
  print(f"ord('0') = {ord('0')}")  # 48

• 2-12 进制字符串转换 创建文件 test_hex.py，完成以下操作：

  • 把数字 255、16、10 转换成十六进制字符串
  • 把数字 8、16、255 转换成八进制字符串
  • 打印每个结果

  批改（2026-09-28）：✅ 正确（hex 输出 0xff/0x10/0xa，oct 输出 0o10/0o20/0o377，六项都对）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：转出来的带前缀标记进制（0x 是十六进制、0o 是八进制），结果类型是字符串 二级 · 方法：hex(255) → '0xff'；oct(8) → '0o10' 三级 · 骨架：print(f"hex(255) = {____(255)}") / print(f"oct(8) = {____(8)}")

  参考答案（做完再点开）

  1
  # 2-12
  2
  print(f"hex(255) = {hex(255)}")  # 0xff
  3
  print(f"hex(16) = {hex(16)}")    # 0x10
  4
  print(f"hex(10) = {hex(10)}")    # 0xa
  5
  
  6
  print(f"oct(8) = {oct(8)}")      # 0o10
  7
  print(f"oct(16) = {oct(16)}")    # 0o20
  8
  print(f"oct(255) = {oct(255)}")  # 0o377