【Python基础篇】——第3篇：从入门到精通：掌握Python数据类型与数据结构

第3篇：数据类型与数据结构

Python中的数据类型概述
列表（List）
- 创建列表
- 列表的基本操作
- 列表方法
- 列表推导式
元组（Tuple）
- 创建元组
- 元组的基本操作
- 元组的不可变性
字典（Dictionary）
- 创建字典
- 字典的基本操作
- 字典方法
集合（Set）
- 创建集合
- 集合的基本操作
- 集合方法
数据结构的选择与应用
示例代码
常见问题及解决方法
总结

Python中的数据类型概述

Python是一种动态类型语言，支持多种内置数据类型和复杂的数据结构。理解这些数据类型和数据结构的特性及其应用场景，是编写高效、可维护代码的基础。

常见的数据类型

数值类型：包括整数（int）、浮点数（float）、复数（complex）。
字符串类型：用于表示文本数据。
布尔类型：表示真（True）或假（False）。
序列类型：如列表（list）、元组（tuple）、字符串（str）。
映射类型：字典（dict）。
集合类型：集合（set）和冻结集合（frozenset）。

本文重点介绍列表、元组、字典和集合这四种常用的数据结构。

列表（List）

列表是Python中最常用的数据结构之一，具有可变性和有序性，允许存储不同类型的元素。

创建列表

# 创建空列表
empty_list = []# 创建包含元素的列表
fruits = ['苹果', '香蕉', '橙子']
numbers = [1, 2, 3, 4, 5]
mixed = [1, '苹果', 3.14, True]

列表的基本操作

访问元素：使用索引访问，索引从0开始，可以使用负数索引从末尾访问。

fruits = ['苹果', '香蕉', '橙子']
print(fruits[0])  # 输出: 苹果
print(fruits[-1]) # 输出: 橙子

切片：获取列表的子集。

numbers = [1, 2, 3, 4, 5]
print(numbers[1:3])  # 输出: [2, 3]
print(numbers[:2])   # 输出: [1, 2]
print(numbers[3:])   # 输出: [4, 5]

修改元素：

fruits = ['苹果', '香蕉', '橙子']
fruits[1] = '草莓'
print(fruits)  # 输出: ['苹果', '草莓', '橙子']

添加元素：

fruits.append('葡萄')
print(fruits)  # 输出: ['苹果', '草莓', '橙子', '葡萄']

删除元素：

fruits.remove('草莓')
print(fruits)  # 输出: ['苹果', '橙子', '葡萄']last_fruit = fruits.pop()
print(last_fruit)  # 输出: 葡萄
print(fruits)      # 输出: ['苹果', '橙子']

列表方法

方法	描述	示例
`append(x)`	在列表末尾添加元素x	`fruits.append('葡萄')`
`extend(iterable)`	使用可迭代对象的元素扩展列表	`fruits.extend(['樱桃', '梨'])`
`insert(i, x)`	在指定位置i插入元素x	`fruits.insert(1, '蓝莓')`
`remove(x)`	删除列表中第一个值为x的元素	`fruits.remove('香蕉')`
`pop([i])`	移除并返回指定位置i的元素，默认为最后一个元素	`last = fruits.pop()`
`clear()`	移除列表中的所有元素	`fruits.clear()`
`index(x)`	返回列表中第一个值为x的元素的索引	`fruits.index('苹果')`
`count(x)`	返回x在列表中出现的次数	`fruits.count('苹果')`
`sort()`	对列表进行就地排序	`numbers.sort()`
`reverse()`	将列表中的元素反转	`fruits.reverse()`
`copy()`	返回列表的浅拷贝	`new_fruits = fruits.copy()`

列表推导式

列表推导式是一种简洁的创建列表的方式，通常用于对现有列表进行操作或过滤。

# 创建一个包含1到10的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6]
evens = [x for x in numbers if x % 2 == 0]
print(evens)  # 输出: [2, 4, 6]

元组（Tuple）

