Python数据类型教程：从基础到实践

Python作为一门动态类型语言，其数据类型的灵活性是其核心优势之一。开发者无需提前声明变量类型，解释器会根据赋值自动推断类型，但理解数据类型的特性和操作仍是编写高效、健壮代码的基础。本教程将系统介绍Python的基本数据类型、操作方法及类型转换技巧，帮助你掌握数据处理的底层逻辑。

一、Python数据类型的分类

Python的数据类型可分为​​基本数据类型​​（用于表示简单值）和​​复合数据类型​​（用于组织复杂数据）两大类：

1. 基本数据类型

• ​​数字（Number）​​：包括整数（int）、浮点数（float）、复数（complex）、布尔值（bool，True/False）。
• ​​字符串（String）​​：用于表示文本信息，用单引号（'）、双引号（"）或三引号（'''/"""）包裹。

2. 复合数据类型

• ​​列表（List）​​：有序、可变序列，可包含不同类型元素，用方括号（[]）表示。
• ​​元组（Tuple）​​：有序、不可变序列，元素不可修改，用圆括号（()）表示。
• ​​集合（Set）​​：无序、不重复元素的集合，用于去重和集合运算，用花括号（{}）或set()函数创建。
• ​​字典（Dict）​​：键值对（key-value）集合，键唯一且不可变（如字符串、数字），值可为任意类型，用花括号（{}）表示。

二、基本数据类型详解

1. 数字（Number）

数字类型用于数值计算，Python支持整数、浮点数、复数及布尔值：

• ​​整数（int）​​：表示无小数部分的数字，可正可负，如5、-10、0。Python 3的整数无大小限制（仅受内存约束）。
• ​​浮点数（float）​​：表示带小数部分的数字，如3.14、-0.5、2.0。浮点数遵循IEEE 754标准，可能存在精度误差（如0.1 + 0.2 != 0.3）。
• ​​复数（complex）​​：由实部和虚部组成，虚部以j结尾，如2 + 3j、1 - j。可通过.real（实部）、.imag（虚部）获取属性。
• ​​布尔值（bool）​​：逻辑值，True表示真，False表示假。布尔值可参与数学运算（True=1、False=0），也可通过bool()函数转换其他类型（如bool(0)为False，bool("hello")为True）。

​​常用操作​​：

# 算术运算
a = 5 + 3      # 加法（8）
b = 5 - 3      # 减法（2）
c = 5 * 3      # 乘法（15）
d = 5 / 3      # 除法（1.666...，返回浮点数）
e = 5 // 3     # 整除（1，返回整数）
f = 5 % 3      # 取余（2）
g = 5 ** 3     # 幂运算（125）

# 比较运算
h = 5 > 3      # 大于（True）
i = 5 == 3     # 等于（False）

2. 字符串（String）

字符串是Python中最常用的数据类型，用于处理文本信息。其核心特性包括：

• ​​不可变性​​：字符串创建后无法修改，任何修改操作（如拼接、替换）都会生成新字符串。
• ​​索引与切片​​：通过索引访问单个字符（从0开始），通过切片获取子字符串（语法：[start:end:step]，左闭右开）。

​​常用操作​​：

s = "Hello, World!"

# 访问字符
print(s[0])    # 'H'（索引从0开始）
print(s[-1])   # '!'（负索引表示从后往前）

# 切片
print(s[0:5])  # 'Hello'（取0到4索引的字符）
print(s[7:])   # 'World!'（从7索引到末尾）
print(s[::-1]) # '!dlroW ,olleH'（反转字符串）

# 常用方法
print(s.upper())    # 'HELLO, WORLD!'（转大写）
print(s.lower())    # 'hello, world!'（转小写）
print(s.replace("World", "Python"))  # 'Hello, Python!'（替换子串）
print(s.split(",")) # ['Hello', ' World!']（按逗号分割成列表）

# 格式化输出
name = "Alice"
age = 25
print(f"My name is {name} and I'm {age} years old.")  # f-string（Python 3.6+）
print("My name is {} and I'm {} years old.".format(name, age))  # str.format()
print("My name is %s and I'm %d years old." % (name, age))  # %格式化（旧方法）

3. 布尔值（Bool）

布尔值用于逻辑判断，只有True和False两个值。可通过比较运算符（>、<、==等）或逻辑运算符（and、or、not）生成：

x = 5 > 3      # True
y = 5 == 3     # False
z = x and y    # False（and：两者都为True才为True）
w = x or y     # True（or：任一为True就为True）
v = not x      # False（not：取反）

4. 复数（Complex）

复数用于数学计算，由实部和虚部组成：

c = 2 + 3j
print(c.real)  # 2.0（实部）
print(c.imag)  # 3.0（虚部）
print(c.conjugate())  # (2-3j)（共轭复数）

三、复合数据类型详解

复合数据类型用于组织多个数据，其核心特性是​​可包含多个元素​​，并支持增删改查操作。

1. 列表（List）

列表是有序、可变的序列，可包含不同类型元素（如整数、字符串、其他列表）。

​​创建列表​​：

fruits = ["apple", "banana", "cherry"]  # 元素为字符串
numbers = [1, 2, 3, 4, 5]              # 元素为整数
mixed = ["apple", 1, True, 3.14]       # 元素为不同类型
empty = []                             # 空列表

​​常用操作​​：

# 访问元素
print(fruits[0])    # 'apple'（索引从0开始）
print(fruits[-1])   # 'cherry'（负索引表示从后往前）

# 修改元素
fruits[0] = "orange"  # 将第一个元素改为'orange'

# 添加元素
fruits.append("grape")  # 末尾添加元素（['apple', 'banana', 'cherry', 'grape']）
fruits.insert(1, "pear")  # 在索引1处插入'pear'（['apple', 'pear', 'banana', ...]）

# 删除元素
fruits.remove("banana")  # 删除第一个'banana'（无返回值）
popped = fruits.pop()    # 删除并返回末尾元素（'grape'）
del fruits[0]            # 删除索引0处的元素

# 切片
print(fruits[1:3])  # ['pear', 'banana']（取1到2索引的元素）
print(fruits[:2])   # ['apple', 'pear']（从0到1索引）
print(fruits[1:])   # ['pear', 'banana', 'cherry']（从1索引到末尾）

# 常用方法
fruits.sort()         # 排序（原地修改，仅适用于同类型元素）
fruits.reverse()      # 反转列表
length = len(fruits)  # 获取列表长度（4）

# 列表推导式（快速生成列表）
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

2. 元组（Tuple）

元组是有序、不可变的序列，创建后无法修改元素。元组的不可变性使其适合存储​​常量数据​​（如坐标、配置项）。

​​创建元组​​：

coordinates = (10, 20)  # 两个元素的元组
single = (5,)           # 单元素元组（必须有逗号，否则为整数）
empty = ()              # 空元组
mixed = ("apple", 1, True)  # 不同类型元素的元组

​​常用操作​​：

# 访问元素
print(coordinates[0])  # 10（索引从0开始）

# 元组是不可变的，无法修改、删除元素

# 切片
print(coordinates[:1])  # (10,)（取0到0索引）

# 常用方法
length = len(coordinates)  # 获取元组长度（2）

# 元组解包（将元组元素赋值给多个变量）
x, y = coordinates  # x=10, y=20

3. 集合（Set）

集合是无序、不重复的元素集合，用于​​去重​​和​​集合运算​​（并集、交集、差集等）。

​​创建集合​​：

fruits = {"apple", "banana", "cherry"}  # 直接创建
numbers = set([1, 2, 2, 3, 4])          # 从列表创建（自动去重，结果为{1, 2, 3, 4}）
empty = set()                           # 空集合（不能用{}，{}表示空字典）

​​常用操作​​：

# 添加元素
fruits.add("orange")  # 添加'orange'（{'apple', 'banana', 'cherry', 'orange'}）

# 删除元素
fruits.remove("banana")  # 删除'banana'（无返回值，若元素不存在会抛出KeyError）
fruits.discard("banana") # 删除'banana'（若元素不存在不会报错）

# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
union = a | b          # 并集（{1, 2, 3, 4, 5}）
intersection = a & b   # 交集（{3}）
difference = a - b     # 差集（{1, 2}，a中有而b中没有的元素）
symmetric_difference = a ^ b  # 对称差集（{1, 2, 4, 5}，仅在a或b中的元素）

# 常用方法
length = len(fruits)  # 获取集合长度（4）
contains = "apple" in fruits  # 检查元素是否存在（True）

4. 字典（Dict）

字典是键值对的集合，键唯一且不可变（如字符串、数字、元组），值可为任意类型。字典的查找速度极快（基于哈希表实现），适合存储​​关联性数据​​（如用户信息、商品库存）。

​​创建字典​​：

person = {"name": "Alice", "age": 25, "city": "New York"}  # 键值对形式
empty = {}                                               # 空字典

​​常用操作​​：

# 访问值
print(person["name"])  # 'Alice'（通过键访问值）

# 修改值
person["age"] = 26  # 将'age'的值改为26

# 添加键值对
person["job"] = "Engineer"  # 添加'job'键值对（{'name': 'Alice', 'age': 26, 'city': 'New York', 'job': 'Engineer'}）

# 删除键值对
del person["city"]  # 删除'city'键值对
popped_value = person.pop("name")  # 删除并返回'name'的值（'Alice'）

# 常用方法
keys = person.keys()    # 获取所有键（dict_keys(['age', 'job']))
values = person.values()  # 获取所有值（dict_values([26, 'Engineer']))
items = person.items()    # 获取所有键值对（dict_items([('age', 26), ('job', 'Engineer')]))
length = len(person)      # 获取字典长度（2）

# 字典推导式（快速生成字典）
squares = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

四、类型转换技巧

类型转换是将一种数据类型转换为另一种数据类型的过程，分为​​隐式转换​​（自动进行）和​​显式转换​​（手动指定）。

1. 隐式转换

隐式转换是Python自动执行的，通常发生在​​混合运算​​中，目的是避免数据丢失。例如：

• 整数与浮点数运算时，整数自动转换为浮点数：5 + 3.14 = 8.14（5转为5.0）。
• 布尔值参与数学运算时，True=1、False=0：True + 2 = 3。

2. 显式转换

显式转换是开发者手动调用内置函数进行的转换，常见函数包括：

• int()：将其他类型转换为整数（浮点数舍弃小数部分，字符串需为有效数字）。

  print(int(3.14))      # 3（浮点数转整数，舍弃小数）
  print(int("123"))     # 123（字符串转整数）
  print(int(True))      # 1（布尔值转整数）
  # print(int("123abc"))  # ValueError（无效字符串）

• float()：将其他类型转换为浮点数（整数转为浮点数，字符串需为有效数字）。

  print(float(5))       # 5.0（整数转浮点数）
  print(float("3.14"))  # 3.14（字符串转浮点数）
  print(float(True))    # 1.0（布尔值转浮点数）

• str()：将其他类型转换为字符串（任何类型均可转换）。

  print(str(123))       # "123"（整数转字符串）
  print(str(3.14))      # "3.14"（浮点数转字符串）
  print(str(True))      # "True"（布尔值转字符串）

• bool()：将其他类型转换为布尔值（非空/非零为True，空/零为False）。

  print(bool(0))        # False（0为False）
  print(bool(1))        # True（非零为True）
  print(bool(""))       # False（空字符串为False）
  print(bool("hello"))  # True（非空字符串为True）

3. 复杂数据类型转换

复杂数据类型（列表、元组、集合、字典）之间的转换需注意​​元素顺序​​和​​唯一性​​：

• ​​列表与元组​​：list()将元组转为列表，tuple()将列表转为元组。

  tup = (1, 2, 3)
  lst = list(tup)  # [1, 2, 3]
  tup_new = tuple(lst)  # (1, 2, 3)

• ​​列表与集合​​：set()将列表转为集合（去除重复元素），list()将集合转为列表。

  lst = [1, 2, 2, 3, 4]
  st = set(lst)  # {1, 2, 3, 4}（去除重复的2）
  lst_new = list(st)  # [1, 2, 3, 4]（顺序可能改变，集合无序）

• ​​字典的键值对转换​​：dict.keys()、dict.values()、dict.items()分别获取键、值、键值对的视图对象，可通过list()转为列表。

  person = {"name": "Alice", "age": 25}
  keys = list(person.keys())  # ["name", "age"]
  values = list(person.values())  # ["Alice", 25]
  items = list(person.items())  # [("name", "Alice"), ("age", 25)]

五、注意事项

1. ​​不可变对象的特性​​：元组、字符串、数字（整数、浮点数、布尔值）是不可变对象，修改操作会生成新对象，原对象不变。例如：

   s = "hello"
   s.upper()  # 返回"HELLO"，s仍为"hello"