Python(六) 类型定义

一、为什么要学习类型

在 Python 中，程序处理的每一个数据都有自己的类型。

例如：

name = "小明"
age = 18
height = 1.75
is_student = True

这几行代码中：

"小明" 是字符串类型。
18 是整数类型。
1.75 是浮点数类型。
True 是布尔类型。

不同类型的数据，能做的事情不一样。

例如：

print(10 + 20)
print("10" + "20")

输出：

30
1020

第一个是数字加法，第二个是字符串拼接。

这说明：

同样是 +，遇到不同类型的数据，含义可能不同。

所以，学习类型可以帮助学生理解：

一个值到底是什么数据。
这个数据能做哪些操作。
为什么有些代码会报错。
为什么输入的数据有时需要转换类型。
如何写出更清晰、更稳定的程序。

二、类型的定义

类型，也叫数据类型，表示数据的种类。

通俗地说：

类型就是数据的“身份类别”。

例如：

是整数类型。

"18"

是字符串类型。

虽然它们看起来都和 18 有关，但在 Python 中完全不是同一种数据。

print(18 + 1)
print("18" + "1")

输出：

19
181

原因是：

18 + 1 是整数加法。
"18" + "1" 是字符串拼接。

三、Python 中常见的数据类型

Python 基础阶段常见的数据类型如下：

类型名称	Python 类型	示例	说明
整数	`int`	`10`、`-3`	不带小数点的数字
浮点数	`float`	`3.14`、`1.75`	带小数点的数字
布尔值	`bool`	`True`、`False`	表示真或假
字符串	`str`	`"Python"`	文本内容
列表	`list`	`[1, 2, 3]`	可变的有序数据集合
元组	`tuple`	`(1, 2, 3)`	不可变的有序数据集合
字典	`dict`	`{"name": "小明"}`	键值对数据集合
集合	`set`	`{1, 2, 3}`	不重复的无序数据集合
空值	`NoneType`	`None`	表示没有值

初学阶段最常用的是：

int
float
str
bool
list
dict

其他类型可以随着课程逐步深入。

四、使用 type() 查看数据类型

Python 中可以使用 type() 查看一个数据的类型。

例子：

print(type(18))
print(type(3.14))
print(type("Python"))
print(type(True))

输出：

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

也可以查看变量中保存的数据类型：

name = "小明"
age = 18

print(type(name))
print(type(age))

输出：

<class 'str'>
<class 'int'>

教学时可以这样讲：

type() 就像给数据做一次“身份检查”，看看它到底属于哪种类型。

五、Python 是动态类型语言

在 Python 中，定义变量时不需要提前声明类型。

例如：

age = 18

不需要写：

age 是整数

Python 会根据右边的值自动判断变量当前保存的是什么类型。

变量的类型也可以随着赋值改变。

x = 10
print(type(x))

x = "Python"
print(type(x))

输出：

<class 'int'>
<class 'str'>

这说明：

变量 x 先保存整数，后来又保存字符串。

不过教学时要提醒学生：

虽然 Python 允许变量类型改变，但实际写代码时，不建议随意让同一个变量一会儿表示数字，一会儿表示字符串。这样容易让代码难懂，也容易出错。

六、整数类型 int

整数类型用来表示不带小数点的数字。

例如：

age = 18
count = 100
temperature = -5

这些都是整数。

查看类型：

print(type(age))

输出：

<class 'int'>

1. 整数的常见运算

a = 10
b = 3

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

输出：

13
7
30
3.3333333333333335
3
1
1000

说明：

+：加法
-：减法
*：乘法
/：除法
//：整除
%：取余
**：乘方

2. 整数常见应用

整数经常用于：

年龄
人数
次数
序号
商品数量
循环计数

例子：

count = 0

for i in range(5):
    count += 1

print(count)

输出：

七、浮点数类型 float

浮点数用来表示带小数点的数字。

例如：

price = 9.9
height = 1.75
temperature = -3.5

查看类型：

print(type(price))

输出：

<class 'float'>

1. 浮点数的常见运算

price = 19.9
count = 3

total = price * count

print(total)

输出可能是：

59.699999999999996

很多学生会疑惑：为什么不是 59.7？

这是因为计算机保存小数时可能存在精度误差。

在基础阶段可以这样讲：

计算机处理小数时，有些结果不能被完全精确表示，所以可能出现很小的误差。

如果只是输出给用户看，可以格式化保留小数位。

print(f"{total:.2f}")

输出：

59.70

