目录

python序列概述

列表

列表常用方法

列表的创建

列表元素的增加

列表元素的删除

切片操作

列表排序

列表推导式

元组

元组的创建与删除

序列解包

生成器推导式

字典

字典的创建与删除

字典元素的读取

字典元素的修改与添加

字典推导式

集合

集合的创建与删除

集合运算

---

python序列概述

列表

列表常用方法

列表的创建

使用“=”直接将一个列表赋值给变量即可创建列表对象

>>> a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list = []                            #创建空列表

也可以使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

>>> a_list = list((3,5,7,9,11))
>>> a_list
[3, 5, 7, 9, 11]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
>>> list('hello world')
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> x = list()                            #创建空列表

当不再使用时，使用del命令删除整个列表。

列表元素的增加

（1）可以使用“+”运算符将元素添加到列表中。

>>> aList = [3,4,5]
>>> aList = aList + [7]
>>> aList
[3, 4, 5, 7]

严格意义上来讲，这并不是真的为列表添加元素，而是创建了一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。

（2）使用列表对象的append()方法在当前列表尾部追加元素，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快。

Python采用的是基于值的自动内存管理方式，当为对象修改值时，并不是真的直接修改变量的值，而是使变量指向新的值，这对于Python所有类型的变量都是一样的。

>>> a = [1,2,3]
>>> id(a)                        #返回对象的内存地址
20230752
>>> a = [1,2]
>>> id(a)
20338208

列表中包含的是元素值的引用，而不是直接包含元素值。

如果是直接修改序列变量的值，则与Python普通变量的情况是一样的

如果是通过下标来修改序列中元素的值或通过可变序列对象自身提供的方法来增加和删除元素时，序列对象在内存中的起始地址是不变的，仅仅是被改变值的元素地址发生变化，也就是所谓的“原地操作”。

>>> a = [1, 2, 3]
>>> id(a)
2389572193096
>>> a.append(4)
>>> a.remove(3)
>>> a[0] = 5
>>> a
[5, 2, 4]
>>> id(a)
2389572193096

（3）使用乘法来扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。

>>> aList = [3,5,7]
>>> aList * 3
[3, 5, 7, 3, 5, 7, 3, 5, 7]

当使用*运算符将包含列表的列表重复并创建新列表时，并不是复制子列表值，而是复制已有元素的引用。因此，当修改其中一个值时，相应的引用也会被修改。

>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0] = 5
>>> x
[[5, None], [5, None], [5, None]]

列表元素的删除

（1）使用del命令删除列表中的指定位置上的元素。

>>> a_list = [3,5,7,9,11]
>>> del a_list[1]
>>> a_list
[3, 7, 9, 11]

（2）使用列表的pop()方法删除并返回指定位置（默认为最后一个）上的元素，如果给定的索引超出了列表的范围则抛出异常。

>>> a_list = list((3,5,7,9,11))
>>> a_list.pop()
11
>>> a_list
[3, 5, 7, 9]
>>> a_list.pop(1)
5
>>> a_list
[3, 7, 9]

（3）使用列表对象的remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

>>> a_list = [3,5,7,9,7,11]
>>> a_list.remove(7)
>>> a_list
[3, 5, 9, 7, 11]

注意：

在删除列表元素时，Python会自动对列表内存进行收缩并移动列表元素以保证所有元素之间没有空隙，增加列表元素时也会自动扩展内存并对元素进行移动以保证元素之间没有空隙。每当插入或删除一个元素之后，该元素位置后面所有元素的索引就都改变了。

#正确代码
>>> x = [1,2,1,2,1,1,1]
>>> for i in range(len(x)-1,-1,-1):         #从后往前删
    if x[i]==1:
        del x[i]
	

切片操作

切片适用于列表、元组、字符串、range对象等类型，但作用于列表时功能最强大。可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。

切片使用2个冒号分隔的3个数字来完成：

第一个数字表示切片开始位置（默认为0）。

第二个数字表示切片截止（但不包含）位置（默认为列表长度）。

