Python回顾与整理3:数字

简介:

0.说明

     

        数字用的次数是否多主要是看需求,如果是做自动化运维平台开发,比如做一个自动监控的系统,那么你肯定需要收集一定量的数据,然后再对这些数据做一定的处理,那么这时候,你就一定需要用得上数字的。当然,我这里所说的要不要用数字,指的是,你是否需要对你的数据做一定的处理。




1.数字简介


        数字是不可更改类型,也就是说变更数字的值会生成新的对象。

(1)创建数值对象并用其赋值(数字对象)

1
2
>>>anInt  =  1
>>>aComplex  =  1.23 + 4.56j


(2)更新数字对象

        因为数字对象是不可变对象,所以所谓的更新指的是:删除该变量原来指向的数字对象,同时生成一个新的数字对象并让该变量指向它。

1
2
3
4
5
6
7
8
>>> anInt  =  1
>>>  id (anInt)
35934552
>>> anInt  + =  1
>>> anInt
2
>>>  id (anInt)
35934528


(3)删除数字对象

        只要数字对象的引用计数器为零,那么该数字对象本身就会被删除。

1
2
3
4
5
>>>  del  anInt
>>>  id (anInt)
Traceback (most recent call last):
File  "<stdin>" , line  1 in  <module>
NameError: name  'anInt'  is  not  defined




2.整型

        

        Python的整型分为几种:布尔型 标准整型  长整型

(1)布尔型

        取值范围只有True和False。


(2)标准整型

        相当于是C的(有符号)长整型,八进制数以数字“0”开始,十六进制数以“0x”或“0X”开头


(3)长整型

        末尾加上字母“L”或“l”,但建议写成大写


        需要注意的是,在现在,Python的标准整型和长整型其实区分已经不明确了,已经不需要考虑是使用标准整型和长整型了,因为一旦有数据溢出的情况,Python将会自动为我们转换为长整型,即整型和长整型会慢慢统一。




3.双精度浮点数


        Python中的浮点型类似C语言中的double类型,是双精度浮点型(即长浮点数),每个浮点型占8个字节,即64位,完全遵守IEEE745标准浮点数规范。(关于长浮点数的表示方法以及在计算机中的处理,可以参考计算机组成原理的相关书籍)

        下面是一些合法的表示方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>>  0.0
0.0
>>>  - 777.
- 777.0
>>>  96e3  *  1.0
96000.0
>>>  4.3e25
4.3e + 25
>>>  9.384e - 23
9.384e - 23
>>>  float ( 12 )
12.0
>>>  4.2E - 10
4.2e - 10




4.复数


        一个复数是一对有序浮点型(x, y),表示为x + yj,其中x是实数部分,y是虚数部分。有下面的注意点:

  • 虚数不能单独存在,它们总是和一个值为0.0的实数部分一起来构成一个复数

  • 复数由实数部分和虚数部分组成

  • 表示虚数的语法:x + yj

  • 实数部分和虚数部分都是浮点型

  • 虚数部分必须有后缀j或J

        根据上面的要点,要写出合法的复数就很简单了。


(1)复数的内建属性

        主要是复数的实部,虚部以及它的共轭复数,如下:

1
2
3
4
5
6
7
>>> aComplex  =  1.3  +  3j
>>> aComplex.real
1.3
>>> aComplex.imag
3.0
>>> aComplex.conjugate()
( 1.3 - 3j )




5.操作符


        Python操作符主要是指三种:标准类型操作符 数值操作符和专门的整型操作符。


(1)混合模式操作符

        主要是指,当两种类型不同的数值进行运算时,Python会根据相应的规则自动帮我们作类型的强制转换,而这些规则如下(其实就是coerce()方法的描述,后面会有介绍):

  • 如果有一个操作数是复数,另一个操作数则被转换为复数

  • 否则,如果有一个操作数是浮点型,另一个操作数被转换为浮点型

  • 否则,如果有一个操作数是长整型,另一个操作数被转换为长整型

  • 否则,两者必须都是普通整型,无须作类型转换


(2)标准类型操作符

        在《Python回顾与整理2:Python对象》中,介绍了Python标准类型的操作符,这些标准类型操作符对数值类型也是适用的,举例如下:

1
2
3
4
5
6
>>>  1  = =  1
True
>>>  1  5  9
True
>>>  1  5  and  5  9
True


(3)算术操作符

        这类操作符在许多编程语言中都有,如加 减 乘 除 取余和幂运算等等。部分介绍如下:

(a)除法

  • 传统除法

1
2
3
4
5
6
>>>  3  /  2
1
>>>  1  /  2
0
>>>  1.0  /  2.0
0.5
  • 真正的除法

1
2
3
4
5
>>>  from  __future__  import  division
>>>  1  /  2
0.5
>>>  1.0  /  2.0
0.5

        需要注意的是,__future__是Python提供新特性测试的一个包,对于可能会在以后支持的特性,Python都会将其归入这个包以供测试。

  • 地板除

1
2
3
4
5
6
>>>  1  / /  2
0
>>>  1.0  / /  2.0
0.0
>>>  3  / /  2
1

        在Python3+版本中,除法已经是真正的除法了,而不是默认的地板除,当然,如果确定是要使用地板除的,只需要使用“//”就可以了。

(b)取余

        比较简单:

1
2
>>>  5  %  2
1

(c)幂运算

        主要是幂运算操作符**,其优先级可描述如下:

  • 比其左侧操作数的一元操作符优先级高

  • 比其右侧操作数的一元操作符优先级低

例子如下:

1
2
3
4
5
6
>>>  3  * *  2
9
>>>  - 3  * *  2
- 9
>>>  4.0  * *  - 1.0
0.25


(4)位操作符(只适用于整型)

        Python整型支持标准位运算,主要是:

  • 取反(~)

1
2
>>> ~ 2
- 3

        即结果为-(num + 1),从二进制角度的解释如下:

2的二进制为:00000010

按位取反后为:11111101

        因为Python中的数默认是有符号数,因此计算机在处理11111101时,认为它是一个负数(最高位为符号位),而负数在计算机中是以补码的形式表示的,因此,在输出11111101的十进制数之前,计算机将其转换为原码,即除符号位外其余各位取反加1,所以最后得到的是10000011,也就是-3了。(关于相关的理论知识,可以参考计算机组成原理的相关内容)

  • 按位与(&)

1
2
>>>  2  3
2

        2为0000|0010,3为0000|0011,按位与即为0000|0010,也就是2了。

  • 或(|)

1
2
>>>  2  3
3

        2为0000|0010,3为0000|0011,按位或即为0000|0011,也就是3了。

  • 异或(^)

1
2
>>>  2  3
1

        2为0000|0010,3为0000|0011,按位或即为0000|0001,也就是1了。

  • 左移(<<)

1
2
>>>  2  <<  1
4

        2的二进制表示为0000|0010,左移一位即为0000|0100,也就是4了。

  • 右移(>>)

1
2
>>>  2  >>  1
1

        2的二进制表示为0000|0010,右移一位即为0000|0001,也就是1了。




6.内建函数与工厂函数


(1)标准类型函数

        在《Python回顾与整理2:Python对象》中,介绍了Python标准类型的内建函数,这些标准类型的内建函数对数值类型也是适用的,举例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>>  cmp ( 1 3 )
- 1
>>>  cmp ( 0xff 255 )
0
>>>  str ( 0xff )
'255'
>>>  str ( 55.3e2 )
'5530.0'
>>>  type ( 0xFF )
< type  'int' >
>>>  type ( 314L )
< type  'long' >
>>>  type ( 2 - 1j )
< type  'complex' >


(2)数字类型函数

        Python数字类型函数主要执行两个方面的功能:

  • 用于数字类型转换(工厂函数)

  • 用于执行一些常用运算(内建函数)

(a)转换工厂函数

        int(),long(),float()和complex()用于将其他数值类型转换为相应的数值类型。

        需要注意的是,在Python2.2以前,这些转换函数只是作为Python的内建函数使用,但在之后,由于Python的类和类型进行了统一,所以这些内建函数实为工厂函数(在《Python回顾与整理2:Python对象》中介绍过,即这些转换函数都是类对象,调用它们实际上是生成了该类的一个实例,这点尤其需要注意):

