id()函数用来查看对象唯一ID，如两个对象ID一样，则表示他们是一个对象。python在给小整数和小字串创建对象时，如果他们的值 相等，则为他们分配到同一个对象。
>>> a=1
>>> id(a)
3629968
>>> a=2
>>> id(a)
3629956
>>> del a
>>> id(a)
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
NameError: name 'a' is not defined
种类
Python 中的数字类型：整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数。
1）整型
a）布尔类型：只有两个值的整型。
>>> a=True, b =False int(a)=1, int(b)=0 >>> bool(1) = True ,bool(True) = True, bool('1') = True >>> bool('0') = True, bool(0) = False, bool('') = False, bool([]) = False >>> a=1, b=a<2 >>> b True >>> True,False=False,True >>> bool(True) False >>> bool(False) True
b）整型和长整型
Python 2.2以后可以认为整型和长整型是一回事。
>>> 10000**8
100000000000000000000000000000000L
>>> 10**8
100000000
2) 双精度浮点数
类似C#中的double。
3)复数
复数由实数部分和虚数部分构成： real+imagj。
负数属性：
num.real 该复数的实部
num num.imag 该复数的虚部
num.conjugate() 返回该复数的共轭复数
>>> a=1+3j, b=1+3j
a.real = 1.0, a.imag = 3.0
>>> a.conjugate
<built-in method conjugate of complex object at 0x012FD368>
4)十进制浮点数
Decimal
>>> from decimal import Decimal
>>> Decimal("0.1")*Decimal("3.1415926")
Decimal("0.31415926")
运算符
1）混合模式运算符
Python支持不同的数字类型相加。
>>> 20+3.5698
23.569800000000001
2）标准类型运算
>>> a=1.2, b=1.20
a==b为True；a>b, b<b 均为False；a>=b，a<=b均为True
>>> (a==b) or(a>=b)
True
3）算术运算符
+，－，*，/，%，**，//
>>> 7.3/7
1.0428571428571429
>>> 7.3//7
1.0
>>> 4**3 #求幂
64
4)位运算符
位运算只支持整数。
取反(~)，按位 与(&), 或(|) 及 异或(^) 及左移(<<)和右移(>>)。
>>> 20&35，30&45，30|45
0, 12, 63
>>> 30<<2, ~30, 30 ^ 45
120, -31, 51
内建函数
1）type，str，type上篇介绍过。
2）对应于数字类型的函数。
int（）、float（）、long()、complex（）、bool（）
>> int(3.1415926), long(3.1415926), float(3.1415926)
3, 3L, 3.1415926000000001
>>> complex(3.1415926)
(3.1415926000000001+0j)
>>> bool(3.1415926), bool(-3.1415926)
True, True
3)功能函数
abs()：求绝对值；
coerce()：返回一个包含类型转换完毕的两个数值元素的元组。
divmod()：返回一个包含商和余数的元组。
pow()：指数运算,两个参数时类似于**；
pow()还接受第三个可选的参数，一个余数参数。如果有这个参数的，pow() 先进行指数运算，然后将运算结果和第三个参数进行取余运算。
round()：对浮点数进行四舍五入运算。
>>> abs(-1), coerce(1,13L)
1, (1L, 13L)
>>> divmod(10,3),divmod(10.21,3.58)
(3, 1), (2.0, 3.0500000000000007)
>>> pow(4,3),4**3, pow(4,3,5)
64, 64, 4
>>> round(3.1415926), round(3.78)
3.0, 4.0
int（）、math.floor()和round的区别：
函数int()直接截去小数部分。（返回值为整数）
函数floor()得到最接近原数但小于原数的整数。（返回值为浮点数）
函数round()得到最接近原数的整数。（返回值为浮点数）
>>> for n in (0.2,0.7,1.2,1.7,-0.2,-0.7,-1.2,-1.7):
print 'int('+str(n)+'):'
print int(n)
print 'floor('+str(n)+'):'
print math.floor(n)
print 'round('+str(n)+'):'
print round(n)
>>>int(0.2),floor(0.2),round(0.2)
0,0.0,0.0
>>>int(0.7),floor(0.7),round(0.7)
0,0.0,1.0
>>>int(-0.2),floor(-0.2),round(-0.2)
0,-1.0,0.0
>>>int(-0.7),floor(-0.7),round(-0.7)
0,-1.0,-1.0
4）仅用于整数的函数
a）进制转换
oct（）：转换成八进制
hex（）：转换成十六进制
>>> oct(100)
'0144'
>>> hex(100)
'0x64'
b）ASCII转换
chr（）：将数值转换为字符
ord（）：将字符转换为数值
>>> chr(89)
'Y'
>>> ord('a')
97
>>> ord('A')
65
和数字相关模块
|
decimal |
十进制浮点运算类 Decimal |
|
array |
高效数值数组（字符，整数，浮点数等等） |
|
math/cmath |
标准C库数学运算函数。常规数学运算在match模块， 复数运算在cmath模块 |
|
operator |
数字运算符的函数实现 |
|
random |
多种伪随机数生成器 |
序列: 字符串、列表和元组
特征
1）有序排列，可以通过下标偏移量访问。
2）可通过切片操作一次得到多个元素。
操作运算符
seq[ind] 获得下标为ind 的元素
seq[ind1:ind2] 获得下标从ind1 到ind2 间的元素集合
seq * expr 序列重复expr 次
seq1 + seq2 连接序列seq1 和seq2
obj in seq 判断obj 元素是否包含在seq 中
obj not in seq 判断obj 元素是否不包含在seq 中
1）访问
>>> 'abc'[0]
'a'
>>> ('a','b','c')[0]
'a'
>>> ['a','b','c'][0]
'a'
>>> ('a','b','c')[0:1]
('a',)
>>> ('a','b','c')[0:2]
('a', 'b')
>>> ['a','b','c'][0:2]
['a', 'b']
>>> 'abc'[0:2]
'ab'
2）重复
>>> 'abc'*3
'abcabcabc'
>>> ('a','b','c')*2
('a', 'b', 'c', 'a', 'b', 'c')
>>> ['a','b','c']*2
['a', 'b', 'c', 'a', 'b', 'c']
3）连接
>>> 'ab'+'c'
'abc'
>>> ['a']+['b']
['a', 'b']
4）成员关系运算符 in 、not in
>>> 'a' in 'abc'
True
>>> 'a' in 'bcd'
False
>>> 'a' in('a','b','c')
True
>>> 'a' in ['a','b','c']
True
>>> 'a' not in ('b','c','d')
True
>>>
内建函数
1）类型转换
|
list(iter) |
把可迭代对象转换为列表 |
|
str(obj) |
把obj 对象转换成字符串(对象的字符串表示法) |
|
unicode(obj) |
把对象转换成Unicode 字符串(使用默认编码) |
|
basestring() |
抽象工厂函数,其作用仅仅是为str 和unicode 函数提供父类，所以不能被 实例化，也不能被调用 |
|
tuple(iter) |
把一个可迭代对象转换成一个元组对象 |
2）其他函数
enumerate(iter) 、len(seq) 、max、min、sort、reversed、sorted、sum、zip。
字符串
Python 里面单引号和双引号的作用是相同的。
类型
1）通常意义的字符串---basestring的子类
2）Unicode字符串---- basestring的子类
操作
1）上面序列的操作都可用于字符串。
2）字符串特有操作
a)格式化
格式化符号
|
%c |
转换成字符(ASCII 码值，或者长度为一的字符串) |
|
%r |
优先用repr()函数进行字符串转换 |
|
%s |
优先用str()函数进行字符串转换 |
|
%d / %i |
转成有符号十进制数 |
|
%u |
转成无符号十进制数 |
|
%o |
转成无符号八进制数 |
|
%x/%X |
(Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写) |
|
%e/%E |
转成科学计数法(e/E 控制输出e/E) |
|
%f/%F |
转成浮点数(小数部分自然截断) |
|
%g/%G |
%e 和%f/%E 和%F 的简写 |
|
%% |
输出% |
>>> "%d,%f" %(32,3.14)
'32,3.140000'
b）模板 Template
两个属性：
substitute：在key 缺少的情况下它会报一个KeyError 的异常出来。
safe_substitute：在缺少key 时，直接原封不动的把字符串显示出来。
>>> from string import Template
>>> s=Template('hi,Welcome to visit ${site}!it is about ${memo}!')
>>> s.substitute(site='apihi',memo='web api')
'hi,Welcome to visit apihi! it is about web api!'
>>> s.safe_substitute(site='apihi')
'hi,Welcome to visit apihi! it is about ${memo}!'
>>> s.substitute(site='apihi')
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
File "D:\Python25\lib\string.py", line 170, in substitute
return self.pattern.sub(convert, self.template)
File "D:\Python25\lib\string.py", line 160, in convert
val = mapping[named]
KeyError: 'memo'
>>>
c）原始字符串（r）
不对字符串内容进行解析
>>> print '123\n4'
123
4
>>> print r'123\n4'
123\n4
d）Unicode字符串（u）
内建函数
字符串的内建函数非常丰富，通过一个例子看一下：
>>> str='hi,Welcome to visit apihi'
>>> str.capitalize()
'Hi,welcome to visit apihi'
>>> str.center(50)
' hi,Welcome to visit apihi '
>>> str.count('i')
5
>>> str.find('i')
1
>>> str.endswith('i')
True
>>> str.index('i',2)
15
>>> str.replace('i','I')
'hI,Welcome to vIsIt apIhI'
特殊性
1）反斜线+单一字符表示特殊字符
如：\n表示换行
2）三引号
可以跨多行，可以包含特殊字符
>>> '''hi!
my name is \n str'''
'hi!\nmy name is \n str'
3）不变性
>>> s='sbc'
>>> id(s)
19779744
>>> s=s+'d'
>>> id(s)
19738496
>>>
列表
列表是可变的容器。
创建及访问
>>> mylist=[1,'a',1.2]
>>> mylist
[1, 'a', 1.2]
>>> mylist.append(3.14)
>>> mylist
[1, 'a', 1.2, 3.1400000000000001]
>>> mylist[1]
'a'
>>> mylist[1:3]
['a', 1.2]
>>> del mylist[1]
>>> mylist
[1, 1.2, 3.1400000000000001]
>>> del mylist
>>> mylist
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
NameError: name 'mylist' is not defined
>>>
操作
1）序列的通用操作
2）列表专用操作 没有专门用于列表的操作符
内建函数
1）标准类型函数
>>> list1,list2=[1,'a'],[1,'a']
>>> cmp(list1,list2)
0
2）序列函数
>>> mylist=[1,2,3,'a']
>>> len(mylist)
4
>>> sorted(mylist)
[1, 2, 3, 'a']
3）专用于列表的函数
>>> mylist=range(8)
>>> mylist
[0, 1, 2, 3, 4, 5, 6, 7]
>>> mylist.append('a')
>>> mylist
[0, 1, 2, 3, 4, 5, 6, 7, 'a']
>>> mylist.count
<built-in method count of list object at 0x012E2D78>
>>> mylist.count(1)
1
>>> mylist.insert(1,'b')
>>> mylist
[0, 'b', 1, 2, 3, 4, 5, 6, 7, 'a']
>>> mylist.reverse()
>>> mylist
['a', 7, 6, 5, 4, 3, 2, 1, 'b', 0]
>>>
元组
元组是不可变的容器。
创建及访问
>>> mytuple=(1,2,3,4,'a')
>>> mytuple
(1, 2, 3, 4, 'a')
>>> tuple('abcdefg')
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> mytuple[0]
1
>>> mytuple[1:4]
(2, 3, 4)
>>> id(mytuple)
19758944
>>> mytuple=mytuple+('b','c')
>>> mytuple
(1, 2, 3, 4, 'a', 'b', 'c')
>>> id(mytuple)
19840112
>>>
操作
>>> mytuple =(1,2,3)
>>> mytuple *2
(1, 2, 3, 1, 2, 3)
>>> 1 in mytuple
True
>>> 4 not in mytuple
True
>>> len(mytuple)
3
>>> (1,2)==(2,1)
False
>>>
特殊性
1）不可变
>>> mytuple=(1,2,3)
>>> id(mytuple)
19773760
>>> mytuple+=('a','b')
>>> id(mytuple)
19758944
>>>
默认元组
1）所有的多对象的，逗号分隔的，没有明确用符号定义。
>>> 1,2,3,'a'
(1, 2, 3, 'a')
2）所有函数返回的多对象
>>> def f():
return 1,2,3
>>> f()
(1, 2, 3)
单对象元组
>>> a=('a')
>>> type(a)
<type 'str'>
>>>
非要创建单对象元组，可以通过下面这种做法：
>>> a=('a',)
>>> type(a)
<type 'tuple'>
列表和元组
元组不可变，即不会被篡改。
列表和元组可以相互转换
>>> mytuple=(1,2,3)
>>> mytuple
(1, 2, 3)
>>> mylist=list(mytuple)
>>> mylist
[1, 2, 3]
>>> tuple(mylist)
(1, 2, 3)