第三个数字表示切片的步长（默认为1），当步长省略时可以顺便省略最后一个冒号。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::]                            #返回包含所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1]                          #逆序的所有元素
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2]                           #偶数位置，隔一个取一个
[3, 5, 7, 11, 15]
>>> aList[1::2]                          #奇数位置，隔一个取一个
[4, 6, 9, 13, 17]
>>> aList[3::]                           #从下标3开始的所有元素
[6, 7, 9, 11, 13, 15, 17]
>>> aList[3:6]                           #下标在[3, 6)之间的所有元素
[6, 7, 9]
>>> aList[0:100:1]                       #前100个元素，自动截断
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100:]                          #下标100之后的所有元素，自动截断
[]
>>> aList[100]                           #直接使用下标访问会发生越界
IndexError: list index out of range

可以使用切片来原地修改列表内容

>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9]      #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]         #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = []                #删除前3个元素
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*5            #替换偶数位置上的元素
>>> aList
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
>>> aList[::2] = [0]*3            #切片不连续，两侧元素个数必须一样多
ValueError: attempt to assign sequence of size 3 to extended slice of size 5

 使用del与切片结合来删除列表元素

>>> aList = [3,5,7,9,11]
>>> del aList[:3]                          #删除前3个元素
>>> aList
[9, 11]
 
>>> aList = [3,5,7,9,11]
>>> del aList[::2]                         #删除偶数位置上的元素
>>> aList
[5, 9]

切片返回的是浅复制。所谓浅复制，是指生成一个新的列表，并且把原列表中所选元素的引用都复制到新列表中。如果原列表中只包含整数、实数、复数等基本类型或元组、字符串这样的不可变类型的数据，一般是没有问题的。

>>> aList = [3, 5, 7]
>>> bList = aList[::]                 #切片，浅复制
>>> aList == bList                    #两个列表的元素完全一样
True
>>> aList is bList                    #但不是同一个对象
False
>>> id(aList) == id(bList)            #内存地址不一样
False
>>> bList[1] = 8                      #修改其中一个不会影响另一个
>>> bList
[3, 8, 7]
>>> aList
[3, 5, 7]

如果原列表中包含列表之类的可变数据类型，由于浅复制时只是把子列表的引用复制到新列表中，这样的话修改任何一个都会影响另外一个。

>>> aList = [3, [5], 7]        #列表aList中包含可变的列表对象
>>> bList = aList[:]           #切片
>>> bList[1].append(6)         #调用子列表的append()方法，这个方法是原地操作的
>>> bList
[3, [5, 6], 7]
>>> aList                      #aList受到影响
[3, [5, 6], 7]

标准库copy中的deepcopy()函数实现深复制。所谓深复制，是指对原列表中的元素进行递归，把所有的值都复制到新列表中，对嵌套的子列表不再是复制引用。新列表和原列表是互相独立，修改任何一个都不会影响另外一个。

>>> aList = [3, [5], 7]
>>> import copy
>>> bList = copy.deepcopy(aList) #深赋值，递归复制，直到遇到可哈希对象
                           #aList和bList完全独立，互相不影响
>>> aList == bList
True
>>> aList is bList
False
>>> bList[1].append(6)         #修改bList不会影响aList
>>> bList
[3, [5, 6], 7]
>>> aList
[3, [5], 7]

列表排序

使用列表对象的sort()方法进行原地排序，支持多种不同的排序方法。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> import random
>>> random.shuffle(aList)
>>> aList
[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort()                            #默认是升序排序
>>> aList
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList.sort(reverse=True)              #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList.sort(key=lambda x:len(str(x)))  #按转换成字符串的长度排序
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

使用内置函数sorted()对列表进行排序并返回新列表。

>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
>>> sorted(aList)                            #升序排序
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> sorted(aList,reverse=True)             #降序排序
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

使用列表对象的reverse()方法将元素原地逆序。

使用内置函数reversed()对列表元素进行逆序排列并返回迭代对象。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> newList = reversed(aList)         #返回reversed对象
>>> list(newList)                     #把reversed对象转换成列表
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> for i in newList:
    print(i, end=' ')                 #这里没有输出内容
                                      #迭代对象已遍历结束
>>> newList = reversed(aList)         #重新创建reversed对象
>>> for i in newList:
    print(i, end=' ')
17 15 13 11 9 7 6 5 4 3

all()和any()：all()函数用来测试列表、元组等序列对象以及map对象、zip对象等类似对象中是否所有元素都等价于True，any()函数用来测试序列或可迭代对象中是否存在等价于True的元素。例如：

>>> all([1,2,3])
True
>>> all([0,1,2,3])
False
>>> any([0,1,2,3])
True
>>> any([0])
False

len(列表)：返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。 max(列表)、 min(列表)：返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。 sum(列表)：对列表的元素进行求和运算，对非数值型列表运算需要指定start参数，同样适用于元组、range。

zip()函数返回可迭代的zip对象。

>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b)                 #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList)                       #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]

