Python核心编程-第五章

摘要: 简述‘数字’的类型及其简单应用

5.1 数字简介

5.1.1 数值对象的创建

anInt = 1

5.1.2 数值对象的更新

重点：数值对象是不可变对象

我们说的更新其实就是创建了一个新的对象并把它赋值给了原先的变量

如下

Int = 1
Int = 1.5            #Int的值变为1.5，但是原先的数值1并没有被改变

5.1.3 数值对象的删除

数值对象没法删除，我们仅仅是不使用了而已。

如果真的删除，可以以下操作

Int = 1
del Int

但我们这样做也仅仅是删除了对象‘1’的引用（Int这个变量）而已，致使我们无法使用‘1’

5.2 整型

5.2.1 布尔型

该类型只有True和False两个值

5.2.2 标准整型

八进制整型以数字“0”开始，十六进制整型以“0X”或“0x”开始

如

0101 84 0x18 -0X92

注意：Python的标准整型类型等价于C语言的（有符号）长整型，其取值跟机器位数有关

5.2.3 长整型

在数值后面加个L，大写的最好，便于区分。

这点不用多说，因为下一小结会说到

5.2.4 整型和长整型的统一

如题，Python2.7已经体会不到两者的区别了

5.3 双精度浮点型

Python的浮点型类似于C的double型。

示例：

1.6 9.43e-23(9.43*10^-23) 6.002e10(6.002*10^10) 4.2E-10(4.2*10^-10)

5.4 复数

关于Python中复数的概念

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

复数由实数部分和虚数部分构成

表示虚数的语法： real+imagj

实数部分和虚数部分都是浮点数（存疑，2.7实部虚部可以是整形）

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

1.

>>> a = 1j
>>> b = 1 + 3j
>>> print a + b
(1+4j)

看到没有，虚数可以单独存在，在运行上述代码根本没有事

可以有 4j 这种实部为零的，也可以有虚部为零的 3+0j，其他的格式没有

特别注意：

>>> c = 3
>>> print a + c
(3 + 1j)                # c 虚部为零，但是没有用0j表示，这就说明这样是可以存在的，但是1j不能单独用j表示

内建属性
补充一下数学知识，我们说的实部或者虚部事实上没有j什么事

2+4j 实部是2，虚部是4

其属性如下

num.real 该复数的实部

num.imag 该复数的虚部

num.conjugate() 返回该复数的共轭复数

使用方法（很纳闷，为啥取共轭还要加个括号）

>>> a = -3.4 + 2.9j
>>> a.real
-3.4
>>> a.imag
2.9
>>> a.conjugate()
-3.4 - 2.9j

5.5 操作符

5.5.1 混合模式操作符

不同类型的数值相加有以下的原则：

整型转换为浮点型，非复数转换为复数

基本意思就是往长了的数型转换，整型 + 浮点型 = 浮点型； 整型 + 复数 = 复数； 浮点型 + 复数 = 复数

5.5.2 标准类型操作符

没什么需要过多了解的，就是第四章的哪些“==”“>=”“<=”“>”“<”“or”“and”"!"

5.5.3 算数操作符

1.除法


传统除法：舍去小数部分，返回一个整型；如果操作数是整形，取比商小的最大整型，就是地板除的做法；若操作数有一个是浮点,则执行真正的除法

>>> 1 / 2
0
>>> 1.0 / 2
0.5

真正的除法：就是实际数学运算的除法

>>>1 / 2
0.5

现阶段2.7是地板除，可以通过

>>> from __future__ import division

来实现真正的除法

地板除

//操作符强行地板除，不论是不是浮点（Python2中默认 / 地板除）

>>> 1.0/2
0.5
>>> 1.0//2
0

2.取余
整型的简单，就是余数

浮点型：x % y

结果就是 x - (math.floor(x/y)*y)

>>> 3.9 % 3
0.89999999999                # 3.9 - (（3.9 // 3）*3)=0.9，至于为啥显示0.899999，后面会讲到

复数：x % y

结果是 x-(math.floor((x/y).real))*y)

>>> (3 + 4j) % (1 + 1j)
1j                        #相除以后（复数相除是被除数除数都乘以除数的共轭），得（3+0j）,取实部3，乘以y得3+3j,相减得1j

3.幂运算
**

基本上要注意优先级

>>> -3 ** 2
-9                优先级高于左边负号
>>> 4.0 ** -1.0
0.25              优先级低于右边负号

5.5.4 位操作符（只适用于整型）

位运算符 功能
~num 单目运算，对数的每一位取反。结果为-（num + 1）
num1 << num2 num1 左移 num2 位
num1 >> num2 num1 右移 num2 位
num1 & num2 num1 与 num2 按位 与
num1 ^ num2 num1 异或 num2 (同零异一)
num1 | num2 num1 与 num2 按位 或

这个取反很有意思，需要记一下

5.6 内建函数与工厂函数

5.6.1 标准类型函数

包括cmp()、str()、type()，这个在第四章讲到过，就不罗嗦了

5.6.2 数字类型函数

1.转换工厂函数

工厂函数：就是指这些内建函数都是类对象，当调用他的时候，实际上是创建了一个类实例