元组与列表类似，但具有不可变性。一旦创建，元组的元素不能被修改、添加或删除。

创建元组

# 创建空元组
empty_tuple = ()# 创建包含元素的元组
fruits = ('苹果', '香蕉', '橙子')
numbers = (1, 2, 3, 4, 5)
mixed = (1, '苹果', 3.14, True)

元组的基本操作

访问元素：与列表类似，使用索引访问。

fruits = ('苹果', '香蕉', '橙子')
print(fruits[0])  # 输出: 苹果
print(fruits[-1]) # 输出: 橙子

切片：

numbers = (1, 2, 3, 4, 5)
print(numbers[1:3])  # 输出: (2, 3)

不可变性：

fruits = ('苹果', '香蕉', '橙子')
fruits[1] = '草莓'  # 会引发TypeError

元组的不可变性

元组的不可变性使其在需要保证数据不被修改的场景下非常有用。例如，用作字典的键或存储固定的配置信息。

# 使用元组作为字典的键
locations = {(40.7128, -74.0060): "纽约",(34.0522, -118.2437): "洛杉矶",
}
print(locations[(40.7128, -74.0060)])  # 输出: 纽约

字典（Dictionary）

字典是Python中用于存储键值对（key-value）的数据结构，具有高效的查找性能。

创建字典

# 创建空字典
empty_dict = {}# 创建包含元素的字典
person = {'name': 'Alice','age': 25,'city': '北京'
}# 使用dict构造函数
car = dict(make='Toyota', model='Camry', year=2020)

字典的基本操作

访问值：通过键访问对应的值。

print(person['name'])  # 输出: Alice
print(person.get('age'))  # 输出: 25

修改值：

person['age'] = 26
print(person['age'])  # 输出: 26

添加键值对：

person['email'] = 'alice@example.com'
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'city': '北京', 'email': 'alice@example.com'}

删除键值对：

del person['city']
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}removed_value = person.pop('email')
print(removed_value)  # 输出: alice@example.com
print(person)         # 输出: {'name': 'Alice', 'age': 26}

字典方法

方法	描述	示例
`dict.keys()`	返回字典中所有的键	`person.keys()`
`dict.values()`	返回字典中所有的值	`person.values()`
`dict.items()`	返回字典中所有的键值对	`person.items()`
`dict.get(key, default)`	返回指定键的值，如果键不存在则返回默认值	`person.get('name', '未知')`
`dict.update(other_dict)`	使用另一个字典更新当前字典	`person.update({'age': 27, 'gender': '女'})`
`dict.pop(key, default)`	移除指定键并返回其值，如果键不存在则返回默认值	`age = person.pop('age', None)`
`dict.clear()`	移除字典中的所有元素	`person.clear()`
`dict.copy()`	返回字典的浅拷贝	`new_person = person.copy()`

集合（Set）

集合是Python中用于存储唯一元素的无序数据结构，适用于去重和集合运算（如并集、交集等）。

创建集合

# 创建空集合
empty_set = set()# 创建包含元素的集合
fruits = {'苹果', '香蕉', '橙子'}
numbers = {1, 2, 3, 4, 5}
mixed = {1, '苹果', 3.14, True}

注意：创建空集合必须使用set()，而不是{}，因为后者表示空字典。

集合的基本操作

添加元素：

fruits.add('葡萄')
print(fruits)  # 输出: {'苹果', '香蕉', '橙子', '葡萄'}

删除元素：

fruits.remove('香蕉')  # 如果元素不存在，会引发KeyError
fruits.discard('草莓')  # 如果元素不存在，不会引发错误
print(fruits)  # 输出: {'苹果', '橙子', '葡萄'}

清空集合：

fruits.clear()
print(fruits)  # 输出: set()

集合方法

