Python学习笔记——内置的数据结构

list []

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

添加到末尾

L.append(object);

插入到n位

L.insert(n-1,”)

移除

L.remove(value)

连接

L.extend(L2)

L = L + L2

L += [“blabla”]

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素

tuple 元祖 ()

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。相当于只读的list。

创建包含1个元素的 tuple,防止歧义

t = (1,)

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的

t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'X'
L[1] = 'Y'
print t

t元祖就变成了 （’a’,’b’,[‘X’,’Y’]）

元祖的遍历

t = (("apple","banana"),("grape","orange"),("watermelon",))
for i in range(len(t)):
print("t[%d]:"%i),
for j in range(len(t[i])):
print(t[i][j]),
print
或
for i in t:
for j in i:
print j

dict 字典 {}

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。(缺点是占用内存大，还会浪费很多内容)

dict的第二个特点就是存储的key-value序对是没有顺序的

dict的第三个特点是作为 key 的元素必须不可变

for key in d:
print key,':',d[key]

删除

del(dict(key))

dict.pop(key)

获得value

dict[key]

dict.get(key,novalue) #不存在返回novalue

更新,相当于合并

dict.update(dict2)

创建新元素

dict.setdefault(key,value)

复制

import copy

dict = {}

普通拷贝

m = dict.copy()

浅拷贝，b变化则a变化

b = copy.copy(dict)

深拷贝，不会随之变化

c =copy.deepcopy(dict)

迭代dict的value

d{}
d.values()
d.itervalues()

values() 方法实际上把一个 dict 转换成了包含 value 的list。

但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

打印 itervalues() 发现它返回一个 <\dictionary-valueiterator> 对象

同时迭代 key和value

d.items()

set

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像,必须是不变对象。

由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。

s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
for name in s:
print name
'Bart' in s

返回True

更新set

s.add()

s.remove()

给定一个list，对list中的每一个元素，如果在set中，就将其删除，如果不在set中，就添加进去。

s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for i in L:
if i in s:
s.remove(i)
continue
else:
s.add(i)
print s

list切片

提取元素

for i in range(n):
r.append(L[i])

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

L[a:b:m] (m:步长)

迭代永远是取出元素本身，而非元素的索引.enumerate() 函数拿到索引

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
print index, '-', name

索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

zip()函数可以把两个 list 变成一个 list

生成列表 [1x2, 3x4, 5x6, 7x8, …, 99x100]

print [x*(x+1) for x in range(1,100,2)]