Python 数据类型进阶：列表、字典与集合

在Python中，数据类型是编程的基础，熟练掌握常用数据结构是成为高级开发者的关键。上一篇文章我们学习到了Python的数据类型：字符串(string)、数字(Number)、布尔值（Boolean） 本文将为你详细介绍Python中常见的三种数据类型：列表（List）、字典（Dict）元组（Tuple）和集合（Set）。我们将探讨它们的创建、常规操作以及如何在它们之间进行转换。

1.列表（List）

列表是一种有序、可变、可以包含重复元素的数据类型。在Python中，列表是非常常用的数据结构之一，它可以容纳不同类型的数据。

1.1创建列表

你可以使用方括号 [] 或者使用list()函数来创建一个列表，可以写不同的数据类型(无限长度)

用法：变量名=[数据类型1,数据类型2,数据类型3,数据类型n+1]

PS：每个数据类型之间使用,隔开 逗号是英文状态下的

list_data=[1,1.5,'字符串数据',True]  #使用[]创建即可
list_data2=list([1,1.5,'字符串数据',True])   #使用list函数的同时还要写[] 比较麻烦一点

print(list_data) #输出：[1,1, 1.5, '字符串数据', True]

1.2常规操作

• 访问元素：通过索引访问列表中的元素，索引从0开始 使用[] 访问 里面填写访问的位置
• 0表示第一位 假如填写5 就是访问第6位置 逗号之间开始算索引 而不是逗号里面的数据
• 也可以使用len()方法查询长度 len(变量名) 这个方法是从1开始计算 而不是0

list_data=[1,1.5,'字符串数据',True]
print(list_data[0]) #输出：1
print(len(list_data)) #输出：5

• 修改元素：通过索引值修改列表中的元素。
• 用法：变量名[索引值] =要修改的数据
• 修改前 [1,1,1.5,'字符串数据',True] 修改后 [['修改了第一位数据',1,1.5,'字符串数据',True]

list_data=[1,1,1.5,'字符串数据',True]
list_data[0] = '修改了第一位数据' #修改索引值为0的数据 修改为字符串
print(my_list)  # 输出 ['修改了第一位数据', '1,1.5,'字符串数据',True]

• 添加元素：使用append()向列表末尾添加一个元素 只会在最后一位
• 用法:变量名.append(添加的数据类型)

list_data=[1,1,1.5,'字符串数据',True]
list_data.append('new')
print(list_data)  # 输出 [1,1,1.5,'字符串数据',True 'new']

• 删除元素：
• 使用remove()删除指定元素 用法：变量名.remove(删除的指定的数据值的类型)
• pop()根据索引删除并返回元素 用法：变量名.pop(根据指定的索引值删除数据)

list_data=[1,1,1.5,'字符串数据',True]

#remove()删除指定的值 
list_data.remove(1.5)  # 删除第一个出现的 1
print(list_data)  # 输出 [1, 1, '字符串数据', True]

#pop()删除指定的索引值
list_data.pop(0)  # 删除索引为0的元素
print(list_data)  # 输出 [1, 1.5, '字符串数据', True]

• 列表切片

切片允许你获取列表的子列表，可以通过 [start:end:step] 来指定开始和结束位置，

start从0开始计算 end不包括 step 可以指定步长 与字符串切片大同小异

list_data = [1, 2, 3, 4, 5]
print(list_data[0:3])  # 输出 [1,2, 3]    从索引值0获取到索引值为3的值
print(list_data[::2])  # 输出 [1, 3, 5]  最后一个2表示跨度为2 表示间隔一个获取数据 

假如写4就是间隔三个数据 然后获取数据

2.字典（Dict）

字典是一个无序的键值对集合，键必须是唯一的，而值则可以是任意类型。字典非常适用于存储有关系的数据，比如属性和值的映射。

创建字典

使用大括号 {} 或dict() 函数来创建一个字典，键和值之间使用冒号 : 分隔 键值对之间使用,分割

用法：变量名={数据类型1:数据类型2,数据类型3:数据类型4} 这里表示有两对数据 而不是四对

PS：一个字典必须有键和值 第一个数据表示键 第二个表示值 连起来就是键值对

#使用{} 创建一个字典  常用{}来创建
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}  #name表示键  Alice表示值 

# 使用 dict() 函数创建字典
my_dict2 = dict(name='Alice', age=25)

# 从一个元组列表创建字典
my_dict3 = dict([('name', 'Alice'), ('age', 25)])

print(my_dict) #输出  {'name': 'Alice', 'age': 25, 'city': 'New York'}

常规操作

• 访问值：通过键来访问(获取)字典中的值
• 使用[]访问(获取)值 用法：变量名[键]
• get()根据键获取值 用法：变量名.get(键)

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(my_dict['name'])  # 输出 Alice
print(my_dict.get('age'))  # 输出 25

