在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是可变的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, 当你的数据既需要唯一性,有需要不可变。