Python基本语法_基本数据类型_数值型详解

目录

• 目录
• 软件环境
• Python变量调用的过程
• 数值型
  • 删除一个数值类型对象
  • 布尔型 Bool
  • 标准整型 Int
  • 长整型
    • 双精度浮点型 Float
    • 复数
• 数值类型对象的内建功能函数
  • absNumber 求Number的绝对值
  • coercex y 将x y转换为同一种数值类型
  • divmodx y 除法-取余运算的结合
  • pow 指数运算或将结果取余
  • round 浮点型的四舍五入运算和求精度
  • 仅用于整型对象的函数
• 数值型相关模块推荐

软件环境

• 系统
  • CentOS 7
• 软件
  
  • Python 2.7.5
  • IPython 5.0.0

Python变量调用的过程

In [44]: anInt = 1

In [45]: anInt
Out[45]: 1

1. 通过变量名 anInt 得到数据对象的引用值 id(anInt) (即得到数据对象在内存中的索引地址)
2. 再通过 id(anInt) 得到数据对象在内存中存放的的值 1
3. 最终将变量 anInt 的值 1 调用出来。

注：步骤1. 2.对程序员而言是透明的。

数值型

• 数值型
  • 布尔型 Bool
  • 标准整型 Integral
  • 长整形
  • 浮点型 Float
  • 复数

数值型数据类型，又称之为数字型。他们适用于各类操作符(EG. 算术/移位/逻辑/…)和用于处理数字的内建函数(EG. abs()/pow()/round()/divmod()/…)。

数值型是一种不可变类型，也就是说改变一个数值型变量的值会生成一个新的数据对象。当然，这个过程对用程序员而言是透明的，但是理解不可变类型的原理，可以更深入的理解Python的赋值实现。

不可变类型：在Python中，变量就像是一个指针。它指向装着变量值(数据对象)的盒子(数据对象占用的内存空间)。对于不可变类型对象来说，我们无法改变盒子的内容，但可以将指针指向另外一个盒子。每次将另外的数字赋给变量时，实际上是创建了一个新的数据对象并将指针重新指向这个新的数据对象。

删除一个数值类型对象

在Python中，我们无法真正的删除一个数值类型对象，但是我们可以不再使用它。——使用del语句来删除数值类型对象的引用。删除数值型对象的引用之后，我们就不能再使用这个引用(变量名)了，除非你再给它赋一个新的值，否则会触发NameError。

其本质是：在Python中，所有类型的数据对象都应该存在一个与之对应的引用(变量名)，倘若这个引用没有对应任何的数据对象时，Python的垃圾回收机制就会自动的将这个引用回收。从而使一个引用失效并节省内存空间。

语法：del variableName

布尔型 Bool

布尔型数据对象的取值范围只有两个值：True | False

在Python中所有存在于具有判断语义的语句中(EG. if/while/elif)的表达式的最终结果都可以用布尔值来表示，这是由类中的_nonzero()函数决定的。

类的nonzero()函数用于将类转换为布尔类型(EG. bool(ClassName))。通常在用类进行判断和将类转换成布尔类型时调用。比如语句if A(): print 'foo'中就会调用A().__nonzero__()的返回值来进行判断。下面这个程序应该能帮助你理解nonzero()的作用:

class A:

    def __nonzero__(self):           #重载了 __nonzero__(self) 函数
        print 'A._nonzero__()'
        return True

if A():                        #隐式类型转换 bool(A())，相当于a = A(); a.__nonzero__();返回为True
    print 'A is not zero'
else:
    print 'A is zero'

print bool(A())

OUTPUT:

A._nonzero__()
A is not zero
A._nonzero__()
True

• 所有存在于具有判断语义的语句中(EG. if/while/elif)的表达式的最终都会隐式的执行Bool类型转换，EG. bool(表达式结果)

• bool()的本质是调用了对象所属类中的__nonzero__()函数，而且只要对象的值不为Null，那么__nonzero__() == True，反正为False。

即：表达式的最终结果要么为True，要么为False。也正因如此，表达式常用于符合判断语义的语句中。

注意：创建布尔值类型变量时，首字母要大写。

标准整型 Int

之所以称之为标准整型，是因为除此之外Python还具有长整型。

标准整型占用的位数：

1. 在32为OS平台上使用32位编译器的话，Int占用32位，取值范围是-2**31 ~ 2**31-1

2. 在64位OS平台上使用64位编译器的话，Int占用64位，取值范围是-2**63 ~ 2**63-1

标准整型Int是一种不可变类型：

In [9]: num = 1

In [10]: num = 2

注意：num = 1; num = 2 两个语句中并不是指的同一个数据对象。第一条语句中的num指向数据对象的Value为 1 ，此时num的引用为数据对象在内存中存储位置的索引地址；第二条句子中的num则表示Value为 2 的数据对象在内存中存储位置的索引地址。

在上面的两次赋值过程中，1、2 两个Vlaue对应的数据对象在内存中并没有任何的改变。本质上只是改变了变量 num 的引用(所指向的内存地址)。所以说Int类型是一种不可变类型(因为数据对象没有改变)。Int类型数据对象的值在内存中并不会发生改变，但可以改变变量的引用。

长整型

Python的长整型与C/C++等编译型语言的长整型有本质的区别，因为Python长整型的取值范围不是固定的，它仅仅与你的PC支持的(虚拟)内存大小有关。这样的话，Python能够轻松的表达一个很大的整型。但是就目前的情况来看，标准整型和长整型有了合并的趋势。