enumerate(列表):枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

>>> for item in enumerate('abcdef'):
    print(item)
 
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')

列表推导式

列表推导式语法形式为：

[expression for expr1 in sequence1 if condition1
            for expr2 in sequence2 if condition2
            for expr3 in sequence3 if condition3
            ...
            for exprN in sequenceN if conditionN]

使用列表推导式实现嵌套列表的平铺

>>> vec = [[1,2,3], [4,5,6], [7,8,9]] 
>>> [num for elem in vec for num in elem] 
[1, 2, 3, 4, 5, 6, 7, 8, 9] 
 
#相当于
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
    for num in elem:
        result.append(num)
 
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]

如果不确定嵌套层数，可以这样做：

data = [[[1],[2],[3]],[[4],[5],[6]],[[7],[8],[9]]]
print(data)
result = []
def take_out(arr):
    for item in arr:
        if isinstance(item, int):
            result.append(item)
        else:
            take_out(item)
 
take_out(data)
print(result)

在列表推导式中使用多个循环，实现多序列元素的任意组合

>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

元组

元组和列表类似，但属于不可变序列，元组一旦创建，用任何方法都不可以修改其元素。

元组的创建与删除

使用“=”将一个元组赋值给变量

>>> a_tuple = ('a', 'b', 'mpilgrim', 'z', 'example')
>>> a_tuple
('a', 'b', 'mpilgrim', 'z', 'example')
>>> a = (3)
>>> a
3
>>> a = (3,)             #包含一个元素的元组，最后必须多写个逗号
>>> a
(3,)
>>> a = 3,               #也可以这样创建元组
>>> a
(3,)
>>> x = ()               #空元组

使用tuple函数将其他序列转换为元组 >>> tuple('abcdefg')  

>>> tuple('abcdefg')                    #把字符串转换为元组
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList)                        #把列表转换为元组
(-1, -4, 6, 7.5, -2.3, 9, -11)
>>> s = tuple()                         #空元组
>>> s
()

使用del可以删除元组对象，不能删除元组中的元素

元组一旦定义就不允许更改。

元组没有append()、extend()和insert()等方法，无法向元组中添加元素。

元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。

元组可用作字典的“键”，也可以作为集合的元素。列表不能作为字典的“键”，包含列表、字典、集合或其他类型可变对象的元组也不能做字典的“键”。

序列解包

可以使用序列解包功能对多个变量同时赋值。 

>>> x, y, z = 1, 2, 3             #多个变量同时赋值
>>> v_tuple = (False, 3.5, 'exp')
>>> (x, y, z) = v_tuple
>>> x, y, z = v_tuple
>>> x, y, z = range(3)            #可以对range对象进行序列解包
>>> x, y, z = iter([1, 2, 3])     #使用迭代器对象进行序列解包
>>> x, y, z = map(str, range(3))  #使用可迭代的map对象进行序列解包
>>> a, b = b, a                   #交换两个变量的值
>>> x, y, z = sorted([1, 3, 2])   #sorted()函数返回排序后的列表
>>> a, b, c = 'ABC'               #字符串也支持序列解包
>>> x = [1, 2, 3, 4, 5, 6]
>>> x[:3] = map(str, range(5))    #切片也支持序列解包

>>> aList = [1,2,3]
>>> bList = [4,5,6]
>>> cList = [7,8,9]
>>> dList = zip(aList, bList, cList)
>>> for index, value in enumerate(dList):
    print(index, ':', value)
 
0 : (1, 4, 7)
1 : (2, 5, 8)
2 : (3, 6, 9)

生成器推导式

使用生成器对象__next__()方法或内置函数next()进行遍历
>>> g = ((i+2)**2 for i in range(10))  #创建生成器对象
>>> g
object  at 0x0000000003095200>
>>> tuple(g)                           #将生成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g)             #生成器对象已遍历结束，没有元素了
[] 
>>> g = ((i+2)**2 for i in range(10))  #重新创建生成器对象
>>> g.__next__()        #使用生成器对象的__next__()方法获取元素
4
>>> g.__next__()        #获取下一个元素
9
>>> next(g)             #使用函数next()获取生成器对象中的元素
16

字典

