Python内置数据结构：列表、元组、字符串、集合、字典
列表：
一种容器类型。列表可以包含任何种类的对象，比如说数字、子串、嵌套其他列表、嵌套元组。
任意对象的有序集合，通过索引访问其中的元素。其长度可变，支持异构(在一个列表中可以包含多种不同类型的元素)，可以任意嵌套。
列表是可变对象，支持在原处修改。列表的可变变现在其内部的每一个元素存储在列表中不是对象本身，而是对象的引用。因此其修改的是对象的引用。
1. 初始化list()，里面可以什么都不放，也可以放可迭代对象。
2. 下标/索引操作：
python中list的索引从0开始。绝大多数语言的下标是从0开始的。
负数的索引表示从后往前数，由-1开始，-1表示最后一个元素。
3. 列表的操作
1.增：
append()：原地修改list，给list最后增加一个元素，返回值是None。时间复杂度是O(1)
extend()：时间复杂度是O(n)，这个n是可迭代对象的长度，并不是原有list的长度n。
insert()：insert方法操作的索引超出范围时，如果是正索引，等效于append，如果是负索引，等效于insert(0, object)。insert的时间复杂度是O(n)，append的时间复杂度是O(1)。因为insert是要做一个遍历的。
删：
clear()：clear方法删除列表的所有元素。
pop()：可以传入index，默认从最后移除一个元素，并且把这个元素返回回来。
remove()：
pop是弹出索引对应的值，remove是删除最左边的一个值。
想删最后一个，可以reverse一下，然后remove，再然后reverse回去
pop针对的是索引，remove针对的是值。
pop和remove的时间复杂度都是O(n)
改：
reverse(): in place
sort():直接修改List in place
查：
count()：指定的value在list中出现的次数
注：这里增加一个python内置方法：len():用于检查List元素个数。并不仅仅是针对List，可以针对很多对象。
index()：根据值查找索引
其他：
copy():
成员关系的判断：
in
not in
举例：去除list中的重复元素
列表相加:
合并两个列表，生成了一个新列表。不会修改原列表。这个和子串的相加是一样的，生成新的子串。
序列相乘：就是重复元素多次。都是生成新对象。
子串乘法：
列表乘法：
切片：切片函数原型，用C实现的，底层速度特别快
切片[::]通常是用来访问数据的，如果你对切片赋值的话，产生的结果是不可预料的。切片操作总是返回一个新的list，不会改变原有的list seq[start, end] [start, end)
如果想获取到最后一个元素，省略end
以上都是从左往右切片，所以左边的数字要小于右边的数字。
start超出索引范围从0开始，end超出索引范围到到len(lst)结束。
start为0时可以省略，end省略表示打印到最后一个元素，start和end都省略就是copy。
切片还有一个第3个参数：step，默认是1
当step为负数的时候，从后往前数，此时start应该大于end，否则返回空列表。
List[::-1] 反转一个链表
Lst[0::2] 求list中偶数下标的元素 从0开始到结束，step=2
Lst[1::2] 求lst中奇数下标的元素 从1开始到结束，step=2
切片赋值
对切片赋值，会替换切片原来的元素。
通常我们是不会对切片进行赋值的，会造成很多的误解。
5. 解包/封包
a, b = b, a
最简单的解包就是如下：把右边的元组或者列表(可迭代对象都行)解开成了左边的两个变量，这种就是解包.网络编程中url的获取
封包就是把一组变量，变成元组。把若干变量或常量封装到一个变量里，这就是封包。
解包是把集合里的元素赋值给变量(集合可以是可迭代对象)，赋值完的变量要么是一个值，要么是个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]),
或for i in t:
for j in i:
print j
dict 字典 {}
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。
dict的 特点：
查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。(缺点是占用内存大，还会浪费很多内容)
存储的key-value序对是没有顺序的
作为 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