python2：数字数字的基本操作整型的位运算整型附加方法float附加方法哈希

81 阅读 0 评论 54 点赞

我是靠谱客的博主冷艳小懒虫，最近开发中收集的这篇文章主要介绍python2：数字数字的基本操作整型的位运算整型附加方法float附加方法哈希，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

python支持3种不同的数字类型：整型、浮点型和复数，布尔类型可以看作整型的子类型。python中的浮点型对应C语言中的double，可以通过sys.float_info来查看精度。

数字的基本操作

python中的数字都支持下面的操作：
   1、x + y：x加y；
   2、x - y：x减y；
   3、x * y：x和y的积；
   4、x / y：x和y的商；
   5、x // y：x和y的商的下限，即取整；
   6、x % y：x/y的余；
   7、abs(x)：x为整型和浮点型，返回x的绝对值；x为复数型，返回x的magnitude（注）；
   8、int(x)：将x转换到整型；
   9、float(x)：将x转换到浮点型；
   10、complex(re, im)：得到实部为re，虚部为im的复数；
   11、c.conjugate()：返回复数c的共轭复数；
   12、divmod(x, y)：返回对(x // y, x % y)；
   13、pow(x, y)：x的y次方；
   14、x ** y：同pow(x, y)，x的y次方。
对数字的操作也可以使用math和cmath模块（后面介绍）。

注：

magnitude的计算规则如下：
1）实数的magnitude就是该实数的正平方根。2的magnitude就是2，-3的magnitude就是3；
2）复数的magnitude是该复数与共轭复数的乘积的正平方根。比如z=3-2j，则magnitude为(3-2j)*(3+2j)的正平方根，也就是9+4＝13的正平方根。

整型的位运算

位运算只能用于整型数据，下面是python中的位运算：
   1、x | y：按位或；
   2、x ^ y：按位异或；
   3、x & y：按位与；
   4、x << y：左移；
   5、x >> y：右移；
   6、~x：取反。

整型附加方法

整型实现了numbers.Integral抽象基础类，在此基础上，新增了下面的方法：

int.bit_length()

返回整数的二进制的bit位数，例如：
>>> a = 8
>>> bin(a)
'0b1000'
>>> a.bit_length()
4

int.to_bytes(length, byteorder, *, signed=False)

将整数转换为字节数组表示，参数说明如下；
   length：数组的长度，如果整数转换出的字节数组长度超过了该长度，则产生OverflowError；
   byteorder：字节序；值为"big"或者"little"，"big"表示最有意义的字节放在字节数组的开头，"little"表示最有意义的字节放在字节数组的结尾。sys.byteorder保存了主机系统的字节序；
   signed：确定是否使用补码来表示整数，如果值为false，并且是负数，则产生OverflowError。默认值False。
例如

>>> (1024).to_bytes(2, byteorder='big')
b'x04x00'
>>> (1024).to_bytes(10, byteorder='big')
b'x00x00x00x00x00x00x00x00x04x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'xffxffxffxffxffxffxffxffxfcx00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'xe8x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

将字节数组转换为整数，参数如下：
   bytes：字节数组或者是一个iterable；
   byteorder：同上；
   signed：同上。
例如：

>>> int.from_bytes(b'x00x10', byteorder='big')
16
>>> int.from_bytes(b'x00x10', byteorder='little')
4096
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

float附加方法

float实现了numbers.Real抽象基础类，并带有如下的额外方法：

float.as_integer_ratio()

将浮点数表示为两个整数的商。无限则抛出OverflowError，NaNs则抛出ValueError。
例如：

>>> a = 1.5
>>> a.as_integer_ratio()
(3, 2)

float.is_integer()

如果float可以转化为整数，则返回True，否则返回False。
例如：

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

float.hex()

返回浮点数的hexadecimal字符串（注）表示，该字符串始终以0x开头，p结尾，并带有一个指数。
例如

>>> a = 1.234
>>> a.hex()
'0x1.3be76c8b43958p+0'

classmethod float.fromhex(s)

将hexadecimal字符串s转换为float，s的开头和结尾允许存在空格。

注

一个hexadecimal字符串的格式为：

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

    sign：可选，+后者-；
   integer，fraction：16进制数字的字符串；
   exponent：十进制数，可带上一个sign作为开头，表示系数为2的exponent次方。
下面是一个例子：
0x3.a7p10表示浮点数：(3 + 10./16 + 7./16**2) * 2.0**10，计算结果为3740.0。

哈希

对于数字x和y，可能是不同的类型，但如果x==y，则要求hash(x) == hash(y)（__hash__()方法文档中有更详细的介绍）。python中提供了一个专门的函数为所有的数字类型计算哈希值。本质上，函数使用了一个固定的质数P，通过和P模运算来计算哈希值。P的值保存在sys.hash_info的modulus属性中。

CPython实现细节
当前，质数的值在32位的机器上是P = 2**32 - 1，在64位的机器上是P = 2**61 - 1。
下面是具体的规则：
   1）如果x = m / n是一个非负的有理数，并且n不整除P，定义hash(x)作为m * invmod(n, P) % P，其中invmod(n, P)表示n mod P的逆；
   2）如果x = m / n是一个非负的有理数，并且n整除P（但是m不），定义hash(x)为常量值sys.hash_info.inf；
   3）如果x = m / n是一个负的有理数，定义hash(x)作为-hash(-x)，如果结果为-1，则修改结果为-2；
   4）特殊值sys.hash_info.inf、-sys.hash_info.inf被用于正无穷大和负无穷大的哈希值，sys.hash_info.nan被用于nan（not a number）的哈希值；
   5）对于复数z，哈希值为hash(z.real) + sys.hash_info.imag * hash(z.imag)，并模运算2**sys.hash_info.width确保值在range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))内。如果结果是-1，则修改为-1。
下面是用于阐述上面逻辑的python代码的例子：

import sys, math
def hash_fraction(m, n):
"""Compute the hash of a rational number m / n.
Assumes m and n are integers, with n positive.
Equivalent to hash(fractions.Fraction(m, n)).
"""
P = sys.hash_info.modulus
# Remove common factors of P.
(Unnecessary if m and n already coprime.)
while m % P == n % P == 0:
m, n = m // P, n // P
if n % P == 0:
hash_ = sys.hash_info.inf
else:
# Fermat's Little Theorem: pow(n, P-1, P) is 1, so
# pow(n, P-2, P) gives the inverse of n modulo P.
hash_ = (abs(m) % P) * pow(n, P - 2, P) % P
if m < 0:
hash_ = -hash_
if hash_ == -1:
hash_ = -2
return hash_
def hash_float(x):
"""Compute the hash of a float x."""
if math.isnan(x):
return sys.hash_info.nan
elif math.isinf(x):
return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
else:
return hash_fraction(*x.as_integer_ratio())
def hash_complex(z):
"""Compute the hash of a complex number z."""
hash_ = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
# do a signed reduction modulo 2**sys.hash_info.width
M = 2**(sys.hash_info.width - 1)
hash_ = (hash_ & (M - 1)) - (hash & M)
if hash_ == -1:
hash_ == -2
return hash_