Python 列表、元组、字典、集合

JSWLCQY

已于 2025-04-17 15:00:09 修改

阅读量1k

点赞数 27

CC 4.0 BY-SA版权

分类专栏： Python学习文章标签： python

于 2024-01-29 19:47:30 首次发布

本文链接：https://blog.csdn.net/JSWLCQY/article/details/135919056

Python学习专栏收录该内容

1 篇文章

订阅专栏

一、列表

1、列表定义

列表是内置可变序列，是包含多个元素的有序的内存空间。定义列表的标准语法格式：
a = [10, 20, 30, 40]
其中10、20、30、40称为：列表a的元素
列表的元素可以各不相同，可以是任意类型。比如：
a = [10, 20, ‘abc’, True]

2、常用列表函数

常用列表函数

3、列表创建

# 列表创建

# 基本语法[]创建
list_1 = [10, 'abc', True]
print("list_1:", list_1)

# list()创建
list_2 = list() #空列表
list_3 = list(range(0, 10, 2))
list_4 = list('hello.world')
print("list_2:", list_2)
print("list_3:", list_3)
print("list_4:", list_4)

# 推导式生成列表
list_5 = [x*2 for x in range(5)]
list_6 = [x*2 for x in range(100) if x%9==0]
print("list_5:", list_5)
print("list_6:", list_6)

3、列表元素增加

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或册除元素，这会大大提高列表的操作效率。

3.1 append()方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。

# 列表元素增加

# append()方法
list_1 = [10, 20]
list_1.append(80)
print(list_1)

3.2 运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

# 运算符操作
list_2 = [20, 40]
print("list_2地址:", id(list_2))
list_2 = list_2 + [50]
print("list_2地址:", id(list_2))
print("list_2:", list_2)

3.3 extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

# extend()方法
list_2 = [20, 40]
print("list_2地址:", id(list_2))
list_2.extend([50, 60])
print("list_2地址:", id(list_2))
print("list_2:", list_2)

3.4 insert插入元素

使用insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有:remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

# insert()插入元素
list_2 = [20, 40]
list_2.insert(1, 100)
print("list_2:", list_2)

3.5 乘法扩展

使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复.

# 乘法扩展
list_1 = ['hello', 40]
list_2 = list_1 * 3
print("list_2:", list_2)

4、列表元素删除

4.1 del删除

删除列表指定位置的元素

# 列表元素删除

# del 删除
list_1 = [10, 20, 30]
del list_1[1]
print("list_1:", list_1)

4.2 pop()方法

删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素

# pop()方法
list_1 = [10, 20, 30, 40, 50]
list_2 = [10, 20, 30, 40, 60]
list_1.pop()
list_2.pop(1)
print("list_1:", list_1)
print("list_2:", list_2)

4.3 remove() 方法

删除首次出现的指定元素，若不存在该元素抛出异常.

# remove()方法
list_1 = [10, 20, 30, 40, 50, 20, 30, 20, 20, 30, 30]
list_1.remove(20)
print("list_1:", list_1)
list_1.remove(100)

4.4 二维列表

# 二维列表

a = [['小明', '12', '上海'], ['小王', '15', '北京'], ['小李', '16', '浙江']]
for i in range(3):
    for j in range(3):
        print(a[i][j], end="\t")
    print()

二、元组

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。

1.元组的核心特点是:不可变序列.
2.元组的访问和处理速度比列表快.
3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用.

1、元组创建

1.1 通过 () 创建元组。小括号可以省略。

如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数1，(1, )解释为元组.

# 元组创建

a = (10, 20, 30)
b = 10, 20, 30
c = (1)
d = (1,)
print(type(a))
print(type(b))
print(type(c))
print(type(d))

1.2 tuple()创建

a = tuple()
b = tuple('abc')
c = tuple(range(3))
d = tuple([2, 3, 4])
print(a)
print(b)
print(c)
print(d)

tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

三、字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象.字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如:整数、浮点数、字符串、元组。但是:列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复.
“值”可以是任意的数据，并且可重复。

1、字典创建

# 字典创建

# 通过{}、dict()创建
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
b = dict(name='B', age='18', job='teacher')
c = dict([('name', 'C'), ('age', '18'), ('job', 'student')])
print(a)
print(b)
print(c)

# 通过zip()创建
k = ['name', 'age', 'job']
v = ['D', '18', 'teacher']
d = dict(zip(k, v))
print(d)

# 通过fromkeys创建值为空的字典
dict_1 = dict.fromkeys(['name', 'age', 'job'])
print(dict_1)

2、字典元素访问

通过**get()方法获得“值”，推荐使用。**优点是:指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象.推荐使用get()获取“值对象”。

# 字典元素访问

# 通过[键]访问
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
print(a['name'])  # 通过[键]访问，若键不存在，则抛出异常

# 通过get()方法获得值
print(a.get('name'), a.get('help'), a.get('name', 'help'))

# 列出所有键值对
print(a.keys())
print(a.values())

# len()键值对的个数
print(len(a))

# 检测一个“键”是否在字典中
print("help" in a)

3、字典元素添加_删除_修改

# 字典元素添加_删除_修改

# 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
a['address'] = 'YiWu'
a['age'] = 16
print("字典a：", a)

# 使用update()将新字典中所有键值对全部添加到旧字典对象上。如果Key有重复，则直接覆盖.
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
b = {'name': 'B', 'money': '100', 'gender': 'man'}
a.update(b)
print("字典a：", a)

# 字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
b = {'name': 'B', 'money': '100', 'gender': 'man'}
del(a['name'])
b.pop('gender')
print("字典a：", a)
print("字典b：", b)

# popitem()：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；poptem弹出随机的项，
# 因为字典并没有“最后的元素”或者其他有关顺序的概念.
# (若想一个接一个地移除并处理项，这个方法就非常有效(因为不用首先获取键的列表)。
a = {'name': 'A', 'age': '18', 'job': 'teacher'}
a.popitem()
print("popitem一次后的字典：", a)
a.popitem()
print("popitem两次后的字典：", a)

4、表格数据存储

# 表格数据存储
dict_1 = {'name': '小明', 'age': '12', 'city': '上海'}
dict_2 = {'name': '小王', 'age': '13', 'city': '北京'}
dict_3 = {'name': '小李', 'age': '14', 'city': '浙江'}
table = [dict_1, dict_2, dict_3]
print(table[1].get('age'))  # 打印第二行人的年龄
for i in range(len(table)):
    print(table[i].get('name'), table[i].get('age'), table[i].get('city'))

四、集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“建对象”，因此是不能重复的且唯一的.

# 集合创建

a = {3, 5, 7}
a.add(9)
print(a)

# 使用set()，将列表、元组等可迭代对象转成集合。
# 如果原来数据存在重复数据，则只保留一个.

set_1 = ['a', 'b', 'b', 'c']
set_2 = set(set_1)
print(set_2)

# remove()删除指定元素；clear()清除整个集合
set_2.remove('a')
print(set_2)