目录
软件环境
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 = 1In [45]: anInt
Out[45]: 1

通过变量名 anInt 得到数据对象的引用值 id(anInt) (即得到数据对象在内存中的索引地址)
再通过 id(anInt) 得到数据对象在内存中存放的的值 1
最终将变量 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 Trueif A():                        #隐式类型转换 bool(A())，相当于a = A(); a.__nonzero__();返回为Trueprint '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 = 1In [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 = -999999999999999999999LIn [4]: type(aLong)
Out[4]: long

双精度浮点型 Float

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

In [51]: floatTest
Out[51]: 3.141592In [52]: floatTest = 3.14159299999999999999999999999999999999999In [53]: floatTest
Out[53]: 3.141593

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

复数

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

In [48]: pulralTest = 3+6jIn [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]: 1In [7]: abs(10.)
Out[7]: 10.0In [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.0In [11]: round(-3.5)
Out[11]: -4.0In [12]: round(-3.4)
Out[12]: -3.0In [13]: round(3.499999999999,1)
Out[13]: 3.5In [14]: round(3.499999999999,0)
Out[14]: 3.0

int()/math.floor()/round() 之间的区别：
1. int():直接截去小数部分(返回整型对象)
2. floor():得到最接近原数但会小于原数的整数(返回值为浮点型对象)
3. round():得到最接近原数的整数(返回浮点型对象)

EXAMPLE:

In [19]: import mathIn [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 — 多种伪随机数生成器 * 常用

Python基本语法_基本数据类型_数值型详解相关推荐

Python数据类型——数值型详解
上一篇文章:Python的变量和数据类型用Python画的滑稽脸这是我之前用Python的 turtle库画的一个滑稽脸的视频,如果想要源码的话可以看我之前的博客: 如何用Python画QQ表情 ...
python数组相减_对Python 中矩阵或者数组相减的法则详解
对Python 中矩阵或者数组相减的法则详解最近在做编程练习,发现有些结果的值与答案相差较大,通过分析比较得出结论,大概过程如下: 定义了一个计算损失的函数: def error(yhat,labe ...
python 生成器装饰器_对Python生成器、装饰器、递归的使用详解
1.Python生成器表达式 1).Python生成器表达式语法格式: (expr for iter_var in iterable) (expr for iter_var in iterable ...
pythondifflib详解_用python标准库difflib比较两份文件的异同详解
[需求背景] 有时候我们要对比两份配置文件是不是一样,或者比较两个文本是否异样,可以使用linux命令行工具diff a_file b_file,但是输出的结果读起来不是很友好.这时候使用python ...
python os模块安装方法_基于python中pygame模块的Linux下安装过程(详解)
一.使用pip安装Python包大多数较新的Python版本都自带pip,因此首先可检查系统是否已经安装了pip.在Python3中,pip有时被称为pip3. 1.在Linux和OS X系统中检查 ...
python二元多次函数拟合_对python实现二维函数高次拟合的示例详解
在参加"数据挖掘"比赛中遇到了关于函数高次拟合的问题,然后就整理了一下源码,以便后期的学习与改进. 在本次"数据挖掘"比赛中感觉收获最大的还是对于神经网络的认识 ...
python telnet线程锁_对python使用telnet实现弱密码登录的方法详解
系统环境: 64位win7企业版 python2.7.10 2016.08.16修改内容: 1)read_until()函数是可以设置timeout的,之前不能获取到password之后的返回是因为调 ...
百家号 python高手养成_【一点资讯】Python使用PyQt5进行图形界面GUI编程之详解QWidget类的坐标体系 www.yidianzixun.com...
Python使用PyQt5进行图形界面GUI编程之详解QWidget类的坐标体系上篇内容,我们详细介绍了使用PyCharm中LiveTemplate功能快速输入一个GUI应用框架的办法.(参见学会这 ...
python url解码_对python中url参数编码与解码的实例详解
一.简介在python中url,对于中文等非ascii码字符,需要进行参数的编码与解码. 二.关键代码 1.url编码对字符串编码用urllib.parse包下的quote(string, saf ...

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

目录