Python核心编程--学习笔记--5--数字

　　本章的主题是Python中的数字，这里详细介绍每一种数字类型，它们适用的各种运算符，以及用于处理数字的内建函数。在本章的末尾简单介绍了几个标准库中用于处理数字的模块。

 

1 数字类型

　　数字：标量贮存，可直接访问。值不可更改，更新数字的值其实是生成了一个新的对象。

　　创建数字对象：赋值的时候就已经创建。

　　更新数字对象：给变量赋新值时，其实是创建了一个新的对象，并将其引用赋值给变量。原对象引用计数减1。

　　删除数字对象：无法真正删除对象，只能用del语句删除对象的这个引用（变量名），之后不能使用这个引用。原对象引用计数减1。

2 整型

2.1 布尔型

　　只有两个值，True和False。进行数值运算时，True为1，False为0。

>>> True + 1
2
>>> False * 1.1
0.0

2.2 标准整数类型

　　等价于C语言的有符号长整型，一般以十进制表示，同时也支持八进制（数字0开头）和十六进制（0x或0X开头）表示。

2.3 长整型

　　与C语言的long不同，Python的长整型可以表达很大的值，只受限于系统虚拟内存。在数字后面加 L 或者 l（字母L大小写，推荐大写）即表示长整型。

2.4 整型和长整型的统一

　　目前整型和长整型正在逐步缓慢统一，只有对长整型调用repr()才会显示L，str()不显示。

>>> aLong = 999999999l 
>>> aLong 
999999999L 
>>> print aLong 
999999999

　　超出整型范围的，会自动转换为长整型：

>>> 1 << 20
1048576
>>> 1 << 32    #自动转换为长整型
4294967296L

　　调用C的人仍然要区分这两种整型。

3 双精度浮点数

　　Python的浮点数类似于C语言的double，遵循IEEE754规范，即 1b符号位 + 11b指数位 + 52b尾数部分。

　　浮点数的表示通常有一个小数点和一个可选的后缀 E或 e（大小写E，科学计数）：

>>> .123　　#只有小数点
0.123
>>> 12.
12.0
>>> 1.e1
10.0
>>> .5E-1
0.05
>>> float(12)　　#工厂函数
12.0

4 复数

　　复数由实数部分和虚数部分组成，实数部分和虚数部分都是浮点数，虚数部分必须有后缀 J或 j（大小写字母J）。虚部不能单独存在，如果没有列出实部，则默认为0.0。

　　复数对象有数据属性real（实部）和imag（虚部），还有conjugate()方法返回其共轭复数对象。复数是无序集合，不能比较大小。

>>> a = 1j　　#实部默认为0.0
>>> a.real
0.0
>>> a = 2 + 3j
>>> a
(2+3j)
>>> a.real　　#实部
2.0
>>> a.imag　　#虚部
3.0
>>> a.conjugate()　　#共轭复数
(2-3j)

5 运算符

5.1 复合模式运算符

　　其实就是自动类型转换，转换等级从高到低为 复数 > 浮点数 > 长整数 > 整数。内建函数coerce()帮助实现这种转换：

>>> 1.0 + (2 + 3j)    #浮点数转换为复数后再相加
(3+3j)
>>> coerce(123L, 0.4) #指出长整型应该转换为浮点数
(123.0, 0.4)

5.2 标准类型运算符

　　比较运算符（比如 >、==、!=等）和逻辑运算符（not、and、or）都可用于数值类型，运算之前同样会进行类型转换。

5.3 算数运算符

　　单目运算符：正号+、负号-

　　双目运算符：加法+、减法-、乘法*、除法/、地板除//、取余%、幂运算**

　　优先级同C语言。以上运算符中需要点明的几个特点：

>>> 1/2    #Python3.0以前的整数除法为地板除
0
>>> from __future__ import division    #执行该指令使用未来版本Python
>>> 1/2
0.5

$ python -Qnew    #进入交互解释器时设置Qdivision_style启动参数为新版本除。默认为-Qold
>>> 1/2
0.5

>>> -1 // 2    #负数地板除，返回比-0.5小的最大整数
-1

