核心数字类型：
数字：int，long，float，complex，bool
字符：str，unicode
列表：list
字典：dict
元组：tuple
文件：file
其他类型：集合(set),frozenset,类型，None
其他文件类工具：pipes，fifos，sockets.
类型转换：
str(),repr()或format():将非字符型数据转换成字符；
int():转换为整数
float():转换为浮点数
list(x):可以把字符串x转换为列表，
tuple(x):将字符串x转换为元组；
set(x):将字符串转换为集合.
dict(d):创建字典，其d必须是[(key,value),(key,value)]的元组序列：
chr(x):将整数转为字符.
ord(x):将字符转换为整数值.
hex(x):将整数转换为16进制字符.
bin(x):将整数转换为2进制字符.
数字类型：
Python的数字字面量：布尔型，整数，浮点数，复数
True:1
False:0
序列类型：
字符类型：
字符串字面量：把文本放入单引号、双引号或三引号中：
如果要使用unicode编码，则在字符之前使用字符u进行表示，如u"xxx"
适用于所有序列的操作和方法：
s[i]:索引运算符
s[i:j]:为切片运算符，s[i:j:stride]为扩展切片运算符
min(s)和max(s)只适用于能够对元素排序的序列
sum(s)只适用于数字序列
all(s)检查s中的所有项是否为True
any(s)检查s中的任意项是否为False>>> str="9876544531"
>>> min(str)
‘1‘
>>> max(str)
‘9‘
用于字符串的操作：
Python2 提供两种字符串对象类型：
字节字符串：字节序列
unicode字符串：Unicode字符序列
Python可以使用32bit整数保存Unicode字符，但此为可选特性.>>> str2="hellow"
>>> str2.islower()
True
>>> str2.isupper()
False
>>> str2.upper()
‘HELLOW‘
capitalize 字符串的首字母大写s.capitalize()
s.index(sub[,start[,end]]) 找到指定字符串sub首次出现的位置，否则报错
s.join(t) 使用s作为分隔符连接序列t中的字符串
s.lower() 转换为小写形式
s.split([sep[,maxsplit]]) 使用sep作为分隔符对一个字符串进行划分。maxsplit是划分的最大次数
s.strip 删掉chrs开头和结尾的空白或字符
s.upper()将一个字符串转换为大写形式
replace(‘old‘,‘new‘) 将所有旧的字符串替换为新的字符串
str="hello world"
l2=list(str)
print l2
str3=‘‘.join(l2)#使用空白作为分隔符将list列表组合起来.
print str3str="hello world"
print str.replace(‘hello‘,‘HELLO‘)
split 以.为分隔符，对字符串进行操作.str="www.baidu.com"
print str.split(‘.‘)
[‘www‘, ‘baidu‘, ‘com‘]
s.strip()用来删除s字符串左右两边的空白字符的.str=" hello "
print str.strip()
hello
列表：
容器类型：
任意对象的有序集合，通过索引访问其中的元素，可变对象，
异构，任意嵌套
支持在原处修改：
修改指定的索引
del() 删除列表中的元素
append() 新增列表中的元素str=[‘1‘,‘a‘,‘b‘,‘7‘]
del(str[1:])
print str
结果:[1]
str=[‘1‘,‘a‘,‘b‘,‘7‘]
str.append("hello")
print str
结果:[‘1‘, ‘a‘, ‘b‘, ‘7‘, ‘hello‘]
count() 获取指定列表中元素出现的次数str=[‘1‘,‘a‘,‘b‘,‘7‘]
print str.count(‘a‘)
结果:1
extend() 列表扩充，将原先列表中的元素扩充进来.str=[‘1‘,‘a‘,‘b‘,‘7‘]
l1=[‘x‘,‘y‘,‘z‘]
str.extend(l1)
print str
结果：[‘1‘, ‘a‘, ‘b‘, ‘7‘, ‘x‘, ‘y‘, ‘z‘]
append() 新增列表元素元素str=[‘1‘,‘a‘,‘b‘,‘7‘]
l1=[‘x‘,‘y‘,‘z‘]
str.append(l1)
print str
结果：[‘1‘, ‘a‘, ‘b‘, ‘7‘, [‘x‘, ‘y‘, ‘z‘]]
打印列表中某元素索引的位置.>>> print str
[‘1‘, ‘a‘, ‘b‘, ‘7‘, ‘x‘, ‘y‘, ‘z‘]
>>> str.index(‘a‘)
1
s.insert 在索引的位置添加新的字符串.>>> str.insert(1,"ccc")
>>> print str
[‘1‘, ‘ccc‘, ‘a‘, ‘b‘, ‘7‘, ‘x‘, ‘y‘, ‘z‘]
s.pop弹出某个索引对应的元素，默认为弹出最后一个列表的元素.
弹出以后将返回这个元素.>>> print str
[‘1‘, ‘ccc‘, ‘a‘, ‘b‘, ‘7‘, ‘x‘, ‘y‘, ‘z‘]
>>> str.pop(2)
‘a‘
>>> str.pop()
‘z‘
s.remove()删除列表中指定元素的值>>> str.remove(‘y‘)
>>> print str
[‘1‘, ‘ccc‘, ‘b‘, ‘7‘, ‘x‘]
>>> str.remove(‘b‘)
>>> print str
[‘1‘, ‘ccc‘, ‘7‘, ‘x‘]
s.sort排序,正序；在原处修改，没人任何返回.>>> print str
[‘1‘, ‘ccc‘, ‘7‘, ‘x‘]
>>> str.sort()
>>> print str
[‘1‘, ‘7‘, ‘ccc‘, ‘x‘]
s.reserse 逆序，倒序>>> print str
[‘1‘, ‘7‘, ‘ccc‘, ‘x‘]
>>> str.reverse()
>>> print str
[‘x‘, ‘ccc‘, ‘7‘, ‘1‘]
l1+l2：合并两个列表，返回一个新的列表，不会修改原列表.>>> l1=[1,2,3]
>>> l2=[7,8,10]
>>> l1+l2
[1, 2, 3, 7, 8, 10]
l1 * N：把l1重复N次，返回一个新列表.>>> l1=[1,2,3]
>>> l1 * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
in:成员关系判断字符
用法：某个元素in 某个容器>>> 2 in l1
True
>>> 2 in l2
False
not in ：判断某个元素不在某个列表中.
列表解析：[]
深度复制列表中的元素,内存中所引用的对象发生变化。
copy.deepcopy()
实例：import copy
l1=[1,2,3]
l2=copy.deepcopy(l1)
print l2
l1.append(4)
print l1
print l2
l2等于l1列表中的所有元素.
l2=l1[:]
元组：
表达式符号:()
容器类型
任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定.
虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组.
列子：l1=(1,2,3,[‘a‘,‘b‘,‘c‘])
print l1
print l1[3]
l1[3].pop()
print l1
字典：dict
字典在其他编程语言中又称作关联数组或散列表；
通过键实现元素存取;无序集合;可变类容器，长度可变，异构，嵌套.
{key:value1，key2:value2}
{}空字典
l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1["x"]
结果为：[‘a‘, ‘b‘, ‘c‘]
对于字典的引用，需要使用key调用对应的值;
字典也支持切片:l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1["x"][1:]
[‘b‘, ‘c‘]
len()返回字典中元素的个数
l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print len(l1)
结果为：2
字典支持修改，元素可变：l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print id(l1)
print l1["y"]
l1["y"] = 504
print l1
print id(l1)
dicr.copy()复制copy，相当于完全copyl1l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1
l2=l1.copy()
print l2
dict.get()获取指定key的value值.l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1.get("x")
查看字典中有没有x这个keyl1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1.get("x")
print l1.has_key("x")
dict.get()和dict[s]区别在于：
dict.get()获取字典中就算没有这个值也不会报错，但是要是dict[]这个值就会直接报错.
dict.items将字典中的key:value以列表元组的形式拆开.l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1.items()
结果：[(‘y‘, 32), (‘x‘, [‘a‘, ‘b‘, ‘c‘])]
l1={"x":[‘a‘,‘b‘,‘c‘],"y":32}
print l1.items()
变量解包，元组支持解包，字典直接不支持解包.t1,t2=l1.items()
print t1,t2
[(‘y‘, 32), (‘x‘, [‘a‘, ‘b‘, ‘c‘])]
(‘y‘, 32) (‘x‘, [‘a‘, ‘b‘, ‘c‘])
m1,m2={‘x‘:1,‘y‘:2}
print m1,m2
结果：y x 可以看到字典时无序的，不支持直接解包.
dict.keys()是key组成的列表，dict.values()字典值组成的列表.l1={‘x‘:21,‘y‘:5}
print l1.keys()
print l1.values()
dict.update()合并字典l1={‘x‘:21,‘y‘:5}
l2={‘a‘:21,‘b‘:7,‘x‘:32}
l1.update(l2)
print l1
dict.next()迭代.l1={‘x‘:21,‘y‘:5}
i1=l1.iteritems()
print i1.next()
zip函数：快速构建字典的方式print zip(‘abcd‘,‘123‘)
print dict(zip(‘abcd‘,‘123‘))
结果：
[(‘a‘, ‘1‘), (‘b‘, ‘2‘), (‘c‘, ‘3‘)]
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘}
