本节摘要：Python中list、tuple、dict、set的介绍与比较
Daily Record：每天一纪念，记录下python的学习历程，入门学习笔记与心得。本学习笔记主要基于廖雪峰大大的Python教程。不积跬步，无以至千里～ .ﾟ(ง •̀_•́)ง
@[toc]
list ()
list，是一种数据类型，即列表，清单的意思。list是一种有序的集合，可以随时添加和删除其中的元素。
- list的创建与访问。
>>> S = ['a', 'b', 'c'] #创建一个名字为S的list，在S中有字符a,b,c三个元素
>>> S
['a', 'b', 'c']
>>> S = [a, b] #错误，list包含的元素类型可以是字符串、整数、浮点数、布尔值、空值
>>> S = [1, 3.14] #可
>>> len(S) #获取list元素的个数
3
>>> S = ['a', 'b', 'c']
>>> S[0] #访问S的第一个元素，索引是从0开始
'a'
>>> S[-1] #访问S的倒数第一个即最后一个元素，即S[-1]=S[2]
'c'
>>> S[-2] #访问S的倒数第二个元素，即S[-2]=S[1]
'b'
>>> S[-3] #访问S的倒数第三个即第一个元素，即S[-3]=S[0]
'a'
- list元素的添加与删除，有关.append( )、.insert( )、.pop( )的运用。
list是一个可变的有序表，所以，可以往list中追加元素到末尾：
>>> S.append('d') #在集合S的末尾追加元素d
>>> S
['a', 'b', 'c', 'd']
也可以把元素插入到指定的位置，比如索引号为1的位置：
>>> S.insert(1, 'e') #在索引号为1的位置插入元素
>>> S
['a', 'e', 'b', 'c', 'd']
要删除list末尾的元素，用pop()方法：
>>> S.pop() #删除集合S的最后一个元素
'd'
>>> S
['a', 'e', 'b', 'c']
要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
>>> S.pop(1) #删除集合S索引号为1的元素
'e'
>>> S
['a', 'b', 'c']
要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
>>> S[1] = 'f'
>>> S
['a', 'f', 'c']
list里面的元素的数据类型也可以不同，比如：
>>> S = ['Apple', 123, True]
>>> S
['Apple', 123, True]
list元素也可以是另一个list，比如：
>>> p = ['a', 'b', ['c', 'd'], 'e']
>>> len(p)
4
拆开写
>>> o = ['c', 'd']
>>> p = ['a', 'b', o, 'e']
>>> p
['a', 'b', ['c', 'd'], 'e']
>>> len(p)
4
要拿到'c'可以写o[0]或者p[2][0]，因此p可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。
>>> o = ['c', 'd']
>>> p = ['a', 'b', o, 'e']
>>> o[0]
'c'
>>> p[2][0] #访问list中的list元素
'c'
如果一个list中一个元素也没有，就是一个空的list，它的长度为0：
>>> D = []
>>> len(D)
0
>>> D = ()
>>> len(D)
0
tuple []
一种有序列表，即元组，数组的意思。和list的区别是，tuple一旦创建好初始化就无法修改，可以访问获取其中元素，但不能添加append()，insert()，也不能删除元素。不能赋值成另外的元素。
tuple不可变的好处：代码更加安全。一般来说，能把list变成tuple最好。
- tuple的创建与访问。
>>> S = () #定义一个空的tuple，通过x=()的形式定义
>>> S = ('a',) #定义只有一个元素的tuple，注意要有逗号，否则T将视为表示字符a的变量
>>> S = (1) #定义只有1个元素的tuple时，这么写定义的不是tuple，是1这个数。
>>> S #因为括号()既可以表示tuple，又可以表示数学公式中的小括号，产生了歧义
1 #Python规定，这种情况下，按小括号进行计算，计算结果是1
>>> S = (1,) #定义只有1个元素的tuple时，加一个逗号,来消除歧义
>>> S
(1,) #Python在显示只有1个元素的tuple时，也会加一个逗号,，以免被误解成数学计算意义上的括号
>>> S = ('a','b') #定义有两个元素的tuple
>>> S
('a', 'b')
>>> S = ('a','b',['c','d']) #定义内含list的tuple
>>> S [2][0] #tuple的访问与list访问一样
c
>>> S = (1, 3.14) #定义一个tuple
>>> S
(1, 3.14)
>>> S = ('a', 3.14)
>>> S
('a', 3.14)
>>> S = () #定义一个空的tuple
>>> S
()
“可变的”tuple：
>>> t = ('a', 'b', ['A', 'B']) #此例子tuple定义后没变，变的是tuple里的list的元素
>>> t[2][0] = 'X' #tuple的不变，是指向不变
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y']) #要想让tuple内容不变，需让tuple中的每一个元素本身不变
总结：
list和tuple是Python内置的有序集合，list可变，tuple不可变。
【交作业】
Python 2.7
>>> L = [
['Apple', 'Google', 'Microsoft'],
['Java', 'Python', 'Ruby', 'PHP'],
['Adam', 'Bart', 'Lisa']
]
>>> print L[0][0] # 打印Apple
Apple
>>> print L[1][1] # 打印Python
Python
>>> print L[2][2] # 打印Lisa
Lisa
Python 3.x
>>> L = [
['Apple', 'Google', 'Microsoft'],
['Java', 'Python', 'Ruby', 'PHP'],
['Adam', 'Bart', 'Lisa']
]
>>> print (L[0][0]) # 打印Apple
Apple
>>> print (L[1][1]) # 打印Python
Python
>>> print (L[2][2]) # 打印Lisa
Lisa
dict {}
dict，即dictionary，字典的意思。使用键—数值（key-value）的方式储存，具有很快的查询速度。需要注意的是，dict的key一定要是不可变对象，如字符串，整数，而list是可变对象不能用作key。
- dict的创建与访问。
把数据放入dict的方法：第一初始化时指定；
>>> D = {'Lareina': 100, 'Michael': 99} #初始化时指定定义好dict中的数据
>>> D
{'Michael': 99, 'Lareina': 100} #Python3.6后的dict有序，3.6之前的dict无序
>>> D['Lucy'] = 60
>>> D
{'Michael': 99, 'Lucy': 60, 'Lareina': 100}
>>> D['Lucy'] = 8
>>> D
{'Michael': 99, 'Lucy': 8, 'Lareina': 100}
>>> D = {'Lareina': 100, 'Michael': 99, 66:'aaa'} #定义一个dict
>>> D['Michael'] #访问D中key为'Michael'的值99
>>> 99
>>> D['66'] = 'bbb' #注意区分D[‘66’]与D[66]，D[‘66’]是新增了一个key
>>> D
{'Lareina': 100, 'Michael': 99, 66:'aaa', '66':'bbb'}
>>> D[66] = 'ccc' #key对应的值可以被修改
>>> D
{'Lareina': 100, 'Michael': 99, 66:'ccc', '66':'bbb'}
>>> D[66]
'ccc'
把数据放入dict的方法：第二通过key放入。
>>> D['Lucy'] = 60 #通过key把数据放入dict
>>> D
['Lucy'] = 60
因为，一个key只能对应一个value，so，多次对一个key放入value时，后面的值会把前面的值冲掉：
>>> D['Lucy'] = 60
>>> D
['Lucy'] = 60
>>> D['Lucy'] = 8 #当第二次把'Lucy'定义成8，把之前的值60冲掉了
>>> D
['Lucy'] = 8
注意：dict内部存放的顺序和key放入的顺序是没有关系的。
- dict的key判断与修改，有关.get( )、 .pop( )的运用。
如果key不存在，dict会报错：
>>> D['Mike'] #若key不存在，dict会报错
Traceback (most recent call last):
File "", line 1, in
KeyError: 'Mike'
避免出现key不存在错误的两种方法：
方法一，通过in判断key是否存在
>>> 'Mike' in D #判断D中是否有'Mike'这一key
False
>>> 'Lareina' in D
>>> True
方法二，通过dict提供的get方法，如果key不存在，可以返回None（返回None的时候Python的交互式命令行不显示结果），或者自己指定的value：
>>> D.get('Lareina') #拿取D中'Lareina'对应的数值
>>> 100
>>> D.get('Mike') ##若没有指定的key，key不存在，则返回None，Python中不显示结果
>>> D.get('Mike', -8) #若没有指定的key，key不存在，返则回制定值value
-8
删除一个key，用pop(key)方法，对应的value也会从dict中删除：
>>> D
{'Michael': 99, 'Lareina': 100}
>>> D.pop('Michael') #用pop(key)的方式来删除key，同时对应的值也会被删除
99
>>> D
{'Lareina': 100}
list 与 dict 区别
| 查找和插入的速度 | 占用空间 | 浪费内存 | |
|---|---|---|---|
| list | 慢，随元素的增加而增加 | 小 | 少 |
| dict | 极快，不会随key增加而变慢 | 大 | 多 |
dict 其实就是以空间换时间，可以用在需要快速查找的地方。
注意： dict的key必须是不可变对象。
原因：dict 是根据key来计算value的储存位置，如果给出相同的key计算的value结果不同，那dict 内部就会混乱。
这种根据key计算位置的算法成为==哈希算法（Hash）==。
为了保证hash的正确性，key的对象不能变。key可以选择不能变的字符串、整数等。不能选择可以变化的list。
>>> D = {'Lareina': 100, 'Michael': 99}
>>> key = [1, 2, 3]
>>> D[key] = 'a list' #list不能作为key，会报错
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
set
set，即一套，集合的意思。在Python中与dict类似，但只有key，没有value。在set中不会有重复的key。同样的，set中的key一定要是不可变对象。
- set的创建、添加与删除。
>>> s = set([2, 4, 6, 8]) #创建一个set，值得注意的是，set是无序和无重复元素的集合
>>> s #传入的参数[1, 2, 3]是一个list
set([8, 2, 4, 6]) #表示set内部有1，2，3这3个元素，但此处的[]不是list
>>> s = {1, 2, 3} #或者直接通过{}创建
>>> s
set([1, 2, 3]) #Python2.7.x显示
{1, 2, 3} #Python3.x显示
>>> s = set([2, 2, 4, 4, 6, 6, 8, 8]) #重复元素在set中自动被过滤
>>> s
set([8, 2, 4, 6])
>>> s.add(10) #add(key)方式添加元素
>>> s
set([8, 2, 4, 10, 6])
>>> s.add(10) #重复添加元素不会有变化
>>> s
set([8, 2, 4, 10, 6])
>>> s.remove(10) #remove()方式删除元素
>>> s
set([8, 2, 4, 6])
- set的集合运算。
>>> s1 = set([1, 3, 5])
>>> s2 = set([3, 5, 7])
>>> s1 | s2 #并集
set([1, 3, 5, 7])
>>> s1 & s2 #交集
set([3, 5])
set 与 dict 区别
| | 储存key对应的value |
|--|--|--|--|
| set | 无 |
| dict | 有 |
相似：set 和 dict 都不能放入可变对象
set中不能放入list，会报错
>>> set([[1, 2], 3)
File "", line 1
set([[1, 2], 3)
^
SyntaxError: invalid syntax
>>> s
set([1, 2, 3])
>>> s.add([1, 2])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
可变对象与不可变对象
- 可变对象
例如list是可变对象，对于list操作，list内部内容会变化
>>> a = ['c', 'b', 'd']
>>> a.sort() #sort()排序函数默认升序
>>> a
['b', 'c', 'd']
- 不可变对象
str是不变对象
>>> a = '345'
>>> a.replace('3', '7')
'745' #创建了新的字符串'745'
>>> a
'345'
字符串虽然有replace()，但其实是创建了新的字符串，让新变量指向了新的字符串而已，原来的变量指向的字符串并没有改变，即不可变对象本身永远是不可变的。
list、tuple、dict、set的比较
| 定义 | 添加元素 | 删除元素 | |
|---|---|---|---|
| list | z = [ , , ] | 末尾追加元素z.append() 指定位置插入元素z.insert(索引号, 元素) |
删除末尾元素z.pop() 删除指定位置元素z.pop(索引号) |
| tuple | z = ( , , ) | 无 | 无 |
| dict | z = {key1: value1, key2: value2} | z[keyi]=valuei | z.pop(key1) |
| set | z=set([ , , ])或z={ , , } | z.add(keyi) | z.remove(keyi) |
/) /)
ฅ(• - •)ฅ ~ ～ ฅ’ω’ฅ