3. python - 序列 ：列表、元组、字典、集合

3. python序列sequence

3.1 序列详解

3.1.1 基本概念

• 序列：一块可存放多个值的连续内存空间，这些值按一定顺序排列，也就是数据的存储方式
• 在 Python 中，序列类型包括：字符串、列表、元组、集合和字典

3.1.2 序列基本操作

• 序列索引
  1. 每个元素在序列中的编号（索引）
  2. python可为：正（ 0 到 n )，也可为：负 (- n 到 -1)
  3. 语法格式： 序列名[ 索引号 ]
• 序列切片
  1. 表示一定范围内的元素
  2. 语法格式： sname[ start : end : step ]
  3. start：开始索引位置（包括该位置），此参数也可以不指定，会默认为 0
  4. end：结束索引位置（不包括该位置），如果不指定，则默认为序列的长度
  5. step：取值间隔，如果省略 step 的值，默认为1，最后一个冒号可以省略
• 序列相加
  1. 两种类型相同的序列用 + 运算符做相加操作
  2. 将两个序列进行连接，但不会去除重复的元素
• 序列相乘
  1. 使用数字 n 用符号 * 乘以一个序列会生成新的序列
  2. 原来序列被重复 n 次后拼接
• 检查元素
  1. 用 in 关键字检查某元素是否为序列的成员
  2. not in 关键字用来检查某个元素是否不包含在指定的序列中
  3. 结果值为 True 或者 False
  4. 语法格式：value in sequense

3.1.3 序列操作内置函数

• Python中与序列相关的一些常用操作内置函数：

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素
max()	找出序列中的最大元素
min()	找出序列中的最小元素
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素和，序列元素必须为数字，不能为字符和字符串
sorted()	对元素进行排序
reversed()	反向序列中的元素
enumerate()	将序列组合为一个索引序列，多用在 for 循环中

3.2 列表 list

3.2.1 列表概念

• 类似c语言数组，将一组数据存储起来
• 列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号 , 分隔
• 语法格式：[element1, element2, element3, ..., elementn]
• 列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型可以不同

3.2.2 列表使用方法

• 创建列表

  1. 使用 [ ] 直接创建列表：listname = [element1,element2,......,elementn]
  2. list()函数：list(其它数据序列)，其它数据序列可以是：字符串、元组、字典、区间等

• 访问列表元素

  1. 索引访问：listname[index]
  2. 切片访问：listname[start: end :step]

• 删除列表，清除内存

  1. 语法格式：del listname
  2. 实际中并不需要用 del 来删除列表，Python 自带的垃圾回收机制会自动销毁无用的列表

• 列表添加元素

  1. + 符号 ：拼接列表，产生一个新的列表
  2. append() 方法： listname.append(obj) ， 将obj视为一个整体从末尾插入进去，不产生新列表
  3. extend()方法： listname.extend(obj) ，将obj以当前列表形式从末尾插入进去，不产生新列表
  4. insert()方法： listname.insert(index,obj) ，将obj视为一个整体从index开始插入到列表中

• 列表删除元素

  1. del方法： del listname[index]或del listname[start:end] ，删除索引的相关内容
  2. pop()方法：listname.pop(index) ，删除index下内容，无index时删除末尾元素
  3. remove()方法：listname.remove(num) ，删除列表中第一个为num的元素，且元素num必须存在
  4. clear()方法：listname.clear()清除列表中所有的元素

• 修改列表中元素

  1. 索引方法：修改单个元素 listname[index] = modify_num
  2. 切片方法：修改多个元素 listname[start: end :step] = [element1,element2,...,elementn]

• 查找元素

  1. index()方法： listname.index(obj,start,end)，在 start 到 end 区间查到 obj 元素，返回该元素的索引号，无 start 和 end 将访问整个列表，obj元素需要存在
  2. count()方法：listname.count(obj) ，统计obj在列表中的次数

• range()快速初始化数字列表

  1. 不是直接创建的一个列表：type(range(1,6)) 结果为：
  2. 语法格式：range(start,end,step)，切片方法一样
  3. list() 函数转换为列表：如 list(range(1,10,2)) == [1,3,5,7,9]

• list 实现栈和队列

  • 队列：先存入的数据最先取出，即“先进先出”
  1. 存入数据时使用 insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据
  2. 读取数据时，使用 pop() 方法，即将队列的最后一个元素弹出
  • 栈 ：最后存入的数据最先取出，即“后进先出”
  1. 使用 append() 方法存入数据
  2. 使用 pop() 方法读取数据
  • deque 结构体
  1. 标准库的 collections 模块中的 deque 结构体，被设计成在两端存入和读取都很快的特殊 list，可以用来实现栈和队列的功能
  2. 创建：listname = deque()
  3. 添加元素：listname.append(element)
  4. 队列功能：listname.popleft()
  5. 栈功能：listname.pop()

• 列表推导式

  1. 快速创建满足某些条件的列表
  2. list = [i for i in range(0,100) if i%2 == 0] ，创建0到100的所有偶数列表
  3. list = [(i,j) for i in range(0,10) for j in range(0,5)]，创建i为0到10，j为0到5的所有坐标点
  4. list = [i if i%2 == 0 else i%3 == 0 for i in range(1,20)]，创建0到20，可以整除2或者3的列表

3.3 元组 tuple

3.3.1 元组概念

• 元组是不可变序列，元组中的元素一旦被创建，就不可更改了
• 元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔
• 语法格式：tuplename = (element1, element2, ... , elementn)

3.3.1 元组使用方法

• 创建元组
  1. 直接创建：tuplename = (element1, element2, ..., elementn)
  2. tuple()函数：tuple(data)，data 表示可以转化为元组的数据，包括字符串、元组、range 对象
  3. 当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串
