Python基础内容（四、组合数据类型之列表、元组和字典）

努力学习的小白P

已于 2022-05-01 18:21:16 修改

阅读量804

点赞数 1

分类专栏： Python基础内容文章标签： python 经验分享

于 2022-04-27 19:07:06 首次发布

本文链接：https://blog.csdn.net/qq_52981661/article/details/124457995

版权

Python基础内容专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

- 四、组合数据类型

四、组合数据类型

内置函数range（）

用于生成一个整数序列，返回值是一个迭代器对象
创建range对象的方式：range（【start，】stop【，step】）（【…】可省略）
- start：起始索引（默认从0开始）
- stop：结束索引（不含stop）
- step：步长，默认为1；步长为负数，表示从右向左切片
range类型的优点：
不管range对象表示的整数的序列有多长，所有range对象占用的内存空间都是相同的；因为仅仅需要存储start，stop，step，只有当用到range对象时，才会去计算序列中的相关元素；
in与not in判断整数序列中是否存在（不存在）指定的整数；

列表

可变序列，顺序存储，表中元素可以重复

创建列表：
- list_demo1 = []
- list_demo2 = list（）
slice切片：语法格式：[start：end：step]
- start：切片开始的索引（默认从0开始）
- end：切片结束的索引（不包含end）（默认序列长度）
- step：步长，默认为1；步长为负数，表示从右向左切片；

-6	-5	-4	-3	-2	-1
p	y	t	h	o	n
0	1	2	3	4	5

list_demo = [1, 2, 3, 4, 5, 6]
print(list_demo[5::-1])
#[6, 5, 4, 3, 2, 1]
print(list_demo[-1::-1])
#[6, 5, 4, 3, 2, 1]

查找：index（x【，start【，end】】）
- 找出x第一次出现的位置；
- start：从开始索引
- end：结束索引

list_demo = [1, 2, 3, 4, 5, 6, 2]
print(list_demo.index(2))	# 1

添加元素

append（）
在列表的尾部追加一个元素，该方法可以接受单个值，也接受元组或列表，但此时，元组或列表作为一个整体追加，形成了嵌套；

list_demo = [1, 2, 3, 4]
list_demo.append([5, 6])
print(list_demo)
#[1, 2, 3, 4, [5, 6]]

insert（指定位置，要插入的元素）
在列表指定的位置插入：

list_demo = [1, 2, 3, 4]
list_demo.insert(1, 9)
print(list_demo)
#[1, 9, 2, 3, 4]

extend（）
将一个列表的元素追加到另一个列表的尾部；

list_demo = [1, 2, 3, 4]
list_demo.extend([5, 6])
print(list_demo)
#[1, 2, 3, 4, 5, 6]

切片添加

list_demo1 = [1, 2, 3, 4]
list_demo2 = [5, 6]
list_demo1[1:] = list_demo2
print(list_demo1)
#[1, 5, 6]

删除元素

del（）
根据索引删除列表中的一个元素或一段区间中的元素；删除列表

list_demo = [1, 2, 3, 4, 5, 6]
del list_demo[1:2]
print(list_demo)	# [1, 3, 4, 5, 6]
del list_demo	# NameError: name 'list_demo' is not defined

remove（）
根据元素本身删除列表中的某个元素

list_demo = [1, 2, 3, 4, 5, 6]
list_demo.remove(2)
print(list_demo)	# [1, 3, 4, 5, 6]

clear（）
清空列表

list_demo = [1, 2, 3, 4, 5, 6]
list_demo.clear()
print(list_demo)	# []

pop（x）
弹出并返回索引x的元素；默认弹出列表最后一个值

list_demo = [1, 2, 3, 4, 5, 6]
list_demo.pop()
print(list_demo)	# [1, 2, 3, 4, 5]

置逆和排序

置逆：reverse（）和 reversed（）
（reversed（）需要列表化）

# 将列表中的元素置逆
list_demo = [1, 2, 3, 4, 5, 6]
list_demo.reverse()
print(list_demo)
# [6, 5, 4, 3, 2, 1]

list_demo1 = [1, 2, 3, 4, 5, 6]
list_demo2 = list(reversed(list_demo1))
print(list_demo2)
# [6, 5, 4, 3, 2, 1]

排序：sort（）和 sorted（）
可以通过reverse = True 使元素逆序

