零基础小白的Python学习之路（三）序列：列表、元组、字典、集合

最新推荐文章于 2023-09-14 09:53:49 发布

Stefan_xiao

最新推荐文章于 2023-09-14 09:53:49 发布

阅读量329

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_35495464/article/details/106722232

版权

python 专栏收录该内容

7 篇文章 2 订阅

订阅专栏

序列

序列
一、列表
二、元组
三、字典
四、集合

参考资料：《Python编程从入门到实战》+ 尚学堂Python400集

序列

序列用于存储一系列数据，这些数据可以不一定是相同类型的。
在内存中，序列就是一块用来存放多个值的连续的内存空间。

10	20	30	40

Python中常用序列结构：
字符串、列表、元组、字典、集合

一、列表

用于存储任意数目、任意类型的数据集合，内置可变序列
基本格式：变量名 = [列表元素1 , 列表元素2 , …]

基本方法汇总

# 列表对象常用方法汇总
a = [23,"dnf",True,40]
print(a)

# 在列表尾部添加元素
a.append(25)
print(a)

# 将另一列表所有元素添加到本列表尾部
list1 = [1,4,7,9]
list2 = [22,3,"acn",6,12]
list1.extend(list2)
print(list1)

# 列表指定位置处插入元素
a.insert(2,50)
print(a)

# 列表删除首次出现的指定元素
b = [12,3,8,3,1,3,7,3]
b.remove(3)
print(b)

# 删除列表指定位置处元素，默认为最后一个
a.pop(3)
print(a)
a.pop() # 删最后一个
print(a)

# 返回指定元素的位置下标，若不存在，抛异常
# 格式：index(value,start,end) 包头不包尾
print("元素50的索引下标:",a.index(50))
print("元素'dnf'的下标",a.index('dnf',0,2))

# 返回指定元素在列表中出现次数
print("元素3出现的次数:",b.count(3))

# 列表长度
print(len(b))

# 翻转列表（原地）
b.reverse()
print(b)

# 列表原地排序
b.sort()
print(b)
b.sort(reverse=True) # 降序排列
print(b)

# 返回列表对象的浅拷贝
c = b.copy()
print(c)

# 清空所有元素（删除所有元素，而不是删除列表对象）
b.clear()
print(b)

在这里插入图片描述

列表的创建

基本语法

>>> a = [] # 空列表对象
>>> a
[]
>>> a = [10,20,'xxx',True]
>>> a
[10, 20, 'xxx', True]
>>>

list()创建

>>> a = list()
>>> a
[]
>>> a = list("computer vision")
>>> a
['c', 'o', 'm', 'p', 'u', 't', 'e', 'r', ' ', 'v', 'i', 's', 'i', 'o', 'n']
>>>

range()创建整数列表

基本格式：range(start , end , step)

start：起始数字，可选，默认为数字0
end：结尾数字，必选
step：步长，可选，默认步长为1
包头不包尾

【注】Python3中range()返回的是一个range对象，而不是列表，我们还需要通过list()方法将其转换成列表对象

>>> a = range(8)
>>> a
range(0, 8)
>>> a = list(a)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7]
>>> a = range(3,15,2)
>>> a
range(3, 15, 2)
>>> a = list(a)
>>> a
[3, 5, 7, 9, 11, 13]
>>> print(list(range(15,3,-1)))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

推导式生成列表

>>> a = [x*2 for x in range(5)]
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if(x%9==0)]
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

乘法扩展

>>> a = [12,'sdf',True]
>>> b = a*3
>>> b
[12, 'sdf', True, 12, 'sdf', True, 12, 'sdf', True]

列表中的“+”运算符操作

“+”运算符操作是通过创建新的列表对象，然后再将原列表的元素和新列表的元素依次复制到新的列表对象中，会涉及大量复制操作，时间复杂度会很高，不建议使用

>>> a = [12,49,30]
>>> id(a)
53323912
>>> a = a + [10,20]
>>> id(a)
59894280
>>> a
[12, 49, 30, 10, 20]

通过id()函数我们发现列表a的地址已经发生了变化，所以说明创建了新的对象

sort()函数和sorted()函数