方法	描述	示例
`set.add(elem)`	向集合添加元素	`fruits.add('樱桃')`
`set.remove(elem)`	移除集合中的指定元素，如果元素不存在则引发错误	`fruits.remove('苹果')`
`set.discard(elem)`	移除集合中的指定元素，如果元素不存在则不操作	`fruits.discard('香蕉')`
`set.pop()`	随机移除并返回一个元素	`item = fruits.pop()`
`set.clear()`	移除集合中的所有元素	`fruits.clear()`
`set.union(other_set)`	返回两个集合的并集	`all_fruits = fruits.union(tropical_fruits)`
`set.intersection(other_set)`	返回两个集合的交集	`common_fruits = fruits.intersection(tropical_fruits)`
`set.difference(other_set)`	返回集合的差集	`unique_fruits = fruits.difference(tropical_fruits)`
`set.symmetric_difference(other_set)`	返回集合的对称差集	`symmetric_fruits = fruits.symmetric_difference(tropical_fruits)`
`set.issubset(other_set)`	判断当前集合是否是另一个集合的子集	`fruits.issubset(all_fruits)`
`set.issuperset(other_set)`	判断当前集合是否是另一个集合的超集	`all_fruits.issuperset(fruits)`

数据结构的选择与应用

不同的数据结构适用于不同的应用场景。选择合适的数据结构可以提高代码的效率和可维护性。

数据结构	特性	适用场景
列表	有序、可变、允许重复元素	需要动态添加、删除元素，或者需要保持元素的顺序时
元组	有序、不可变、允许重复元素	需要保证数据不被修改，或作为字典的键时
字典	无序、键唯一、可变	需要快速查找、关联键值对的数据时
集合	无序、不重复、可变	需要去重、进行集合运算（并集、交集等）时

示例应用：

列表：存储用户输入的数据，处理动态数据。
元组：存储固定的配置信息，如数据库连接参数。
字典：存储用户信息，快速通过用户名查找对应的详细信息。
集合：统计文章中的独特单词，进行标签的去重。

示例代码

以下示例代码展示了如何使用列表、元组、字典和集合进行基本操作。

# 列表示例
fruits = ['苹果', '香蕉', '橙子']
fruits.append('葡萄')
print(fruits)  # 输出: ['苹果', '香蕉', '橙子', '葡萄']# 元组示例
coordinates = (40.7128, -74.0060)
print(coordinates)  # 输出: (40.7128, -74.0060)# 字典示例
person = {'name': 'Alice','age': 25,'city': '北京'
}
print(person['name'])  # 输出: Alice# 集合示例
unique_numbers = {1, 2, 3, 2, 1}
print(unique_numbers)  # 输出: {1, 2, 3}

常见问题及解决方法

问题1：列表和元组的区别是什么？

原因：列表是可变的，而元组是不可变的。

解决方法：根据需求选择使用列表还是元组。如果需要修改数据，使用列表；如果数据不需要改变，使用元组以提高代码的安全性和性能。

问题2：如何在字典中查找键是否存在？

解决方法：使用in关键字或字典的get()方法。

person = {'name': 'Alice', 'age': 25}# 使用in关键字
if 'age' in person:print("年龄存在")# 使用get方法
age = person.get('age')
if age is not None:print(f"年龄是 {age}")

问题3：集合中如何进行并集和交集操作？

解决方法：使用union()和intersection()方法，或者使用|和&运算符。

set1 = {'苹果', '香蕉', '橙子'}
set2 = {'香蕉', '葡萄', '草莓'}# 并集
union_set = set1.union(set2)
print(union_set)  # 输出: {'苹果', '香蕉', '橙子', '葡萄', '草莓'}# 交集
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {'香蕉'}# 使用运算符
union_set = set1 | set2
intersection_set = set1 & set2

问题4：如何对字典进行遍历？

解决方法：可以遍历字典的键、值或键值对。

person = {'name': 'Alice', 'age': 25, 'city': '北京'}# 遍历键
for key in person:print(key)# 遍历值
for value in person.values():print(value)# 遍历键值对
for key, value in person.items():print(f"{key}: {value}")