>>> 10.2 % 0.2    #浮点数求余x/y，返回 x - (math.floor(x/y) * y)，即10.2 - （math.floor(5.1) * 0.2) = 10.2 - 10.0 = 0.2
0.19999999...     #0.2，浮点数不会精确表示

>>> (10.2 + 0.4j) % 0.2    #复数求余类似于浮点数，x - ( math.floor( (x/y).real )  *  y )
0.199999993+0.4j

>>> -3 ** 2    #幂运算符优先级高于左侧符号位
-9
>>> 1 + 1j ** 2
0j

5.4 位运算符，只适用于整数

　　标准位运算：按位取反(~)，按位与(&)，按位或(|)，按位异或(^)，左移(<<)，右移(>>)。

　　Python对数字的处理也是按补码来进行的，可以参考C语言。由于Python对数字范围的支持扩大，左移的时候符号位可以无限的向左扩展。 　

　　优先级： 取反~  ==　正负号±  >  乘*除/幂**  >  加+减-  >  左移<<右移>>  >  与&或|异或^

>>> ~1    #1的补码00000001，按位取反11111110，这是-2的补码
-2
>>> ~-1   #-1的补码11111111，按位取反00000000，这是0的补码
0
>>> 1>>4
0
>>> -1>>4    #-1的补码11111111，右移时符号位也扩充
-1
>>> -1<<4
-16
>>> -1<<100  #符号位可以向左无限扩展，不会溢出
-1267650600228229401496703205376L
>>> 1&-1
1
>>> 1|-1
-1
>>> 1^-1
-2

6 内建函数与工厂函数

6.1 标准类型函数

　　包括之前提到过的cmp(obj1, obj2)、str(obj)、type(obj)，它们适用于所有标准类型。对于整数，分别用于比较两个数大小、将数字转换为字符串表示、返回数字对象类型。

6.2 数字类型函数

　　转换工厂函数——bool()、int()、long()、float()、complex()：

>>> bool(0)    　 #1 bool(obj)，返回obj对象的布尔值，也就是obj.__nonzero__()方法的返回值
False
>>> bool([1,2])   #非空列表布尔值
True
>>> bool({})    　#空字典布尔值
False

>>> int(123.5)    #2 int(obj, base=10)，返回字符串或数值对象的整型表示
123
>>> int('123', 8) #接受一个整数的字符串表示 和 一个整数 为参数，返回 8进制的123对应的十进制数
83
>>> int('123')　　#接受一个整数的字符串表示 为参数，默认返回其 十进制的数
123

>>> long('123', 8) #3 long(obj, base=10)，三种用法同int()
83L

>>> float('123')   #4 float(obj)，接受一个整数/浮点数 或 其字符串表示 为参数，返回一个浮点数
123.0
>>> float(123)
123.0

>>> complex('123')  #5 complex(str) 或者 complex(real, imag=0.0)，返回一个复数。 本例接受一个 整数/浮点数的字符串表现 为参数，充当实部
(123+0j)
>>> complex(123, 5) #接受两个实数，返回复数
(123+5j)
>>> complex(123)    #虚部默认为0.0
(123+0j)

　　内建功能函数——abs()、coerce()、divmod()、pow()、round()： 

>>> abs(-10.2)    #1 abs()  返回数值对象的绝对值
10.199999999999999
>>> abs(5)
5
>>> abs(3+4j)     #复数返回其实部与虚部平方和的正平方根，即复数的模
5.0

>>> coerce(1, 134L)     #2 coerce() 返回类型转换后的元组。可以不依赖Python解释器，自定义数值类型转换方法。
(1L, 134L) 
>>> coerce(1.3, 134L) 
(1.3, 134.0) 
>>> coerce(1.23-41j, 1.3) 
((1.23-41j), (1.3+0j)) 

>>> divmod(10,3)    #3 divmod() 返回商和余数组成的元组
(3, 1)
>>> divmod(10,2.4)  #浮点数的商 math.floor(x/y)
(4.0, 0.40000000000000036)
>>> divmod(2.5+2.5j, 2+1j)   #复数的商 math.floor( (x/y).real ) 。不推荐对复数进行 divmod() // % 等操作！！！！
((1+0j), (0.5+1.5j))