sort(默认升序，reverse=True为降序)：永久性排序，排序已经完全改变，无法再找到原来的排序
sorted(变量名)：临时性排序，不影响列表的原始排序

>>> a = [12,9,10,1,2,7]
>>> a.sort()
>>> print(a)
[1, 2, 7, 9, 10, 12]

>>> a = [12,9,10,1,2,7]
>>> print(sorted(a))
[1, 2, 7, 9, 10, 12]
>>> print(a)
[12, 9, 10, 1, 2, 7]

列表的遍历

namelist = ['Geo','Jack','Ted','Lily']
for memberlist in namelist:
    print(memberlist)

在这里插入图片描述

其他操作

打乱顺序（随机排序）：
-import random
-random.shuffle(列表)

>>> a = [12,40,30,70]
>>> a.sort(reverse = True)
>>> a
[70, 40, 30, 12]
>>> import random
>>> random.shuffle(a)
>>> a
[30, 70, 12, 40]
>>> random.shuffle(a)
>>> a
[70, 12, 30, 40]

reversed()：返回迭代器
-同样支持逆序排列，与列表对象reverse()方法不同的是，reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象，并且这个迭代器只能用一次，第一次用输出元素，第二次用就空了。请看代码：

>>> a = [12,30,40,70]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x03F33A60>
>>> list(c)
[70, 40, 30, 12]
>>> list(c)
[]

多维列表

二维列表

存储二维、表格的数据

a = [
    ["Jack",'M',21,30000,"New York"],
    ["Sid",'F',22,25000,"London"],
    ["Ted",'M',19,10000,"Beijing"],
    ["Stefan",'M',25,40000,"Paris"]
]
# for循环打印整个二维表格
for i in range(4):
    for j in range(5):
        print(a[i][j],end = "\t")
    print()

在这里插入图片描述

for循环的使用

num = [n for n in range(101)]
for m in num:
    if m % 10 == 0:
        print()
    print(m,end=' ')

在这里插入图片描述

