高级语言程序Python——列表~元组~字典~集合
列表
概述
类型名称：list，定界符：方括号【】，可变有序。
在Python中，一个列表中的数据类型可以各不相同，可以同时分别整数，实数，字符串等基本类型，甚至是列表，元组，字典，集合以及其他自定义类型对象。
列表创建：
- 使用“=”直接将一个列表赋值给变量。
>>>alist = []
- 使用list(),函数，将元组，range对象，字符串等可迭代的对象类型转换为列表。
>>>alist=list((1,2,3,4,5)) #元组
'''>>>alist
[1,2,3,4,5]'''
>>>alist=list(range(1,10,2)) #range对象
'''>>>alist
[1,3,5,7,9]'''
>>>list('hello') #字符串
['h','e','l','l','o']
>>>alist=list() #list()函数
'''>>>alist
[]'''
列表删除
- 使用del命令删除整个列表。
<<<del alist
- 使用del命令删除指定位置上的元素。
>>>alist=[1,2,3,4,5]
>>>del alist[1]
[1,3,4,5]
- 使用del与切片结合删除元素
>>>alist=[1,2,3,4,5]
>>>del alist[:3] #删除前3个元素
[4,5]
- 使用pop(obj),方法，删除并返回指定位置上的元素（默认为最后一个元素），给定索引超出列表范围则抛出异常。
>>>alist=[1,2,3,4,5]
>alist.pop()
[5]
>>>alist=[1,2,3,4,5]
>>>alist.pop(1)
[2]
- 使用remove(obj),删除首次出现的指定元素。删除列表中不存在的元素，则抛出异常。没有返回值
>>>alist=[1,3,2,3,4]
>>>alist.remove(3)
[1,2,3,4]
>>>alist=[1,2,1,2,1,1,1] #切片 删除1 （后面详细说）
>>>for i in alist[::]:
if i == 1:
alist.remove(i)
>>>alist=[1,2,1,2,1,1,1] #从后往前删
>>>for i in range(len(x)-1,-1,-1):
if alist[i]==1:
del alist[i]
元素添加
- 使用”+“运算符添加元素（创建了一个新的列表）速度慢
>>>alist=[1,3]
>>>alist=alist+[5] #中括号里是单个元素值
[1,3,5]
- 使用“+=” 运算符添加元素
>>>alist=[]
>>>alist += '1234'
['1','2','3','4']
>>>alist += range(3)
['1','2','3','4',0,1,2]
- 使用append(object)[对象]方法，在列表尾部追加元素，原地修改列表，没有返回值。速度较快
将参数视为element,作为一个整体添加
>>>alist=[1,3]
>>>alist.append(5)
[1,3,5]
>>>alist=[1,2,3] #对比extend()
>>>alist.append(['A','B'])
[1,2,3 ['A','B']]
- 使用extend(sequence)[元素列表]方法，在列表尾部添加一个迭代对象所有元素，原地修改列表，没有返回值。
将参数视为list,作为序列合并，List里可以有任何数据类型。
>>>alist=[1,2,3]
>>>alist.extend([7,8])
[1,2,3,7,8]
>>>alist=[1,2,3]
>>>alist.extend((7,8))
[1,2,3,7,8]
>>>alist=[1,2,3] #对比append()
>>>alist.extend(['A','B'])
[1,2,3,'A','B']
- 使用insert(index,obj)[索引位置，对象]方法，添加元素到指定位置。没有返回值 速度慢
>>>alist=[1,2,3]
>>>alist.insert(2,6)
[1,2,6,3]
- 使用乘法，扩展列表改变列表位置。列表复制原理，当修改其中一个值是，相应的引用也会被修改。
>>>alist=[1,2,3]
>>>alist=alist*3
[1,2,3,1,2,3,1,2,3]
>>>alist=[[1,2]]*3
[[1,2],[1,2],[1,2]]
>>>alsit[0][0]=5
[[5,2],[5,2],[5,2]]
>>>alist=[[None]*2]*3
[[None,None],[None,None],[None,None]]
元素访问与计数
- 使用下标，直接访问，下标不存在，则抛出异常。
>>>alist=[1,2,3,4,5]
>>>alist[3]
[4]
- 使用index(obj),方法，获取指定元素首次出现的下标，下标不存在，则抛出异常。
>>>alist=[1,3,2,3,4]
>>>alist.index(3)
1
- 使用count(obj),方法，统计指定元素在列表中出现的次数。
>>>alist[1,3,2,3,4]
>>>alist.count(3)
2
成员资格判断
使用in关键字来判断一个值是否在列表中，返回结果为True,False。
>>>alist=[1,2,3,4,5]
>>>3 in alist
True
切片操作
切片适用于列表，元组，字符串，range对象等类型，但作用于列表时功能强大。
切片使用两个冒号分割的三个数字来完成：
第一个数字表示切片开始位置（默认为0）
第二个数字表示切片截止（但不包含）位置（默认为列表长度）
第三个数字表示切片的步长（默认为1），当步长为默认值1时，可以省略最后一个冒号
- 截取列表中任何部分
>>>alist=[1,2,3,4,5,6,7,8]
>>>alist[::] #返回包含所有元素的新列表
[1,2,3,4,5,6,7,8]
>>>alist[::-1] #逆序的所有元素
[8,7,6,5,4,3,2,1]
>>>alist[::2] #奇数位置，隔一个取一个
[1,3,5,7]
>>>alist[1::2] #偶数位置，隔一个取一个
[2,4,6,8]
>>>alist[3::] #从下标3开始的所有元素
[4,5,6,7,8]
>>>alist[3:6] #下标【3，6）之间的所有元素
[4,5,6]
>>>alist[0:100:1] #前100个元素，自动阶段
[1,2,3,4,5,6,7,8]
>>>alist[100:] #下标100之后的所有元素，自动截断
[]
- 原地修改列表内容
>>>alist=[1,2,3,4,5]
>>>alist[len(alist):]=[0] #在尾部追加元素
[1,2,3,4,5,0]
>>>alist[:3]=[7,8,9] #替换前3个元素
[7,8,9,4,5]
>>>alist[:3]=[] #删除前3个元素
[4,5]
>>>alist[::2]=[0]*3 #替换奇数上的元素
[0,2,0,4,0]
列表排序
- 使用sort(key,reverse)[主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序,排序规则，reverse = True 降序， reverse = False 升序（默认）]方法，原地排序。
>>>alist=[1,3,5,2,4,6]
>>>alist.sort()
[1,2,3,4,5,6]
>>>alist.sort(reverse=True)
[6,5,4,3,2,1]
>>>alist=[5,3,13,15,4,2]
>
- 使用内置函数sorted(key,reverse)，对列表进行排序并返回新列表。
>>>alist=[1,3,5,2,4,6]
>>>sorted(alist,reverse=True)
[6,5,4,3,2,1]
- 使用reverse(),方法，将原地逆序。
>>>alist=[1,3,5,2,4,6]
>>>alist.reverse()
[6,4,2,5,3,1]
- 使用内置函数reversed()，将列表元素进行逆序排列并返回迭代对象，只能进行一次循环遍历。
>>>alist=[1,3,5,2,4,6] #一个列表alist
>>>reversed(alist)
<list_reverseiterator at 0x1eea1d3e588> #显示为一个迭代器对象的内存地址
>>>blist=reversed(alist) #一个对象blist
>>>print(list(blist))
[6,4,2,5,3,1]
>>>print(list(blist)) #再次输出对象blist
[] #显示为空列表
用于序列操作的常用内置函数
- len(list)：返回列表中元素个数，同样适用于元组，字典，集合，字符串等。
- max(list)：返回列表中最大元素，同样适用于元组，字典，集合，range对象等。
- min(list)：返回列表中最小元素，同样适用于元组，字典，集合，range对象等。
- sum(list)：对列表的元素进行求和运算，对非数值型列表运算需要指定start参数，同样适用于元组，range对象。
>>>sum(range(1,11)) #sum()函数的start参数默认为0
55
>>>sum(range(1,11),5) #指定start参数为5，等价于5+sum(range(1,11))
60
- zip(),函数返回可迭代的zip对象
>>>alist=[1,2,3]
>>>blist=[4,5,6]
>>>zip(alist,blist) #返回zip对象
<zip at 0x1eea1d49288>
>>>clist=zip(alist,blist)
>>>list(clist) #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]
- enumerate(list)[sequence, start=0：枚举列表元素，返回枚举对象，其中每个元素为包含下标和值得元组，对元组，字符串同样有效。
>>>alist=['a','b','c']
>>>list(enumerate(alist))
[(0,'a'),(1,'b'),(2,'c')]
列表推导式
variable = [out_exp_res for out_exp in input_list if out_exp == x ]
out_exp_res: 列表生成元素表达式，可以是有返回值的函数。
for out_exp in input_list：迭代input_list将out_exp传入out_exp_res表达式中。
if out_exp == x: 根据条件过滤哪些值可以。
>>>alist=[i*2 for i in range(10) if i % 2 == 0]
>>> print(alist)
[0, 4, 8, 12, 16]
元组
概述
类型名称：tuple，定界符：圆括号（），不可变有序。
元组一旦定义就不允许更改，元组没有append(),extend(),和insert()等方法，无法向源诅中添加对象。
元组没有remove()或pop()方法，也无法对元组元素进行del操作。
元组的速度比列表更快。
元组创建
- 使用“=”，将一个元组赋值给变量。
>>>atuple=('a','z')
>>>atuple=(3)
3
>>>atuple=(3,) #包含一个元素的元组，最后必须多写个逗号
(3,)
>>>atuple=3, #也可以这样写
(3,)
>>>atuple=() #创建空元组
- 使用tuple(iterable)[要转换为元组的可迭代序列]，将其他序列转换为元组。
>>>tuple('abcd') #把字符串转换为元组
('a','b','c','d')
>>>tuple([1,2,3,4]) #把列表转换为元组
(1,2,3,4)
>>>atuple=tuple() #创建空元组
()
删除元组
使用del可以删除元组对象，不能删除元组中元素。
生成器推导式
生成器推导式的结果是一个生成器对象，使用生成器对象的元素时，可以根据需要将其转化为列表或元组，可以使用__next__()或者内置函数next()访问生成器对象.
(表达式 for 迭代变量 in 可迭代对象 if 条件表达式 )
- 使用for循环直接迭代生成器对象
>>>a = (x for x in range(1,10)) #创建生成器对象
'''>>>tuple(a) #将生成器对象转换为元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>>list(a) #生成器对象已经遍历结束，没有元素
[] '''
>>>for i in a:
print(i,end=' ')
1 2 3 4 5 6 7 8 9
>>>print(tuple(a))
(2, 3, 4, 5, 6, 7, 8, 9)
- 使用生成器对象__next__()方法或内置函数next()进行遍历
>>>a = (x for x in range(1,10))
>>>a.__next__() #使用生成器对象的__next__()方法获取元素
1
>>>a.__next__() #接着获取下一个元素
2
>>next(a) #使用函数next()获取生成器对象中元素
3
字典
概述
类型名称：dict，定界符：大括号{ }，可变无序。
定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有元素放在一堆大括号中。
字典中的键可以为任意不可变数据，如：整数，实数，复数，字符串，元组等。
- global(),返回包含当前作用域内所有全局变量和值得字典。
- locals(),返回包含当前作用域内左右局部变量和值得字典。
字典创建
- 使用“=”，将一个字典赋值给一个变量。
>>>adict={'server':'python','database':'mysql'}
>>>adict={} #创建空字典
- 使用dict()，利用已有数据创建字典。
>>>adict=dict()
>>>key=['a','b','c']
>>>value=[1,2,3]
>>>adict=dict(zip(key,value))
{'a': 1,'b': 2, 'c': 3}
- 使用dict()，根据给定的键，值创建字典。
>>>adict=dict(name='Dong',age=37)
{'name': 'Dong', 'age': 37}
- 以给定内容为键。创建值为空的字典。
>>>adict=dict.fromkeys(['name','age','sex'])
{'name': None, 'age': None, 'sex': None}
删除字典
- 使用del删除字典
- 使用clear(),删除字典中所有元素
- 使用pop(),删除并返回指定键的元素
- 使用popitem(),删除并返回字典中的一个元素
元素读取
- 以键作为下标，读取字典元素，若键不在，则抛出异常。
>>>adict={'name':'dong','sex':'male'}
>>>adict['name']
'dong'
- 使用get((key, default=None)[字典中要查找的键,如果指定键的值不存在时返回该默认值]方法，获取指定键对应的值，并且可以在键不存在是返回指定值。
>>>adict.get('address')
None
>>>adict.get('address','SDIBT')
SDIBT
>>>adict['score']=adict.get('score',[])
>>>adict['score'].append(98)
>>>adict['score'].append(99)
{'score': [98, 99]}
- 使用items()，可以返回字典的键，值对
>>>adict={'name':'dong','sex':'male','age':37}
>>>for dic in adict.items(): #输出字典所有元素
print(dic)
('name', 'dong')
('sex', 'male')
('age', 37)
>>>for dic in adict: #默认输出键
print(dic)
name
sex
age
>>>for key,value in adict.items(): #序列解包用法
print(key,value)
name dong
sex male
age 37
- 使用keys()，可以返回字典的键
>>>adict={'name':'dong','sex':'male','age':37}
>>>adict.keys() #返回所有键
dict_keys(['name', 'sex', 'age'])
- 使用values()，可以返回字典的值
>>>adict={'name':'dong','sex':'male','age':37}
>>>adict.values() #返回所有值
dict_values(['dong', 'male', 37])
元素添加与修改
- 当一指定键为下标给字典赋值时，若键存在，则可以修改键的值；若不在，则表示添加一个键，值对。
>>>adict['age']=30
- 使用update(),方法，将另一个字典的键，值对添加到当前字典。
>>>adict={'name':'dong','sex':'male','age':30}
>>>adict.update({'a':'a','b':'b'})
{'name': 'dong', 'sex': 'male', 'age': 30, 'a': 'a', 'b': 'b'}
有序字典
- python内置字典时无序的，如果需要一个可以记住元素顺序的字典，可以使用collections.OrderedDict
>>>import collections
>>>adict=collections.OrderedDict()
>>>adict['a']=3
>>>adict['b']=5
>>>adict['c']=8
>>>adict
OrderedDict([('a', 3), ('b', 5), ('c', 8)])
字典推导式
{表达式 for 迭代变量 in 可迭代对象 if 条件表达式 }
>>>adict={'a':1, 'b':2, 'c':3}
>>>bdict={v:k for k, v in adict.items()}
>>>bdict
{1: 'a', 2: 'b', 3: 'c'}
集合
概述
类型名称：set，定界符：大括号{ }，可变无序。
元素不可重复，集合中只能包含数字，字符串，元组等不可变类型的数据，而不能包含列表，字典，集合等可变类型的数据。
集合创建
- 直接将集合赋值给变量
>>>aset={1,3}
- 使用set，将其他类型转换为集合
>>>Aset=set() #创建空集合
>>>aset=set(range(8,14))
{8,9,10,11,12,13}
>>bset=set([0,1,2,3,0,1,2,3,7,8]) #自动去除重复
{0,1,2,3,7,8}
删除集合
- 使用del删除整个集合
- 使用pop(),弹出并删除其中一个元素
- 使用remove(),直接删除指定元素
>>>aset={1,2,3,4}
>>>aset.remove(2)
{1, 3, 4}
- 使用clear(),清空集合
集合操作
- 交集，并集，差集等运算
>>>aset={1,2,3,4,5}
>>>bset={4,5,6,7,8}
>>>aset|bset #并集
{1,2,3,4,5,6,7,8}
>>>aset&bset #交集
{4,5}
>>>aset-bset #差集
{1,2,3}
>>>aset.union(bset) #并集
{1,2,3,4,5,6,7,8}
>>>aset.intersection(bset) #交集
{4,5}
>>>aset.difference(bset) #差集
{1,2,3}
>>>aset.symmetric_difference(bset) #对称差集
{1, 2, 3, 6, 7, 8}
>>>aset.issubset(bset) #是否为子集
False
>>>{3}&{4}
set()
>>>{3}.isdisjoint({4}) #两个集合交集为空，返回True
True
- 判断包含关系
>>>x={1,2,3}
>>>y={1,2,5}
>>>z={1,2,3,4}
>>>x<y #比较包含关系
False
>>x<z #真子集
True
>>>{1,2,3}<={1,2,3} #子集
True
集合推导式
集合推导式跟列表推导式差不多，都是对一个列表的元素全部执行相同的操作，
但集合是一种无重复无序的序列。跟列表推到式的区别在于，结果中无重复。
>>> aset={i*2 for i in [1,1,2]}
>>> print(aset)
{2,4}
序列解包
- 把多个值赋给一个变量时，Python会自动的把多个值封装成元组，称为序列封包
>>>a=1,2,3
(1,2,3)
- 把一个序列（列表、元组、字符串等）直接赋给多个变量，此时会把序列中的各个元素依次赋值给每个变量，但是元素的个数需要和变量个数相同，这称为序列解包
序列可以理解为可以进行切片、相加相乘、索引、成员资格（用关键字in、not in关键字判断某个元素在不在这个序列）
- 简单序列解包
>>>a,b,c=1,2,3
>>>a
1
>>>b
2
>>>c
3
- 利用 * 获取单个变量中的多个元素,* 获取的值默认为 list。
>>> a, b, *c = 0, 1, 2, 3
>>> a
0
>>> b
1
>>> c
[2, 3]
>>> a, *b, c = 0, 1
>>> a
0
>>> b
[]
>>> c
1
- range对象序列解包
>>>a,b,c=range(3)
>>>print(a,b,c)
0 1 2
- 迭代对象的序列解包
>>>a,b,c= map(str, range(3))
>>>print(a,b,c)
0 1 2
- 列表序列解包
>>>alist=[1,2,3,4]
>>>a,b,c,d=alist
>>>b
2
>>>a,b,c=sorted([1,3,5])
>>>b
3
- 字典序列解包
>>>adict={'a':1,'b':2,'c':3}
>>>x,y,z=adict
>>>x,y,z
('a', 'b', 'c')
>>>x,y,z=adict.items()
>>>print(x,y,z)
('a', 1) ('b', 2) ('c', 3)
- 序列解包遍历，及遍历enumerate对象
>>>keys = ['x','y','z','n']
>>>values = [1,2,3,4]
for k,v in zip(keys, values):
print(k,v)
x 1
y 2
z 3
n 4
>>>x = ['a','b','c']
>>>for i, v in enumerate(x):
print('the value on position {0} is {1}'.format(i,v))
the value on position 0 is a
the value on position 1 is b
the value on position 2 is c