python容器（list, tuple, set, dict）

python中的序列

序列的概念: 有序存储, 并能通过下表偏移进行访问.

序列对象: str, list, tuple

标准操作

成员操作: in, not in
连接与重复: + *
索引和切片访问

其他操作（BIF）

len()
reversed()返回对象, 可以用list()再强制类型转换
sorted(a), a.sorted(),
max()
min()
sum()
enumerate()
a=zip(l1,l2,l3), 序列拼接,按每个元素的位置拼接element-wised, 解开用l1, l2, l3 = zip(*a)
any判断是否存在对象，存在即为真， 即$\exists$
all判断是否所有都是对象，所有不为空就为真，有一个为空就为假， 即$\forall$
type()

>>> a = [3, 2, 3, 1]
>>> sorted(a)
[1, 2, 3, 3]
>>> a
[3, 2, 3, 1]
>>> a.sort()
>>> a
[1, 2, 3, 3]

>>> for i, item in enumerate(a):
...     print(i, item)
... 
0 1
1 2
2 3
3 4

>>> a = ['a', 'b', 'c']
>>> b = [1,2,3]
>>> list(zip(a,b))
[('a', 1), ('b', 2), ('c', 3)]
>>> c = list(zip(a,b))
>>> d, e = zip(*c)
>>> d
('a', 'b', 'c')
>>> e
(1, 2, 3)

>>> a = ['a', 'b', '']
>>> b = ['', '', '']
>>> any(a)
True
>>> any(b)
False
>>> all(a)
False
>>> all(b)
False
>>> c = ['a', 'b', 'c']
>>> all(c)
True

list

list内部操作:

append
extend()将列表里的元素一一添加进去
insert(index, element)插入
index(element)返回第一个位置返回
count(element)
pop()和append对应, 队尾先返回再弹出, 也可以指定位置pop(index)
del l1[-1]
remove(elememnt)按值删除
reverse的()反转
比较 <, >逐元素比较

>>> a = ['a', 'b', 'c']
>>> b = ['e', 'f']
>>> a.append(b) ##添加到未尾,如果元素是列表，也是按照列表添加进来
>>> a 
['a', 'b', 'c', ['e', 'f']]
>>> a.pop() #返回并弹出
['e', 'f']
>>> a
['a', 'b', 'c']
>>> a.extend(b) #扩展，如果是扩展元素是列表，是只添加列表内的元素
>>> a
['a', 'b', 'c', 'e', 'f']
>>> a.insert(0, 'a') #插入元素，按索引
>>> a
['a', 'a', 'b', 'c', 'e', 'f']
>>> a.index('a') #获得指定元素的索引位置，如果存在相同元素，返回的是从左到右第一个的索引位置
0
>>> a.pop(0) #返回并弹出指定索引位置的元素
'a'
>>> a
['a', 'b', 'c', 'e', 'f']
>>> del a[-2:] #删除列表元素，按索引位置删除
>>> a
['a', 'b', 'c']
>>> a.remove('c')#指定元素进行删除，如果存在相同元素，则删除从左至右第一个元素
>>> a
['a', 'b']
>>> a.count('a')#统计元素出现的次数
1
>>> a < b #列表比较，逐元素进行对比
True

列表推导式(list comprehension), 利用现有的列表生成新列表

语法：
□ [表达式 for 变量 in 列表]
□ [表达式 for 变量 in 列表 if 条件]

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x for x in a if x%2==0]
[0, 2, 4, 6, 8]
>>> [(i, j) for i in range(5) for j in range(5)]
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)]

元组Tuple

▪ 元组tuple是只读有序序列。
▪ 可以认为tuple是只读列表， 它有许多操作和list很接近， 不再列举。 除了对其进行修改

t=(5,6,[7,3])
dir(t)可以看所有的操作
输入多个默认是tuple
解包:a,b,c=t
访问t[0]
tuple里的object指的是里面的元素,所谓的不可修改是针对tuple里面的每个元素,如果里面的元素是列表或者字典,是可以修改的。参考python可变对象和不可变对象