int()、float()、complex()等可以用来强制转换数值类型的函数

>>> int(4.233)
4
>>> float(3)
3.0
>>> complex(1,4)
(1 + 4j)
>>> complex(4)
(4 + 0j)
>>> complex(0,4)
4j                            #没想到complex还能这么用

类（工厂函数） 操作
bool(obj) 返回obj对象的布尔值，也就是obj.__nonzero__()方法的返回值

int(obj, base=10) 返回一个字符串或数值对象的整数表示，base是进制的意思，默认是10

long(obj, base=10) 返回一个字符或数据对象的长整数表示

float(obj) 返回一个字符串或数据对象的浮点数表示

complex(str) orcomplex(real, imag=0.0) 返回一个字符串的复数表示，或者根据给定的实数（及一个可选的虚数部分）生成一个复数对象。

2. 功能函数
有5个运算内建函数

abs() 取绝对值，如果是复数则返回模值

coerce(n1,n2) 将n1和n2转换为同一类型，然后以元组形式返回

divmod(n1,n2) 返回n1除以n2的商和余数（这里的除是地板除），元组形式

pow(x,y,z = 1) 实现x**y%z,直接返回最终数值

round(flt,ndig = 1) 接收一个浮点值，进行四舍五入（真正的四舍五入），保存ndig个小数位

列举几个比较有代表性的例子：

>>> abs(3 + 4j)
5
>>> coerce(1.3 ,1+1j)
(1.3 + 0j,1 + 1j)
>>> divmod(2.5,10)
(0.0,2.5)
>>> pow(5,2,3)
1
>>> round(-3.5)
-4                            #这个四舍五入真的会5入！

int()、floor()、round()大对比

int()是直接截去小数部分（返回值整型）

floor()得到最接近原数但小于原数的整型（返回值浮点型）

round()得到四舍五入值

>>> int(-1.2)
-1.0
>>> floor(-1.2)            #看到没，“最接近且小于”的含义！
-2.0
>>> round(-1.2)
-1.0

5.6.3 仅用于整型的函数

1.进制转换函数

oct() 八进制 和 hex()十六进制

>>> hex(255)
'0xff'
>>> oct(255)
'0377'

2.ASCII转换函数
实现ASCII码（就是字符）和其序列值之间的转换

chr(num) 数字转成字符并且0<=num<=255

ord(chr) 字符转数字

unichr(num) 接受Unicode码值，返回对应的字符

>>> ord('a')
97
>>> chr(97)
'a'

5.7 其他数字类型

5.7.1 布尔“数”

布尔类型的主要概念：

（copy的，看看吧）

有两个永不改变的值 True 或 False。

布尔型是整型的子类，但是不能再被继承而生成它的子类。

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

对于值为零的任何数字或空集（空列表、空元组和空字典等）在 Python 中的布尔值都是 False。

在数学运算中，Boolean 值的 True 和 False 分别对应于 1 和 0。

以前返回整数的大部分标准库函数和内建布尔型函数现在返回布尔型。

True 和 False 现在都不是关键字，但是在 Python 将来的版本中会是。

>>> bool(1)
True
>>> bool(0)
False
>>> bool('0')            #这是个字符
True
>>> bool([])             #这是个空集

有个比较有意思的事情

>>> bar = True
>>> print bar + 2
3
>>> print '%s' % bar
True
>>> print '%d' % bar
1

另外，如果没有__nozero__()方法来特别说明，则默认是True

#没有__nonzero__()
>>> class C: pass
>>> c = C()
>>>
>>> bool(c) True
>>> bool(C) True
# 重载 __nonzero__() 使它返回 False
>>> class C:
... def __nonzero__(self):
... return False
...
>>> c = C()
>>> bool(c) False
>>> bool(C) True

5.7.2 十进制浮点型

跟文中说的不一样

文中有

>>> 0.1
0.100000000001

但是在2.7中是

>>>0.1
0.1

这个在2.7中没有限制，所以不做深入了解

但要记住的是，我们看到的数值 0.1 ，是用二进制表示的

额，实验了2.7发现好多问题：

>>> 1.1
1.1
>>> print 1.1
1.1
>>> 1.1 - 1
0.10000000009
>>>print 1.1 - 1
0.1
>>> from decimal import Decimal
>>> dec = Decimal(1.1)
>>> dec
Decimal('1.1000000000008881')    #太长了不写了，但是肯定不止这些
>>> print dec
1.1000000000008881                #和上面一样
>>> dec - 1
Decimal('0.1000000000008881')        #比上面短
>>> dec - Decimal('1')
Decimal('0.1000000000008881')        #看到没，我不知道如何解释

核心模块
随机数生成：

randint() 两个整数参数，返回二者之间的随机整数

randrange() 它接受和range()函数一样的参数 ， 随机返回

uniform() 几乎和 randint()一样， 不过它返回的是二者之间的一个浮点数(不包括范围上限)。

random() 类似 uniform() 只不过下限恒等于 0.0，上限恒等于 1.0

choice() 随机返回给定序列（关于序列，见第六章）的一个元素

使用方法

from random import randint