Python and django（四）--详解python中的数字和序列

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):
     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):
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!
 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)