Python基础系列三：序列

序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列是一块用来存放多个值的连续的内存空间。
Python中的序列主要有以下几种，字符串、列表、元组、字典、集合等。

1. 列表

列表是用于存储任意项目、任意类型的数据集合，列表大小可变，根据需要随时增加或缩小。

1.1 列表操作

方法	要点	描述
list.append(x)	增加元素	将元素x增加到列表list尾部
list.extend(alist)	增加元素	将alist增加到列表list尾部
list.insert(index,x)	增加元素	在列表指定位置index处插入元素x
list.remove(x)	删除元素	在列表中删除首次出现的元素x
list.pop([index])	删除元素	用于移除列表中index指定的元素（默认最后一个元素），并且返回该元素的值
list.clear()	删除所有元素	删除所有元素，保留列表对象
list.index(x)	访问元素	返回列表中第一个x的位置，如果不存在x则抛出异常
list.count(x)	计数	统计元素x在list中出现的次数
len(list)	列表长度	统计列表中元素个数
list.reverse()	列表翻转	列表元素翻转
list.sort()	列表排序	所有元素排序
list.copy()	浅拷贝	返回列表对象的浅拷贝

1.2 列表的创建

1.2.1 基本语法[]创建

a = [] #创建空列表
a = [10,20,'a','b']

1.2.2 list()创建

list()可以将任何可迭代的数据转换成列表

