[PYTHON] 核心编程笔记之五-Python数字

yunvn

　　5.1 数字类型
　　创建数值对象和给变量赋值
　　anInt = 1
　　aLong = -9999999999L
　　aFloat = 3.1415926
　　aComplex = 1.23+4.56j
　　如何更新数字对象
　　变量像一个指针指向装变量值的盒子,对不可变类型来说,你无法改变盒子内容,但可以将指针指向一个新盒子,每次将另外的数字赋给变量时,实际上是创建了一个新的对象并把它赋给变量
　　anInt += 1
　　aFloat = 2.718281828
　　如何删除数字对象
　　del anInt
　　del aLong,aFloat,aComplex
　　5.2 整型
　　5.2.1 布尔型
　　5.2.2 标准整数类型
　　0101 84 -237 0x80 017 -680 -0x92
　　5.2.3 长整型
　　16384L -0x4E8L -2323124 045332423
　　29432432 0xDDWAFEGEGREHREHRERTJW -5432432L
　　注:用大写字母"L"表示长整型
　　>>> aLong = 99999999999l
　　>>> aLong
　　99999999999L
　　>>> print aLong
　　99999999999
　　5.3 双精度浮点数
　　0.0 -777. 1,6 -5.532423423 9.6e3 * 1.0
　　4.3e25 float(12) 4.2E-10 -90. -1.609E-19
　　5.4 复数
　　64.375+1j 4.23-8.5j 0.23-8.55j 1.23e-045+6.7e+089j
　　9.82432-8.342432J -.0224+0j
　　5.4.1复数的内建属性
　　属性描述
　　num.real该复数的实部
　　num num.imag该复数的虚数
　　num.conjugate()返回该复数的共轭复数
　　>>> aComplex = -8.333-1.47j
　　>>> aComplex
　　(-8.333-1.47j)
　　>>> aComplex.real
　　-8.333
　　>>> aComplex.imag
　　-1.47
　　>>> aComplex.conjugate()
　　(-8.333+1.47j)
　　5.5 运算符
　　5.5.1 混合模式运算符
　　>>> 1 + 4.5
　　5.5
　　5.5.2 标准类型运算符
　　>>> 5.2 ==5.2
　　True
　　>>> -719 >= 833
　　False
　　>>> 2 < 5 <9
　　True
　　>>> 77 > 66 == 66
　　True
　　>>> 0. < -90.4 < 55.3e2 != 3 <181
　　False
　　>>> (-1 < 1) or (1 < -1)
　　True
　　5.5.3 算数运算符
　　传统除法
　　>>> 1/2 # 地板除
　　0
　　>>> 1.0/2.0 # 真正除法
　　0.5
　　真正的除法
　　>>> from __future__ import division
　　>>> 1 / 2
　　0.5
　　>>> 1.0 / 2.0
　　0.5
　　地板除
　　>>> 1 // 2# 地板除,返回整数
　　0
　　>>> 1.0 // 2.0# 地板除,返回浮点数
　　0.0
　　>>> -1 // 2# 返回比 -0.5小的整数,也就是 -1
　　-1
　　取余
　　>>> 4%3
　　1
　　>>> 4%2
　　0
　　幂运算
　　>>> 3**2
　　9
　　>>> -3 ** 2
　　-9
　　>>> (-3) ** 2
　　9
　　>>> 4.0 ** -1.0
　　0.25
　　Python数值运算的例子:
　　>>> -442-77
　　-519
　　>>> 4 ** 3
　　64
　　>>> 4.2 ** 3.2
　　98.71831395268974
　　>>> 8/3
　　2.6666666666666665
　　>>> 8.0/3.0
　　2.6666666666666665
　　>>> 8%3
　　2
　　>>> (60. - 32.) * (5. /9.)
　　15.555555555555557
　　>>> 14 * 0x04
　　56
　　>>> 0170 / 4
　　30.0
　　>>> 0x80 + 0777
　　639
　　>>> 45L * 22L
　　990L
　　>>> 16399L + 0xA94E8L
　　709879L
　　>>> -2147483648L - 52147483648L
　　-54294967296L
　　>>> 64.375+1j + 4.23-8.5j
　　(68.605-7.5j)
　　>>> 0+1j ** 2
　　(-1+0j)
　　>>> 1+1j ** 2
　　0j
　　>>> (1+1j) ** 2
　　2j
　　5.5.4 *位运算符(只适用于整数)
　　位运算符功能
　　-num单目运算,对数的每一位去反,结果为
　　num1 << num2Num1 左移 num2位
　　num1 << num2Num1 右移 num2位
　　num1 & num2Num1 与 num2按位 与
　　num1 ^ num2Num1 异或 num2位
　　num1 | num2Num1 与 num2位按位 或
　　例:
　　>>> 30 & 45
　　12
　　>>> 30 | 45
　　63
　　>>> 45 & 60
　　44
　　>>> ~30
　　-31
　　>>> ~45
　　-46
　　>>> 45 << 1
　　90
　　>>> 60 >> 2
　　15
　　>>> 30 ^ 45
　　51
　　5.6 内建函数与工厂函数
　　5.6.1 标准类型函数
　　>>> cmp(-6,2)
　　-1
　　>>> cmp(-4.33333,-2.7118281828)
　　-1
　　>>> cmp(0xFF,255)
　　0
　　>>> str(0xFF)
　　'255'
　　>>> str(55.3e2)
　　'5530.0'
　　>>> type(0xff)
　　<type 'int'>
　　>>> type(9876543210L)
　　<type 'long'>
　　>>> type(2-1j)
　　<type 'complex'>
　　5.6.2 数字类型函数
　　内建函数示例:
　　>>> int(4.25)
　　4
　　>>>
　　>>> int(4.2555)
　　4
　　>>> long(42)
　　42L
　　>>> float(4)
　　4.0
　　>>> complex(4)
　　(4+0j)
　　>>> complex(2.4,-8)
　　(2.4-8j)
　　>>> complex(2.3e-10,45.3e4)
　　(2.3e-10+453000j)
　　数值工厂函数总结
　　类(工厂函数)操作
　　bool(obj) b返回obj对象的布尔值,也就是obj.__nonzero__()方法的返回值
　　int(obj,base=10)返回一个字符串或数值对象的整数表示,类似string.atoi();
　　long(obj,base=10)返回一个字符或数据对象的长整数表示,类似string.atol()
　　float(obj)返回一个字符串或数据对象的浮点数表示,类似string.atol()
　　complex(str) or
　　complex(real,imag=0.0)返回一个字符串的复数表示,或者根据给定的实数(及一个可选的虚数部分)生成一个复数对象
　　功能函数:
　　Python有五个运算内建函数用于数值运算: abs(),coerce(),divmod(),pow()和round()
　　abs()返回给定参数的绝对值
　　>>> abs(-1)
　　1
　　>>> abs(10.)
　　10.0
　　>>> abs(1.2-2.1j)
　　2.418677324489565
　　>>> abs(0.23-0.78)
　　0.55
　　函数coerce()返回一个包含类型转换完毕的两个数值元素的元祖
　　>>> coerce(1,2)
　　(1, 2)
　　>>> coerce(1.3,134L)
　　(1.3, 134.0)
　　>>> coerce(1,134L)
　　(1L, 134L)
　　>>> coerce(1j,134L)
　　(1j, (134+0j))
　　>>> coerce(1.23-41j,134L)
　　((1.23-41j), (134+0j))
　　divmod()会把除法和取余结合起来组成一个元祖
　　>>> divmod(10,3)
　　(3, 1)
　　>>> divmod(3,10)
　　(0, 3)
　　>>> divmod(10,2.5)
　　(4.0, 0.0)
　　>>> divmod(2.5,10)
　　(0.0, 2.5)
　　>>> divmod(2+1j,0.5-1j)
　　((-0+0j), (2+1j))
　　pow()和 ** 都可以进行指数运算
　　>>> pow(2,5)
　　32
　　>>> pow(5,2)
　　25
　　>>> pow(3.141592,2)
　　9.869600294464002
　　KeyboardInterrupt
　　>>> pow(1+1j,3)
　　(-2+2j)
　　round()对浮点数进行四舍五入,第二个参数表示精确到小数点多少位,没有表示精确到整数位
　　>>> round(3)
　　3.0
　　>>> round(3.45)
　　3.0
　　>>> round(3.499999999999)
　　3.0
　　>>> round(3.499999999999,1)
　　3.5
　　>>> import math
　　>>> for eachNum in range(10):
　　...   print round(math.pi,eachNum) #pi即为π
　　...
　　3.0
　　3.1
　　3.14
　　3.142
　　3.1416
　　3.14159
　　3.141593
　　3.1415927
　　3.14159265
　　3.141592654
　　>>> round(-3.5)
　　-4.0
　　>>> round(-3.4)
　　-3.0
　　>>> round(-3.49)
　　-3.0
　　>>> round(-3.49,1)
　　-3.5
　　注:
　　int() 直接截去小数部分(返回值为整数)
　　floor()得到最接近原数但小于原数的整数(返回浮点数)
　　round()得到最接近原数的整数(返回浮点数)\
　　>>> for eachNum in (.2,.7,1.2,1.7,-.7,-1.2,-1.7):
　　...   print "int(%.1f) \t %+.1f" % (eachNum,float(int(eachNum)))
　　...   print "floor(%.1f) \t %+.1f" % (eachNum,math.floor(eachNum))
　　...   print "round(%.1f) \t %+.1f" % (eachNum,round(eachNum))
　　...   print '-' * 20
　　...
　　int(0.2)        +0.0
　　floor(0.2)      +0.0
　　round(0.2)      +0.0
　　--------------------
　　int(0.7)        +0.0
　　floor(0.7)      +0.0
　　round(0.7)      +1.0
　　--------------------
　　int(1.2)        +1.0
　　floor(1.2)      +1.0
　　round(1.2)      +1.0
　　--------------------
　　int(1.7)        +1.0
　　floor(1.7)      +1.0
　　round(1.7)      +2.0
　　--------------------
　　int(-0.7)       +0.0
　　floor(-0.7)     -1.0
　　round(-0.7)     -1.0
　　--------------------
　　int(-1.2)       -1.0
　　floor(-1.2)     -2.0
　　round(-1.2)     -1.0
　　--------------------
　　int(-1.7)       -1.0
　　floor(-1.7)     -2.0
　　round(-1.7)     -2.0
　　--------------------
　　数值运算内建函数
　　函数功能
　　abs(num)返回num的绝对值
　　coerce将num1和num2转换成同一类型,然后以一个元祖的形式返回
　　divmod(num1,num2)除法-取余运算的结合,返回一个元祖(num1/num2,num1%num2),对浮点数和复数的商进行下舍入
　　(复数取实数部分的商)
　　pow(num1,num2,mod=1)取num1的num2次方,如果提供mod参数,则计算结果再对mod进行取余运算
　　round(flt,ndig=0)接受一个浮点数fit并对其四舍五入,白村ndig位小数,若不提供ndig参数,则默认小数点后0位
　　round()仅用于浮点数.
　　5.6.3 仅用于整数的函数
　　进制转换函数
　　>>> hex(255)
　　'0xff'
　　>>> hex(4324324)
　　'0x41fbe4'
　　>>> hex(432432*2)
　　'0xd3260'
　　>>> oct(255)
　　'0377'
　　>>> oct(4324324)
　　'020375744'
　　>>> oct(432432*2)
　　'03231140'
　　ASCII转换函数
　　>>> ord('a')
　　97
　　>>> ord('A')
　　65
　　>>> ord('O')
　　79
　　>>> chr(97)
　　'a'
　　>>> chr(65L)
　　'A'
　　>>> chr(48)
　　'0'
　　仅适用于整数的内建函数
　　函数操作
　　hex(num)将数字转化成16进制并以字符串输出
　　oct(num)将数字转换成8进制并以字符串输出
　　chr(num)将ASCII值的数字转换成ASCII字符 范围0<=num<=255
　　ord(chr)接受一个ASCII或Unicode字符(长度为1的字符串),返回相应的ASCII或Unicode值
　　unichr(num)接受Unicode码值,范围其对应的Unicode字符,所接受的码值范围依赖于你的Python是构建于USC-2还是UCS-4
　　5.7.1 布尔"数"
　　永恒不变的两个值 True或False
　　布尔型是整型的子类,但不能再被继承二生成它的子类
　　没有__nonzero__()方法的对象默认是True
　　对于值为零的任何数字或空集(空列表,空元祖和空字典等)在Python中布尔值都为False
　　在数字运算中,布尔值的True和False分别对应1和0
　　#intro
　　>>> bool(1)
　　True
　　>>> bool(True)
　　True
　　>>> bool(0)
　　False
　　>>> bool('1')
　　True
　　>>> bool('0')
　　True
　　>>> bool([])
　　False
　　>>> bool((1,))
　　True
　　# 使用布尔值
　　>>> foo = 42
　　>>> bar = foo < 100
　　>>> bar
　　True
　　>>> print bar + 100
　　101
　　>>> print '%s' % bar
　　True
　　>>> print '%d' % bar
　　1
　　# 无 __nonzero__()

　　>>>>　　...
　　>>> c = C()
　　>>> bool(c)
　　True
　　>>> bool(C)
　　True
　　慎用:
　　>>> True,False = False,True
　　>>> bool(True)
　　False
　　>>> bool(False)
　　True
　　5.7.2 十进制浮点数
　　5.8 相关模块
　　模块介绍
　　decimal十进制浮点运算类Decimal
　　array高效数值数组(字符,整数,浮点数等等)
　　math/cmath标准C库数学运算函数,常规数学运算在match模块,复数运算在cmath模块
　　operator数学运算符的函数实现,比如 tor.sub(m,n)等价于 m - n
　　random多种伪随机数生成器
　　核心模块:ramdom
　　两个整数参数,返回两者之间的随机整数:
　　randrange()随机返回range([start,]stop[,step])结果的一项
　　uniform()几乎和randint()一样,不过它返回时两者之间的一个浮点数
　　random()类似uniform() 不过下限为0.0 上限为1.0
　　choice()随机返回给定序列的一个元素