Python and django（四）
前面的内容：
python and Django(一) 准备工作
python and Django(二) 走马观花识python
python and Django(三) 下马看花赏python-python中的对象
从这篇起开始详细介绍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
>>> int(a)
1
>>> a=False
>>> int(a)
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
>>> id(a)
19911528
>>> id(b)
19911600
>>> 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
False
>>> b<b
False
>>> a>=b
True
>>> a<=b
True
>>> (a==b) or(a>=b)
True
3）算术运算符
+，－，*，/，%，**，//
>>> 7.3/7
1.0428571428571429
>>> 7.3//7
1.0
>>> 4**3
64
>>>
4)位运算符
位运算只支持整数。
取反(~)，按位 与(&), 或(|) 及 异或(^) 及左移(<<)和右移(>>)。
>>> 4**3
64
>>> 20&35
0
>>> 30&45
12
>>> 30|45
63
>>> 30<<2
120
>>> 30<<2
120
>>> ~30
-31
>>> 30 ^ 45
51
>>>
内建函数
1）type，str，type上篇介绍过。
2）对应于数字类型的函数。
int（）、float（）、long()、complex（）、bool（）
>> int(3.1415926)
3
>>> long(3.1415926)
3L
>>> float(3.1415926)
3.1415926000000001
>>> complex(3.1415926)
(3.1415926000000001+0j)
>>> bool(3.1415926)
True
>>> bool(-3.1415926)
True
>>> bool(0)
False
>>>
3)功能函数
abs()：求绝对值；
coerce()：返回一个包含类型转换完毕的两个数值元素的元组。
divmod()：返回一个包含商和余数的元组。
pow()：指数运算。
两个参数时类似于**；
pow()还接受第三个可选的参数，一个余数参数。如果有这个参数的， pow() 先进 行指数运算，然后将运算结果和第三个参数进行取余运算。
round()：对浮点数进行四舍五入运算。
>>> abs(-1)
1
>>> coerce(1,13L)
(1L, 13L)
>>> divmod(10,3)
(3, 1)
>>> divmod(10.21,3.58)
(2.0, 3.0500000000000007)
>>> pow(4,3)
64
>>> 4**3
64
>>> pow(4,3,5)
4
>>> round(3.1415926)
3.0
>>> round(3.78)
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):
int(0.2):
0
floor(0.2):
0.0
round(0.2):
0.0
int(0.7):
0
floor(0.7):
0.0
round(0.7):
1.0
int(1.2):
1
floor(1.2):
1.0
round(1.2):
1.0
int(1.7):
1
floor(1.7):
1.0
round(1.7):
2.0
int(-0.2):
0
floor(-0.2):
-1.0
round(-0.2):
0.0
int(-0.7):
0
floor(-0.7):
-1.0
round(-0.7):
-1.0
int(-1.2):
-1
floor(-1.2):
-2.0
round(-1.2):
-1.0
int(-1.7):
-1
floor(-1.7):
-2.0
round(-1.7):
-2.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')
>>> str.replace('i','I')
'hI,Welcome to vIsIt apIhI'
特殊性
1）反斜线+单一字符表示特殊字符
如：\n表示换行
2）三引号
可以跨多行，可以包含特殊字符
>>> '''hi!
'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():
>>> 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)