0基础学python-9：数据容器（列表、元组、字典、集合）

目录

前言：

一、列表 (List)

1.创建列表

2.索引和切片

3.增加元素

4.删除元素

5.修改元素

6.查询元素

二、元组（Tuple）

1.创建元组

2.索引和切片

3.查询元素

三、字典（Dictionaries）

[1. 定义和访问字典](#1. 定义和访问字典)

[2. 增加和修改元素](#2. 增加和修改元素)

[3. 删除元素](#3. 删除元素)

[4. 查询操作](#4. 查询操作)

四、集合（Set）

[1. 定义和创建集合](#1. 定义和创建集合)

[2. 添加和删除元素](#2. 添加和删除元素)

[3. 集合运算](#3. 集合运算)

其他操作

---

前言：

在Python中，数据容器是用来存储和组织数据的数据结构。Python提供了几种主要的内置数据容器，如：列表（list）、元组（tuple）、字典（dict）和集合（set），每种容器都有其特定的特性和用途。

一、列表 (List)

• 列表是Python中最常用的数据容器之一。
• 使用方括号 [] 定义，可以包含任意类型的元素。
• 可以进行一系列序列操作 如 索引、 切片、增加、删除、修改、查询元素等。

1.创建列表

my_list = [1, 2, 3, 'a', 'b', 'c']

输出：

[1, 2, 3, 'a', 'b', 'c']

2.索引和切片

# 定义一个列表
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']

输出：

1
a
[2, 3, 'a']

注意！列表的切片操作与字符串的一致，也要注意几个参数的取值

下面文章中有具体讲：

0基础学python-5：python字符串格式化和切片-CSDN博客

3.增加元素

增加元素有多种方法，以下是其中最常用的两种，利用.append()和.insert()

# 定义一个列表
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']

输出：

[1, 2, 3, 'a', 'b', 'c', 'd']
[1, 2, 'x', 3, 'a', 'b', 'c', 'd']

4.删除元素

[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']

输出：

[1, 2, 'x', 3, 'b', 'c', 'd']
[2, 'x', 3, 'b', 'c', 'd']
x
[2, 3, 'b', 'c', 'd']

5.修改元素

[2, 3, 'b', 'c', 'd']

# 修改指定位置的元素
my_list[1] = 'y'
print(my_list)      # 输出: [2, 'y', 'b', 'c', 'd']

输出：

[2, 'y', 'b', 'c', 'd']

6.查询元素

[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

输出：

True
3
1

二、元组（Tuple）

• 元组是不可变（Immutable）的序列。
• 使用圆括号 () 定义，逗号分隔各元素。
• 支持索引访问和切片操作，但不能修改元素。
• 通常用于不可变的数据集合，如函数返回值、数据库查询结果等。
• 实际上，tuple的使用可以使得代码更安全，防止错误赋值导致重要对象的改变。

1.创建元组

my_tuple = (1, 2, 3, 'x', 'y', 'z')

输出：

(1, 2, 3, 'x', 'y', 'z')

2.索引和切片

# 定义一个元组
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')

输出：

1
x
(2, 3, 'x')

3.查询元素

# 查询元素是否在元组中
print('x' in my_tuple)   # 输出: True

# 获取元素索引
index = my_tuple.index('y')
print(index)        # 输出: 4

# 统计元素出现次数
count = my_tuple.count(3)
print(count)        # 输出: 1

输出:

True
4
1

注意！元组是不可变的，因此增、删、改的操作并不适用。

三、字典（Dictionaries）

• 字典是键-值对（Key-Value）的映射集合。
• 使用花括号 {} 定义，每个键值对使用冒号 : 分隔。
• 键必须是唯一的且不可变（通常是字符串或数字），值可以是任意类型。
• 是一种非常灵活和有用的数据结构，能够存储键值对并支持高效的增加、删除、修改和查询操作。

1. 定义和访问字典

# 定义一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 访问字典中的值
print(my_dict['name'])    # 输出: 'Alice'
print(my_dict['age'])     # 输出: 30

输出：

Alice
30

2. 增加和修改元素

# 增加新的键值对
my_dict['email'] = 'alice@example.com'   # 默认在末尾增加
print(my_dict)            # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York', 'email': 'alice@example.com'}

# 修改现有键的值
my_dict['age'] = 31
print(my_dict)            # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}

输出：

{'name': 'Alice', 'age': 30, 'city': 'New York', 'email': 'alice@example.com'}
{'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}

3. 删除元素

{'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}

# 删除键值对
del my_dict['city']       # 将{'city':'New York'} 删除了
print(my_dict)            # 输出: {'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}

# 使用 pop 方法删除并返回值
removed_email = my_dict.pop('email')
print(removed_email)      # 输出: 'alice@example.com'
print(my_dict)            # 输出: {'name': 'Alice', 'age': 31}

输出：

{'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}
alice@example.com
{'name': 'Alice', 'age': 31}

4. 查询操作

{'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)])

输出：

True
dict_keys(['name', 'age'])
dict_values(['Alice', 31])
dict_items([('name', 'Alice'), ('age', 31)])

四、集合（Set）

• 集合是无序、不重复的元素集合。
• 使用花括号 {} 定义，逗号分隔各元素。
• 支持成员检测、添加、删除等操作。
• 可变（Mutable）。
• 是一种无序且元素唯一的数据结构，支持高效的集合运算（并集、交集、差集等）。

1. 定义和创建集合

# 定义一个集合
my_set = {1, 2, 3, 4, 5}

# 打印集合
print(my_set)   # 输出: {1, 2, 3, 4, 5}

输出：

{1, 2, 3, 4, 5}

2. 添加和删除元素

{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}

输出：

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}
{1, 2, 4, 5, 6}

3. 集合运算

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}

输出：

{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}

其他操作

• 列表，字典，集合都可以使用.clear()方法清空所有元素
• 单元组的定义需要(a,)，在第一个元素后加一个逗号，不然会报错