Python interview - list & tuple & set & dictionary

在python中，list，tuple，set，dictionary是平时经常用到和考到的基本结构。

List

首先，list是mutable的。

list的用途很广泛，它能同事包含不相同类型的数据，并非像Java的数组一样单一。但功能基本相同，index从0开始，可以被分割，被连接，等等。python中，list和string有一定程度上的相同，但是string是一个immutable的类型。

How to construct a list 如何构造一个list

<pre name="code" class="python">l = ['a', 'b', 123]
print l
# result
['a', 'b', 123]

用一对square brackets：[] 来建立一个list，每一个元素用comma：，分开。

或者用关键词list，可以转换为list

t = (1, 2, 3)
l = list(t)

How to Retrieve an Element From a List 如何从list中得到元素

print l[0]
print l[10]
# result
a
Traceback (most recent call last): IndexError: list index out of range

就像上述，我们可以用类似取Java数组的方式（index从0开始），用下标来取得元素，当超过的时候，会得到list index out of range的报错。

How to Slice a List 如何切割一个list

slice的操作，返回一个浅拷贝的list。slice操作的参数是可以不填的，同样的操作也可以对string进行。

l = ['a', 'b', 123]
print l[:]
new_l = l[1:]
print new_l
print l
# result
['a', 'b', 123]
['b', 123]
['a', 'b', 123]

我们可以看到，new_l是一个新的list，原来的l并没有进行变化。

Inserting and removing elements 增加和删除元素

l=['a', 'b', 123]
l.append(234)
print l
l.insert(2, 'c')
print l
l.insert(-1, 111)
print l
l.remove(111)
print l
l.remove('sefwefvg')
# result
['a', 'b', 123, 234]
['a', 'b', 'c', 123, 234]
['a', 'b', 'c', 123, 111, 234]
['a', 'b', 'c', 123, 234]
Traceback (most recent call last): ValueError: list.remove(x): x not in list

append在list最后加上元素，insert可以在指定位置加上元素（注意list是从0开始的），remove从list中删除一个指定的元素，如果这个元素不在list中，就会报错x not in list。

Retrieving and looking up elements 查找元素

list可以被当做是stack或者queue来使用，因为python中list可以很简单从前或者从后增加以及删除元素。

l=['a', 'b', 123, 234]
last_element = l.pop()
print last_element
print l
third_element = l.pop(2)
print third_element
print l
print l.index('a')
print l.count('a')
# result
234
['a', 'b', 123]
123
['a', 'b']
0
1

我们可以看到，pop 方法能得到最后的元素，也可以输入index得到指定位置的元素。可以用index方法获得指定元素的位置。用count方法获得指定元素的个数。

l=['a', 'b', 123, 234]
l.extend([1, 2])
print l
l.sort()
print l
l.reverse()
print l
# result
['a', 'b', 123, 234, 1, 2]
[1, 2, 123, 234, 'a', 'b']
['b', 'a', 234, 123, 2, 1]

对于整个list，我们还可以用extend方法直接添加一个list，sort得到顺序的list，reverse方法把整个list反过来。

list comprehensions可以参考另一篇博文。

小结：

* 需要一个混合的集合

* 需要有顺序

* 需要可变的

* 不需要自定义index

* stack，queue

* 没有必要数据唯一性

Set

set是一个没有顺序的没有重复值的集合。可以使用set关键词或者使用curly braces大括号{}来定义。

P.S.  一个空的set只能用set关键词定义，{}定义的是一个空的dictionary字典。

How to Construct a Set 如何构造一个set

l=[1, 2, 3]
s=set(l)
print s
# result
set([1, 2, 3])

以上的code使用了set关键词，下面用{}直接构造一个set

s={1, 2, 3}
print s
# result
set([1, 2, 3])

set一般用于去掉重复值

l=[1, 2, 3, 4, 4]
s=set(l)
print s
# result
set([1, 2, 3, 4])

set的原理是检查是否有重复数字，并且把每个元素创建一个hash。那就意味着set中的每个元素必须是可以hash的。

set([1, [1, 2]])
# result
Traceback (most recent call last): TypeError: unhashable type: 'list'

我们可以看到，list类型是不能hash的，所以这个set是错误的。

P.S. 注意一点，一个可以被hash的对象并不一定要有__hash__方法。重要的点在于，在这个对象的lifetime期间，hash值并不会改变，所以很明显的list，set，dictionary不是这一类的，他们是mutable的类型，可以变化值。

Set Operations 一些set的操作符

类似于bit的操作符

Union | 或（在第一个set，或者在第二个set的全部元素）

Intersection & 且（在一个set，并且也同时存在在第二个set，满足两个条件的元素）

Difference - 非（在第一个set，不在第二个set）