2. 浮点数常见应用

浮点数经常用于：

价格
身高
体重
温度
平均分
比例
面积

例子：

radius = 3.5
pi = 3.14159
area = pi * radius ** 2

print(f"圆的面积是{area:.2f}")

八、布尔类型 bool

布尔类型只有两个值：

True
False

注意首字母必须大写。

正确：

is_student = True
is_login = False

错误：

is_student = true
is_login = false

Python 会把小写的 true 和 false 当作普通变量名，因此会报错。

1. 比较表达式会得到布尔值

age = 18

print(age >= 18)
print(age < 18)

输出：

True
False

这里：

age >= 18

就是一个比较表达式，它的结果是布尔值。

2. 布尔值常用于条件判断

is_login = True

if is_login:
    print("欢迎回来")
else:
    print("请先登录")

输出：

欢迎回来

3. bool 和数字的关系

在 Python 中，bool 是比较特殊的类型。

print(True == 1)
print(False == 0)

输出：

True
True

在计算时：

True 有时可以当作 1。
False 有时可以当作 0。

例如：

print(True + 1)
print(False + 1)

输出：

2
1

不过教学时不建议一开始鼓励学生这样写。布尔值最好用于表示真假，不要随便当数字使用。

九、字符串类型 str

字符串用于表示文本内容。

字符串可以用单引号、双引号或三引号表示。

name = "小明"
city = '北京'
message = """欢迎学习 Python"""

查看类型：

print(type(name))

输出：

<class 'str'>

1. 字符串可以包含中文、英文、数字和符号

text1 = "Python"
text2 = "你好"
text3 = "123"
text4 = "邮箱：test@example.com"

注意：

"123" 是字符串，不是整数。

print(type("123"))
print(type(123))

输出：

<class 'str'>
<class 'int'>

2. 字符串拼接

first_name = "张"
last_name = "三"

print(first_name + last_name)

输出：

张三

字符串和数字不能直接用 + 拼接。

错误：

age = 18
print("年龄：" + age)

正确：

age = 18
print("年龄：" + str(age))

更推荐：

age = 18
print(f"年龄：{age}")

3. 字符串重复

print("Python" * 3)

输出：

PythonPythonPython

也可以用来输出分隔线：

print("-" * 20)

输出：

--------------------

4. 字符串索引

字符串中的每个字符都有位置编号，这个编号叫索引。

索引从 0 开始。

word = "Python"

print(word[0])
print(word[1])
print(word[-1])

输出：

P
y
n

说明：

word[0] 是第一个字符。
word[1] 是第二个字符。
word[-1] 是最后一个字符。

5. 字符串切片

切片用于取出字符串的一部分。

word = "Python"

print(word[0:2])
print(word[2:6])
print(word[:3])
print(word[3:])

输出：

Py
thon
Pyt
hon

切片规则可以简单记为：

左闭右开：包含起始位置，不包含结束位置。

6. 常见字符串方法

text = "  Python  "

print(text.strip())
print(text.lower())
print(text.upper())
print(text.replace("Python", "Java"))

说明：

strip()：去掉前后空白。
lower()：转成小写。
upper()：转成大写。
replace()：替换内容。

这些方法在处理用户输入时很常用。

answer = input("请输入 yes 或 no：").strip().lower()

if answer == "yes":
    print("你选择了 yes")

十、列表类型 list

列表用于保存多个数据。

列表使用方括号 [] 表示，元素之间用逗号隔开。

students = ["小明", "小红", "小刚"]
scores = [90, 85, 100]
mixed = ["小明", 18, True]

查看类型：

print(type(students))

输出：

<class 'list'>

1. 列表是有序的

列表中的元素有顺序，可以通过索引访问。

students = ["小明", "小红", "小刚"]

print(students[0])
print(students[1])
print(students[-1])

输出：

小明
小红
小刚

2. 列表可以修改

students = ["小明", "小红", "小刚"]

students[0] = "小李"

print(students)

输出：

['小李', '小红', '小刚']

列表是可变类型，这意味着列表创建后，里面的内容可以改变。

3. 列表常见操作

students = ["小明", "小红"]

students.append("小刚")
print(students)

students.remove("小红")
print(students)

print(len(students))

输出：

['小明', '小红', '小刚']
['小明', '小刚']
2

说明：

append()：在列表末尾添加元素。
remove()：删除指定元素。
len()：获取列表长度。

4. 遍历列表

students = ["小明", "小红", "小刚"]

for student in students:
    print(student)

输出：

