python知识体系第四节——序列

1 序列

序列是一种数据的存储方式，用来存储一系列的数据，在内存中，序列就是一块用来存放多个值的连续的内存空间。序列主要包含字符串(str)、列表(list)、元组(tuple)、字典(dict)、集合(set)，在python中的常见的表现形式如下：

>>> a='123'
>>> type(a)
<class 'str'>
>>> a=[1,2,3]
>>> type(a)
<class 'list'>
>>> a=(1,2,3)
>>> type(a)
<class 'tuple'>
>>> a={'name':1,'age':2,'time':'3'}
>>> type(a)
<class 'dict'>
>>> a={1,2,3}
>>> type(a)
<class 'set'>

2 列表

列表：用于存储任意数目、任意类型的数据集合。

2.1 创建列表的3种方法

（1）基本语法[]创建，例如:

a=[1,2,3]
type(a)

（2）list()函数创建列表，可以将任何可迭代的数据转化成列表，例如：

>>> list('zhangsan123张三')
['z', 'h', 'a', 'n', 'g', 's', 'a', 'n', '1', '2', '3', '张', '三']

通过list()内置range()函数形成list(range())函数，可以快速生成有序列表，其语法形式为：
list(range(start,end,step))
start:表示开始的数字，可以写，也可以不写，默认为0；
end：表示结束的数字，必须写。
step:表示步长，±表示方向。
例如：

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

（3）推导式生成列表，使用循环语句，例如 ：

>>> a=[x*2 for x in range(0,10,1)]
>>> a
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> 
>>> a=[x*2 for x in range(0,10,1) if x%2==0]
>>> a
[0, 4, 8, 12, 16]

2.2 列表元素的增加

（1）append()函数为在列表尾部添加元素，只接受增加一个元素，元素可以是任何数据类型，并且不改变变量的位置，运行效率较高，推荐使用，例如：

>>> a=[1,2,3,4]
>>> id(a)
46587528
>>> a.append(4)
>>> 
>>> a
[1, 2, 3, 4, 4]
>>> id(a)
46587528
>>> 

（2）+运算符操作，是将两个列表相加创建新的列表，会产生新的内存，当数据量较大的时候不建议使用，例如：

>>> a=[1,2]
>>> id(a)
4488616
>>> a=a+[3,4]
>>> a
[1, 2, 3, 4]
>>> id(a)
53020200

（3）extend()方法，相比于append()只能添加一个元素，并且将每个元素拆分开来分别添加列表中，例如：

>>> a=[1,2,3,4]
>>> b=[1,2,'张三',3.14]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 1, 2, '张三', 3.14]

(4) insert()函数，将一个元素插入到列表中，insert(插入位置，插入元素)，注意插入的元素是在序号（位置）之前插入，例如：

a=[1,2,3,4]
>>> b=['张三','李四',1,2]
>>> a.insert(3,b)
>>> a
[1, 2, 3, ['张三', '李四', 1, 2], 4]

(5) 乘法扩展的方法
乘法扩展指的是将列表元素进行多次重复列出，并且适用的还有字符串，元组，字典，集合，例如：

>>> a=[1,2,3,4]
>>> b=a*3
>>> b
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
>>> a="123"
>>> b=a*3
>>> b
'123123123'

2.3 列表元素的删除

（1）del删除
删除列表指定位置的元素，例如：

>>> a=[1,2,3,4]
>>> del a[1]
>>> a
[1, 3, 4]

（2）pop()删除
pop()删除指的是删除列表指定位置的元素，并返回被删除的值，如果没有指定位置，则默认删除列表末尾的元素，例如：

>>> a=[1,2,3,4]
>>> a.pop(1)
2
>>> a
[1, 3, 4]
>>> a=[10,20,30,40]
>>> a.pop()
40
>>> a
[10, 20, 30]

(3) remove() ，删除首次出现的指定元素，若不存在该元素则报错，例如：