Symmetric Difference ^ 异或 （在第一个set，或者第二个set，但是不同时在两个set存在）

set1=set([1,2,3])
set2=set([3,4,5])

print set1 | set2
print set1 & set2
print set1 - set2
print set1 ^ set2
# result
set([1, 2, 3, 4, 5])
set([3])
set([1, 2])
set([1, 2, 4, 5])

Set Comprehensions

和list comprehension差不多的意思。

vowels = ['a', 'e', 'i', 'o', 'u']
print {x for x in 'maintenance' if x not in vowels }
# result
set(['c', 'm', 't', 'n'])

Frozensets 

一个frozenset仅仅就是一个常规的set，为了的区别是，frozenset是immutable不可变的。需要用到frozenset关键词

frozen=frozenset([1, 2, 3])

小结

* 需要数据唯一性

* 可变的（frozenset不可变）

* 数据集合需要做简单的数学操作，difference，union，intersection，etc

* 不需要存list，set，dic。set不支持不能hash的类型

Tuple

Tuple和list类似也同样可以存很多的值，由逗号，分割。但是tuple是不可变immutable，list可变mutable。返回值由圆括号包括。尽管Tuple是不可变，但是它可以hold可变数据。

How to Construct a Tuple 如何构造一个元祖

一个空的元祖

t = ()

一个含有一个元素的元祖

t = 'a', 或者 t = ('a',)

含有多个元素的元祖

t = 'a', 'b'

my_empty_tuple=()
one_element_tuple1 = 'a'
one_element_tuple2 = 'a',
one_element_tuple3 = ('a')
one_element_tuple4 = ('a',)
s = 'a', 'b', [1, 2, 3]
print my_empty_tuple
print one_element_tuple1
print one_element_tuple2
print one_element_tuple3
print one_element_tuple4
print s
# result
()
a
('a',)
a
('a',)
('a', 'b', [1, 2, 3])

小结

* 存的数据不需要改变。tuple不可变。

* performance，呈现需要好看的时候。

* 需要把数据存成有一定逻辑的不可变paris。

Dictionary
Dictionary是可变的mutable。字典里都是key-value名值对。key必须是不可变的并且是唯一的，value可以是任何形式的，可变或者不可变都行。

How to Construct a Dictionary 如何构造一个字典

使用大括号{}

vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
print vowels
# result
{1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}

使用comprehensions来构造。使用已有的数据来构造一个key：value的名值对。

print {x:x*x for x in (1, 2, 3)}
# result
{1: 1, 2: 4, 3: 9}

使用dict关键词，传入一串key：value名值对的list。

print dict([(1,'a'), (2,'e'), (3,'i'), (4,'o'), (5,'u')])
# result
{1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}

如果key是string的，那么可以很简单的赋值即可。如果key是数字的，那么就会报错。

print dict(a=1, e=2, i=3, o=4, u=5)
print dict(1=a, 2=e, 3=i, 4=o, 5=u)
# result
{'i': 3, 'u': 5, 'e': 2, 'a': 1, 'o': 4}
SyntaxError: keyword can't be an expression

Dictionary Operations 字典操作符

vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
print vowels
print vowels[1]
print vowels[10]
del(vowels[1])
print vowels
# result
{1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}
a
KeyError: 10
{2: 'e', 3: 'i', 4: 'o', 5: 'u'}

python 字典相比较java中的hashmap来说，有类似概念。用list取值的方法，中括号，根据key取值value。如果没有这个key就会报错KeyError。可以用del方法删除key，即删除整个名值对。

Build-in Methods 自带的方法。

字典的python方法有keys() ，values()， iteritems()， itervalues()， has_key()等。

vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
print vowels.keys()
print vowels.values()

for k, v in vowels.iteritems():
    print k, v

for v in vowels.itervalues():
    print v
# result
[1, 2, 3, 4, 5]
['a', 'e', 'i', 'o', 'u']
1 a
2 e
3 i
4 o
5 u
a
e
i
o
u

小结

* 当逻辑需要key：value名值对显示的时候

* 需要快速查找

* 数据需要时常改变。字典是可变类型。

总结

1. 使用list，当你的数据不需要随机访问。随机访问，你需要清楚的知道数据的index是多少。所以选用list的时候，最好是只需要简单的，迭代的。List对于构造set和dict很有帮助，使用comprehension expressions。

2. 使用set， 当你的数据需要唯一性，并且你不需要一个嵌套的dict或者list。 P.S. set不支持不可hash的类型。

3. 使用tuple， 当你的数据不需要改变。很多时候tuple用在字典当中，可能表现为一个key，因为tuple不可变，而且表现效果好。

4. 使用frozensets， 当你的数据既需要唯一性，有需要不可变。