小明
小红
小刚

十一、元组类型 tuple

元组和列表很像，也可以保存多个有序数据。

元组使用小括号 () 表示。

point = (3, 5)
weekends = ("Saturday", "Sunday")

查看类型：

print(type(point))

输出：

<class 'tuple'>

1. 元组和列表的主要区别

列表可以修改，元组不能修改。

numbers = [1, 2, 3]
numbers[0] = 100
print(numbers)

输出：

[100, 2, 3]

但是元组不能这样改：

numbers = (1, 2, 3)
numbers[0] = 100

这会报错。

所以：

需要经常修改数据，用列表。
数据确定后不希望被修改，可以用元组。

2. 只有一个元素的元组

这是初学者容易出错的地方。

a = (10)
print(type(a))

输出：

<class 'int'>

因为 (10) 只是给数字加了小括号，并不是元组。

一个元素的元组要加逗号：

a = (10,)
print(type(a))

输出：

<class 'tuple'>

十二、字典类型 dict

字典用于保存键值对数据。

字典使用大括号 {} 表示，每一项由“键: 值”组成。

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

这里：

"name" 是键。
"小明" 是值。
"age" 是键。
18 是值。

查看类型：

print(type(student))

输出：

<class 'dict'>

1. 通过键读取值

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

print(student["name"])
print(student["score"])

输出：

小明
95

2. 修改字典中的值

student = {
    "name": "小明",
    "score": 95
}

student["score"] = 100

print(student)

输出：

{'name': '小明', 'score': 100}

字典也是可变类型。

3. 添加新的键值对

student = {
    "name": "小明"
}

student["age"] = 18

print(student)

输出：

{'name': '小明', 'age': 18}

4. 判断键是否存在

student = {
    "name": "小明",
    "score": 95
}

if "score" in student:
    print("有成绩")
else:
    print("没有成绩")

对字典使用 in 时，默认判断的是键，不是值。

5. 使用 get() 安全读取

如果直接读取不存在的键，会报错。

student = {"name": "小明"}

print(student["score"])

这会报 KeyError。

可以使用 get()：

student = {"name": "小明"}

print(student.get("score"))
print(student.get("score", 0))

输出：

None
0

说明：

student.get("score") 如果没有这个键，返回 None。
student.get("score", 0) 如果没有这个键，返回默认值 0。

十三、集合类型 set

集合用于保存多个不重复的数据。

集合使用大括号 {} 表示，但里面不是键值对。

numbers = {1, 2, 3, 3, 4}

print(numbers)

输出可能是：

{1, 2, 3, 4}

重复的 3 会被自动去掉。

查看类型：

print(type(numbers))

输出：

<class 'set'>

1. 集合的特点

集合有两个重要特点：

元素不重复。
元素没有固定顺序。

因此，集合不支持用索引取元素。

错误示例：

numbers = {1, 2, 3}
print(numbers[0])

这会报错。

2. 集合常见用途：去重

names = ["小明", "小红", "小明", "小刚"]
unique_names = set(names)

print(unique_names)

输出可能是：

{'小明', '小红', '小刚'}

注意：

集合没有固定顺序，所以输出顺序可能和原列表不同。

3. 空集合的写法

这是一个常见坑。

a = {}
print(type(a))

输出：

<class 'dict'>

空的大括号 {} 表示空字典，不是空集合。

创建空集合要使用：

a = set()
print(type(a))

输出：

<class 'set'>

十四、空值 None 和 NoneType

None 表示没有值、空值或暂时没有结果。

result = None

print(result)
print(type(result))

输出：

None
<class 'NoneType'>

None 不是字符串 "None"，也不是数字 0，也不是空字符串。

print(None == 0)
print(None == "")
print(None == "None")

输出：

False
False
False

1. None 的常见用途

函数没有找到结果时，可以返回 None。

def find_student(name):
    students = ["小明", "小红", "小刚"]

    if name in students:
        return name
    return None


result = find_student("小李")

if result is None:
    print("没有找到学生")
else:
    print("找到了学生")

2. 判断 None 推荐使用 is

十五、类型转换

类型转换指的是把一种类型的数据转换成另一种类型。

例如，把字符串 "18" 转换成整数 18。

1. 转换成整数 int()

age_text = "18"
age = int(age_text)

print(age)
print(type(age))

输出：

18
<class 'int'>

常见场景：处理用户输入。

age = int(input("请输入年龄："))

if age >= 18:
    print("已成年")

注意：

如果字符串不是合法整数，转换会报错。