>>> a=[1,2,3,4]
>>> a.remove(1)
>>> a
[2, 3, 4]
>>> a.remove(5)
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    a.remove(5)
ValueError: list.remove(x): x not in list

2.4 列表元素的访问和计数

（1）通过索引的方法 a[] 直接访问元素，例如：

>>> a=[1,2,3,4]
>>> a[1]
2

（2）index(value，start，end)表示查找某个值在列表中首次出现的位置，start，end表示搜索的起始位置与结束位置（范围），如果无搜索范围默认从列表开始/结束位置搜索，例如：

>>> a=[1,2,3,4,4,5,6,7,8,2]
>>> a.index(2)
1
>>> a.index(2,2)
9
>>> a.index(4,0,4)
3

（3）count()函数获得指定元素在列表中出现的次数，例如：

>>> a=[1,2,3,4,5,6,3,2,4,5,3,2,56,7]
>>> a.count(2)
3
>>> a.count(5)
2

（4）len()返回列表的长度，例如：

>>> a=[1,2,3,4,5,6,3,2,4,5,3,2,56,7]
>>> len(a)
14

(5) 判断指定元素是否在列表中，用 in/not in 来判断，例如：

>>> a=[1,2,3,4,5,6,3,2,4,5,3,2,56,7]
>>> 10 in a
False
>>> 5 in a
True
>>> 2 not in a
False

2.5 切片操作slice

切片操作指的是从列表截取部分元素形成子列表，语法为a[起始偏移量start:终止偏移量end:步长step]，切片操作同样适用于列表，元组，字符串等，例如：

>>> a=[1,2,3,4,5,6,3,2,4,5,3,2,56,7]
>>> a[1:7:1]
[2, 3, 4, 5, 6, 3]
>>> a[7:1:-1]
[2, 3, 6, 5, 4, 3]
>>> a[1::1]
[2, 3, 4, 5, 6, 3, 2, 4, 5, 3, 2, 56, 7]

2.6 遍历列表

2.7 列表的复制

list1=list2操作只是将list2的地址，值，类型赋给list1，并未创建新的列表，可以使用list1=[]+list2, 例如：

>>> a=[1,2,3,4]
>>> list1=[1,2,3,4]
>>> list2=list1
>>> id(list2)
18087624
>>> list2=[]+list1
>>> id(list2)
18087656

2.8 列表排序

（1）不建立新列表的排序
升序：a.sort() ,降序：a.sort(reverse=True)
随机排序：random.shuffle(a),例如：

>>> a=[2,4,2,7,4,6,7,4,3,2,6,8,3,2]
>>> a.sort()
>>> a
[2, 2, 2, 2, 3, 3, 4, 4, 4, 6, 6, 7, 7, 8]
>>> a.sort(reverse=True)
>>> a
[8, 7, 7, 6, 6, 4, 4, 4, 3, 3, 2, 2, 2, 2]
>>> import random
>>> random.shuffle(a)
>>> a
[2, 2, 4, 8, 4, 6, 7, 3, 6, 2, 4, 2, 7, 3]

（2）建立新列表的排序
语法为：升序排列: a=sorted(a),降序排列：a=sorted(a,reverse=Ture) ，例如：

>>> a=[1,2,3,4,5]
>>> id(a)
56929832
>>> a=sorted(a)
>>> a
[1, 2, 3, 4, 5]
>>> id(a)
18087912
>>> c=sorted(a,reverse=True)
>>> c
[5, 4, 3, 2, 1]
>>> id(c)
56929480

（3）reversed()函数返回逆序排列的迭代器，并且返回的列表只能输出一次，例如：

>>> a=[1,2,3,4]
>>> b=reversed(a)
>>> b
<list_reverseiterator object at 0x01127C28>
>>> list(b)
[4, 3, 2, 1]
>>> list(b)
[]

2.9 列表相关其他内置函数

max(a)：输出列表的最大值；
min(a)：输出列表的最小值；
sum(a):输出列表元素值的和，例如：

