序列
一、序列简介
序列就是一块用来存放 多个值的连续的内存空间。
a = [10,20,30,40]的存储方式如下:
常用序列结构
字符串、列表、元组、字典、集合
序列解包
可用于元组、列表、字典。方便的对多个变量赋值。
x,y,z=(20,30,10)#元祖
(a,b,c)=(9,8,10)
[a,b,c]=[10,20,30]#列表
序列解包用于字典时,默认是对“键”进行操作;
如果需要对键值对操作,则需要使用 items();
如果需要对“值”进行操作,则需要使用 values();
s = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s #默认对键进行操作
name,age,job=s.items() #对键值对进行操作
name,age,job=s.values() #对值进行操作
二、列表
列表:用于存储任意数目、任意类型的数据集合。
内置可变序列,是包含多个元素的有序连续的内存空间
方法 | 要点 | 描述 |
---|---|---|
list.append(x) | 增加元素 | 将元素 x 增加到列表 list 尾部 |
list.extend(aList) | 增加元素 | 将列表 alist 所有元素加到列表 list 尾部 |
list.insert(index,x) | 增加元素 | 在列表 list 指定位置 index 处插入元素 x |
list.remove(x) | 删除元素 | 在列表 list 中删除首次出现的指定元素 x |
list.pop([index]) | 删除元素 | 删除并返回列表 list 指定为止 index 处的元素,默认是 最后一个元素 |
list.clear() | 删除所有元素 | 删除列表所有元素,并不是删除列表对象 |
list.index(x) | 访问元素 | 返回第一个 x 的索引位置,若不存在 x 元素抛出异常 |
list.count(x) | 计数 | 返回指定元素 x 在列表 list 中出现的次数 |
len(list) | 列表长度 | 返回列表中包含元素的个数 |
list.reverse() | 翻转列表 | 所有元素原地翻转 |
list.sort() | 排序 | 所有元素原地排序 |
list.copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
列表创建
- []创建
a = [10, 20, 'zifuchuan', True]
a = [] #创建一个空的列表对象
-
list()创建
使用list()
可以将任何可迭代的数据转化成列表a = list() #创建一个空的列表对象 a = list(range(10)) a [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a = list("123lpf") a ['1', '2', '3', 'l', 'p', 'f']
-
range()创建整数列表
返回的是一个 range 对象,而不是列表。我们需要通过list()
方法将其 转换成列表对象。range([start,] end [,step])
start 参数:可选,表示起始数字。默认是 0
end 参数: 必选,表示结尾数字。
step 参数:可选,表示步长,默认为 1 -
推导式生成列表
>>> 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] #通过 if 过滤元素 >>> a [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
列表元素增加和删除
除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率。
-
append()方法
原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用 -
+运算符操作
不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次 复制到新的列表对象中。>>> a = [20,40] >>> a = a+[50]
-
extend()方法
将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。合并列表推荐>>> a = [20,40] >>> id(a) 46016072 >>> a.extend([50,60]) >>> id(a) 46016072
-
insert()插入元素
使用insert()
方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后 面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。类似发生移动的函数还有:remove()、pop()、del()
>>> a = [10,20,30] >>> a.insert(2,100) >>> a [10, 20, 100, 30]
-
乘法扩展
使用乘法扩展列表,生成一个新列表,新列表元素时原列表元素的多次重复。
列表元素删除
-
del 删除
删除列表指定位置的元素,无返回值。 -
pop()方法
pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。 -
remove()方法
删除首次出现的指定元素,若不存在该元素抛出异常。
列表元素访问和计数
- 索引直接访问
索引的区间在[0, 列表长度-1]
,超过这个范围则会抛出异常。 - index()
index()可以获取指定元素首次出现的索引位置
index(value,[start,[end]])
start 和 end 指定搜索范围 - count()获得指定元素在列表中出现的次数
- len()返回列表长度
成员是否存在
count()
方法,返回 0 则表示不存在,返回 大于 0 则表示存在in / not in
(推荐)
切片操作
同字符串,“包头不包尾”
[起始偏移量 start:终止偏移量 end[:步长 step]]
列表的遍历
for obj in listObj:
print(obj)
复制列表
这是浅拷贝
list1 = [30,40,50]
list2 = list1
这是深拷贝
- 通过+号
list1 = [30,40,50] list2 = [] + list1
- copy模块
列表排序
-
修改原列表,不建新列表的排序(sort()方法)
a.sort() #默认是升序排列 a.sort(reverse=True)#降序排列 random.shuffle(a) #打乱顺序
-
建新列表的排序(内置函数sorted())
内置函数sorted()
进行排序,这个方法返回新列表,不对原列表做修改。a = sorted(a) #默认升序 sorted(a,reverse=True) #降序
-
reversed()返回迭代器
内置函数reversed()
也支持进行逆序排列,与列表对象reverse()
方法不同的是,内置函数reversed()
不对原列表做任何修改,只是返回一个逆序排列的迭代器对象迭代对象只能用一次
列表相关其他函数
max 和 min
返回列表最大最小值
sum
对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。
多维列表
[[“高一”,18,30000,‘北京’], [‘高二’,19,2000,‘上海’], [‘高一’,20,10000,‘深圳’],
]
最后子列表后的,
可加可不加
三、元组
不可变序列
支持一下操作
1. 索引访问 2. 切片操作 3. 连接操作 4. 成员关系操作 5. 比较运算操作 6. 计数:元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。7.创建和删除
元祖创建
-
通过()创建元组。
小括号可以省略
元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1)
解释为整数 1,(1,)
解释为元组。 -
通过 tuple()创建元组
tuple(可迭代的对象)
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。b = tuple() b = tuple("abc") b = tuple(range(3)) b = tuple([2,3,4])
-
生成器推导式创建元组
从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号。列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象。#python shell s = (x*2 for x in range(5)) s <generator object <genexpr> at 0x0000024E11B0EA40> tuple(s) (0, 2, 4, 6, 8) list(s) []
通过生成器对象:
1. 转化成列表或者元组
2. 使用生成器对象的__next__()
方法进行遍历
3. 直接作为迭代器对象来使用。
只能访问一次元素
元组的元素访问和计数
元组的元素访问和列表一样,只不过返回的仍然是元组对象
元组无sorted()方法(因不可变)。对元组排序,只能使用内置函数 sorted(tupleObj)
,并生成新的列表对象。
zip()
zip(列表 1,列表 2,…)将多个列表对应位置的元素组合成为元组,并返回这个 zip 对象
a = [18,2,3]
b = [34,32,44]
c = [2,5,6]
d = zip(a,b,c)
list(d)
[(18, 34, 2), (2, 32, 5), (3, 44, 6)]
元组优点
元组的访问和处理速度比列表快
元组可作为字典的键
四、字典
“键值对”的无序可变序列
“键”是任意的不可变数据,比如:整数、浮点数、字符串、元组。
“值”可以是任意的数据,并且可重复。
- 键必须可散列
(1) 数字、字符串、元组,都是可散列的。
(2) 自定义对象需要支持下面三点才可为键:
支持hash()
函数
支持通过__eq__()
方法检测相等性。
若a==b
为真,则hash(a)==hash(b)
也为真。 - 字典在内存中开销巨大,典型的空间换时间。
- 键查询速度很快
- 往字典里面添加新建可能导致扩容,导致散列表中键的次序变化。因此,不要在遍历字典的同时进行字典的修改(先遍历后修改)。
字典创建
-
通过{}、dict()来创建字典对象
a = {'name':'gaoqi','age':18,'job':'programmer'} #{'name': 'gaoqi', 'age': 18, 'job': 'programmer'} b = dict(name='gaoqi',age=18,job='programmer') #{'name': 'gaoqi', 'age': 18, 'job': 'programmer'} a = dict([("name","gaoqi"),("age",18)]) c = {} #空的字典对象 d = dict() #空的字典对象
-
zip()创建字典对象
k = ['name','age','job'] v = ['lpf',19,'writer'] d = dict(zip(k,v)) d {'name': 'lpf', 'age': 19, 'job': 'writer'}
-
通过 fromkeys 创建值为空的字典
a = dict.fromkeys(['name','age']) a {'name': None, 'age': None}
字典元素访问
-
通过
[键]
获得“值”。若键不存在,则抛出异常。k = ['name','age','job'] v = ['lpf',19,'writer'] a = dict(zip(k,v)) a['name'] 'lpf'
-
通过
get()
方法获得“值”。推荐使用。优点是:指定键不存在,返回None
;也可以设定指定键不存在时默认返回的对象。
a.get('name')
'lpf'
a.get('sex','man')
'man'
- 列出所有的键值对
a.items()
- 列出所有的键
a.keys()
,列出所有的值a.values()
len()
键值对的个数- 检测一个“键”是否在字典中
in / not in
字典元素添加、修改、删除
-
给字典新增“键值对”。如果“键”已经存在,则覆盖旧的键值对;如果“键”不存在, 则新增“键值对”。
a['address']='西三旗 1 号院'
-
使用
update()
将新字典中所有键值对全部添加到旧字典对象上。如果key
有重复,则直接覆盖。a = {'name':'lpf','age':18,'job':'programmer'} b = {'name':'wangming','money':3000,'sex':'男的'} a.update(b) a {'name': 'wangming', 'age': 18, 'job': 'programmer', 'money': 3000, 'sex': '男的'}
-
字典中元素的删除,可以使用
del()
方法;或者clear()
删除所有键值对;pop()
删除指定键值对,并返回对应的“值对象”; -
popitem()
随机删除和返回该键值对。字典是“无序可变序列”,因此没有第一个元素、最后一个元素的概念;popitem 弹出随机的项,因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项,这个方法就非常有效(因为不用首先获取键的列表)
字典底层实现
字典对象的核心是散列表。散列表是一个稀疏数组,bucket 有两部分:一个是键对象的引用,一个是值对象的引用
扩容:python 会根据散列表的拥挤程度扩容。接近 2/3 时,数组就会扩容。
五、集合
无序可变,元素不能重复
集合底层类似字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的。
集合创建和删除
- 使用
{}
创建集合对象,并使用add()
方法添加元素 - 使用
set()
,将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据,则只保留一个。 remove()
删除指定元素;clear()
清空整个集合
集合相关操作
并集:a|b
a.union(b)
交集:a&b
a.intersection(b)
差集:a-b
a.difference(b)