sort（）是直接在原列表上排序，sorted（）是新生成一个列表进行排序，对原列表无影响

# 将列表中的元素排序
list_demo = [1, 3, 2, 4, 6, 0]
list_demo.sort(reverse=True)
print(list_demo)
# [6, 5, 4, 3, 2, 1]

list_demo1 = [1, 3, 2, 4, 6, 0]
list_demo2 = sorted(list_demo1)
print(list_demo1)	
# [1, 3, 2, 4, 6, 0]
print(list_demo2)
# [0, 1, 2, 3, 4, 6]

浅拷贝与深拷贝

copy（）：浅拷贝，原列表中的可变序列会根据拷贝列表中的序列元素变化而变化
deepcopy（）：深拷贝，避免了浅拷贝对原列表和拷贝列表中可变序列变化的影响

# 浅拷贝
import copy
list_demo1 = [1, 1, 1, [1, 1, 1]]
list_demo2 = copy.copy(list_demo1)
list_demo2[0] = 9
list_demo2[3][0] = 9
print(list_demo1)
# [1, 1, 1, [9, 1, 1]]
print(list_demo2)
# [9, 1, 1, [9, 1, 1]]

# 深拷贝
import copy
list_demo1 = [1, 1, 1, [1, 1, 1]]
list_demo2 = copy.deepcopy(list_demo1)
list_demo2[0] = 9
list_demo2[3][0] = 9
print(list_demo1)
# [1, 1, 1, [1, 1, 1]]
print(list_demo2)
# [9, 1, 1, [9, 1, 1]]

列表生成式

list_demo = [表达式 for i in range（范围）【if 条件】]

list_demo = [i * i for i in range(10) if i % 2 == 0]
print(list_demo)
# [0, 4, 16, 36, 64]

元组

不可变序列，顺序存储，元组中元素可以重复

创建元组
- tuple_demo1 = （）
- tuple_demo2 = tuple（）
- tuple_demo3 = 1,
若创建时只有一个元素，则必须在元素后加逗号，否则被视为变量；

字典

可变序列，哈希存储，字典中的键不可重复且必须是不可变序列，值可以重复

创建字典

dict_demo1 = {}
dict_demo2 = dict（）

以关键字参数的形式创建字典

dict_demo3 = dict(name='努力学习的小白P', age=30)
print(dict_demo3)
# {'name': '努力学习的小白P', 'age': 20}

访问元素：字典名[键名]

如果键名不存在，则返回KeyError: ‘键名’、

添加元素

字典名[键名] = 值

如果键已存在，则修改值，否则添加新键；

删除元素

del （）字典名[键名]

popitem（）

返回并删除字典最后一个键值对；

dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
print(dict_demo.popitem())
# ('occupation', '学生')

pop（键名）

弹出并返回与键名对应的元素；
clear（）

清空字典；

获取键值

get（）

返回指定键对应的值，并允许该键不存在时返回特定的值,默认返回None；

dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
print(dict_demo.get('努力学习的小白P', '一起来学习吧！'))
# 一起来学习吧！

items（）
可以返回字典的键和值，返回值为键值类型；

dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
x = dict_demo.items()
print(x, '\n', type(x))
# dict_items([('name', '努力学习的小白P'), ('age', 20), ('occupation', '学生')]) 
# <class 'dict_items'>

keys（）

返回字典的键；
values（）

返回字典的值；

fromkeys（keys，value）

创建新字典，给定keys作字典的键，value为字典所有键的值；

dict_demo = {}
x = dict_demo.fromkeys(['小白P', '小白L', '小白J'], '快去学习！')
print(x)
# {'小白P': '快去学习！', '小白L': '快去学习！', '小白J': '快去学习！'}

字典生成式

zip()函数

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表；
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同；
利用 * 号操作符，可以将元组解压为列表；

a = [1, 2, 3]
b = [3, 2, 1]
c = [1, 2, 3, 4, 5]
zipped = zip(a, b)
print(zipped)
# <zip object at 0x00000168D2C77780>
print(list(zipped))
# [(1, 3), (2, 2), (3, 1)]
print(list(zip(a, c)))
# [(1, 1), (2, 2), (3, 3)]

e, d = zip(*zip(a, b))
print(list(e))
# [1, 2, 3]
print(list(d))
# [3, 2, 1]