1
2
3
4
>>>  type ( int )
< type  'type' >
>>>  type ( long )
< type  'type' >

        分别介绍如下:

  • int(obj, base=10):将其他类型数值转换为int类型数值或将数值字符串转换为int类型数值

    base为进制转换参数,如果是数字类型之间的转换,则不需要提供这个参数,否则会引发异常:

1
2
>>>  int ( 3.0 )
3

        如果是对字符串进行转换,则可以提供进制参数,表示要转换的字符串原来的进制,默认base为10:

1
2
3
4
5
6
>>>  int ( '123' )
123
>>>  int ( '123' 8 )
83
>>>  int ( '123' 16 )
291

        当然也可以指定为0,说明把原来的字符串数作为一个整型(跟base=10时一样):

1
2
>>>  int ( '123' 0 )
123
  • long(obj, base=10):将其他类型数值转换为long类型数值或将数值字符串转换为long类型数值,与int()的使用方法一样

  • float(obj):将其他类型数值转换为float类型数值或将数值字符串转换为float类型数值

1
2
3
4
>>>  float ( 123 )
123.0
>>>  float ( '123' )
123.0
  • complex(str)或complex(real, imag=0.0):将complex数值字符串转换为complex类型数值

1
2
3
4
>>>  complex ( 2.3e - 10 45.3e4 )
>>>  complex ( '2+3j' )
( 2 + 3j )
( 2.3e - 10 + 453000j )

(b)功能函数

        即主要用来对数值进行运算的函数,包括:abs(), coerce, divmod(), pow()和round(),这些函数为内建函数:

1
2
3
4
>>>  type ( abs )
< type  'builtin_function_or_method' >
>>>  type ( coerce )
< type  'builtin_function_or_method' >

        分别介绍如下:

  • abs(num):返回给定参数的绝对值,如果是参数为复数,则返回复数的模长

1
2
3
4
5
6
>>>  abs ( - 1 )
1
>>>  abs ( 10.0 )
10.0
>>>  abs ( 3 + 4j )
5.0
  • coerce(num1, num2):将num1和num2转换为同一类型,然后以一个元组的形式返回

1
2
3
4
5
6
7
8
>>>  coerce ( 3 3 + 2j )
(( 3 + 0j ), ( 3 + 2j ))
>>>  coerce ( 3.0 2 )
( 3.0 2.0 )
>>>  coerce ( 3 2L )
( 3L 2L )
>>>  coerce ( 3 2 )
( 3 2 )
  • divmod(num1, num2):接收两个参数,返回一个包含商和余数的元组

1
2
3
4
5
6
>>>  divmod ( 10 3 )
( 3 1 )
>>>  divmod ( 10 2.5 )
( 4.0 0.0 )
>>>  divmod ( 2 + 1j 0.5 - 1j )
(( - 0 + 0j ), ( 2 + 1j ))
  • pow(num1, num2, mod=1):取num1的num2次方,如果提供mod参数,则计算结果再对mod取余

1
2
3
4
>>>  pow ( 2 5 )
32
>>>  pow ( 2 5 15 )
2
  • round(flt, ndig=1):接受一个浮点型flt并对其四舍五入,保存ndig位小数,若不提供ndig参数,则默认小数点后0位

