【第三章】Python 数据类型及操作详解-优快云博客

Python 数据类型及操作详解

文章目录

Python 数据类型及操作详解
前言
一、Python 数据类型的分类
二、基本数据类型及操作
三、复合数据类型及操作
四、数据类型转换
总结

前言

在 Python 编程中，数据类型是处理数据的基础。Python 提供了丰富的内置数据类型，每种类型都有其独特的特性和适用场景。理解这些数据类型及其操作，是写出高效、简洁代码的关键。本文将详细介绍 Python 中常见的数据类型，并通过实例讲解它们的核心操作。

一、Python 数据类型的分类

Python 的数据类型可分为基本数据类型和复合数据类型：

基本数据类型：直接存储单一值，如整数、浮点数、字符串、布尔值等。
复合数据类型：由多个元素组成，可存储一组值，如列表、元组、字典、集合等。

此外，根据值是否可修改，数据类型还可分为不可变类型（值创建后无法修改）和可变类型（值可动态修改）：

不可变类型：整数、浮点数、字符串、元组等。
可变类型：列表、字典、集合等。

二、基本数据类型及操作

2.1 整数（int）

整数是没有小数部分的数字，Python 中整数支持任意大小（不受位数限制），可正可负。

基本操作

算术运算：+（加）、-（减）、*（乘）、/（除，结果为浮点数）、//（整除，向下取整）、%（取余）、**（幂运算）。
比较运算：==（等于）、!=（不等于）、>（大于）、<（小于）等。
其他操作：abs(x)（取绝对值）、int(x)（类型转换）等。

举例：

运行
# 整数定义
a = 10
b = -5
c = 1000000000000000000000000  # 大整数，Python无大小限制