list1 = [12,10,1,2,3,9,7,11]
# 首尾元素相加存储到新的列表中
b = []
for j in range(len(list1)//2):
    b.append(list1[j] + list1[len(list1)-j-1])
print(b)

在这里插入图片描述

二、元组

元组，和列表不同，列表是可变序列，可以通过直接赋值改变列表中的元素值；而元组属于不可变序列，不能修改元组中的元素，因此我们只需学习元组的创建、删除、元素访问、元素计数等操作方法即可。

元组的创建

通过()创建（小括号可省略）

>>> a = (1,3,6)
>>> b = 2,33,19
>>> a
(1, 3, 6)
>>> b
(2, 33, 19)
>>> print(type(a))
<class 'tuple'>
>>> print(type(b))
<class 'tuple'>

通过tuple()创建元组

>>> a = tuple()
>>> a
()
>>> b = tuple("university")
>>> b
('u', 'n', 'i', 'v', 'e', 'r', 's', 'i', 't', 'y')
>>> c = tuple(range(6))
>>> c
(0, 1, 2, 3, 4, 5)
>>> d = tuple([12,2,55,7])
>>> d
(12, 2, 55, 7)

生成器推导式创建元组

只能访问一次元素，第二次就空了，需要再生成一次

>>> a = (x*2 for x in range(5))
>>> a
<generator object <genexpr> at 0x039096F0>
>>> tuple(a)
(0, 2, 4, 6, 8)
>>> list(a)
[]
>>> tuple(a)
()

>>> s = (x*2 for x in range(6))
>>>> s
<generator object <genexpr> at 0x00B97D80>
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
8
>>> s.__next__()
10
>>> s.__next__()
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    s.__next__()
StopIteration

注意，s._next_()是两个下划线

元组元素访问及计数

【注1】元组的元素不能修改

>>> d = tuple([12,2,55,7])
>>> d
(12, 2, 55, 7)
>>> d[3] = 4
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    d[3] = 4
TypeError: 'tuple' object does not support item assignment

【注2】元组元素访问返回的是元组对象

>>> a = (12,4,5,10,50)
>>> a[2]
5
>>> a[1:3]
(4, 5)
>>> a[:3]
(12, 4, 5)

【注3】元组只有内置函数sorted(tupleObj)，并生成新的列表对象

>>> a = (12,4,5,10,50)
>>> sorted(a)
[4, 5, 10, 12, 50]
>>> sorted(a,reverse=True)
[50, 12, 10, 5, 4]
>>> a
(12, 4, 5, 10, 50)

zip()函数的用法

基本格式：zip(列表1，列表2，…列表n)
将多个列表对应位置的元素组合成为元组，并返回这个对象

a = tuple(range(5))
b = tuple("afhhj")
c = tuple([2,6,8])
print(a)
print(b)
print(c)

d = zip(a,b,c)
print(list(d))

在这里插入图片描述
【元组小结】

不可变序列
访问和处理速度比列表快
同整数和字符串，元组（不可变序列）可作为字典的建，而列表则不能（列表元素可变）

三、字典

字典是“键值对”的无序可变序列，包含“键对象”和“值对象”。
可以通过“键对象”实现快速获取、删除、更新对应的“值对象”

列表中，下标数字找对应的对象
字典中，键对象找到对应值对象

查字典的过程就是通过键对象去找对应值对象的
键：任意不可变数据（不可重复）
值：任意可重复数据

基本定义：变量名 = {‘name’:‘xiaoxin’,‘age’:24,‘job’:‘Engineer’}

字典的创建

{}、dict()创建

a = {'name':'stefan','age':24,'job':'student'}
b = dict(name = 'xiaoxin',age = 24,job = 'stu')
c = dict([('name','ssdf'),('sex','boy')])
d = {}
e = dict()
print(a)
print(b)
print(c)
print(d)
print(e)

在这里插入图片描述

通过zip()创建字典对象

a = ['admin','age','job']
b = ['stefanxx',24,'teacher']
c = dict(zip(a,b))
print(c)

在这里插入图片描述

通过fromkeys()创建值为空的字典对象

a = dict.fromkeys(['name','age','job'])
print(a)

在这里插入图片描述

字典元素访问

通过[键]获得值，键不存在，抛异常

a = {'name':'stefan','age':24,'job':'student'}
print(a['name'])
print(a['age'])
print(a['sex']) # 键是不存在的

在这里插入图片描述

get()方法获得值

推荐使用这个来访问字典元素，因为在调用get()方法的同时，可以进行指定键不存在时的一个默认返回值的设置，比如，如果这个键是不存在的，你想让它显示出来‘不存在’，就可以键值后加上该设置

a = {'name':'stefan','age':24,'job':'student'}
print(a.get('name','键值不存在！'))
print(a.get('sex','键值不存在！'))

在这里插入图片描述

列出所有键值对（item()方法）

>>> a = {'name':'stefan','age':24,'job':'student'}
>>> a
{'name': 'stefan', 'age': 24, 'job': 'student'}
>>> a.items()
dict_items([('name', 'stefan'), ('age', 24), ('job', 'student')])

列出所有的键，列出所有的值

>>> a
{'name': 'stefan', 'age': 24, 'job': 'student'}
>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['stefan', 24, 'student'])

键值对的个数

len()函数

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

新增键值对

【注】如果新增一个键值对，则添加；如果增加已经存在的键值对，则新增加的值会覆盖掉旧值

>>> a
{'name': 'stefan', 'age': 24, 'job': 'student'}
>>> a['address'] = 'New York'
>>> a
{'name': 'stefan', 'age': 24, 'job': 'student', 'address': 'New York'}
>>> a['job'] = 'Engineer'
>>> a
{'name': 'stefan', 'age': 24, 'job': 'Engineer', 'address': 'New York'}
>>>

update()方法将新字典中所有的键值对全部添加到旧字典对象上

重复同样会覆盖

>>> a
{'name': 'stefan', 'age': 24, 'job': 'Engineer', 'address': 'New York'}
>>> b = {'name':'Jason','sex':'male','address':'Beijing'}
>>> a.update(b)
>>> a
{'name': 'Jason', 'age': 24, 'job': 'Engineer', 'address': 'Beijing', 'sex': 'male'}