#tuple成员操作
t1=(5,6,7)
t1+4#这里会报错
t1+(4,)#这里成功
#通常我们在命令行输入4,5,6返回的是一个tuple
#而只输入4时，返回的是一个数值型
#解包unpack
a,b,c,d=t1
#tuple不可修改的是什么？
t1=(1,2,3,[4,5,6])
#t1[0]=0#报错
#'tuple' object does not support item assignment
#这里的tuple object指的是tuple中的元素
t1[-1].append(7)#成功

集合set

□ 一组key的无序排列集合， 因此无法用索引及切片访问
□ 主要作用：用于去重及集合间操作
集合初始化:s1 = set(list(range(8)))
l1 = [1,2,3,4,1,2,3,4]
set(l1)
成员操作
内部操作s1.add() s1.remove()
交集: &
并集: |
差集: -
集合合并

>>> l = [1,2,3,4]
>>> a = set(l)#初始化
>>> a
{1, 2, 3, 4}
>>> a[0]#'set' object does not support indexing
>>> 1 in a #成员操作
True
#集合内部操作
>>> a.add('b')#添加key
>>> a
{1, 2, 3, 4, 'b'}
>>> a.remove(1)
>>> a
{2, 3, 4, 'b'}
#集合间操作
>>> a = set('abcde')
>>> b = set('cdefg')
>>> a
{'b', 'd', 'e', 'c', 'a'}
>>> b
{'d', 'e', 'c', 'f', 'g'}
>>> a & b # &交集
{'c', 'd', 'e'}
>>> a | b # |并集
{'b', 'd', 'e', 'c', 'a', 'f', 'g'}
>>> a - b # -差集
{'a', 'b'}
>>> a.update(b) #集合合并
>>> a
{'b', 'd', 'e', 'c', 'a', 'f', 'g'}

字典dict

字典这种数据结构， 是把一个元素映射到另一个元素上,可以简单理解为k： v对应。
■ 常见操作：
□ 初始化
□ 成员判断
□ 访问
□ 字典推导式
Key值的选取：
■ Key值必须是可被哈希的， 也就是说key只能是数字， 字符串或者元组
K V对应
d1 = {‘name’: jack, ‘age’: 4}
d2 = dict({‘name’: tom, ‘age’ :3})
d1.items()
成员操作:针对的是key,不是value
增加d1[‘address’]=‘beijing’
不可以用列表当key
访问:d1[‘name’]
list(d1.keys())
list(d1.values())
for key, value in d1
删除成员:d1.pop(key)返回key,并弹出元素
d1.popitem()返回整个元素,并弹出
清空d1.clear()
key是用hash()取得,所以只有不可变对象可以做key,数值字符串元组,可变对象list不可以

#初始化
>>> d1={'name':'Shuan','age':24}
>>> d2=dict({'salary':29999,'level':9})
>>> 'name' in d1 #成员判断(针对 key)
True
>>> d1['address'] = 'Hangzhou' #新增成员
>>> d1
{'name': 'Shuan', 'age': 24, 'address': 'Hangzhou'}
#访问：按key访问value：
>>> d1['name']
'Shuan'
>>> d1.get('name',-1) #不存在则返回-1, default=None
'Shuan'
>>> d1.keys() #访问所有key
dict_keys(['name', 'age', 'address'])
>>> d1.values() #访问所有value
dict_values(['Shuan', 24, 'Hangzhou'])
>>> d1.items() #访问所有元素
dict_items([('name', 'Shuan'), ('age', 24), ('address', 'Hangzhou')])
#修改成员
>>> d1['address'] = 'Suzhou'
>>> d1
{'name': 'Shuan', 'age': 24, 'address': 'Suzhou'}
#删除成员
>>> d1.pop('address') #返回指定key的值。并弹出元素
'Suzhou'
>>> d1
{'name': 'Shuan', 'age': 24} 
>>> d1.popitem() #返回整个元素。并弹出
('age', 24)
>>> d1
{'name': 'Shuan'}
>>> d1.clear() #清空
>>> d1
{}
#Key值的选取，能被hash的值都可以做为key，即不可变类型可以做为key值。
>>> hash('name')
-4805806528160776221
>>> hash(['name'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'