目录
[1. 定义和访问字典](#1. 定义和访问字典)
[2. 增加和修改元素](#2. 增加和修改元素)
[3. 删除元素](#3. 删除元素)
[4. 查询操作](#4. 查询操作)
[1. 定义和创建集合](#1. 定义和创建集合)
[2. 添加和删除元素](#2. 添加和删除元素)
[3. 集合运算](#3. 集合运算)
前言：
在Python中，数据容器是用来存储和组织数据的数据结构。Python提供了几种主要的内置数据容器，如：列表（list）、元组（tuple）、字典（dict）和集合（set），每种容器都有其特定的特性和用途。
一、列表 (List)
- 列表是Python中最常用的数据容器之一。
- 使用方括号
[]定义，可以包含任意类型的元素。 - 可以进行一系列序列操作 如 索引、 切片、增加、删除、修改、查询元素等。
1.创建列表
python
my_list = [1, 2, 3, 'a', 'b', 'c']输出：
python
[1, 2, 3, 'a', 'b', 'c']2.索引和切片
python
# 定义一个列表
my_list = [1, 2, 3, 'a', 'b', 'c']
# 索引访问
print(my_list[0]) # 输出: 1
print(my_list[3]) # 输出: 'a'
# 切片操作
print(my_list[1:4]) # 输出: [2, 3, 'a']输出：
python
1
a
[2, 3, 'a']注意！列表的切片操作与字符串的一致，也要注意几个参数的取值
下面文章中有具体讲：
0基础学python-5：python字符串格式化和切片-CSDN博客
3.增加元素
增加元素有多种方法，以下是其中最常用的两种，利用.append()和.insert()
python
# 定义一个列表
my_list = [1, 2, 3, 'a', 'b', 'c']
# 在列表末尾增加元素
my_list.append('d')
print(my_list) # 输出: [1, 2, 3, 'a', 'b', 'c', 'd']
# 在指定位置插入元素
my_list.insert(2, 'x') # 第一个参数为下标的值，第二个参数为要插入的元素
print(my_list) # 输出: [1, 2, 'x', 3, 'a', 'b', 'c', 'd']输出：
python
[1, 2, 3, 'a', 'b', 'c', 'd']
[1, 2, 'x', 3, 'a', 'b', 'c', 'd']4.删除元素
python
[1, 2, 'x', 3, 'a', 'b', 'c', 'd']
# 删除指定值的元素
my_list.remove('a')
print(my_list) # 输出: [1, 2, 'x', 3, 'b', 'c', 'd']
# 删除指定位置的元素
del my_list[0]
print(my_list) # 输出: [2, 'x', 3, 'b', 'c', 'd']
# 弹出（删除并返回）指定位置的元素
popped_element = my_list.pop(1)
print(popped_element) # 输出: 'x'
print(my_list) # 输出: [2, 3, 'b', 'c', 'd']输出：
python
[1, 2, 'x', 3, 'b', 'c', 'd']
[2, 'x', 3, 'b', 'c', 'd']
x
[2, 3, 'b', 'c', 'd']5.修改元素
python
[2, 3, 'b', 'c', 'd']
# 修改指定位置的元素
my_list[1] = 'y'
print(my_list) # 输出: [2, 'y', 'b', 'c', 'd']输出：
python
[2, 'y', 'b', 'c', 'd']6.查询元素
python
[2, 'y', 'b', 'c', 'd']
# 查询元素是否在列表中
print('b' in my_list) # 输出: True
# 获取元素索引
index = my_list.index('c')
print(index) # 输出: 3
# 统计元素出现次数
count = my_list.count('b')
print(count) # 输出: 1输出：
python
True
3
1二、元组（Tuple）
- 元组是不可变（Immutable）的序列。
- 使用圆括号
()定义，逗号分隔各元素。 - 支持索引访问和切片操作，但不能修改元素。
- 通常用于不可变的数据集合，如函数返回值、数据库查询结果等。
- 实际上，tuple的使用可以使得代码更安全，防止错误赋值导致重要对象的改变。
1.创建元组
python
my_tuple = (1, 2, 3, 'x', 'y', 'z')输出：
python
(1, 2, 3, 'x', 'y', 'z')2.索引和切片
python
# 定义一个元组
my_tuple = (1, 2, 3, 'x', 'y', 'z')
# 索引访问
print(my_tuple[0]) # 输出: 1
print(my_tuple[3]) # 输出: 'x'
# 切片操作
print(my_tuple[1:4]) # 输出: (2, 3, 'x')输出：
python
1
x
(2, 3, 'x')3.查询元素
python
# 查询元素是否在元组中
print('x' in my_tuple) # 输出: True
# 获取元素索引
index = my_tuple.index('y')
print(index) # 输出: 4
# 统计元素出现次数
count = my_tuple.count(3)
print(count) # 输出: 1输出:
python
True
4
1注意！元组是不可变的，因此增、删、改的操作并不适用。
三、字典（Dictionaries）
- 字典是键-值对（Key-Value）的映射集合。
- 使用花括号
{}定义，每个键值对使用冒号:分隔。 - 键必须是唯一的且不可变（通常是字符串或数字），值可以是任意类型。
- 是一种非常灵活和有用的数据结构，能够存储键值对并支持高效的增加、删除、修改和查询操作。
1. 定义和访问字典
python
# 定义一个字典
my_dict = {
'name': 'Alice',
'age': 30,
'city': 'New York'
}
# 访问字典中的值
print(my_dict['name']) # 输出: 'Alice'
print(my_dict['age']) # 输出: 30输出：
python
Alice
302. 增加和修改元素
python
# 增加新的键值对
my_dict['email'] = '[email protected]' # 默认在末尾增加
print(my_dict) # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York', 'email': '[email protected]'}
# 修改现有键的值
my_dict['age'] = 31
print(my_dict) # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': '[email protected]'}输出：
python
{'name': 'Alice', 'age': 30, 'city': 'New York', 'email': '[email protected]'}
{'name': 'Alice', 'age': 31, 'city': 'New York', 'email': '[email protected]'}3. 删除元素
python
{'name': 'Alice', 'age': 31, 'city': 'New York', 'email': '[email protected]'}
# 删除键值对
del my_dict['city'] # 将{'city':'New York'} 删除了
print(my_dict) # 输出: {'name': 'Alice', 'age': 31, 'email': '[email protected]'}
# 使用 pop 方法删除并返回值
removed_email = my_dict.pop('email')
print(removed_email) # 输出: '[email protected]'
print(my_dict) # 输出: {'name': 'Alice', 'age': 31}输出：
python
{'name': 'Alice', 'age': 31, 'email': '[email protected]'}
[email protected]
{'name': 'Alice', 'age': 31}4. 查询操作
python
{'name': 'Alice', 'age': 31}
# 查询键是否存在
print('age' in my_dict) # 输出: True
# 获取所有键
keys = my_dict.keys()
print(keys) # 输出: dict_keys(['name', 'age'])
# 获取所有值
values = my_dict.values()
print(values) # 输出: dict_values(['Alice', 31])
# 获取所有键值对
items = my_dict.items()
print(items) # 输出: dict_items([('name', 'Alice'), ('age', 31)])输出：
python
True
dict_keys(['name', 'age'])
dict_values(['Alice', 31])
dict_items([('name', 'Alice'), ('age', 31)])四、集合（Set）
- 集合是无序、不重复的元素集合。
- 使用花括号
{}定义，逗号分隔各元素。 - 支持成员检测、添加、删除等操作。
- 可变（Mutable）。
- 是一种无序且元素唯一的数据结构，支持高效的集合运算（并集、交集、差集等）。
1. 定义和创建集合
python
# 定义一个集合
my_set = {1, 2, 3, 4, 5}
# 打印集合
print(my_set) # 输出: {1, 2, 3, 4, 5}输出：
python
{1, 2, 3, 4, 5}2. 添加和删除元素
python
{1, 2, 3, 4, 5}
# 添加元素
my_set.add(6)
print(my_set) # 输出: {1, 2, 3, 4, 5, 6}
# 重复添加相同元素不会产生变化
my_set.add(6)
print(my_set) # 输出: {1, 2, 3, 4, 5, 6}
# 删除元素
my_set.remove(3)
print(my_set) # 输出: {1, 2, 4, 5, 6}
# 使用 discard 删除元素，如果元素不存在，不会引发错误
my_set.discard(10)
print(my_set) # 输出: {1, 2, 4, 5, 6}输出：
python
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}
{1, 2, 4, 5, 6}3. 集合运算
python
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
# 并集
union_set = set1.union(set2)
print(union_set) # 输出: {1, 2, 3, 4, 5, 6, 7}
# 交集
intersection_set = set1.intersection(set2)
print(intersection_set) # 输出: {3, 4, 5}
# 差集
difference_set = set1.difference(set2)
print(difference_set) # 输出: {1, 2}输出：
python
{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}其他操作
- 列表，字典，集合都可以使用.clear()方法清空所有元素
- 单元组的定义需要(a,)，在第一个元素后加一个逗号，不然会报错