• 添加或更新键值对：可以通过直接指定键来添加或更新值
• 更改值使用方法：变量名[键]=需要更改的值
• 添加值方法：变量名[键]=值

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'} 
my_dict['age'] = 26  # 更新 'age' 的值为 26
my_dict['gender'] = 'Female'  # 添加新键 'gender'
print(my_dict)  # 输出 {'name': 'Alice', 'age': 26, 'city': 'New York', 'gender': 'Female'}

• 删除键值对：
• 使用del关键字删除指定键 用法：del 变量名[删除的指定的键] 删除键值就会不存在
• pop()根据指定键删除值 用法：变量名.pop(根据指定的键删除值) 删除键值就会不存在
• PS:这两个删除方法的代码都是单独运行，而不是在一起运行

#使用del关键字删除
del my_dict['city']  # 删除 'city' 键
print(my_dict)  # 输出 {'name': 'Alice', 'age': 26, 'gender': 'Female'}

#使用pop方法删除
my_dict.pop('age')  # 删除 'age' 键并返回其值
print(my_dict)  # 输出 {'name': 'Alice', 'city': 'New York'}

• 获取所有键、值与项：
• 使用keys()方法获取字典所有键 用法：变量名.keys()
• 使用values()方法获取字典所有值 用法：变量名.values()
• 使用items()方法获取字典所有键值 用法：变量名.items()
• PS：这几个方法不接受任何参数，因此括号里不能传递其他参数

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'} 

print(my_dict.keys())  # 输出 dict_keys(['name', 'age', 'city'])
print(my_dict.values())  # 输出 dict_values(['Alice', 25, 'New York'])
print(my_dict.items())  #输出  dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

3.元组（Tuple）

元组是一个有序的、不变的元素集合。与列表类似，但元组创建后不能修改，通常用于存储不可更改的数据，如坐标、日期等。

创建元组
使用小括号 () 或tuple()函数来创建一个元组，元素之间用逗号 , 分隔。

# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)

#tuple函数创建
my_tuple = tuple((1,2,3,4,5))

常规操作

• 访问元素：可以通过索引访问元组中的元素。

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])  # 输出 1

• 切片：与列表类似，元组也可以使用切片来获取一部分元素。

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

• 连接元组：可以使用 + 运算符将元组合并。

my_tuple = (1, 2, 3, 4, 5)
tuple_a = (1, 2)
tuple_b = (3, 4)
print(tuple_a + tuple_b)  # 输出 (1, 2, 3, 4)

• 重复元组：可以使用 * 运算符重复元组。

tuple_c = (5, 6)
print(tuple_c * 3)  # 输出 (5, 6, 5, 6, 5, 6)  重复输出3遍

• 元组运算：元组支持一些基本的运算，如查找元素个数、元素位置等
• count() 方法查找某个元素在元组里面存在的个数
• index() 方法根据指定的数据 查找所在的索引值

my_tuple = (1, 2, 3, 4, 5)

# 查找元素个数   
print(my_tuple.count(3))  # 查找数据3my_tuple存在的次数 在输出 1

# 查找元素的位置
print(my_tuple.index(4))  #查找数据4的索引值 输出 3

4.集合（Set）

集合是一个无序的、不重复的元素集合。集合通常用于去重和进行集合运算（如交集、并集、差集等）。

创建集合

使用大括号 {} 或ste()函数 来创建一个集合

PS：字典（dict）和集合（set）都使用花括号 {} 来创建，虽然它们的用途和行为是不同的，但有一些设计上的相似性

如何区分：通过 {} 的内容（是否有 :）来区分，字典有: 而集合没有

# {}创建一个集合
my_set = {1, 2, 3, 4, 5}

# 使用 set() 函数创建集合
my_set2 = set([1, 2, 3])

常规操作

• 添加元素：使用add()方法将元素添加到集合中 使用方法：变量名.add(添加的数据类型)

my_set = {1, 2, 3, 4, 5}
my_set.add(6)  #添加int类型的数字6
print(my_set)  # 输出 {1, 2, 3, 4, 5, 6}

• 删除元素：
• 使用remove()方法删除元素 （删除不存在的会报错）
• 使用discard()方法删除元素（如果元素不存在不会报错）

my_set = {1, 2, 3, 4, 5}
my_set.remove(3)  # 删除元素 3   删除不存在的会报错
my_set.discard(7)  # 删除元素 7，如果不存在也不会报错
print(my_set)  # 输出 {1, 2, 4, 5, 6}

• 集合运算：
• 1.交集（Intersection）

交集操作用于获取两个集合中都存在的元素。

使用 & 运算符来进行交集操作。

示例：

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print(set_a & set_b)  # 输出 {3}

解释： 交集结果 {3} 表示 set_a 和 set_b 中都包含的元素是 3，因此输出是 {3}

• 2.并集（Union）

并集操作用于获取两个集合中所有元素的集合，重复的元素会自动去重。

使用 | 运算符来进行并集操作。

