《转》python基础下

转自http://www.cnblogs.com/BeginMan/archive/2013/04/12/3016323.html

一、数字

在看《Python 核心编程》的时候，我就有点疑问，为什么没有把Python数字放在基础范围之内呢，可能作者先要通过Python对象，然后在深入到数字，这样会更加容易理解。这里有一个观点就是“Python的一切皆对象”原则，通过上一节的学习变量赋值，就能深刻体现这个原则，具体见下节的学习入门笔记。

由于数字在Python中用到的并不很多，就像学js的数字类型一样，我觉得最好放在基础篇之内，这样对于下节的对象有个铺垫的作用。

本节主要是学习Python的数字类型、操作、与数字有关的内建函数。

1、数字类型

在上节中说，Python变量无须定义类型，这是由于它是动态类型的语言，在内存中根据所赋值动态地确定其类型。如果偏偏要在python中给变量分类的话，那么可分：可变类型和不可变类型。

这里整理了可变类型(mutable)和不可变类型(immutable)的相关知识：
(或许我们在学习了下一节才能对此有深刻理解，如果曾学习过C，它像C指针的艺术；如果学了C#，它像C#值类型与引用类型的性质；如果学了js，它的性质基本上同Python；总的来说，一切的编程语言都围绕着基础核心，只是各自体现不一样而已，我们要学会融会贯通，举一反三。。。不过感觉好难哦。)

这里推荐一篇文章：《如何学会600多种编程语言》 -----------------------------------------------------------------------------------

不可变类型(immutable):就是内存中的那可内容(value)是否可以被改变，如果是不可变则，在对对象本身操作的时候，必须在内存的另外地方再申请一块区域(因为老区域#不可变#)，老的区域就丢弃了(如果还有其他ref，则ref数字减1，类似unix下的hard-link)。

可变类型(mutable):对对象操作的时候，不需要再在其他地方申请内存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。

不可变类型有:string、interger、tuple：

 1 >>> var1 = 1
 2 >>> var2 = var1
 3 >>> var1,var2
 4 (1, 1)
 5 >>> id(var1),id(var2) #同指同一内存区域，id相同
 6 (21200672, 21200672)
 7 >>> var1 += 1
 8 >>> var1,var2
 9 (2, 1)
10 >>> id(var1),id(var2)
#由于var1,var2数据不可变的，对var1+1后，申请另外一块区域，id(var1)变了，id(var2)不变,对此区域ref数字-1
11 (21200660, 21200672)
12 >>>

可变类型：list,dict

 1 >>> lst1 = [1,2,3]
 2 >>> lst2 = lst1
 3 >>> lst1,lst2
 4 ([1, 2, 3], [1, 2, 3])
 5 >>> id(lst1),id(lst2)
 6 (28497360, 28497360)
 7 >>> lst1.append(4)#可变类型的，append后，address会保持不变
 8 >>> lst1,lst2
 9 ([1, 2, 3, 4], [1, 2, 3, 4])
10 >>> id(lst1),id(lst2)#lst1,lst2一直指向同一区域
11 (28497360, 28497360)
12 >>>
13 在操作这种类型的时候要特别小心，dict的key不用可变类型的，函数传参的时候不用可变类型的。
14 eg:
15 >>> def dis(arg=[]):
16 ...     arg.append('1')
17 ...     print arg
18 ...
19 >>> dis()
20 ['1']
21 >>> dis()
22 ['1', '1']
23 >>>id(dis())
24 ['1', '1', '1']
25 505246615
26 >>>id(dis())
27 ['1','1','1','1']
28 505246615

参考：http://blog.chinaunix.net/uid-26249349-id-3080279.html

数字就是不可变类型，也就是说更改数字的值就会产生新的对象，当然这个我们无须考虑。

python数字类型可分为：整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数

(1)、整型：

如：0101、8、-3、0X80、-0X78

(2)、布尔型

True、False

(3)、长整型

在整型后面加L(或l)，目前整型和长整型在慢慢统一。只有对它调用repr()函数才有机会看到L，调用str()函数则看不到L：

>>> aLong=11111111111111111111
>>> aLong  (在命令行中，直接输入变量名显示值，这种情况实际上调用了repr()函数)
11111111111111111111L
>>> print aLong （在命令行中，如果在变量前面使用print 则调用str()函数）
11111111111111111111
>>> 

 

(4)、双精度浮点型

类似C中的double。实际精度依赖Python解释器的编译器。

(5)、复数

 1 >>> aComplex=2.1+3j
 2 >>> aComplex
 3 (2.1000000000000001+3j)
 4 >>> aComplex.real
 5 2.1000000000000001
 6 >>> aComplex.imag
 7 3.0
 8 >>> aComplex.conjugate()
 9 (2.1000000000000001-3j)
10 >>> 

更多见python core programming

2、操作符

分别是：+、-、*、/、%、**、//（地板除）

很有意思的是，python的除法运算。

在js中实现以下代码：

1 <script type="text/javascript">
2 var a=1,b=2;
3 var c=0.1,d=0.2;
4 var result1=a/b;
5 var result2=c/d;
6 alert(result1);#0.5
7 alert(result2);#0.5
8 </script>

如果我们在Python中实现，则如下:

>>>1/2
0
>>>0.1/0.2
0.5

有些奇怪吧，Python是这样处理的；

传统除法：如果是整型除法，则传统除法会舍弃小数点部分，返回一个整型(地板除)；如果操作数之一是浮点型，则执行真正地除法。

真正除法：返回真实的商，在未来Python版本中会成为统一标准，不过现在我们通过from __future__ import division可以实现。

>>> from __future__ import division
>>> 1/2
0.5
>>> 1.0/2.0
0.5

地板除：从Python2.2开始，新操作符//，被称为地板除、即不管操作数是什么类型，总会舍弃小数部分，返回整数。

>>> 1//2
0
>>> 1.0//2.0
0.0
>>> -1//2
-1

其他操作符有兴趣可以在《Python 核心编程》和官网文档看看。

3、与数字有关的内建函数

关于更多内建函数，将会在后面学习中具体说明，今天先学习关于数字的内建函数。它们有：

(1)、标准内建函数：

cmp()、str()、type()对于任何类型都可以使用

>>> cmp(1,2) #比较大小
-1
>>> cmp(2,1)
1
>>> cmp(2,2)
0
>>> str(0xFF) #转换成字符串
'255'
>>> type(0xFF) #返回对象类型
<type 'int'>
>>> type('str')
<type 'str'>

（2）、转换工厂函数：

int()、long()、float()、bool()、complex()，它们都是转换成跟数字有关的函数。如：

>>> '111'
'111'
>>> int('222')
222
>>> long('222')
222L
>>> float('222')
222.0
>>> bool(1)
True
>>> complex(2)
(2+0j)
>>> bool(True)
True
>>> bool(454)
True
>>> bool(0)
False

(3)、功能函数

有abs()返回给定参数的绝对值：

>>> abs(-3)
3

coerce()数据类型对两个参数进行转换函数：

>>> coerce(1,2)   #python 3中已经去除
(1, 2)
>>> coerce(1,-2)
(1, -2)
>>> coerce(1,123L)
(1L, 123L)
>>> coerce(1.3,123L)
(1.3, 123.0)
>>> coerce(1j,123L)
(1j, (123+0j))

divmod()通过取余，返回商和余数的元祖：

>>> divmod(10,2)
(5, 0)
>>> divmod(10,3)
(3, 1)

pow()和**都可以进行指数运算：

>>> 5**2
25
>>> pow(5,2)
25

round()四舍五入：

>>> round(3)
3.0
>>> round(3.45)
3.0
>>> round(3.999999,1)
4.0