number = int("abc")

这会报 ValueError。

2. 转换成浮点数 float()

price = float("9.9")

print(price)
print(type(price))

输出：

9.9
<class 'float'>

常见场景：

height = float(input("请输入身高："))

3. 转换成字符串 str()

age = 18
text = str(age)

print(text)
print(type(text))

输出：

18
<class 'str'>

常见场景：字符串拼接。

age = 18

print("年龄：" + str(age))

不过实际教学中，也可以推荐 f-string：

age = 18

print(f"年龄：{age}")

4. 转换成布尔值 bool()

print(bool(1))
print(bool(0))
print(bool("hello"))
print(bool(""))
print(bool([]))
print(bool([1, 2, 3]))

输出：

True
False
True
False
False
True

常见规则：

数字 0 转成 False，非 0 数字转成 True。
空字符串 "" 转成 False，非空字符串转成 True。
空列表 [] 转成 False，非空列表转成 True。
None 转成 False。

5. 转换成列表 list()

text = "abc"
chars = list(text)

print(chars)

输出：

['a', 'b', 'c']

也可以把元组转换成列表：

numbers = (1, 2, 3)
numbers_list = list(numbers)

print(numbers_list)

输出：

[1, 2, 3]

6. 转换成元组 tuple()

numbers = [1, 2, 3]
numbers_tuple = tuple(numbers)

print(numbers_tuple)

输出：

(1, 2, 3)

7. 转换成集合 set()

numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = set(numbers)

print(unique_numbers)

输出可能是：

{1, 2, 3}

集合可以用于去重。

十六、input() 和类型

input() 是学习类型时必须重点讲的内容。

无论用户输入什么，input() 得到的都是字符串。

age = input("请输入年龄：")

print(age)
print(type(age))

用户输入：

输出：

18
<class 'str'>

这说明：

虽然用户输入的是 18，但 Python 得到的是字符串 "18"。

1. 输入后做加法的常见问题

错误示例：

a = input("请输入第一个数：")
b = input("请输入第二个数：")

print(a + b)

用户输入：

10
20

输出：

原因：

a 和 b 都是字符串，字符串之间的 + 表示拼接。

正确写法：

a = int(input("请输入第一个数："))
b = int(input("请输入第二个数："))

print(a + b)

输出：

2. 输入小数

price = float(input("请输入商品单价："))
count = int(input("请输入购买数量："))

total = price * count

print(f"总价是{total:.2f}元")

十七、可变类型和不可变类型

Python 中的数据类型还可以按“能不能修改”分为两类：

可变类型
不可变类型

1. 不可变类型

不可变类型指的是对象创建后，内容不能被原地修改。

常见不可变类型：

int
float
bool
str
tuple
NoneType

例子：

text = "Python"
text[0] = "J"

这会报错，因为字符串不可变。

如果想得到 "Jython"，可以创建一个新的字符串：

text = "Python"
new_text = "J" + text[1:]

print(new_text)

输出：

Jython

2. 可变类型

可变类型指的是对象创建后，内容可以修改。

常见可变类型：

list
dict
set

例子：

numbers = [1, 2, 3]
numbers[0] = 100

print(numbers)

输出：

[100, 2, 3]

字典也可以修改：

student = {"name": "小明", "score": 90}
student["score"] = 100

print(student)

输出：

{'name': '小明', 'score': 100}

3. 可变类型容易出现的引用问题

a = [1, 2, 3]
b = a

b.append(4)

print(a)
print(b)

输出：

[1, 2, 3, 4]
[1, 2, 3, 4]

很多学生会问：

为什么修改 b，a 也变了？

原因是：

b = a

不是复制一个新列表，而是让 b 和 a 指向同一个列表对象。

如果想复制列表，可以使用：

a = [1, 2, 3]
b = a.copy()

b.append(4)

print(a)
print(b)

输出：

[1, 2, 3]
[1, 2, 3, 4]

十八、isinstance() 类型判断

除了 type()，还可以用 isinstance() 判断一个数据是否属于某种类型。

age = 18

print(isinstance(age, int))
print(isinstance(age, str))

输出：

True
False

基本格式：

isinstance(数据, 类型)

1. 判断多个可能类型

value = 3.14

print(isinstance(value, (int, float)))

输出：

True

这表示 value 只要是 int 或 float 中的一种，就返回 True。

2. type() 和 isinstance() 的区别

基础阶段可以这样理解：

type() 常用来查看类型。
isinstance() 常用来判断类型。