示例：

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print(set_a | set_b)  # 输出 {1, 2, 3, 4, 5}

解释： 并集结果 {1, 2, 3, 4, 5} 包含了 set_a 和 set_b 中所有的元素，重复的 3 只会出现一次，最终结果去重后输出 {1, 2, 3, 4, 5}

• 3.差集（Difference）

差集操作用于获取在一个集合中但不在另一个集合中的元素。

使用 - 运算符来进行差集操作。

示例：

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print(set_a - set_b)  # 输出 {1, 2}

解释： 差集结果 {1, 2} ，set_a里面3在set_b里面 -获取不在的元素，即 1 和 2

• 总结

1. 交集（&）：返回两个集合中都存在的元素。
2. 并集（|）：返回两个集合中的所有元素（去重）。
3. 差集（-）：返回一个集合中存在而另一个集合中不存在的元素。

这些集合操作在处理数据时非常有用，尤其在需要快速去重、查找共同元素或计算差异的情况下。在实际开发中，掌握这些基本操作能够提高代码的效率和可读性。

4.数据类型转换

Python提供了灵活的方式进行不同数据类型之间的转换：

• 如何查看数据类型:通过type()函数查看 通过输出可以确定其数据类型：

# 查看一个字符串的类型
name = "Alice"
print(type(name))  # 输出 <class 'str'>

# 查看一个整数的类型
x = 10
print(type(x))  # 输出 <class 'int'>


# 查看一个列表的类型
my_list = [1, 2, 3]
print(type(my_list))  # 输出 <class 'list'>

# 查看一个元组的类型
my_tuple = (1, 2, 3)
print(type(my_tuple))  # 输出 <class 'tuple'>

# 查看一个字典的类型
my_dict = {'name':'tom','age':18}
print(type(my_dict))  # 输出 <class 'dict'>

• 字符串转数字（只包含数字类等）

age='18'  #需要注意这个添加了''就表示字符串 
to_int=int(age) #使用int函数转换.
print(to_int) #输出18
print(type(to_int)) #输出<class 'int'>

• 数字转字符串

age=18  #只是替换了数据类型和函数
to_int=str(age) #使用str函数转换.
print(to_int) #输出18
print(type(to_int)) #输出<class 'str'>

• 列表 (List) 转 元组 (Tuple)

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出 (1, 2, 3)  

• 元组 (Tuple) 转 列表 (List)

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出 [1, 2, 3]

不同的数据类型，有何区别？如何体现出来？

• 列表（List）：有序、可变，适用于存储多个元素并保持其顺序 体现特性代码：

# 创建列表
my_list = [1, 2, 3, 4]

# 保持顺序
print(my_list)  # 输出 [1, 2, 3, 4, 5]

# 添加元素（可变）
my_list.append(5)

# 通过索引访问元素
print(my_list[0])  # 输出 1

• 字典（Dict）：无序、键值对结构，适合存储键值映射 体现特性代码：

# 创建字典
my_dict = {'name': 'Alice', 'age': 25}

# 字典中的键值对
print(my_dict['name'])  # 输出 Alice

# 添加新的键值对
my_dict['city'] = 'New York'
print(my_dict)  # 输出 {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 无序（遍历顺序不固定）
for key, value in my_dict.items():
    print(key, value)

• 元组(Tuple):有序的、不变的元素集合 体现特性代码：

# 创建元组
my_tuple = (1, 2, 3, 4)

# 元组是不可变的，不能修改
# my_tuple[0] = 10  # 尝试修改索引值0的值为10  会抛出 TypeError 错误

# 通过索引访问元素
print(my_tuple[1])  # 输出 2

• 集合（Set）：无序、不可重复，适合进行去重和集合运算 体现特性代码：

# 创建集合
my_set = {1, 2, 3, 4, 5}

# 添加元素（无序，且元素不可重复）
my_set.add(6)
my_set.add(3)  # 3 已经存在，不会添加

print(my_set)  # 输出 {1, 2, 3, 4, 5, 6}

# 集合去重功能
my_list_with_duplicates = [1, 2, 2, 3, 4, 4]
unique_set = set(my_list_with_duplicates)
print(unique_set)  # 输出 {1, 2, 3, 4}

总结：

• 列表 (List)：你可以看到它是有顺序的，且你可以修改它（通过 append）。
• 字典 (Dict)：它存储的是 键值对，顺序不固定，但通过键可以直接访问值。
• 元组 (Tuple)：它是不可变的，元素一旦定义就不能改变。
• 集合 (Set)：它是无序的，并且自动去重，不允许重复元素。你可以对集合进行集合运算（如并集、交集）。

• 理解这些基本数据类型及其常规操作，能够让你在Python编程中更加得心应手。如果你掌握了它们，你将能够处理大多数编程任务，并为后续学习更复杂的数据结构和算法打下坚实的基础。

希望这篇文章对你理解Python的数据类型有所帮助！如果有任何问题，欢迎随时提问！