本节摘要：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 "<stdin>", line 1, in <module>
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 区别

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 "<stdin>", line 1, in <module>
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 "<stdin>", line 1
    set([[1, 2], 3)
                  ^
SyntaxError: invalid syntax
>>> s
set([1, 2, 3])
>>> s.add([1, 2])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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的比较

 /) /)
ฅ(• - •)ฅ ~ ～ ฅ’ω’ฅ