例子：

value = "Python"

print(type(value))

if isinstance(value, str):
    print("这是字符串")

十九、类型和运算的关系

不同类型支持的操作不同。

1. 数字可以进行数学运算

print(10 + 20)
print(10 * 3)

2. 字符串可以拼接和重复

print("Hello" + "Python")
print("Hi" * 3)

3. 列表可以添加、删除、遍历

students = ["小明", "小红"]

students.append("小刚")

for student in students:
    print(student)

4. 字典可以通过键查找值

student = {"name": "小明", "score": 95}

print(student["name"])

5. 类型不匹配会报错

age = 18
print("年龄：" + age)

这会报错，因为字符串和整数不能直接用 + 拼接。

正确写法：

age = 18
print("年龄：" + str(age))

或：

print(f"年龄：{age}")

二十、常见类型错误

1. TypeError：类型不支持这种操作

错误示例：

print("年龄：" + 18)

问题：

字符串不能和整数直接相加。

修改：

print("年龄：" + str(18))

或：

print(f"年龄：{18}")

2. ValueError：值不能转换成目标类型

错误示例：

number = int("abc")

问题：

"abc" 不是合法整数，不能转换成 int。

修改：

text = input("请输入整数：")

if text.isdigit():
    number = int(text)
    print(number)
else:
    print("输入的不是整数")

注意：

isdigit() 适合简单判断正整数。如果要处理负数或小数，需要更完整的方法。

3. IndexError：索引超出范围

错误示例：

students = ["小明", "小红"]

print(students[5])

问题：

列表只有两个元素，索引只有 0 和 1，没有索引 5。

4. KeyError：字典中没有这个键

错误示例：

student = {"name": "小明"}

print(student["score"])

问题：

字典中没有 "score" 这个键。

修改：

student = {"name": "小明"}

print(student.get("score", "暂无成绩"))

二十一、类型使用注意事项

1. 注意 input() 得到的是字符串

这是最常见的问题。

age = input("请输入年龄：")

即使用户输入 18，age 也是字符串。

如果要比较大小或做数学运算，需要转换：

age = int(input("请输入年龄："))

2. 不要混淆数字和数字字符串

number1 = 100
number2 = "100"

它们看起来类似，但类型不同。

print(type(number1))
print(type(number2))

输出：

<class 'int'>
<class 'str'>

3. 浮点数计算可能有精度误差

print(0.1 + 0.2)

输出可能是：

0.30000000000000004

基础阶段可以用格式化输出处理显示：

result = 0.1 + 0.2
print(f"{result:.2f}")

输出：

0.30

如果以后做金融等高精度计算，可以学习 decimal 模块。

4. 空列表、空字符串、0 和 None 不一样

empty_list = []
empty_string = ""
zero = 0
nothing = None

它们都可以在条件判断中表现为 False，但它们不是同一种东西。

print(type(empty_list))
print(type(empty_string))
print(type(zero))
print(type(nothing))

输出：

<class 'list'>
<class 'str'>
<class 'int'>
<class 'NoneType'>

教学时可以提醒：

“判断时都像假”，不代表“它们是同一个值”。

5. 字典的键要唯一

student = {
    "name": "小明",
    "name": "小红"
}

print(student)

输出：

{'name': '小红'}

后面的 "name" 会覆盖前面的 "name"。

所以字典中的键必须尽量保持唯一。

6. 集合会自动去重，但不保证顺序

numbers = {3, 1, 2, 3}

print(numbers)

输出顺序不一定固定。

所以集合适合判断是否存在、去重，不适合依赖顺序。

7. 判断 None 使用 is None

8. 变量名要体现类型或含义

好的变量名能帮助理解类型。

二十二、教学中可以这样讲

可以用生活中的分类来解释类型：

数字、文字、真假、名单、信息表，都是不同种类的数据。

对应到 Python：

数字中的整数：int
数字中的小数：float
文字：str
真或假：bool
名单：list
固定名单：tuple
信息表：dict
不重复集合：set
没有值：None

再用一句话帮助学生记忆：

类型决定数据能做什么。

例如：

10 + 20

能做数字加法。

"10" + "20"

做的是字符串拼接。

["小明", "小红"].append("小刚")

列表可以添加元素。

{"name": "小明"}["name"]

字典可以通过键取值。

二十三、课堂综合示例

示例：学生信息录入

name = input("请输入学生姓名：").strip()
age = int(input("请输入学生年龄："))
score = float(input("请输入学生成绩："))