字典是无序、可变序列。

定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。

字典中的键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等。

globals()返回包含当前作用域内所有全局变量和值的字典。

locals()返回包含当前作用域内所有局部变量和值的字典。

字典的创建与删除

使用dict利用已有数据创建字典：

>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values))
>>> dictionary
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> x = dict() #空字典
>>> x
{}

使用dict根据给定的键、值创建字典 

>>> d = dict(name='Dong', age=37)
>>> d
{'name': 'Dong', 'age': 37}

以键作为下标可以读取字典元素，若键不存在则抛出异常

>>> aDict = {'name':'Dong', 'sex':'male', 'age':37}
>>> aDict['name']
'Dong'

字典元素的读取

使用字典对象的get()方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。

使用字典对象的items()方法可以返回字典的元素。

使用字典对象的keys()方法可以返回字典的“键”。

使用字典对象的values()方法可以返回字典的“值”。

>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> for item in aDict.items():     #输出字典中所有元素
    print(item)
 
('age', 37)
('name', 'Dong')
('sex', 'male')
>>> for key in aDict:              #不加特殊说明，默认输出“键”
    print(key)
 
age
name
sex
 
>>> for key, value in aDict.items():       #序列解包用法
    print(key, value)
 
age 37
name Dong
sex male
>>> aDict.keys()                           #返回所有“键”
dict_keys(['name', 'sex', 'age'])
>>> aDict.values()                         #返回所有“值”
dict_values(['Dong', 'male', 37])

字典元素的修改与添加

当以指定键为下标为字典赋值时：1）若键存在，则可以修改该键的值；2）若不存在，则表示添加一个键、值对。

>>> aDict['age'] = 38                 #修改元素值
>>> aDict
{'age': 38, 'name': 'Dong', 'sex': 'male'}
>>> aDict['address'] = 'SDIBT'        #增加新元素
>>> aDict
{'age': 38, 'address': 'SDIBT', 'name': 'Dong', 'sex': 'male'}

使用字典对象的update()方法将另一个字典的键、值对添加到当前字典对象。

>>> aDict
{'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.items()
dict_items([('age', 37), ('score', [98, 97]), ('name', 'Dong'), ('sex', 'male')])
>>> aDict.update({'a':'a','b':'b'})
>>> aDict
{'a': 'a', 'score': [98, 97], 'name': 'Dong', 'age': 37, 'b': 'b', 'sex': 'male'}

使用del删除字典中指定键的元素

使用字典对象的clear()方法来删除字典中所有元素

使用字典对象的pop()方法删除并返回指定键的元素

使用字典对象的popitem()方法删除并返回字典中的一个元素

字典推导式

>>> {i:str(i) for i in range(1, 5)}
{1: '1', 2: '2', 3: '3', 4: '4'}
>>> x = ['A', 'B', 'C', 'D']
>>> y = ['a', 'b', 'b', 'd']
>>> {i:j for i,j in zip(x,y)}
{'A': 'a', 'C': 'b', 'B': 'b', 'D': 'd'}

集合

集合是无序、可变序列，使用一对大括号界定，元素不可重复，同一个集合中每个元素都是唯一的。

集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。

集合的创建与删除

使用set将其他类型数据转换为集合

>>> a_set = set(range(8,14))
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8])   #自动去除重复
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> c_set = set()                                 #空集合
>>> c_set
set()

当不再使用某个集合时，可以使用del命令删除整个集合。

集合对象的pop()方法弹出并删除其中一个元素，remove()方法直接删除指定元素，clear()方法清空集合。

>>> a = {1, 4, 2, 3}
>>> a.pop()
1
>>> a.pop()
2
>>> a
{3, 4}
>>> a.add(2)
>>> a
{2, 3, 4}
>>> a.remove(3)
>>> a
{2, 4}

交集、并集、差集、对称差集等运算

交集、并集、差集、对称差集等运算
>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set                             #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set & b_set                             #交集
{8}
>>> a_set - b_set
{9, 10, 11, 12, 13}
>>> a_set ^ b_set                             #对称差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}

集合运算

集合包含关系测试
>>> x = {1, 2, 3}
>>> y = {1, 2, 5}
>>> z = {1, 2, 3, 4}
>>> x < y                                #比较集合大小/包含关系
False
>>> x < z                                #真子集
True
>>> y < z
False
>>> {1, 2, 3} <= {1, 2, 3}               #子集
True