核心数字类型：

数字：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 str3

str="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，相当于完全copyl1

l1={"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这个key

l1={"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'}