字典中元素删除

（1）del()方法删除指定键值对（没有返回）

>>> b
{'name': 'Jason', 'sex': 'male', 'address': 'Beijing'}
>>> del(b['sex'])
>>> b
{'name': 'Jason', 'address': 'Beijing'}

（2）pop()方法删除指定键值对（返回对应的“值对象”）

>>> b
{'name': 'Jason', 'address': 'Beijing'}
>>> c = b.pop('address')
>>> c
'Beijing'
>>> b
{'name': 'Jason'}

（3）clear()方法清除所有键值对

>>> b.clear()
>>> b
{}

（4）popitem()方法

popitem()方法，用于随机删除和返回该键值对
由于字典是无序的
会随机弹出，没有顺序的概念

>>> a
{'name': 'Jason', 'age': 24, 'job': 'Engineer', 'address': 'Beijing', 'sex': 'male'}
>>> a.popitem()
('sex', 'male')
>>> a.popitem()
('address', 'Beijing')
>>> a.popitem()
('job', 'Engineer')
>>> a
{'name': 'Jason', 'age': 24}

序列解包

（1）对键进行操作（默认）

>>> s = {'name':'lifff','age':'22','job':'teacher'}
>>> a,b,c = s
>>> a
'name'
>>> b
'age'
>>> c
'job'

（2）对整个键值对进行操作

>>> s
{'name': 'lifff', 'age': '22', 'job': 'teacher'}
>>> a,b,c = s.items()
>>> a
('name', 'lifff')
>>> b
('age', '22')
>>> c
('job', 'teacher')
>>>

（3）对值进行操作

>>> s
{'name': 'lifff', 'age': '22', 'job': 'teacher'}
>>> a,b,c = s.values()
>>> a
'lifff'
>>> b
'22'
>>> c
'teacher'

复杂表格数据存储（列表+字典）

如，给定一个表格：

姓名	年龄	薪资	城市
李飞	18	30000	北京
王刚	19	20000	上海
李白	20	10000	深圳

在这里插入图片描述

r1 = {'name':'李飞','age':18,'salary':30000,'city':'北京'}
r2 = {'name':'王刚','age':19,'salary':20000,'city':'上海'}
r3 = {'name':'李白','age':20,'salary':10000,'city':'深圳'}

tb = [r1,r2,r3]

# 获得第二行人的薪资
print(tb[1].get('salary'))

# 打印表中所有薪资
for i in range(len(tb)):
    print(tb[i].get('salary'))

# 打印表中所有数据
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

在这里插入图片描述

四、集合

集合，无序可变，元素不能重复。
集合的所有元素都是字典中的“键对象”，因此不能重复（唯一）

集合的创建和删除

用{}创建集合对象，用add()方法添加元素

>>> a = {3,5,7}
>>> a
{3, 5, 7}
>>> a.add(10)
>>> a
{10, 3, 5, 7}

set()方法

set()方法可用于将列表、元组等可迭代对象转成集合，若重复，则只保留一个

>>> a = ['a','s','y','s']
>>> b = set(a)
>>> b
{'s', 'y', 'a'}

remove()删除指定元素 / clear()清空整个集合

>>> a = {12,3,5,1,3,12}
>>> a.remove(3)
>>> a
{1, 12, 5}
>>> a.clear()
>>> a
set()

集合相关操作

并集：a|b 、 a.union(b)
交集：a&b 、 a.intersection(b)
差集：a-b / b-a 、 a.difference(b) / b.difference(a)

>>> a = {1,3,2,4,7}
>>> b = {1,2,5,7,9,12,13}
>>> a|b # 并集
{1, 2, 3, 4, 5, 7, 9, 12, 13}
>>> a&b # 交集
{1, 2, 7}
>>> a-b # 差集
{3, 4}
>>> b-a # 差集
{9, 13, 12, 5}
>>> a.union(b) # 并集
{1, 2, 3, 4, 5, 7, 9, 12, 13}
>>> a.intersection(b) # 交集
{1, 2, 7}
>>> a.difference(b) # 差集
{3, 4}
>>> b.difference(a) # 差集
{9, 13, 12, 5}