在Python 2.2之前，标准整型数据对象超出了取值范围时会出现溢出ERROR，现在如果还出现溢出的话会被Python解析器自动的被捕获并隐式的将标准整型转换为长整型对象。

在一个整型数字后面加L|l标识一个长整型的数值类型对象。

In [3]: aLong = -999999999999999999999L

In [4]: type(aLong)
Out[4]: long

双精度浮点型 Float

双精度浮点型，简称浮点型，类似C中的Double Float。浮点型数据类型对象占用64位内存空间，有十进制(.)和科学记数法(e)两种表示方式。

In [51]: floatTest
Out[51]: 3.141592

In [52]: floatTest = 3.14159299999999999999999999999999999999999

In [53]: floatTest
Out[53]: 3.141593

上面的例子可以看出Python中float类型的数据同样有着存储限制(8Byte)。

复数

Python还支持复数数据类型，一个实数和一个虚数的组合构成一个复数。一个复数是一对有序浮点型(x,y)，表示为 x + yj，其中x为实数部分，y为虚数部分。

注意：实数部分和虚数部分都是浮点型。

In [48]: pulralTest = 3+6j

In [49]: pulralTest
Out[49]: (3+6j)

数值类型对象的内建功能函数

下列介绍的所有函数都是数值型对象都能够使用的内建功能函数

abs(Number) 求Number的绝对值

abs(…)

abs(number) -> number

Return the absolute value of the argument.

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

In [6]: abs(-1)
Out[6]: 1

In [7]: abs(10.)
Out[7]: 10.0

In [8]: abs(0.23 - 0.78)
Out[8]: 0.55

coerce(x, y) 将x, y转换为同一种数值类型

coerce(…)

coerce(x, y) -> (x1, y1)

Return a tuple consisting of the two numeric arguments converted to a common type, using the same rules as used by arithmetic operations. If coercion is not possible, raise TypeError.

将x, y转换为同一种数值类型：

如果有一个操作数是复数， 另一个操作数被转换为复数。

否则，如果有一个操作数是浮点数， 另一个操作数被转换为浮点数。

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

否则，两者必然都是普通整数，无须类型转换 。

>>> coerce(1.23-41j, 134)
((1.23-41j), (134+0j)) 

>>> coerce(1j, 134L)
(1j, (134+0j))

>>> coerce(1.3, 134L)
(1.3, 134.0)

>>> coerce(1, 134L)
(1L, 134L)

>>> coerce(1, 2)
(1, 2)

divmod(x, y) 除法-取余运算的结合

divmod(…)

divmod(x, y) -> (quotient, remainder)

Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.

divmod()内建函数将除法和取余运算结合起来，返回一个包含了商和余数的元组；

对于整型而言，divmod()返回值是地板除和取余操作的结果。

对于浮点型而言，返回的商部分是math.floor(num1/num2)

对于复数而言，返回的商部分是ath.floor((num1/num2).real)

>>> 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))

地板除 // ：//除法不管操作数是什么数值类型，其得到的商总会舍去小数部分，并取数字序列中比真正的商小且最接近的值。

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

pow() 指数运算，或将结果取余

pow(…)

pow(x, y[, z]) -> number

With two arguments, equivalent to x**y. With three arguments,

equivalent to (x**y) % z, but may be more efficient (e.g. for longs).

pow()内建函数和( )操作符，都能够进行指数运算。但是pow()还附加了一个取余参数，来进行取余运算：**

EG. pow(2,5,3) ==> 2 ** 5 % 3

而且pow(2,5,3)的效率要高于pow(2,5) % 3。这个特性常用于密码运算。

round() 浮点型的四舍五入运算和求精度

round(…)

round(number[, ndigits]) -> floating point number

Round a number to a given precision in decimal digits (default 0 digits).

This always returns a floating point number. Precision may be negative.

rouund()内建函数提供了一个可断的[, ndigits]参数，如果不传递这个参数，则函数返回与number参数最接近的浮点型对象。如果传递了这个参数，则返回指定number参数精度的浮点型值：

注意：rount()内建函数是按照四舍五入的规则进行取整(但返回值仍是浮点型对象)

In [10]: round(3.45)
Out[10]: 3.0

In [11]: round(-3.5)
Out[11]: -4.0

In [12]: round(-3.4)
Out[12]: -3.0

In [13]: round(3.499999999999,1)
Out[13]: 3.5

In [14]: round(3.499999999999,0)
Out[14]: 3.0

int()/math.floor()/round() 之间的区别：

1. int():直接截去小数部分(返回整型对象)

2. floor():得到最接近原数但会小于原数的整数(返回值为浮点型对象)

3. round():得到最接近原数的整数(返回浮点型对象)

EXAMPLE:

In [19]: import math

In [20]: for eachNum in (.2, .7, 1.2, 1.7, -.2, -.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.2)   +0.0
floor(-0.2) -1.0
round(-0.2) -0.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
--------------------

仅用于整型对象的函数

进制转换函数

八进制：oct()

十六进制：hex()

ASCII转换函数

chr()：接收一个整型值，返回一个其值对应的字符。

In [22]: chr(97)
Out[22]: 'a'

ord(): 接收一个字符，返回其对应的整型值。

In [23]: ord('a')
Out[23]: 97

数值型相关模块推荐

• 对高级的数字科学计算应用来说，你会对下面两个第三方包感兴趣

  • NumPy
  • SciPy

• 模块

  • devimal — 十进制浮点运算类
  • array — 高效数值数组
  • math/cmath — 标准C库数学运算函数
  • random — 多种伪随机数生成器 * 常用