>>> pow(3j, 2)    #4 pow()等同于**运算符
(-9+0j)
>>> pow(2,5,10)   #可以有第三个参数，相当于pow(x,y,z) = x**y % z，但是pow()效率更高 
2

>>> round(3.4)    #5 round() 四舍五入，返回整数的浮点表现形式
3.0
>>> round(3.5)
4.0
>>> round(-3.5)
-4.0
>>> import math
>>> for i in range(6):
...     print round(math.pi, i)    #可以带第二个参数，表示小数点后保留的位数
... 
3.0
3.1
3.14
3.142
3.1416
3.14159

6.3 仅用于整数的函数

　　进制转换函数——hex()、oct()：

>>> hex(65535)  #将整数转换为十六进制并返回其字符串表示形式  
'0xffff'
>>> hex(255L)
'0xffL'
>>> oct(65535)  #八进制
'0177777'
>>> oct(255L)
'0377L'

　　ASCII转换函数——ord()、chr()、unichr()：

>>> ord('a')    #接受一个ASCII或Unicode字符（Python中为长为1的字符串），返回其ASCII或Unicode码值
97
>>> ord('0')
48
>>> chr(48)     #接受[0,255]内的整数，返回对应的ASCII字符
'0'
>>> chr(65)
'A'
>>> unichr(65)  #接受Unicode码值，返回对应的Unicode字符
u'A'

7 其他数字类型

7.1 布尔“数”

　　关于布尔值之前也提了不少，这里仅说一下自定义类及其对象的布尔值：

　　没有__nonzero__()方法的对象，其默认值是True。

>>> class myclass:
...     pass
... 
>>> mc = myclass()
>>> bool(myclass)
True
>>> bool(mc)    #没有__nonzero__()方法，默认为True
True

>>> class myclass:
...     def __nonzero__(self):    #重载__nonzero__()方法，使其返回False
...         return False
... 
>>> mc = myclass()
>>> bool(myclass)
True
>>> bool(mc)    #False
False

7.2 十进制浮点数

　　由于Python中浮点数遵循IEEE754规范，64bit中有52bit用于底，因此浮点数只有52位精度。会出现以下现象：

>>> 0.1
0.10000000000000001

　　要防止这种现象，需要使用Decimal类：

>>> from decimal import Decimal
>>> Decimal(0.1)    #参数为浮点数，导致错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib64/python2.6/decimal.py", line 649, in __new__
    "First convert the float to a string")
TypeError: Cannot convert float to Decimal.  First convert the float to a string

>>> Decimal('0.1')  #将参数转换为字符串表现形式
Decimal('0.1')
>>> print Decimal('0.1')
0.1
>>> print Decimal(str(0.1)) + Decimal(str(12.24))    #而且十进制浮点数 只能和 十进制浮点数进行运算
12.34

8 相关模块

　　Python标准库中几个专门用于处理数值类型对象的模块，具体请参阅这些模块的文献或在线文档：

decimal 　　#十进制浮点运算类Decimal 
array  　　 #高效数值数组（字符，整数，浮点数等等） 
math/cmath #标准C库数学运算函数。常规数学运算在match模块，复数运算在cmath模块 
operator   #数字运算符的函数实现。比如operator.sub(m,n)等价于m - n
random  　　#多种伪随机数生成器

　　关于random模块介绍几个常用函数：

>>> random.randrange(10)    #接受整数参数，和range()一样，只不过随机返回range([start,]stop[,step])中一个
5
>>> random.randint(1,100)   #接受整数参数，randint(low, high)，随机返回[low, high]中一个整数
15
>>> random.uniform(1,100)   #接受数值参数，返回[low, high]或[low, high)中的一个浮点数，具体范围视环境而定
48.019722125274484
>>> random.random()    #不接受参数，随机返回[0, 1)中一个浮点数
0.30147732406052019
>>> random.choice(range(10)) #随机返回序列中的一项
3

