Python入门笔记(3)：基础(下)

kidys

一、数字　　在看《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
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
　　如果我们在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('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)
(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
　　更多内建函数见Python官网文档。