>>> a=[1,2,3,4]
>>> max(a)
4
>>> min(a)
1
>>> sum(a)
10

2.10 多维列表

a=[[1,2,34,4],[1,2,3,4],[2,3,4,4]]
>>> a
[[1, 2, 34, 4], [1, 2, 3, 4], [2, 3, 4, 4]]
>>> for i in range(3):
	for j in range(4):
		print(a[i][j],end='\t')
	print()

1	2	34	4	
1	2	3	4	
2	3	4	4

3 元组

列表属于可变序列，元组属于不可变序列，因此元组不支持元素的添加、删除、修改等操作，元组支持以下操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：max()/min()/sum()/len()/count()

3.1 元组的创建

（1）通过()来创建元组，例如a(1,2,3,4)，外面的括号可以省去，a=1,2,3,4
如果只有一个元素a(1,),后面的括号一定不能省去，否在系统会将其识别为整形数据：

>>> a=1
>>> type(a)
<class 'int'>
>>> a=1,
>>> type(a)
<class 'tuple'>

（2）通过tuple()创建元组，该方法与()创建元组的区别在于tuple()函数可以将其他数据类型转换成元组，例如：

>>> a=tuple()
>>> a=('1,2,3')
>>> a
'1,2,3'
>>> a=tuple('2,3,3')
>>> a
('2', ',', '3', ',', '3')
>>> a=tuple([1,2,3])
>>> a
(1, 2, 3)

3.2 元组元素的访问与计数

（1）元组元素不能修改

>>> a
(1, 2, 3, 3, 4)
>>> a[1]=3
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    a[1]=3
TypeError: 'tuple' object does not support item assignment

（2）元组的元素访问与列表的访问一致，都是a[]的形式，例如：

>>> a
(1, 2, 3, 4, 45, 3)
>>> a[0:2]
(1, 2)
>>> 

（3）元组不支持元素的修改，删除，排序等操作，但如果想要对元组进行排序，可以使用sorted()函数，使得其成为序列类型：

>>> a=[2,3,4,21,23,46,3]
>>> sorted(a)
[2, 3, 3, 4, 21, 23, 46]

3.3 zip函数

zip()功能主要是将多个列表对应位置的元素组合成为元组，并返回zip对象，相当于常说的压缩操作：

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> c=[7,8,9]
>>> d=zip(a,b,c)
>>> d
<zip object at 0x03670F68>
>>> list(d)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

3.4 生成器推导式创建元组

生成器推导式生成列表相当于生成一串字符串存储在某一个地址里面，使用list()/tuple()以供提取，并且可以使用.next()进行序列遍历，例如：

>>> a=(x*2 for x in range(5))
>>> a
<generator object <genexpr> at 0x00DA7E28>
>>> tuple(a)
(0, 2, 4, 6, 8)
>>> list(a)
[]
>>> a=(x*2 for x in range(5))
>>> a.__next__()
0
>>> a.__next__()
2
>>> a.__next__()
4
>>> a.__next__()
6
>>> a.__next__()
8
>>> a.__next__()
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    a.__next__()
StopIteration

4 字典

字典包含键对象与值对象，可以通过键对象快速的查找值对象，键是任意的不可变数据，比如整数，浮点数，字符串，元组，
但是，列表、字典、集合这些可变数据不能作为键对象，并且键不可重复，值可以是任意的数据，并且可重复。
字典的常见形式为：
a={‘name’:’’,‘age’:18,‘job’:‘IT’}

4.1 字典的创建

（1）通过{}，dict()来创建，例如

>>> a={'name':'zhangsan','age':18}
>>> a
{'name': 'zhangsan', 'age': 18}
>>> a=dict(name='zhangsan',age=18)
>>> a=dict([('name','zhangsan'),('age',18)])
>>> a
{'name': 'zhangsan', 'age': 18}

(2) 通过zip()来创建字典对象，例如

>>> a=['name','age']
>>> b=['zhangsan','18']
>>> c=dict(zip(a,b))
>>> c
{'name': 'zhangsan', 'age': '18'}