• 访问元组元素
  1. 索引访问： tuplename[index]
  2. 切片访问 ：tuplename[start : end : step]
• 修改元组
  1. 元组中元素不可修改，但是可以整体赋值修改元组内容，tuplename = new_tupledata
  2. 通过+连接多个元组，本质上创建了一个新的元组
• 删除元组
  1. del 方法：del tuplename
  2. Python 自带垃圾回收功能，会自动销毁不用的元组

3.4 字典 dict

3.4.1 字典概念

• 字典： Python 中唯一的映射类型，通过键值对储存的一种无序的、可变的序列
• 各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”
• 字典中的键必须唯一，不支持同一个键出现多次，否则只会保留最后一个键值对
• 字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表
• 键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }

3.4.2 字典使用方法

• 创建dict
  1. 用 { } 创建字典 ： dictname = {'key1':'value1','key2':'value2'...}
  2. fromkeys() 方法：dictname = dict.fromkeys(list,value=None)，list 参数表示字典中所有键的列表
  3. 映射函数创建 ： dictname = dict(key1=value1,key2=value2,...)
  4. dict() 函数：dict(demo)，demo为列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值
  5. dict() 函数和 zip() 函数：dict(zip(keys,values))，keys 和 values 为两个列表
• 访问字典
  1. 通过键访问：dictname[key]，返回键对应的值
  2. get()函数：dictname.get(key,[default])，当键不存在时，返回default内容，可以省略
• 删除字典
  1. 整体删除：del dictname
  2. 删除某个值：del dictname[key]
• 添加键值对
  1. 语法格式：dictname[key]=value
  2. 添加的key必须不存在，存在就修改了value值
• 修改键值对
  1. 语法格式： dictname[key]=new_value
  2. 只能修改value值，key值不可修改
• 判断是否存在键值对
  1. 语法格式：key in dictname
  2. 语法格式：key not in dictname
  3. 返回 True : 存在 或者 False ：不存在
• 操作函数

函数	作用	使用方法
keys()	获取所有键	dictname.keys()
values()	获取所有值	dictname.values()
items()	获取所有键值对	dictname.items()
copy()	复制一个字典	new_dictname = old_dictname.copy()
update()	更新字典	dictname.update(‘key’:‘newvalue’…)
pop()	指定删除键值	dictname.pop(key)
popitem()	删除最后一个键值	dictname.popitem(key)
setdefault()	查找键对应的值，不存在添加新的键值对	dictname.setdefault(key, defaultvalue)

• 格式化字符串

# 字符串: 
s = " my name is %(name)s , age is %(age)d"
# 字典
qwq = {'name':'QWQ','age':18}
print(s % qwq)
# 结果打印：my name is QWQ , age is 18

3.5 集合 set

3.5.1 集合概念

• 用来保存互不相同的元素集合,数据无序存放
• 所有元素放在一对大括号 {} 中，相邻元素之间用 , 分隔
• 语法格式：{element1,element2,...,elementn}
• 只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型

3.5.2 集合使用方法

• 创建set

  1. 用 { } 创建 ：setname = {element1,element2,...,elementn}
  2. set()函数 ：setname = set(iteration)

• 访问set

  1. 集合是无序存放，无法通过下标访问
  2. 使用循环可以访问：for ele in setname

• 删除set

  1. 删除集合：del setname
  2. clear()函数：setname.clear()，清楚集合中所有元素

• 添加元素

  1. add()函数：setname.add(element)
  2. 添加的元素，只能是数字、字符串、元组或者布尔类型值，不能添加列表、字典、集合

• 移除元素

  1. remove()函数：setname.remove(ele)
  2. discard()函数：setname.discard(ele)
  3. 要删除的值必须存在

• 集合运算

运算操作	运算符	用法	含义
交集	&	set1 & set1	两集合都包含的元素
并集	|	set1 | set2	两集合全部元素
差集	-	set1 - set2	set1有而set2无的元素
对称差集	^	set1 ^ set1	取交集外的所有元素

• 集合操作函数

方法名	语法格式	功能
add()	set1.add()	向 set1 集合中添加数字、字符串、元组或者布尔类型
clear()	set1.clear()	清空 set1 集合中所有元素
copy()	set2 = set1.copy()	拷贝 set1 集合给 set2
difference()	set3 = set1.difference(set2)	将 set1 中有而 set2 没有的元素给 set3
difference_update()	set1.difference_update(set2)	从 set1 中删除与 set2 相同的元素
discard()	set1.discard(elem)	删除 set1 中的 elem 元素
intersection()	set3 = set1.intersection(set2)	取 set1 和 set2 的交集给 set3
intersection_update()	set1.intersection_update(set2)	取 set1和 set2 的交集，并更新给 set1
isdisjoint()	set1.isdisjoint(set2)	判断 set1 和 set2 是否没有交集，有交集返回 False
issubset()	set1.issubset(set2)	判断 set1 是否是 set2 的子集
issuperset()	set1.issuperset(set2)	判断 set2 是否是 set1 的子集
pop()	a = set1.pop()	取 set1 中一个元素，并赋值给 a
remove()	set1.remove(elem)	移除 set1 中的 elem 元素
symmetric_difference()	set3 = set1.symmetric_difference(set2)	取 set1 和 set2 中互不相同的元素，给 set3
symmetric_difference_update()	set1.symmetric_difference_update(set2)	取 set1 和 set2 中互不相同的元素，并更新给 set1
union()	set3 = set1.union(set2)	取 set1 和 set2 的并集，赋给 set3
update()	set1.update(elem)	添加列表或集合中的元素到 set1

---

感谢阅读，如有错误，敬请见谅！！！

---