1
2
3
4
5
6
>>>  round ( 3.499 )
3.0
>>>  round ( 3.599 )
4.0
>>>  round ( 3.49999 1 )
3.5


        提及round(),来区分下面的三个函数:

  • int():直接去掉小数部分,结果为整型

  • math.floor():得到最接近原数但又小于原数的整型(返回值为浮点型)

  • round():四舍五入

        可以举下面的例子来作区分:        

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
>>>  from  math  import  floor
>>>  def  compare(num):
...   print  'int(%.1f)\t%+.1f'  %  (num,  int (num))
...   print  'floor(%.1f)\t%+.1f'  %  (num, floor(num))
...   print  'round(%.1f)\t%+.1f'  %  (num,  round (num))
...
>>> compare( 0.2 )
int ( 0.2 )     + 0.0
floor( 0.2 )   + 0.0
round ( 0.2 )   + 0.0
>>> compare( 0.7 )
int ( 0.7 )     + 0.0
floor( 0.7 )   + 0.0
round ( 0.7 )   + 1.0
>>> compare( 1.2 )
int ( 1.2 )     + 1.0
floor( 1.2 )   + 1.0
round ( 1.2 )   + 1.0
>>> compare( 1.7 )
int ( 1.7 )     + 1.0
floor( 1.7 )   + 1.0
round ( 1.7 )   + 2.0
>>> compare( - 0.2 )
int ( - 0.2 )    + 0.0
floor( - 0.2 - 1.0
round ( - 0.2 - 0.0
>>> compare( - 0.7 )
int ( - 0.7 )    + 0.0
floor( - 0.7 - 1.0
round ( - 0.7 - 1.0
>>> compare( - 1.2 )
int ( - 1.2 )    - 1.0
floor( - 1.2 - 2.0
round ( - 1.2 - 1.0
>>> compare( - 1.7 )
int ( - 1.7 )    - 1.0
floor( - 1.7 - 2.0
round ( - 1.7 - 2.0

        这样比较之后,它们之间的区别就非常明显了。


(3)仅用于整型的函数

        主要有两类,一类用于进制转换,另一类用于ASCII转换。需要注意的是,这里的整形包括标准整型和长整型。

(a)进制转换函数

        主要是下面的两个函数:

  • oct():将数值转换为八进制数,返回值为字符串

  • hex():将数值转换为十六进制数,返回值为字符串

        如下:

1
2
3
4
5
6
7
8
9
>>>  hex ( 255 )
'0xff'
>>>  hex ( 3893 )
'0xf35'
>>>
>>>  oct ( 255 )
'0377'
>>>  oct ( 3893 )
'07465'

(b)ASCII转换函数

        主要是下面的两个函数:

  • chr():接受一个单字节整型值(0~255),返回一个字符串(其实是一个字符,只是在Python中并没有“字符数据类型”)

  • ord():接受一个ASCII范围内的字符,返回其对应的整型值

  • unichr():接受Unicode码值,返回其对应的Unicode字符

    如下:

1
2
3
4
5
6
7
8
9
>>>  chr ( 65 )
'A'
>>>
>>>  ord ( 'A' )
65
>>>
>>>  unichr ( 1725 )
u '\u06bd'
>>>  print  unichr ( 1725 )




7.其他数字类型


(1)布尔“数”

        布尔类型只有两个值:True和False,实际上它是整型的子类,只是它不能再被继承而生成它的子类,其它的注意点如下:

  • 没有__nonzero__()方法的对象的布尔值默认是True

  • 值为零的任何数字或空集(空列表 空元组和空字典等)在Python中的布尔值都是False

        下面举几个例子:

1
2
3
4
5
6
>>>  bool ( 1 )
True
>>>  bool ( 3 )
True
>>>  bool ([])
False

        对于对象的__nonzero__()方法,可见下面的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#对象无__nonzero__方法的情况
>>>  class  C:  pass
...
>>> c  =  C()
>>>  bool (c)
True
 
#重载__nonzero__方法,使它返回False
>>>  class  C:
...   def  __nonzero__( self ):
...     return  False
...
>>> c  =  C()
>>>  bool (c)
False
>>>  bool (C)
True


(2)十进制浮点数

        该问题在Python后续版本中已经解决,如下:

1
2
>>>  0.1
0.1

        当然,如果你在安卓手机上使用QPython,会发现该问题依然存在。




8.相关模块


        比较著名的是Numeric(NumPy)和SciPy,这两个包都是第三方扩展包。

        其它的数字类型相关模块为:decimal array  math/cmath  operator  random,需要用到时,查阅相关资料即可,这里主要介绍一下random模块。

        random模块中最常用的函数如下:

  • randint(num1, num2):返回num1和num2之间的随机整数(能取到下限和上限)

1
2
3
4
5
6
7
8
>>> random.randint( 1 2 )
2
>>> random.randint( 1 2 )
2
>>> random.randint( 1 2 )
2
>>> random.randint( 1 2 )
1
  • randrange(num1, num2):返回值为range(num1, num2)之间的数,即不能取到上限

1
2
3
4
5
6
7
>>> random.randrange( 1 2 )
1
>>> random.randrange( 1 2 )
1
>>> random.randrange( 1 2 )
1
……

        结果总是为1。

  • uniform(num1, num2):几乎和randint()一样,不过它返回的是二者之间的一个浮点型(不包括范围上限)

1
2
3
4
5
6
>>> random.uniform( 1 2 )
1.2845602051034062
>>> random.uniform( 1 2 )
1.0178567905561313
>>> random.uniform( 1 2 )
1.8440532614481977
  • random():类似于uniform,不过它不接收参数,并且下限恒等于0.0,上限恒等于1.0

1
2
3
4
5
6
>>> random.random()
0.04360809434722357
>>> random.random()
0.7386566820354784
>>> random.random()
0.8564193451546396
  • choice():随机返回给定序列的一个元素

1
2
3
4
5
6
7
8
9
10
11
12
>>> random.choice( 'xpleaf' )
'l'
>>> random.choice( 'xpleaf' )
'f'
>>> random.choice( 'xpleaf' )
'f'
>>> random.choice([ 1 2 3 ])
1
>>> random.choice([ 1 2 3 ])
1
>>> random.choice([ 1 2 3 ])
3


        OK,数字类型的总结就到这里了,虽然实际当中你可能并不需要用到这么多的特性,不过学习过之后,你会对Python有更深入的了解。

相关文章
|
Python
【python实战】top1 数字组合——有四个数字:1、2、3、4,能组成多少个互不相同且无重复数字的三位数?各是多少?
【python实战】top1 数字组合——有四个数字:1、2、3、4,能组成多少个互不相同且无重复数字的三位数?各是多少?
585 0
【python实战】top1 数字组合——有四个数字:1、2、3、4,能组成多少个互不相同且无重复数字的三位数?各是多少?
|
索引 Python 容器
【Python基础速览1】变量 | 输出和输入 | 数字类型 | 字符串类型(二)
最近得了急性胃肠炎(草),所以咕咕咕了好几天,等过段时间一定好好肝文。这次就发一发前几年学Python时自己记的笔记吧,还是和之前一样,适合用来复习过一遍基础,并不适合从零开始。
162 0
【Python基础速览1】变量 | 输出和输入 | 数字类型 | 字符串类型(二)
|
Java C语言 Python
【Python基础速览1】变量 | 输出和输入 | 数字类型 | 字符串类型(一)
最近得了急性胃肠炎(草),所以咕咕咕了好几天,等过段时间一定好好肝文。这次就发一发前几年学Python时自己记的笔记吧,还是和之前一样,适合用来复习过一遍基础,并不适合从零开始。
124 0
【Python基础速览1】变量 | 输出和输入 | 数字类型 | 字符串类型(一)
|
机器学习/深度学习 Python
「Python」数字推盘游戏-pygame
本文是课本上的pygame小项目,是一个游戏设计—数字推盘
326 0
「Python」数字推盘游戏-pygame
|
设计模式 编解码 前端开发
「Python」数字推盘游戏
前面知识只是简单的对pygame进行参数的介绍,后面还需要用到MVC设计模式,在这里不多做说明,建议直接观察源代码
572 0
「Python」数字推盘游戏
|
开发工具 git Python
python:变量是储存数字的盒子吗???
在我们在使用乘法时,Git这个实例会抛出异常,但是仍然输出了git的id所以表面了在求积之前其实会创建一个新的Git实例,但是不可否认的是肯定不会创建变量y,因为在右边进行求值时抛出了异常
python:变量是储存数字的盒子吗???
|
存储 Python
Python 编程 | 连载 02 - 数字与字符串
Python 编程 | 连载 02 - 数字与字符串
Python 编程 | 连载 02 - 数字与字符串
|
存储 Python
Python 数据类型和数字(3)
Python 数据类型和数字(3)
121 0
Python 数据类型和数字(3)
|
人工智能 Python
Python 数字类型
Python 中数字类型有4种,分别是整型int、浮点型float、复数型comlex、布尔型bool。本文为大家介绍整型、浮点型两种类型。
79 0
Python 数字类型
Python 求数字开方
Python 求数字开方
下一篇
无影云桌面