核心数字类型：
数字：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
|
1
2
3
4
5
|
>>>
str
=
"9876544531"
>>>
min
(
str
)
'1'
>>>
max
(
str
)
'9'
|
用于字符串的操作：
Python2 提供两种字符串对象类型：
字节字符串：字节序列
unicode字符串：Unicode字符序列
Python可以使用32bit整数保存Unicode字符，但此为可选特性.
|
1
2
3
4
5
6
7
|
>>> 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') 将所有旧的字符串替换为新的字符串
|
1
2
3
4
5
|
str
=
"hello world"
l2
=
list
(
str
)
print
l2
str3
=
''.join(l2)
#使用空白作为分隔符将list列表组合起来.
print
str3
|
|
1
2
|
str
=
"hello world"
print
str
.replace(
'hello'
,
'HELLO'
)
|
split 以.为分隔符，对字符串进行操作.
|
1
2
3
|
str
=
"www.baidu.com"
print
str
.split(
'.'
)
[
'www'
,
'baidu'
,
'com'
]
|
s.strip()用来删除s字符串左右两边的空白字符的.
|
1
2
3
|
str=
" hello "
print str.strip()
hello
|
列表：
容器类型：
任意对象的有序集合，通过索引访问其中的元素，可变对象，
异构，任意嵌套
支持在原处修改：
修改指定的索引
del() 删除列表中的元素
append() 新增列表中的元素
|
1
2
3
4
|
str=[
'1'
,
'a'
,
'b'
,
'7'
]
del(str[1:])
print str
结果:[1]
|
|
1
2
3
4
|
str=[
'1'
,
'a'
,
'b'
,
'7'
]
str.append(
"hello"
)
print str
结果:[
'1'
,
'a'
,
'b'
,
'7'
,
'hello'
]
|
count() 获取指定列表中元素出现的次数
|
1
2
3
|
str=[
'1'
,
'a'
,
'b'
,
'7'
]
print str.count(
'a'
)
结果:1
|
extend() 列表扩充，将原先列表中的元素扩充进来.
|
1
2
3
4
5
|
str=[
'1'
,
'a'
,
'b'
,
'7'
]
l1=[
'x'
,
'y'
,
'z'
]
str.extend(l1)
print str
结果：[
'1'
,
'a'
,
'b'
,
'7'
,
'x'
,
'y'
,
'z'
]
|
append() 新增列表元素元素
|
1
2
3
4
5
|
str=[
'1'
,
'a'
,
'b'
,
'7'
]
l1=[
'x'
,
'y'
,
'z'
]
str.append(l1)
print str
结果：[
'1'
,
'a'
,
'b'
,
'7'
, [
'x'
,
'y'
,
'z'
]]
|
打印列表中某元素索引的位置.
|
1
2
3
4
|
>>> print str
[
'1'
,
'a'
,
'b'
,
'7'
,
'x'
,
'y'
,
'z'
]
>>> str.index(
'a'
)
1
|
s.insert 在索引的位置添加新的字符串.
|
1
2
3
|
>>> str.insert(1,
"ccc"
)
>>> print str
[
'1'
,
'ccc'
,
'a'
,
'b'
,
'7'
,
'x'
,
'y'
,
'z'
]
|
s.pop弹出某个索引对应的元素，默认为弹出最后一个列表的元素.
弹出以后将返回这个元素.
|
1
2
3
4
5
6
|
>>> print str
[
'1'
,
'ccc'
,
'a'
,
'b'
,
'7'
,
'x'
,
'y'
,
'z'
]
>>> str.pop(2)
'a'
>>> str.pop()
'z'
|
s.remove()删除列表中指定元素的值
|
1
2
3
4
5
6
|
>>> str.remove(
'y'
)
>>> print str
[
'1'
,
'ccc'
,
'b'
,
'7'
,
'x'
]
>>> str.remove(
'b'
)
>>> print str
[
'1'
,
'ccc'
,
'7'
,
'x'
]
|
s.sort排序,正序；在原处修改，没人任何返回.
|
1
2
3
4
5
|
>>> print str
[
'1'
,
'ccc'
,
'7'
,
'x'
]
>>> str.
sort
()
>>> print str
[
'1'
,
'7'
,
'ccc'
,
'x'
]
|
s.reserse 逆序，倒序
|
1
2
3
4
5
|
>>>
print
str
[
'1'
,
'7'
,
'ccc'
,
'x'
]
>>>
str
.reverse()
>>>
print
str
[
'x'
,
'ccc'
,
'7'
,
'1'
]
|
l1+l2：合并两个列表，返回一个新的列表，不会修改原列表.
|
1
2
3
4
|
>>> l1=[1,2,3]
>>> l2=[7,8,10]
>>> l1+l2
[1, 2, 3, 7, 8, 10]
|
l1 * N：把l1重复N次，返回一个新列表.
|
1
2
3
|
>>> l1=[1,2,3]
>>> l1 * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
|
in:成员关系判断字符
用法：某个元素in 某个容器
|
1
2
3
4
|
>>> 2
in
l1
True
>>> 2
in
l2
False
|
not in ：判断某个元素不在某个列表中.
列表解析：[]
深度复制列表中的元素,内存中所引用的对象发生变化。
copy.deepcopy()
实例：
|
1
2
3
4
5
6
7
|
import
copy
l1=[1,2,3]
l2=copy.deepcopy(l1)
print l2
l1.append(4)
print l1
print l2
|
l2等于l1列表中的所有元素.
l2=l1[:]
元组：
表达式符号:()
容器类型
任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定.
虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组.
列子：
|
1
2
3
4
5
|
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调用对应的值;
字典也支持切片:
|
1
2
3
|
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
字典支持修改，元素可变：
|
1
2
3
4
5
6
|
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
|
1
2
3
4
|
l1={
"x"
:[
'a'
,
'b'
,
'c'
],
"y"
:32}
print l1
l2=l1.copy()
print l2
|
dict.get()获取指定key的value值.
|
1
2
|
l1={
"x"
:[
'a'
,
'b'
,
'c'
],
"y"
:32}
print l1.get(
"x"
)
|
查看字典中有没有x这个key
|
1
2
3
|
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以列表元组的形式拆开.
|
1
2
3
|
l1={
"x"
:[
'a'
,
'b'
,
'c'
],
"y"
:32}
print l1.items()
结果：[(
'y'
, 32), (
'x'
, [
'a'
,
'b'
,
'c'
])]
|
|
1
2
|
l1={
"x"
:[
'a'
,
'b'
,
'c'
],
"y"
:32}
print l1.items()
|
变量解包，元组支持解包，字典直接不支持解包.
|
1
2
3
4
|
t1,t2=l1.items()
print t1,t2
[(
'y'
, 32), (
'x'
, [
'a'
,
'b'
,
'c'
])]
(
'y'
, 32) (
'x'
, [
'a'
,
'b'
,
'c'
])
|
|
1
2
3
|
m1,m2={
'x'
:1,
'y'
:2}
print m1,m2
结果：y x 可以看到字典时无序的，不支持直接解包.
|
dict.keys()是key组成的列表，dict.values()字典值组成的列表.
|
1
2
3
|
l1={
'x'
:21,
'y'
:5}
print l1.keys()
print l1.values()
|
dict.update()合并字典
|
1
2
3
4
|
l1={
'x'
:21,
'y'
:5}
l2={
'a'
:21,
'b'
:7,
'x'
:32}
l1.update(l2)
print l1
|
dict.next()迭代.
|
1
2
3
|
l1={
'x'
:21,
'y'
:5}
i1=l1.iteritems()
print i1.next()
|
zip函数：快速构建字典的方式
|
1
2
3
4
5
|
print zip(
'abcd'
,
'123'
)
print dict(zip(
'abcd'
,
'123'
))
结果：
[(
'a'
,
'1'
), (
'b'
,
'2'
), (
'c'
,
'3'
)]
{
'a'
:
'1'
,
'c'
:
'3'
,
'b'
:
'2'
}
|
