【Python零基础学习全系列】------（序列）

阿土不土

于 2023-08-24 10:59:23 发布

阅读量105

点赞数

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

本文链接：https://blog.csdn.net/weixin_45889291/article/details/132361285

版权

python学习入门专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.列表简介

列表：用于存储任意数目、任意类型的数据集合

列表是内置可变序列，是包含多个元素的有序连续的内存空间。

列表的标准语法格式：

a=[10,20,30,40]

其中，10，20，30，40，这些称为列表a的元素

列表中的元素可以各不相同，可以是任意类型。比如：

a=[20,30,'abc',True]

Python的列表大小可变，根据需要随时增大或减小

2.列表的创建：

2.1 基本语法[ ]创建

[10,20,30,40,50]

2.2 list()创建

c = list("xxxxxfg,vhhu")
print(c) #输出 ['x', 'x', 'x', 'x', 'x', 'f', 'g', ',', 'v', 'h', 'h', 'u']

2.3 range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中极其有用，语法格式为：

range([start,]end,[,step])

start参数：可选，表示起始数字，默认值0

end参数，必填，表示结尾数字

step参数：可选，表示步长，默认值为1

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

举例：

a = list(range(3,15,2))
print(a)        #输出[3, 5, 7, 9, 11, 13]
b = list(range(15,9,-1))
print(b)        #输出[15, 14, 13, 12, 11, 10]
c = list(range(3,-4,-1))
print(c)        #输出[3, 2, 1, 0, -1, -2, -3]

2.4 推导式生成列表

使用列表推导式可以非常方便的创建列表，在开发中经常使用。

举例：

#循环创建多个元素[0,2,4,6,8]
a= [x*2 for x in range(5)]
#通过if过滤元素[0,18,36,54,72,90,108,126,144,162,180,198]
b=[x*2 for x in range(100) if x%9==0]
print(a,b)

3.列表元素的增加

当列表添加和删除元素时，列表会自动进行内存管理，大大减少程序员的负担，但也由于列表元素的大量移动，导致效率降低

3.1 append()方法

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

a=[10,20]
a.append(30)
print(a) #输出[10，20，30]

3.2 +运算符操作

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

a=[20,40]
print(id(a))
a=a+[50]
print(id(a)) #两次地址不一样，创建了新的对象

3.3 extend()方法

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

a=[20,40]
print(id(a)) #输出 2536991684096
b=[50,60]
a.extend(b)  #原对象修改
print(id(a)) #输出 2536991684096
a = a+b      #创建了新的对象
print(id(a)) #输出  2536991944896

3.4 insert()方法

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

a=[20,40]
a.insert(2,100)
print(a) #输出 [20, 40, 100]

3.5 乘法扩展

使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重置。

a=["xxx",40]
b= a*3
print(a) #输出 ['xxx', 40]
print(b) #输出 ['xxx', 40, 'xxx', 40, 'xxx', 40]

4.列表元素的删除

4.1 del删除

删除列表指定位置的元素。

a=[100,200,300,888,400]
del a[3]
print(a) #输出:[100,200,300,400]

4.2 pop()方法

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

a=[10,20,30,40,50]
b= a.pop()
b1 = a.pop(1)
print(b) #输出 50
print(b1) #输出 20
print(a) #输出 [10, 30, 40]

4.3 remove()

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

a=[10,20,30,40,50,20,30,20,30]
a.remove(20)
print(a) #输出 [10, 30, 40, 50, 20, 30, 20, 30]
a.remove(100) #输出 ValueError: list.remove(x): x not in list

5.列表元素的访问和计数

5.1 索引直接访问元素

索引的区间在[0,列表长度-1] 这个范围

5.2 index()获得指定元素在列表中首次出现的索引

index(value,[start,end[]]),其中，start和end指定了搜索范围。

a=[10,20,30,40,50,20,30,20,30]
print(a.index(20)) #输出 1
print(a.index(20,3)) #输出 5 从索引位置3开始往后搜索第一个20出现的位置
print(a.index(30,5,7)) #输出 6 从索引位置5到7这个区间，第一次出现30元素的位置

5.3 count()获得指定元素在列表中出现的次数

count()可以返回指定元素在列表中出现的次数

a=[10,20,30,40,50,20,30,20,30]
print(a.count(20)) #输出 3

5.4 len()返回列表长度

len()返回列表长度，即列表中包含元素的个数

a=[10,20,30,40,50,20,30,20,30]
print(len(a)) #输出 3

5.5 成员资格判断 in/not in

