序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40]，示意表示：

从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。

??我们上一章学习的字符串就是一种序列。关于字符串里面很多操作，在这一章中仍然会用到，大家一定会感觉非常熟悉。

??本章内容，我们必须非常熟悉。无论是在学习还是工作中，序列都是每天都会用到的技术，可以非常方便的帮助我们进行数据存储的操作。

列表

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

列表的创建

• []

a = [10,20,'hello','world']
b = []  #创建一个空的列表对象
print(a)

• list()

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

• range()：创建整数列表

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

start参数：可选，表示起始数字。默认是0

end参数：必选，表示结尾数字。

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)

• 推导式生成列表

#循环创建多个元素 [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)

列表元素的增加

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。

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

• append()：原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。

a = [20,40]
a.append(80)
print(a)    #结果：[20, 40, 80]

• + 运算符

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

a = [20,40]
print(id(a))
a = a+[50]
print(id(a))  #两次地址不一样，创建了新的对象

• extend()

目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

a = [20,40]
print(id(a))
b = [50,60]
a.extend(b)   #原对象修改
print(id(a))
a = a+b     #产生新对象
print(id(a))

• insert()

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

a = [10,20,30]
a.insert(2,100)
print(a)   #结果：[10, 20, 100, 30]

• 乘法扩展

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

a = ['hello',100]
b = a*3
print(a) #结果：['hello', 100]
print(b) #结果：['hello', 100, 'hello', 100, 'hello', 100]

适用于乘法操作的，还有：字符串、元组。例如：

c = 'hello'
d = c*3   #结果：'hellohellohello'

列表元素的删除

• del：删除列表指定位置的元素

a = [100,200,888,300,400]
del a[2]
print(a)   #结果：[100,200,300,400]

• 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

• 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

列表元素访问和计数

• 通过索引直接访问元素

索引的区间在[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

• 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元素的位置

• count()：获得指定元素在列表中出现的次数

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3

• len()：返回列表长度，即列表中包含元素的个数

>>> a = [10,20,30]
>>> len(a)
3

• in/not in：成员资格判断

判断列表中是否存在指定的元素，我们可以使用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

切片操作

类似字符串的切片操作，对于列表的切片操作和字符串类似。

切片是Python序列及其重要的操作，适用于列表、元组、字符串等等。

切片slice操作可以让我们快速提取子列表或修改。标准格式为：

[起始偏移量start:终止偏移量end[:步长step]]

典型操作(三个量为正数的情况)如下：

其他操作（三个量为负数）的情况：

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会当做0，终止偏移量大于“长度-1”会被当成”长度-1”。例如：

[10,20,30,40][1:30]

结果：[20, 30, 40]

我们发现正常输出了结果，没有报错。

列表的遍历

a = [10,20,30,40]
for obj in a:       #obj是临时变量名称，随意起
	print(obj)

列表的复制

list1 = [10, 20, 30]

list2 = [] + list1 # + 连接 会产生新的列表对象

print(id(list1)) # 2423155053760
print(id(list2)) # 2423214197440

列表排序

• 修改源列表，不建新列表的排序

>>> 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]

• 建新列表的排序

sorted()排序，返回新列表，不对原列表做修改。

a = [10, 30, 4, 50]
b = sorted(a) # 升序
c = sorted(a, reverse=True) # 降序
print(id(a)) # 1942186284224
print(id(b)) # 1942244855552
print(id(c)) # 1942245362368

内置函数reversed() 返回迭代器，不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

列表内置函数

• max()
• min()

>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3

• sum()

>>> a = [3,10,20,15,9]
>>> sum(a)
57

多维列表

• 一维列表：存储一维、线性的数据。
• 二维列表：存储二维、表格的数据。

元组

列表属于可变序列，可以任意修改列表中的元素。

元组属于不可变序列，不能修改元组中的元素。

因此，元组没有增加元素、修改元素、删除元素相关的方法。

• 元组的创建

通过()创建元组。小括号可以省略。 a = (10,20,30) 或者 a = 10,20,30。

通过tuple()创建元组。tuple(可迭代的对象)

a = tuple()     #创建一个空元组对象
b = tuple("abc")
c = tuple(range(3))
d = tuple([2,3,4])

• 元组排序

内置函数sorted(tuple obj), 生成新的列表对象。

a = (20,10,30,9,8)
b = sorted(a)  #b是新对象，内容是：[8, 9, 10, 20, 30]

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)

生成器推导式创建元组

b = (x * 10 for x in range(5))
print(b)

c = tuple(b)
print(c) # (0, 10, 20, 30, 40)

d = tuple(b)
print(d) # ()

• 列表推导式

a = [x * 10 for x in range(5)]
print(a) # [0, 10, 20, 30, 40]

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

字典创建

通过{}、dict()创建字典对象。

通过zip()创建字典对象。

通过fromkeys()创建值为空的字典。

c = dict([("name","java"),("age",18)])
print(c) # {'name': 'java', 'age': 18}

k = ['name','age']
v = ['C++', 67]
d = dict(zip(k,v))
print(d) # {'name': 'C++', 'age': 67}

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

字典的访问

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

通过get()方法获得"值"。指定键不存在，返回None。

列出所有的键值对。

a = {'name':"hello", 'age':18}

b = a.items() # 列出所有的键值对

# 列出所有的键，列出所有的值
k = a.keys()
v = a.values()

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

键存在，覆盖旧的键值对；

键不存在，新增键值对。

a = {'name':"hello", 'age':18}

a['address'] = "beijing" # 新增
a['age'] = 16 # 覆盖

b= {"name":"world", "gender":"male"}
a.update(b) # 全部添加到旧字典对象上，key有重复，则直接覆盖

del()：删除指定元素

clear()：删除所有键值对

pop()：删除指定键值对，并返回对应的"值对象"

popitem()：随机删除和返回键值对。字典时"无序可变序列"

a = {'name':"hello", 'age':18}

del(a['name'])

age = a.pop("age")

序列解包

x,y,z=(20,30,10)
(a,b,c)=(9,8,10)
[m,n,p]=[10,20,30]

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

集合

集合是无序可变，元素不能重复。集合底层时字典实现。

集合创建和删除

{}创建集合对象，使用add()添加元素。

set()将列表、元组等可迭代对象转成集合。

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

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

a = ['a','b','c','b']
b = set(a) #{'b', 'a', 'c'}

a = {10,20,30,40,50}
a.remove(20)  #{10, 50, 40,30}

集合的并集、交集、差集

>>> a = {1,3,'hello'}
>>> b = {'he','it','hello'}
>>> a|b                 #并集
{1, 3, 'hello', 'he', 'it'}
>>> a&b                 #交集
{'hello'}
>>> a-b                 #差集
{1, 3}
>>> a.union(b)              #并集
{1, 3, 'hello', 'he', 'it'}
>>> a.intersection(b)       #交集
{'hello'}
>>> a.difference(b)         #差集
{1, 3}