# 算术运算
print(a + b)  # 输出：5
print(a * 3)  # 输出：30
print(a / 3)  # 输出：3.3333333333333335（除法结果为浮点数）
print(a // 3)  # 输出：3（整除）
print(a % 3)   # 输出：1（取余）
print(2 **3)  # 输出：8（2的3次方）

# 类型转换
print(int("123"))  # 输出：123（字符串转整数）
print(int(3.9))    # 输出：3（浮点数转整数，截断小数部分）

2.2 浮点数（float）

浮点数是带小数部分的数字，也可表示科学计数法（如1.2e3表示 1200）。

基本操作

与整数类似，支持算术运算和比较运算，但需注意浮点数的精度问题（由于二进制存储特性，可能存在微小误差）。
常用函数：float(x)（类型转换）、round(x, n)（四舍五入，保留 n 位小数）等。

举例：

运行
# 浮点数定义
x = 3.14
y = -0.5
z = 1.2e3  # 等价于1200.0

# 运算
print(x + y)  # 输出：2.64
print(x * 2)  # 输出：6.28

# 精度问题
print(0.1 + 0.2)  # 输出：0.30000000000000004（而非0.3）

# 四舍五入
print(round(x, 1))  # 输出：3.1（保留1位小数）

# 类型转换
print(float("3.14"))  # 输出：3.14（字符串转浮点数）
print(float(5))       # 输出：5.0（整数转浮点数）

2.3 字符串（str）

字符串是由字符组成的序列，用单引号（‘）、双引号（"）或三引号（’‘’/“”"）包裹。三引号可用于定义多行字符串。

核心特性

不可变：字符串创建后，不能修改单个字符（修改会生成新字符串）。
支持索引（[]）和切片（[:]）：通过位置访问字符或子串。

常用操作

操作类型	示例代码	说明
拼接	“Hello” + " World"	合并两个字符串，结果为"Hello World"
重复	“a” * 3	重复字符串，结果为"aaa"
索引	“Python”[0]	获取索引 0 的字符，结果为"P"
切片	“Python”[1:4]	获取索引 1 到 3 的子串，结果为"yth"
长度	len(“Python”)	返回字符串长度，结果为 6
查找	“Python”.find(“tho”)	查找子串位置，结果为 2
替换	“Hello”.replace(“H”, “h”)	替换子串，结果为"hello"
分割	“a,b,c”.split(“,”)	按分隔符分割，结果为[“a”, “b”, “c”]
大小写转换	“Hello”.lower()	转为小写，结果为"hello"

举例：

运行
# 字符串定义
s1 = 'hello'
s2 = "world"
s3 = '''多行
字符串'''  # 包含换行符

# 拼接与重复
print(s1 + " " + s2)  # 输出：hello world
print(s1 * 2)         # 输出：hellohello

# 索引与切片（索引从0开始，负数表示从末尾计数）
print(s1[0])      # 输出：h
print(s1[-1])     # 输出：o（最后一个字符）
print(s1[1:4])    # 输出：ell（索引1到3的字符）
print(s1[:3])     # 输出：hel（从开头到索引2）
print(s1[2:])     # 输出：llo（从索引2到末尾）

# 常用方法
print(s1.upper())        # 输出：HELLO（转大写）
print("  test  ".strip())# 输出：test（去除首尾空格）
print("apple".count("p"))# 输出：2（统计子串出现次数）

2.4 布尔值（bool）

布尔值用于表示真（True）或假（False），主要用于条件判断。

基本操作

逻辑运算：and（与）、or（或）、not（非）。
任何值都可通过bool(x)转换为布尔值：空值（如""、0、None、[]）转换为False，非空值转换为True。

举例：

运行
# 布尔值定义
a = True
b = False

# 逻辑运算
print(a and b)  # 输出：False（与运算，两者都为True才返回True）
print(a or b)   # 输出：True（或运算，至少一个为True则返回True）
print(not a)    # 输出：False（非运算，取反）

# 类型转换
print(bool(0))      # 输出：False（0为假）
print(bool(1))      # 输出：True（非0数字为真）
print(bool(""))     # 输出：False（空字符串为假）
print(bool("abc"))  # 输出：True（非空字符串为真）
print(bool([]))     # 输出：False（空列表为假）

三、复合数据类型及操作

3.1 列表（list）

列表是有序、可变的元素集合，用方括号（[]）定义，元素之间用逗号分隔。列表可包含任意类型的元素，且元素可重复。

核心特性

有序：元素有明确的位置，可通过索引访问。
可变：可添加、删除、修改元素（不创建新列表）。
支持嵌套：列表中的元素可以是另一个列表。

常用操作

操作类型	示例代码	说明
创建	[1, 2, 3] 或 list(range(3))	定义列表或通过其他序列转换
索引/ 切片	lst[0]、lst[1:3]	访问单个元素或子列表
添加元素	lst.append(4)	在末尾添加元素
插入元素	lst.insert(1, 5)	在索引 1 处插入元素 5
删除元素	lst.remove(2) 或 del lst[0]	移除指定值的元素或指定索引的元素
排序	lst.sort()	对列表元素排序（原地修改）
反转	lst.reverse()	反转列表元素（原地修改）

举例：

运行
# 列表创建
lst = [1, "hello", True, 3.14]  # 包含多种类型元素
empty_lst = []                  # 空列表
nested_lst = [1, [2, 3], 4]     # 嵌套列表

# 索引与切片
print(lst[1])       # 输出：hello（访问索引1的元素）
print(lst[1:3])     # 输出：['hello', True]（获取索引1到2的子列表）
print(nested_lst[1][0])  # 输出：2（访问嵌套列表的元素）

# 修改元素
lst[0] = 100
print(lst)  # 输出：[100, 'hello', True, 3.14]

# 添加元素
lst.append(5)
print(lst)  # 输出：[100, 'hello', True, 3.14, 5]
lst.insert(2, "new")
print(lst)  # 输出：[100, 'hello', 'new', True, 3.14, 5]

# 删除元素
lst.remove("hello")  # 移除值为"hello"的元素
print(lst)  # 输出：[100, 'new', True, 3.14, 5]
del lst[0]  # 删除索引0的元素
print(lst)  # 输出：['new', True, 3.14, 5]

# 排序（元素类型需一致，否则会报错）
num_lst = [3, 1, 4, 2]
num_lst.sort()
print(num_lst)  # 输出：[1, 2, 3, 4]

3.2 元组（tuple）

元组是有序、不可变的元素集合，用圆括号（()）定义（元素较少时可省略括号）。元组的特性与列表类似，但元素一旦创建就无法修改。

核心特性

不可变：不能添加、删除或修改元素（修改会报错）。
有序：支持索引和切片，与列表用法一致。
适合存储固定数据：如坐标（x, y）、日期（年，月，日）等。

常用操作

元组的操作与列表类似，但缺少修改元素的方法（如append、insert），主要操作包括索引、切片、拼接、重复等。

举例：

运行
# 元组创建
tpl = (1, "hello", 3.14)
single_tpl = (5,)  # 单个元素的元组需加逗号，否则会被视为普通值
empty_tpl = ()     # 空元组

# 索引与切片
print(tpl[1])     # 输出：hello
print(tpl[1:3])   # 输出：('hello', 3.14)

# 拼接与重复
tpl2 = (4, 5)
print(tpl + tpl2)  # 输出：(1, 'hello', 3.14, 4, 5)
print(tpl2 * 2)    # 输出：(4, 5, 4, 5)

# 不可变性（修改会报错）
# tpl[0] = 100  # 执行会报错：'tuple' object does not support item assignment

3.3 字典（dict）

字典是无序（Python 3.7 + 开始有序）的键值对集合，用花括号（{}）定义，键与值之间用冒号（:）分隔，键值对之间用逗号分隔。字典通过键（key）访问值（value），键必须唯一且不可变（如整数、字符串、元组），值可以是任意类型。

核心特性

键值对映射：通过键快速查找值（时间复杂度为 O (1)）。
可变：可添加、删除、修改键值对。

常用操作

操作类型	示例代码	说明
创建	{“name”: “Alice”, “age”: 30}	定义字典
访问值	dict[“name”] 或 dict.get(“name”)	通过键访问值，get方法在键不存在时返回默认值
添加 / 修改键值对	dict[“gender”] = “female”	键不存在则添加，存在则修改
删除键值对	del dict[“age”] 或 dict.pop(“age”)	删除指定键的键值对，pop返回对应值
获取键 / 值	dict.keys()、dict.values()	返回所有键、所有值的视图
检查键是否存在	“name” in dict	存在返回True，否则返回False

举例：

运行
# 字典创建
person = {
    "name": "Alice",
    "age": 30,
    "hobbies": ["reading", "music"]
}
empty_dict = {}  # 空字典

# 访问值
print(person["name"])       # 输出：Alice
print(person.get("age"))    # 输出：30
print(person.get("gender", "unknown"))  # 输出：unknown（键不存在时返回默认值）

# 添加/修改键值对
person["gender"] = "female"  # 添加新键值对
person["age"] = 31           # 修改已有键的值
print(person)  # 输出：{'name': 'Alice', 'age': 31, 'hobbies': ['reading', 'music'], 'gender': 'female'}

# 删除键值对
del person["gender"]
print(person)  # 输出：{'name': 'Alice', 'age': 31, 'hobbies': ['reading', 'music']}
age = person.pop("age")
print(age)     # 输出：31（返回删除的值）

# 遍历字典
for key in person.keys():
    print(key)  # 输出：name、hobbies
for value in person.values():
    print(value)  # 输出：Alice、['reading', 'music']
for key, value in person.items():
    print(f"{key}: {value}")  # 输出键值对

3.4 集合（set）

集合是无序、不重复的元素集合，用花括号（{}）或set()函数定义（空集合必须用set()，因为{}表示空字典）。

核心特性

去重：自动移除重复元素。
无序：不支持索引和切片，不能通过位置访问元素。
支持集合运算：如交集、并集、差集等。

常用操作

操作类型	示例代码	说明
创建	{1, 2, 3} 或 set([1, 2, 3])	定义集合或通过其他序列转换
添加元素	s.add(4)	添加单个元素
删除元素	s.remove(2) 或 s.discard(2)	删除元素，remove在元素不存在时报错，discard不报错
交集	s1 & s2 或 s1.intersection(s2)	两个集合的共同元素
并集	s1 \| s2或s1.union(s2)	两个集合的所有元素（去重）
差集	s1 - s2 或 s1.difference(s2)	属于 s1 但不属于 s2 的元素

举例：

运行
# 集合创建（自动去重）
s = {1, 2, 2, 3}
print(s)  # 输出：{1, 2, 3}
empty_set = set()  # 空集合

# 添加与删除元素
s.add(4)
print(s)  # 输出：{1, 2, 3, 4}
s.remove(2)
print(s)  # 输出：{1, 3, 4}

# 集合运算
s1 = {1, 2, 3}
s2 = {3, 4, 5}

# 交集（共同元素）
print(s1 & s2)  # 输出：{3}

# 并集（所有元素）
print(s1 | s2)  # 输出：{1, 2, 3, 4, 5}

# 差集（s1有而s2没有的元素）
print(s1 - s2)  # 输出：{1, 2}

四、数据类型转换

Python 中可通过内置函数实现不同数据类型之间的转换，常见转换函数如下：

函数	说明	示例
int(x)	转换为整数	int(“123”) → 123
float(x)	转换为浮点数	float(“3.14”) → 3.14
str(x)	转换为字符串	str(123) → “123”
list(x)	转换为列表	list(“abc”) → [“a”, “b”, “c”]
tuple(x)	转换为元组	tuple([1, 2]) → (1, 2)
set(x)	转换为集合（去重）	set([1, 2, 2]) → {1, 2}
dict(x)	转换为字典	（x 需为键值对序列） dict([(“a”, 1), (“b”, 2)]) → {“a”:1, “b”:2}

举例：

运行
# 字符串转列表
s = "hello"
print(list(s))  # 输出：['h', 'e', 'l', 'l', 'o']

# 列表转集合（去重）
lst = [1, 2, 2, 3]
print(set(lst))  # 输出：{1, 2, 3}

# 元组转字典
tpl_list = [("name", "Bob"), ("age", 25)]
print(dict(tpl_list))  # 输出：{'name': 'Bob', 'age': 25}