Python列表、元祖、字典、集合及其相关操作

序列

• 一、序列简介
• • 常用序列结构
  • 序列解包
• 二、列表
• • 列表创建
  • 列表元素增加和删除
  • 列表元素删除
  • 列表元素访问和计数
  • 成员是否存在
  • 切片操作
  • 列表的遍历
  • 复制列表
  • 列表排序
  • 列表相关其他函数
  • • max 和 min
    • sum
  • 多维列表
• 三、元组
• • 元祖创建
  • 元组的元素访问和计数
  • zip()
  • 元组优点
• 四、字典
• • 字典创建
  • 字典元素访问
  • 字典元素添加、修改、删除
  • 字典底层实现
• 五、集合
• • 集合创建和删除
  • 集合相关操作

一、序列简介

序列就是一块用来存放 多个值的连续的内存空间。
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()	浅拷贝	返回列表对象的浅拷贝

列表创建

1. []创建

>>> a = [10,20,'gaoqi','sxt'] 
>>> a = [] #创建一个空的列表对象

2. list()创建
   使用 list()可以将任何可迭代的数据转化成列表

>>> a = list() #创建一个空的列表对象 
>>> a = list(range(10)) 
>>> a 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> a = list("gaoqi,sxt") 
>>> a ['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']

3. range()创建整数列表
   返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其 转换成列表对象。

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

   start 参数：可选，表示起始数字。默认是 0
   end 参数： 必选，表示结尾数字。
   step 参数：可选，表示步长，默认为 1
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] #通过 if 过滤元素
>>> a [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素增加和删除

除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

1. append()方法
   原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用
2. +运算符操作
   不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次 复制到新的列表对象中。

>>> a = [20,40]
>>> a = a+[50]

3. extend()方法
   将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。合并列表推荐

>>> a = [20,40] 
>>> id(a) 
46016072 
>>> a.extend([50,60]) 
>>> id(a) 
46016072

4. insert()插入元素
   使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后 面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生移动的函数还有：remove()、pop()、del()

>>> a = [10,20,30]
>>> a.insert(2,100)
>>> a 
[10, 20, 100, 30]

5. 乘法扩展
   使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复。

列表元素删除

1. del 删除
   删除列表指定位置的元素，无返回值。

2. pop()方法
   pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。

3. remove()方法
   删除首次出现的指定元素，若不存在该元素抛出异常。

列表元素访问和计数

1. 索引直接访问
   索引的区间在[0, 列表长度-1]，超过这个范围则会抛出异常。
2. index()
   index()可以获取指定元素首次出现的索引位置
   index(value,[start,[end]])
   start 和 end 指定搜索范围
3. count()获得指定元素在列表中出现的次数
4. len()返回列表长度

成员是否存在

1. count()方法，返回 0 则表示不存在，返回 大于 0 则表示存在
2. in / not in（推荐）

切片操作

同字符串，“包头不包尾”
[起始偏移量 start:终止偏移量 end[:步长 step]]

列表的遍历

for obj in listObj: 
	print(obj)

复制列表

这是浅拷贝

list1 = [30,40,50] list2 = list1

这是深拷贝

1. 通过+号

list1 = [30,40,50] list2 = [] + list1

2. copy模块

列表排序

1. 修改原列表，不建新列表的排序（sort()方法）
   a.sort() #默认是升序排列
   a.sort(reverse=True) #降序排列
   random.shuffle(a) #打乱顺序

2. 建新列表的排序（内置函数sorted()）
   内置函数 sorted()进行排序，这个方法返回新列表，不对原列表做修改。
   a = sorted(a) #默认升序
   sorted(a,reverse=True) #降序

3. 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，(1,) 解释为元组。
2. 通过 tuple()创建元组
   tuple(可迭代的对象)
   tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
   list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
3. 生成器推导式创建元组
   从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

通过生成器对象：

1. 转化成列表或者元组
2. 使用生成器对象的__next__() 方法进行遍历
3. 直接作为迭代器对象来使用。
   只能访问一次元素

元组的元素访问和计数

元组的元素访问和列表一样，只不过返回的仍然是元组对象

元组无sorted()方法（因不可变）。对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

zip()

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

元组优点

元组的访问和处理速度比列表快
元组可作为字典的键

四、字典

“键值对”的无序可变序列
“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。
“值”可以是任意的数据，并且可重复。

1. 键必须可散列
   (1) 数字、字符串、元组，都是可散列的。
   (2) 自定义对象需要支持下面三点才可为键：
   支持 hash()函数
   支持通过__eq__()方法检测相等性。
   若 a==b 为真，则 hash(a)==hash(b)也为真。
2. 字典在内存中开销巨大，典型的空间换时间。
3. 键查询速度很快
4. 往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改（先遍历后修改）。

字典创建

1. 通过{}、dict()来创建字典对象
   a = {‘name’:‘gaoqi’,‘age’:18,‘job’:‘programmer’}
   b = dict(name=‘gaoqi’,age=18,job=‘programmer’)
   a = dict([(“name”,“gaoqi”),(“age”,18)])
   c = {} #空的字典对象
   d = dict() #空的字典对象
2. zip()创建字典对象
3. 通过 fromkeys 创建值为空的字典

字典元素访问

1. 通过 [键] 获得“值”。若键不存在，则抛出异常。
2. 通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设 定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”
3. 列出所有的键值对a.items()
4. 列出所有的键a.keys()，列出所有的值a.values()
5. len() 键值对的个数
6. 检测一个“键”是否在字典中 in / not in

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

1.给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在， 则新增“键值对”。
a['address']='西三旗 1 号院'
2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖。
3. 字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；
4. popitem() 随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）

字典底层实现

字典对象的核心是散列表。散列表是一个稀疏数组，bucket 有两部分：一个是键对象的引用，一个是值对象的引用

扩容：python 会根据散列表的拥挤程度扩容。接近 2/3 时，数组就会扩容。

五、集合

无序可变，元素不能重复
集合底层类似字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

集合创建和删除

1. 使用{}创建集合对象，并使用 add()方法添加元素
2. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。
3. remove()删除指定元素；clear()清空整个集合

集合相关操作

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