is_passed = score >= 60

student = {
    "name": name,
    "age": age,
    "score": score,
    "is_passed": is_passed
}

print("学生信息：")
print(f"姓名：{student['name']}")
print(f"年龄：{student['age']}")
print(f"成绩：{student['score']:.2f}")

if student["is_passed"]:
    print("结果：及格")
else:
    print("结果：不及格")

这段代码中包含多种类型：

name 是字符串。
age 是整数。
score 是浮点数。
is_passed 是布尔值。
student 是字典。

可以引导学生分析：

input() 得到字符串。
年龄需要用 int() 转换。
成绩需要用 float() 转换。
score >= 60 得到布尔值。
字典把一个学生的多项信息组织在一起。

二十四、课堂练习

练习 1：查看类型

请查看下面数据的类型：

18
3.14
"Python"
True
[1, 2, 3]
{"name": "小明"}
None

参考答案：

print(type(18))
print(type(3.14))
print(type("Python"))
print(type(True))
print(type([1, 2, 3]))
print(type({"name": "小明"}))
print(type(None))

练习 2：输入两个整数求和

请让用户输入两个整数，并输出它们的和。

参考答案：

a = int(input("请输入第一个整数："))
b = int(input("请输入第二个整数："))

print(f"和是{a + b}")

练习 3：判断输入类型转换问题

下面代码的输出是什么？

a = input("请输入第一个数：")
b = input("请输入第二个数：")

print(a + b)

如果用户输入 10 和 20，输出是：

原因：

input() 得到的是字符串，字符串的 + 表示拼接。

练习 4：创建学生字典

请创建一个字典保存学生姓名、年龄和成绩。

参考答案：

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

print(student)

练习 5：列表去重

给定列表：

numbers = [1, 2, 2, 3, 3, 3]

请去掉重复元素。

参考答案：

numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = set(numbers)

print(unique_numbers)

如果需要再变回列表：

unique_numbers = list(set(numbers))

注意：变成集合后，顺序可能改变。

练习 6：判断变量是否为 None

result = None

请判断它是否没有结果。

参考答案：

result = None

if result is None:
    print("没有结果")
else:
    print("有结果")

练习 7：修正类型错误

下面代码有什么问题？请改正。

age = 18
print("年龄：" + age)

参考答案：

问题是字符串不能和整数直接拼接。

修改方式一：

age = 18
print("年龄：" + str(age))

修改方式二：

age = 18
print(f"年龄：{age}")

练习 8：判断数据是否是字符串

请使用 isinstance() 判断变量是否是字符串。

参考答案：

value = "Python"

if isinstance(value, str):
    print("这是字符串")
else:
    print("这不是字符串")

二十五、常见错误对照表

错误现象	常见原因	修改方法
输入 `10` 和 `20` 得到 `1020`	`input()` 得到的是字符串	用 `int()` 或 `float()` 转换
`"年龄：" + 18` 报错	字符串不能和整数直接拼接	使用 `str()` 或 f-string
`int("abc")` 报错	`"abc"` 不是合法整数	转换前检查输入，或使用异常处理
`0.1 + 0.2` 结果不精确	浮点数存在精度问题	输出时格式化，或高精度场景用 `decimal`
`students[5]` 报错	列表索引超出范围	确认列表长度和索引范围
`student["score"]` 报错	字典中没有这个键	先判断键是否存在，或用 `get()`
`(10)` 不是元组	单元素元组缺少逗号	写成 `(10,)`
`{}` 不是空集合	空大括号表示空字典	空集合用 `set()`
判断 `None` 使用 `== None`	不符合常见规范	使用 `is None`

二十六、总结

类型是 Python 中非常重要的基础概念。

每个数据都有类型，类型决定了这个数据能做什么操作。

基础阶段需要重点掌握：

int 表示整数。
float 表示小数。
bool 表示真假，只有 True 和 False。
str 表示字符串，也就是文本。
list 表示列表，可以保存多个有序数据，并且可以修改。
tuple 表示元组，可以保存多个有序数据，但不能修改。
dict 表示字典，用键值对保存数据。
set 表示集合，元素不重复且无固定顺序。
None 表示没有值。
type() 可以查看类型。
isinstance() 可以判断类型。
int()、float()、str()、bool() 等可以进行类型转换。

教学时可以让学生记住一句话：

类型决定数据的用途，转换解决类型不合适的问题。

把类型学清楚，后面学习输入输出、条件判断、循环、函数、列表字典和面向对象都会更加顺畅。