判断列表中是否存在指定的元素，我们可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是，一般我们会使用更加简洁的in关键字来判断，直接返回True 或False

a=[10,20,30,40,50,20,30,20,30]
print(100 in a) #输出 False
print(100 not in a) #输出 True

6. 切片操作

切片是Python序列及其重要的操作，适用于列表、元祖、字符串等。切片slice操作可以让我们快速提取子列表或修改。

标准格式为：[起始偏移量start:终止偏移量end[:步长step]]

典型操作(三个量为正数的情况）如下：

以a=[10,20,30,40]为前提：

操作和说明	示例	结果
[:]提取整个列表	print(a[:])	[10,20,30,40]
[start:]从start索引开始到结尾	print(a[1:])	[20,30,40]
[:end]从头开始直到end-1	print(a[:2])	[10,20]
[start:end]从start到end-1	print(a[1:3])	[20,30]
[start:end:step]从start提取到end-1，步长step	print(a[1:4:2])	[20,40]

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错，起始偏移量小于0，则会当作0，终止偏移量大于"长度-1"，会被当成长度-1，例如：

[1:30] 结果:[20,30,40]

7.列表的遍历

a=[10,20,30,40]
for temp in a:
    print(temp)

7.1复制列表所有的元素到新列表对象

a=[10,20,30,40]
b = a
print(b,id(b)) #输出 [10, 20, 30, 40] 1746972964352
print(a,id(a)) #输出 [10, 20, 30, 40] 1746972964352

上述代码并没有实现元素的复制，只是将b也指向了列表对象，也就是说a和b持有地址值是相同的，列表对象本身的元素并没有复制。

我们可以采用如下方法：

a=[10,20,30,40]
b =[]+ a
print(b,id(b)) #输出 [10, 20, 30, 40] 2073967194304
print(a,id(a)) #输出 [10, 20, 30, 40] 2073966933504

后面会有copy模块。

8.列表排序

8.1 建新列表排序

可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

a=[20,10,40,30]
print(a,id(a)) #输出 [20, 10, 40, 30] 1815844156928
b =sorted(a);
print(b,id(b)) #输出 [10, 20, 30, 40] 1815844417728  默认升序
c =sorted(a,reverse=True)
print(c,id(c)) #输出 [10, 20, 30, 40] 1815844417728 降序

通过上面操作，我们可以看出，生成的列表对象b和c都是完全新的列表对象。

8.2 修改原列表，不建新列表的排序

a=[20,10,40,30]
print(a,id(a)) #输出 [20, 10, 40, 30] 1486596863488
a.sort();
print(a,id(a)) #输出 [10, 20, 30, 40] 1486596863488  默认升序
a.sort(reverse=True);
print(a,id(a)) #输出 [40, 30, 20, 10] 1486596863488 降序

8.3 reversed()返回迭代器

内置函数reverse()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代对象。

a=[20,10,40,30]
c = reversed(a)
print(c) #输出 <list_reverseiterator object at 0x000001B958627FA0>
print(list(c)) #输出 [10, 20, 30, 40]

8.4 max,min,sum

max，min ：用于返回列表中的最大值和最小值。

sum ：对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。

9. 多维列表

二维列表：

a=[
    ["张三",18,60000,"上海"],
    ["李四",23,70000,"北京"],
    ["王五",38,50000,"深圳"],
    ["赵六",28,30000,"大连"],
  ]

for m in range(4):
    for n in range(4):
      print(a[m][n],end="\t")
    print()
    
# #输出
# 张三	18	60000	上海	
# 李四	23	70000	北京	
# 王五	38	50000	深圳	
# 赵六	28	30000	大连

10. 元组 tuple

列表属于可变序列，可以任意修改列表中的元素

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

10.1 元组的创建

10.1.1通过()创建元组

小括号可以省略。a=(10,20,30)或者a=10,20,30

a=10,20,30
b=(40,50,60)
print(type(a)) #输出 <class 'tuple'>
print(type(b)) #输出 <class 'tuple'>

10.1.2通过tuple()创建元组

tuple(可迭代的对象)

c = tuple()
d = tuple("abc")
e = tuple(range(5))
f = tuple([2,3,4])
print(c) #输出 ()
print(d) #输出 ('a', 'b', 'c')
print(e) #输出 (0, 1, 2, 3, 4)
print(f) #输出 (2, 3, 4)

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

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

10.2 元组的访问和计数

列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象。

a=(20,30,10,9,8)

print(a[2]) #输出 10
print(a.index(30)) #输出 1
print(a.count(30)) #输出 1
print(a[1:4]) #输出 (30, 10, 9)
b = sorted(a);
print(b) #输出 [8, 9, 10, 20, 30]
print(a) #输出 (20, 30, 10, 9, 8)

#zip
b=(5,6,8,9,2)
c=(1,2,3)
d=zip(a,b,c)
print(list(d)) #输出 [(20, 5, 1), (30, 6, 2)]

这里有个zip，zip(列表1，列表2，...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

10.3生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。亦可以使用其_next_()方法进行遍历，或者直接作为迭代器对象来进行使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

b = (x*10 for x in range(5))
c = tuple(b)
print(c) #输出(0, 10, 20, 30, 40)
d = tuple(b) 
print(d) #输出()


e = (x for x in range(3))
print(e.__next__())
print(e.__next__())
print(e.__next__())
#输出
# 0
# 1
# 2

11. 字典

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

一个典型的字典的定义方式：

a={'name':'zhangsan','age':18,'job':'programmer'}

11.1 字典的创建

通过()、dict()来创建字典对象

a = {'name':'zhangsan','age':18,'job':'programmer'}
b = dict(name='lisi',age=20,job='teacher')
c = dict([('name','wangwu'),('age',18)])
e={}   #空的字典对象
f=dict() #空的字典对象
print(a) #输出 {'name': 'zhangsan', 'age': 18, 'job': 'programmer'}
print(b) #输出 {'name': 'lisi', 'age': 20, 'job': 'teacher'}
print(c) #输出 {'name': 'wangwu', 'age': 18}
print(e) #输出 {}
print(f) #输出 {}

2. 通过zip()创建字典对象

k=['name','age','job']
v=['zhangsan',18,'programmer']
d = zip(k,v)
print(dict(d)) #输出 {'name': 'zhangsan', 'age': 18, 'job': 'programmer'}

3. 通过fromkeys创建值为空的字典

f =dict.fromkeys(['name','age','job'])
print(f) #输出 {'name': None, 'age': None, 'job': None}

11.2 字典元素的访问

通过[键]获得“值”，若键不存在，则抛出异常

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

a = {'name':'zhangsan','age':18,'job':'programmer'}
b= a.get('name') 
c=a['age']
print(b) #输出 zhangsan
print(c) #输出 18

列出所有的键值对

print(a.items())  #输出 dict_items([('name', 'zhangsan'), ('age', 18), ('job', 'programmer')])

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

print(a.keys())  #输出 dict_keys(['name', 'age', 'job'])
print(a.values()) #输出 dict_values(['zhangsan', 18, 'programmer'])

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

给字典新增“键值对",如果"键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对"。使用update()将新字典中所有键值对全部添加到旧字典对象上。如果key有重复，则直接覆盖。

a = {'name':'zhangsan','age':18,'job':'programmer'}
b = {'name':'lisi','age':18,'job':'programmer'}
a.update(b)
print(a) #输出{'name': 'lisi', 'age': 18, 'job': 'programmer'}

字典中的元素的删除，可以使用del()方法；或者clear()删除所有键值对;pop()删除指定键值对。并返回对应的“值对象”。

a = {'name':'zhangsan','age':18,'job':'programmer'}
b = {'name':'lisi','age':18,'job':'programmer'}
a.update(b)
nianling = a.pop('age')
del(a['name'])
print(a) #输出 {'job': 'programmer'}
print(nianling) #输出 18

popitem():随机删除和返回该键值对。字典是“无序可变序列”。因此没有第一个元素、最后一个元素的概念；popitem弹出随机的项，因为字典并没有“最后的元素”或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表。

12. 序列解包

序列解包可以用于元组、列表、字典、序列解包可以让我们方便的多个变量赋值。

序列解包用于字典时，默认是对“键”进行操作，如果需要对键值对操作，则需要使用items()；如果需要对”值"进行操作,则需要使用values()。

s={'name':'zhangsan','age':18,'job':'teacher'}
a,b,c=s #默认对键进行操作
print(a) #输出 name
a1,b1,c1=s.values()#对值进行操作
print(a1) #输出 zhangsan
a2,b2,c2=s.items()#对键值对进行操作
print(a2) #输出 ('name', 'zhangsan')

13. 列表和字典综合使用

r1={'name':'zhangsan','age':18,'job':'teacher'}
r2={'name':'lisi','age':13,'job':'student'}
r3={'name':'wangwu','age':28,'job':'master'}
t=[r1,r2,r3]
print(t)
for i in range(len(t)):
    print(t[i].get('name'),'--',t[i].get('age'),'--',t[i].get('job'))