a = list() #空列表
a = list(range(10)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = list("hello,world") #['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd']

1.2.3 range()创建整数列表

range()可以创建整数列表，语法格式为

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

start：可选，表示其实数字，默认是0
end：必选，表示结尾数字
step：可选，表示步长，默认是1
Python3中range()返回的是一个range对象，不是列表，需要用list()将range对象转换成列表对象。

a = list(range(10)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

1.2.4 推导式生成列表

a = [x*2 for x in range(5)] #[0, 2, 4, 6, 8]
a = [x for x in range(100) if x%9==0] #[0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

1.3 列表元素的添加

当列表增加和删除元素时，列表会自动进行内存管理，这个过程涉及列表元素的大量移动，效率较低。一般只在列表的尾部添加元素或删除元素，大大提高列表的操作效率。

1.3.1 append()

在原列表尾部添加新的元素，速度最快

a = [10,20,'a','b']
a.append(30) #[10, 20, 'a', 'b', 30]

1.3.2 +运算符操作

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

1.3.3 extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。当涉及两表合并时，推荐使用该方法。

1.3.4 insert插入元素

将元素插入到列表中任意指定位置，涉及元素移动，影响处理速度。同样发生元素移动的函数还有remove()、pop()、del()，它们在删除非尾部元素时也会发生元素移动操作。

1.3.5 乘法扩展

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

a = [10,20]
a = a*3 #[10, 20, 10, 20, 10, 20]

1.4 列表元素的删除

1.4.1 del删除

删除列表指定位置的元素，涉及元素的移动。

a = [10,20,'a','b']
del a[2] #[10, 20, 'b']

1.4.2 pop()方法

pop()删除并返回指定位置的元素，默认列表最后一个元素

a = [10,20,'a','b']
b = a.pop() #b
c = a.pop(2) #a

1.4.3 remove()方法

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

a = [10,20,'a','b',10,20,'a','b']
a.remove(10)

1.4.4 列表元素访问

1.4.4.1 通过索引直接访问元素

可以通过索引直接访问元素，索引的区间在[0,列表长度-1]，超出该范围，则会抛出异常。

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

index()获取指定元素在列表中首次出现的索引。语法是:index(value,[start,[end]])，其中start和end指定了搜索的范围。

a = [10,20,'a','b',10,20,'a','b']
a.index(10) #0
a.index(10,3) #4，从索引3开始搜索元素10

1.4.5 成员资格判断

判断列表中是否存在指定的元素，一般会使用 in 关键字。

a = [10,20,'a','b',10,20,'a','b']
10 in a # True
30 in a # True

1.5 列表切片操作

列表的切片操作使用slice函数，格式为slice[起始偏移量start：终止偏移量end[：步长step]]

对于a=[10,20,30]

操作	说明	示例	结果
[:]	提取整个列表	a[:]	[10,20,30]
[start:]	从start开始到结尾	a[1:]	[20,30]
[:end]	从开始到end-1	a[:2]	[10,20]
[start:end]	从start到end-1	a[0:2]	[10,20]
[start🔚step]	从start到end-1,步长step	a[1:3:2]	[20]

1.6 列表的排序

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

sort()：升序排序
sort(reverse=True)：降序 排序
random.shuffle()：打乱排序，需提前引入random包

import random
a = [10,20,50,30,40,0]
a.sort() #[0, 10, 20, 30, 40, 50]
a.sort(reverse=True) #[50, 40, 30, 20, 10, 0]
random.shuffle(a) #[40, 30, 10, 0, 20, 50]

1.6.2 返回新列表的排序

sorted()：内置函数，升序排序，返回新列表
sorted(reverse=True)：内置函数，降序排序，返回新列表

a = [10,20,50,30,40,0]
b = sorted(a) #[0, 10, 20, 30, 40, 50]
c = sorted(a,reverse=True) #[50, 40, 30, 20, 10, 0]

1.6.3 reversed()返回迭代器

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

1.6.4 max和min函数

max：返回列表最大值
min：返回列表最小值

a = [10,20,50,30,40,0]
b = max(a) #50
c = min(a) #0

1.6.5 sum函数

sum：返回列表各元素之和，只适用于数值型列表

a = [10,20,50,30,40,0]
b = sum(a) #150

2. 元组tuple

元组属于不可变序列，不能修改元组中的元素，因此元组没有增删改等操作。

2.1 元组的创建

2.1.1 通过()创建元组

元组可以通过()创建，其中小括号可以省略。元组只有一个元素时，后面必须加逗号。

a = (1,)
type(a) #tuple
a = (1)
type(a) #int
a = 1,
type(a) #tuple
a= 1
type(a) #int
a = (10,20,50,30,40,0)
a = 10,20,50,30,40,0

2.1.2 通过tuple()创建元组

tuple(可迭代对象)：将其他可迭代对象转换成元组

tuple(range(3)) #(0, 1, 2)
tuple("abc") #('a', 'b', 'c')
tuple([2,3,4]) #(2, 3, 4)

2.1.2 通过tuple()创建元组

2.2 元组的访问和计数

元组的访问和计数和列表相同，参考1.4.4

2.3 元组的总结

元组的核心特点是：不可变序列
元组的访问和处理速度比列表快
与整数和字符串一样，元组可以作为字典的键，列表不能作为字典的键使用。因为整数、字符串以及元组都是不可变的，而列表可变。

3. 字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含："键对象"和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的值对象。
键是任意的不可变数据，比如整数、浮点数、字符串、元组。列表、字典、集合这些可变对象，不能作为键，并且键不可重复。

3.1 字典的创建

3.1.1 通过{}和dict()创建字典

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
b = dict(name='lilei',age=18) #{'name': 'lilei', 'age': 18}
c = dict([('name','lilei'),('age',18)]) #{'name': 'lilei', 'age': 18}
c = {} #空的字典对象
c = dict(); #空的字典对象

3.1.2 通过zip()创建字典

k = ['name','age']
v = ['lilei','18']
d = dict(zip(k,v)) #{'name': 'lilei', 'age': '18'}

3.1.3 通过fromkeys创建值为空的字典

a = dict.fromkeys(['name','age','job']) #{'name': None, 'age': None, 'job': None}

3.2 字典元素的访问

3.2.1 通过[键]获得值

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

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['name']

3.2.2 通过get()获得值

通过get(键)获得值，推荐使用，若键不存在返回None。

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['name']

3.2.3 列出所有的键值对

items()：获取所有键值对，返回列表，每个元素为元组
keys()：列出所有的键
values()：列出所有的值

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a.items() #dict_items([('name', 'lilei'), ('age', 18)])
a.keys() #dict_keys(['name', 'age'])
a.values() #dict_values(['lilei', 18])

3.2.4 len()键值对的个数

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
len(a) #2

3.2.5 检测字典中是否存在该键

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
'name' in a #True

3.3 元素添加、修改、删除

给字典新增**“键值对”**。如果键已经存在，则覆盖该键值对，否则新增“键值对”

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
a['job'] = 'teacher' #{'name': 'lilei', 'age': 18, 'job': 'teacher'}
len(a) #2

使用update()将新字典中所有键值对全部添加到旧字典上，如果key重复，则直接覆盖。

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
b = {'name':'lilei','age':25,'job':'teacher'} #{'name': 'lilei', 'age': 18}
a.update(b) #b覆盖a
len(a) #2

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

a = {'name':'lilei','age':18} #{'name': 'lilei', 'age': 18}
del(a['name'])
b = a.pop('age') #18

3.4 序列解包

序列解包用于元组、列表、字典。

a = {'name':'lilei','age':25,'job':'teacher'} #{'name': 'lilei', 'age': 18}
name,age,job = a #默认对键进行操作
name,age,job = a.items() #对键值对进行操作
name,age,job = a.values() #对值进行操作

3.5 字典核心底层原理

字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组)

3.6 字典用法总结

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

4. 集合

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

4.1 集合的创建和删除

可以使用{}创建集合对象，并使用add()方法添加元素

a = {3,5,7}
a.add(9) #{9, 3, 5, 7}

可以使用set()函数将列表、元组等可迭代对象转换成集合。如果原始数据存在重复数据，则只保留一个。

a = [3,5,7,3,9,'dd',7]
b = set(a) #{3, 5, 7, 9, 'dd'}

remove()删除指定元素，clear()清空整个集合

a = {3, 5, 7, 9, 'dd'}
b = a.remove(3)

4.2 集合相关操作

Python对集合也提供了并集、交集、差集等运算。

a = {3, 5, 7, 9, 'dd'}
b = {'dd',0,3,20,30}
a|b ##并集 {0, 3, 5, 7, 9, 'dd', 20, 30}
a.union(b) ##并集 {0, 3, 5, 7, 9, 'dd', 20, 30}
a&b #交集 {'dd', 3}
a.intersection(b) #交集 {'dd', 3}
a-b #差集 {9, 5, 7}
a.difference(b) #差集 {9, 5, 7}