（3）通过fromkeys创建值为空的字典，例如：

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

4.2 字典元素的访问

（1）通过键值进行访问，例如：

>>> a={'name':'zhangsan','age':18}
>>> a['name']
'zhangsan'
>>> a['age']
18

（2）通过get()获得键值，例如：

>>> a={'name':'zhangsan','age':18}
>>> a.get('name')
'zhangsan'
>>> a.get('age')
18
>>> a.get('job')#当输入的键对象不存在时，将会输出空对象

（3）a.items()列出所有的键值对，以列表的形式输出，例如：

>>> a={'name':'zhangsan','age':18}
>>> a.items()
dict_items([('name', 'zhangsan'), ('age', 18)])

（4）a.keys() 列出所有的键，a.values列出所有的值，例如:

>>> a={'name':'zhangsan','age':18}
>>> a.keys()
dict_keys(['name', 'age'])
>>> a.values()
dict_values(['zhangsan', 18])

（5）len()统计键值对的个数，例如：

>>> a={'name':'zhangsan','age':18}
>>> len(a)
2

（6）in 检测一个键是否在字典中，例如：

>>> a={'name':'zhangsan','age':18}
>>> 'name' in a
True
>>> 'age' in a
True
>>> 'job' in a
False

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

（1）给字典添加新的键值对，如果键值对存在，则覆盖原有键值对，不存在则新增，例如：

>>> a={'name':'zhangsan','age':18}
>>> a['job']='programmer'
>>> a['score']=98
>>> a
{'name': 'zhangsan', 'age': 18, 'job': 'programmer', 'score': 98}
>>> a['age']=20
>>> a
{'name': 'zhangsan', 'age': 20, 'job': 'programmer', 'score': 98}

（2）a.update(b) 更新字符串，运用b键值对的内容更新a键值对的内容，例如：

>>> a={'name':'zhangsan','age':18}
>>> b={'name':'lisi','job':'programmer'}
>>> a.update(b)
>>> a
{'name': 'lisi', 'age': 18, 'job': 'programmer'}

（3）删除字典中的键值对，可以使用del(a[‘name’])，或者使用clear()，或者使用a.pop()删除指定键值对，或者popitem(）随机删除所选项并返回键值，直至删除的项为空值，例如：

>>> a={'name':'zhangsan','age':18,'job':'programmer'}
>>> del(a['age'])
>>> a
{'name': 'zhangsan', 'job': 'programmer'}
>>> a.pop('job')
'programmer'
>>> a={'name':'zhangsan','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> >>> a.popitem()
SyntaxError: invalid syntax
>>> a.popitem()
('age', 18)
>>> a.popitem()
('name', 'zhangsan')
>>> a.popitem()

5 集合

举一个集合的标准形式的例子{1,2,3,4,5}，从该形式中可以看出，集合的形式与字典相似，都是用{}括了起来，但集合是只有键没有值的，与字典一样，集合是无序且元素不能重复的。

5.1 集合的创建与元素添加、删除

（1）使用{}创建集合，并用add()添加元素，remove()删除元素，例如：

>>> a=[1,2,'zhangsan',3.14]
>>> a={1,2,'zhangsan',3.14}
>>> a.add(1.14)
>>> a
{'zhangsan', 1, 2, 3.14, 1.14}
>>> a={1,2,3,4}
>>> a.remove(4)
>>> a
{1, 2, 3}

（2）使用set()将列表，元组等转换成集合，例如：

>>> a=[1,2,3,4]
>>> set(a)
{1, 2, 3, 4}
>>> a=(1,2,3,4)
>>> set(a)
{1, 2, 3, 4}

5.2 集合的合并于相交

>>> a={1,2,3,4,2,3}
>>> b={1,2,3,3,2,34}
>>> a|b#a与b的并集
{1, 2, 3, 4, 34}
>>> a&b#a与b的交集
{1, 2, 3}
>>> a-b#a与b的差集
{4}