　　对于高级的数字科学计算应用，有两个著名的第三方包NumPy www.numpy.org 和SciPy www.scipy.org ，详细请访问网址。

 

练习题 

5-4 取余。判断给定年份是否是闰年。使用下面的公式：一个闰年就是指它可以被4整除，但不能被100整除，或者它既可以被400又可以被100整除。比如 1992，1996和2000年是闰年，但1967和1900则不是闰年。下一个是闰年的整世纪是2400年。

#!/usr/bin/env python

year = int( raw_input("Please input a year: ") )
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print 'leap year'
else:
    print 'nonleap year'

5-5 取余。取一个任意小于1美元的金额，然后计算可以换成最少多少枚硬币。硬币有1美分，5美分，10美分，25美分四种。1美元等于100美分。举例来说，0.76美元换算结果应该是3枚25美分，1枚1美分。类似76枚1美分，2枚25美分+2枚10美分+1枚5美分+1枚1美分这样的结果都是不符合要求的。 

#!/usr/bin/env Python

while True:
    your_money = float( raw_input("Please input your money: ") )
    if not (0 < your_money < 1):
        print 'Error, input like this: 0.xx'
    else:
        break

cents = int( your_money * 100 )

cent25 = cents / 25
cent10 = cents % 25 / 10
cent5  = cents % 25 % 10 / 5
cent1  = cents - cent25 * 25 - cent10 * 10 - cent5 * 5

coins  = cent25 + cent10 + cent5 + cent1

print 'your money can be changed to %d coins:' % coins
if cent25 > 0:    print '25 cents: %d' % cent25
if cent10 > 0:    print '10 cents: %d' % cent10
if cent5  > 0:    print ' 5 cents: %d' % cent5 
if cent1  > 0:    print ' 1 cents: %d' % cent1 

5-6 算术。写一个计算器程序 你的代码可以接受这样的表达式，两个操作数加一个运算符，N1 运算符 N2。其中N1和N2为整数或浮点数，运算符可以是+，-，*，/，%，**分别表示加法，减法，乘法，整数除，取余和幂运算。计算这个表达式的结果，然后显示出来。提示：可以使用字符串方法split()，但不可以使用内建函数eval()。

#!/usr/bin/env Python

exp = raw_input("Please input your expression: ")
exp = exp.split()

if '.' in exp[0]:
    num1 = float(exp[0])
else:
    num1 = int(exp[0])

if '.' in exp[2]:
    num2 = float(exp[2])
else:
    num2 = int(exp[2])

if   exp[1] == '+'  : print num1 +  num2
elif exp[1] == '-'  : print num1 -  num2
elif exp[1] == '*'  : print num1 *  num2
elif exp[1] == '/'  : print num1 /  num2
elif exp[1] == '%'  : print num1 %  num2
elif exp[1] == '**' : print num1 ** num2

5–15 最大公约数和最小公倍数。请计算两个整数的最大公约数和最小公倍数。 

#!/usr/bin/env Python

def GCD(num1, num2):
    if num1 < num2:
        num1, num2 = num2, num1
    while num2 != 0:
        num1, num2 = num2, num1 % num2
    return num1

num1 = int(raw_input("Please input the 1st num: "))
num2 = int(raw_input("Please input the 2nd num: "))
gcd  = GCD(num1, num2)

print 'GCD is %d' % gcd
print 'LCM is %d' % (num1 * num2 / gcd)

5-17 随机数。熟读随机数模块然后解下面的题：生成一个有N个元素的由随机数n组成的列表，其中N和n的范围为：(1 < N <= 100)，(0 <= n <= 2³¹ - 1)。然后再随机从这个列表中取M(1 <= M <= 100)个随机数出来，对它们排序，然后显示这个子集。

#!/usr/bin/env Python

import random

N = random.randint(2, 100)

list1 = []
list2 = []

for i in range(N):
    n = random.randint(0, (1 << 31) - 1)
    list1.append(n)

M = random.randint(1, N)

for i in range(M):
    idx = random.randint(0, N - 1)
    list2.append( list1[idx] )

list2.sort()
print list2