- 学习:知识的初次邂逅
- 复习:知识的温故知新
- 练习:知识的实践应用
目录
一,本章知识简介
主线A:列表
主线B:元组
回顾前面知识
pyhthon学习路线:
- pyhton的概述
- pyhton环境安装;
- 注释
- 标识符
- 关键字
- 变量
- 数据类型
- 输入
- 输出
- 运算符
- 选择分支
- 循环结构
- 字符串
一,邂逅Python,搭建python环境,基础语法介绍:python注释,关键字,标识符,变量,数据类型,print()输出,input()输入,数据类型转换等-CSDN博客
二,PyCharm软件的使用,Python运算符,变量的介绍与运用,以及本章综合测试-CSDN博客
三,python控制语句 (条件分支与循环结构)-CSDN博客
四,python之字符串. [字符串的特点,操作,常用方法,遍历,综合测试]-CSDN博客
二,序列
1,序列的本质
序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40],示意表示:
2,序列的内存结构
从图示中,我们可以看出序列中存储的是整数对象的地址,而不是整数对象的值
无论是在学习还是工作中, 序列都是每天都会用到的技术,可以非常方便的帮助我们进行数据存储的操作。
三,列表
1,列表的简介
列表:用于存储任意数目、任意类型的数据集合。列表是内置可变序列,是包含多个元素的有序连续的内存空间。列表的标准语法格式: a = [10,20,30,40] 其中,10,20,30,40 这些称为:列表 a 的 元素 。列表中的元素可以各不相同,可以是任意类型。比如: a = [10,20,'abc',True]Python 的列表大小可变,根据需要随时增加或缩小。列表对象的常用方法汇总如下:
字符串和列表都是序列类型,一个字符串是一个字符序列,一个列表是任何元素的序列。我们前面学习的很多字符串的方法,在列表中也有类似的用法,几乎一模一样。
2,列表的创建
基本语法 [] 创建
a = [10,20,'aa','ccc']
b = [] #创建一个空的列表对象
print(a)
list()创建
使用list()可以将任何可迭代的数据转化成列表
a = list() #创建一个空的列表对象
b = list(range(10)) #结果:[0, 1, 2, 3, 4,5, 6, 7, 8, 9]
range()创建整数列表
range()可以帮助我们非常方便的创建整数列表,这在开发中及其有
用。语法格式为:
range([start,] end [,step])start 参数:可选,表示起始数字。默认是 0end 参数:必选,表示结尾数字。step 参数:可选,表示步长,默认为 1⚠️ python3 中 range() 返回的是一个 range 对象,而不是列表。我们需要通过 list() 方法将其转换成列表对象。
a = list(range(3,15,2)) #结果:[3, 5, 7, 9,
11, 13]
b = list(range(15,9,-1)) #结果:[15, 14, 13,
12, 11, 10]
c = list(range(3,-4,-1)) #结果:[3, 2, 1, 0,
-1, -2, -3]
print(a,b,c)
3,列表推导式
使用列表推导式可以非常方便的创建列表,在开发中经常使用。
#循环创建多个元素 [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)
4,列表元素的增加
当列表增加和删除元素时,列表会自动进行内存管理,大大减少了程序员的负担。但这个特点涉及列表元素的大量移动,效率较低。⚠️ 除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率。
4.1,append()方法
原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用。
a = [20,40]
a.append(80)
print(a) #结果:[20, 40, 80]
4.2,+运算符操作
并不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中。这样,会涉及大量的复制操作,对于操作大量元素不建议使用。
a = [20,40]
print(id(a))
a = a+[50]
print(id(a)) #两次地址不一样,创建了新的对象
通过如上测试,我们发现变量 a 的地址发生了变化。也就是创建了新的列表对象。
4.3, extend()方法
将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。
a = [20,40]
print(id(a))
b = [50,60]
a.extend(b) #原对象修改
print(id(a))
a = a+b #产生新对象
print(id(a))
4.4,insert()插入元素
使用 insert() 方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。类似发生这种移动的函数还有:remove() 、 pop() 、 del() ,它们在删除非尾部元素时也会发生操作位置后面元素的移动。
a = [10,20,30]
a.insert(2,100)
print(a) #结果:[10, 20, 100, 30]
4.5,乘法扩展
使用乘法扩展列表,生成一个新列表,新列表元素是原列表元素的多次重复。
a=['xuping']
print(a*3) #['xuping', 'xuping', 'xuping']
适用于乘法操作的,还有:字符串、元组。
5,列表元素的删除
5.1,del 删除
a = [100,200,888,300,400]
del a[2]
print(a) #结果:[100,200,300,400]
5.2,pop()方法
pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。
a = [10,20,30,40,50]
b1 = a.pop() #结果:b1=50
print(a,b1) #结果:[10, 20, 30, 40] 50
b2 = a.pop(1)
print(a,b2) #结果:[10, 30, 40],20
5.3,remove()方法
删除首次出现的指定元素,若不存在该元素抛出异常。
a = [10,20,30,40,50,20,30,20,30]
a.remove(20) #[10, 30, 40, 50, 20, 30, 20,
30]
a.remove(100) #报错:
ValueError:list.remove(x): x not in list
6,列表元素访问和计数
6.1,通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在 [0, 列表长度 - 1] 这个范围。超过这个范围则会抛出异常
a = [10,20,30,40,50,20,30,20,30]
print(a[2]) #结果:30
print(a[10]) #报错:IndexError: list index out
of range
6.2,index()获得指定元素在列表中首次出现的索引
index() 可以获取指定元素首次出现的索引位置。语法是: index(value,[start, [end]]) 。其中, start 和 end 指定了搜索的范围。
a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20) #结果:1
>>> a.index(20,3) #结果:5 从索引位置3开始往
后搜索的第一个20
>>> a.index(30,5,7) #结果:6 从索引位置5到7这个
区间,第一次出现30元素的位置
6.3,count()获得指定元素在列表中出现的次数
count() 可以返回指定元素在列表中出现的次数。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3
6.4,len()返回列表长度
>>> a = [10,20,30]
>>> len(a)
3
7,列表的成员资格判断
判断列表中是否存在指定的元素,我们可以使用 count() 方法,返回 0 则表示不存在,返回大于0 则表示存在。但是,一般我们会使用更加简洁的 in 关键字来判断,直接返回 True 或 False
>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 100 not in a
True
>>> 30 not in a
False
8,列表的切片操作
类似字符串的切片操作,对于列表的切片操作和字符串类似
切片是 Python 序列及其重要的操作,适用于列表、元组、字符串等等。切片 slice 操作可以让我们快速提取子列表或修改。标准格式为:[起始偏移量start:终止偏移量end[:步长step]]
三个量为负数的情况下:
切片操作时,起始偏移量和终止偏移量不在 [0,字符串长度 - 1] 这个范围,也不会报错。起始偏移量 小于0 则会当做 0 ,终止偏移量 大于 “长度- 1” 会被当成 ”长度 - 1” 。例如:[10,20,30,40][1:30] 结果: [20, 30, 40]我们发现正常输出了结果,没有报错。
9,列表的遍历
a = [10,20,30,40]
for obj in a: #obj是临时变量名称,随意起
print(obj)
10,复制列表所有的元素到新列表对象
list1 = [30,40,50]
list2 = [] + list1 #生成了新列表对象
后面文章详细阐述深拷贝与浅拷贝
11,列表的排序
1,修改原列表,不建新列表的排序
>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a.sort() #默认是升序排列
>>> a
[10, 20, 30, 40]
>>> a = [10,20,30,40]
>>> a.sort(reverse=True) #降序排列
>>> a
[40, 30, 20, 10]
>>> import random
>>> random.shuffle(a) #打乱顺序
>>> a
[20, 40, 30, 10]
2,建新列表的排序
>>> a = [20,10,30,40]
>>> id(a)
46016008
>>> b = sorted(a) #默认升序
>>> b
[10, 20, 30, 40]
>>> id(b)
45907848
>>> c = sorted(a,reverse=True) #降序
>>> c
[40, 30, 20, 10]
通过上面操作,我们可以看出,生成的列表对象 b 和 c 都是完全新的列表对象。
3,reversed()返回迭代器 排序
内置函数 reversed() 也支持进行逆序排列,与列表对象 reverse() 方法不同的是,内置函数reversed() 不对原列表做任何修改,只是返回一个逆序排列的迭代器对象
>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at
0x0000000002BCCEB8>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
我们打印输出 c 发现提示是: list_reverseiterator 。也就是一个迭代 对象。同时,我们使用list(c) 进行输出,发现只能使用一次。第一次输出了元素,第二次为空。那是因为迭代对象在第一次时已经遍历结束了,第二次不能再使用。
12,列表相关的其他内置函数汇总
1,max和min
>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3
2,sum
对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。
>>> a = [3,10,20,15,9]
>>> sum(a)
57
13,多维列表
1,二维列表
一维列表可以帮助我们存储一维、线性的数据。二维列表可以帮助我们存储二维、表格的数据。
a = [
["一",18,30000,"北京"],
["二",19,20000,"上海"],
["三",20,10000,"深圳"],
]
print(a[1][0],a[1][1],a[1][2]) #二 19 20000
嵌套循环打印二维列表所有的数据:
a = [
["一",18,30000,"北京"],
["二",19,20000,"上海"],
["三",20,10000,"深圳"],
]
for i in range(3):
for j in range(4):
print(a[i][j],end=' ')
print()
''''
一 18 30000 北京
二 19 20000 上海
三 20 10000 深圳
'''
四,元组
列表属于可变序列,可以任意修改列表中的元素。元组属于不可变序列,不能修改元组中的元素。因此,元组没有增加元素、修改元素、删除元素相关的方法。因此,我们只需学元组的创建和删除,元素的访问和计数即可。元组支持如下操作:
1 索引访问2 切片操作3 连接操作4 成员关系操作5 比较运算操作6 计数:元组长度len()、最大值max()、最小值min()、求和sum()等
1,元组的创建
1.1 通过()创建
通过 () 创建元组。小括号可以省略。a = (10,20,30) 或者 a = 10,20,30
如果元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1) 解释为整数 1 , (1,) 解释为元组。 a = 10,
>>> a = (1)
>>> type(a)
<class 'int'>
>>> a = (1,) #或者 a = 1,
>>> type(a)
<class 'tuple'>
2.1 通过tuple()创建元组
a = tuple() #创建一个空元组对象
b = tuple("abc")
c = tuple(range(3))
d = tuple([2,3,4])
总结:1 tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。2 list()可以接收元组、字符串、其他序列类型、迭代器等生成列表
2,元组的元素访问和计数
元组的元素不能修改
>>> a = (20,10,30,9,8)
>>> a[3]=33
Traceback (most recent call last):
File "<pyshell#313>", line 1, in
<module>
a[3]=33
TypeError: 'tuple' object does not support
item assignment
元组的元素访问、 index() 、 count() 、切片等操作,和列表一样。
>>> a = (20,10,30,9,8)
>>> a[1]
10
>>> a[1:3]
(10, 30)
>>> a[:4]
(20, 10, 30, 9)
列表关于排序的方法 list.sorted() 是修改原列表对象,元组没有该方法。如果要对元组排序,只能使用内置函数 sorted(tupleObj),并生成新的列表对象。
a = (20,10,30,9,8)
b = sorted(a) #b是新对象,内容是:[8, 9,10, 20, 30]
3, zip 组合元组
zip( 列表 1 ,列表 2 , ...) 将多个列表对应位置的元素组合成为元组,并返回这个zip 对象。
a = [10,20,30]
b = [40,50,60]
c = [70,80,90,100]
d = zip(a,b,c)
print(d) #zip object
e = list(d) #列表:[(10, 40, 70), (20, 50,
80), (30, 60, 90)]
print(e)
4, 推导式生成元组
从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号。列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象。我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的 __next__() 方法进行遍 历,或者直接作为迭代器对象来使用。不管什么方式使用,元素访问结束后,如果需要重新访问其 中的元素,必须重新创建该生成器对象。
#列表推导式: [0, 2, 4, 6, 8]
#a = [x*2 for x in range(5)]
#print(a)
s = (x*2 for x in range(5))
print(s) #<generator object <genexpr> at
0x0000021C80BE2880>
b = tuple(s)
print(b) #(0, 2, 4, 6, 8)
c = tuple(s)
print(c) #()
s2 = (x for x in range(3))
print(s2.__next__()) #0
print(s2.__next__()) #1
print(s2.__next__()) #2
print(s2.__next__()) #报错:
StopIteration
元组总结1 元组的核心特点是:不可变序列。2 元组的访问和处理速度比列表快。3 与整数和字符串一样,元组可以作为字典的键,列表则永远不能作为字典的键使用。
- 学习:知识的初次邂逅
- 复习:知识的温故知新
- 练习:知识的实践应用