python - 官方文档 笔记(4) 内置类型 数字类型

数字类型—int,float,complex

存在三种不同的数字类型:整数,浮点数和复数。此外，布尔值属于整数的子类型。整数具有无限的精度。浮点数通常使用C中的double来实现；有关你的程序运行所在机器上浮点数的精度和内部表示法可在sys.float_info中查看。复数包含实部和虚部，分别以一个浮点数表示。要从一个复数z中提取这两个部分，可使用z.real和z.imag。（标准库包含附加的数字类型，如表示有理数的fractions.Fraction以及以用户定制精度表示浮点数的decimal.Decimal。）

数字是由数字字面值或内置函数与运算符的结果来创建的。不带修饰的整数字面值（包括十六进制、八进制和二进制数）会生成整数。包含小数点或幂运算符（math.pow()）的数字字面值会生成浮点数。在数字字面值末尾加上’j’或’J’会生成虚数（实部为零的复数），你可以将其与整数或浮点数相加来得到具有实部和虚部的复数。

Python完全支持混合算术：当二进制算术运算符具有不同数值类型的操作数时，具有“较窄”类型的操作数将扩展为另一个，即整数比浮点数窄，比浮点数窄。 比较不同类型的数字的行为就像比较这些数字的确切值一样。2构造函数int（），float（）和complex（）可用于生成特定类型的数字

所有数字类型（复数除外）都支持下列运算

所有numbers.Real类型(实数：int和float)还包括下列运算:

更多请查询help(numbers.Real)

整数类型的按位运算

按位运算只对整数有意义。计算按位运算的结果，就相当于使用无穷多个二进制符号位对二的补码执行操作。
二进制按位运算的优先级全都低于数字运算，但又高于比较运算；一元运算~具有与其他一元算术运算(+and-)相同的优先级。此表格是以优先级升序排序的按位运算列表:

1
20 0B 00 00 00 00 00 00 10 8D 0F AE FD 7F 00 00
01 00 00 00 00 00 00 00 01 00 00 00
~1：-2
4C .00 00 .00 00 .00 00 .00 10 8D 0F AE FD 7F 00 00
FF FF FF FF FF FF FF FF 02 00 00 00

？？？？

其实python的运算机制和存储机制不同，运算是按C来的，存储是独立的，python的正负数就如上：
1、头部 2、类型
3、正负 4、非符号位整数部分

C:int 16位
　１： ００００００００　０００００００１
～１： １１１１１１１１　１１１１１１１０

解码~1：
－ ００００００００　０００００００１
＋１ ００００００００　００００００１０
－ ２
－２

数字的层次

class numbers.Complex
内置在类型complex里的子类描述了复数和它的运算操作。
这些操作有：转化至complex和bool，real、imag、+、-、*、/、abs()、conjugate()、==和!=。所有的异常，-和!=，都是抽象的。
real
抽象的。得到该数字的实数部分。
imag
抽象的。得到该数字的虚数部分。
abstractmethod conjugate()
抽象的。返回共轭复数。例如(1+3j).conjugate() == (1-3j)。

class numbers.Real
相对于Complex，Real加入了只有实数才能进行的操作。
简单的说，它们是：转化至float，math.trunc()、round()、math.floor()、math.ceil()、divmod()、//、%、<、<=、>、和>=。
实数同样默认支持complex()、real、imag和conjugate()。

class numbers.Rational
子类型Real并加入numerator和denominator两种属性，这两种属性应该属于最低的级别。加入后，这默认支持float()。
numerator摘要。
denominator摘要。

class numbers.Integral
子类型Rational加上转化至int。默认支持float()、numerator和denominator。
在**中加入抽象方法和比特字符串的操作：<<、>>、&、^、|、~。

整数类型的附加方法

classnumbers.Integral子类型Rational加上转化至int。默认支持float()、numerator和denominator。在**中加入抽象方法和比特字符串的操作：<<、>>、&、^、|、~。
int类型实现了numbers.Integralabstract base class。此外，它还提供了其他几个方法:
int.bit_length()：返回整数部分二进制长度

def bit_length(num):
    numb=bin(num)
    if numb[0]=="-":
        numv=numb[3:]
    else:numv=numb[2:]
    return len(numv)

num=int(input("输入一个整数："))

print(bit_length(num))

print(num.bit_length())

int.to_bytes(length,byteorder,*,signed=False)
整数会使用length个字节来表示。如果整数不能用给定的字节数来表示则会引发OverflowError。
byteorder参数确定用于表示整数的字节顺序。如果byteorder为"big"，则最高位字节放在字节数组的开头。如果byteorder为"little"，则最高位字节放在字节数组的末尾。要请求主机系统上的原生字节顺序，请使用sys.byteorder作为字节顺序值。
sys.byteorder本地字节顺序的指示符。在大端序（最高有效位优先）操作系统上值为’big’，在小端序（最低有效位优先）操作系统上为’little’。
主机字节序和网络字节序（大端序，小端序，网络序）
signed参数确定是否使用二的补码来表示整数。如果signed为False并且给出的是负整数，则会引发OverflowError。signed的默认值为False。

classmethodint.from_bytes(bytes,byteorder,*,signed=False)
返回由给定字节数组所表示的整数。

bytes参数必须为一个bytes-like object或是生成字节的可迭代对象。
byteorder参数确定用于表示整数的字节顺序。如果byteorder为"big"，则最高位字节放在字节数组的开头。如果byteorder为"little"，则最高位字节放在字节数组的末尾。要请求主机系统上的原生字节顺序，请使用sys.byteorder作为字节顺序值。
signed参数指明是否使用二的补码来表示整数。

int.as_integer_ratio()
返回一对整数，其比率正好等于原整数并且分母为正数。整数的比率总是用这个整数本身作为分子，1作为分母。

In [64]: int.as_integer_ratio(11)
Out[64]: (11, 1)

In [65]: type(int.as_integer_ratio(11))
Out[65]: tuple

浮点类型的附加方法

float类型实现了numbers.Realabstract base class。float还具有以下附加方法。

float.as_integer_ratio()
返回一对整数，其比率正好等于原浮点数并且分母为正数。无穷大会引发OverflowError而NaN则会引发ValueError。

In [1]: 1.25.as_integer_ratio()
Out[1]: (5, 4)

float.is_integer()
如果float实例可用有限位整数表示则返回True，否则返回False:

In [3]: (-2.0).is_integer()
Out[3]: True

In [4]: 32.5.is_integer()
Out[4]: False

In [9]: (-32.5).is_integer()
Out[9]: False

In [6]: -2.0.is_integer() #错误演示，-(2.0.is_integer())
Out[6]: -1

In [8]: -32.5.is_integer()
Out[8]: 0

两个方法均支持与十六进制数字符串之间的转换。由于Python浮点数在内部存储为二进制数，因此浮点数与十进制数字符串之间的转换往往会导致微小的舍入错误。而十六进制数字符串却允许精确地表示和描述浮点数。这在进行调试和数值工作时非常有用。

float.hex()
以十六进制字符串的形式返回一个浮点数表示。对于有限浮点数，这种表示法将总是包含前导的0x和尾随的p加指数。

In [12]: 0.999999.hex()
Out[12]: '0x1.ffffde7210be9p-1'

classmethodfloat.fromhex(“str”)
返回以十六进制字符串str表示的浮点数的类方法。字符串s可以带有前导和尾随的空格。请注意float.hex()是实例方法，而float.fromhex()是类方法。

In [16]: float.fromhex('0x1.ffffde7210be9p-1')
Out[16]: 0.999999

In [20]: (-0.999999).hex()
Out[20]: '-0x1.ffffde7210be9p-1'

十六进制字符串采用的形式为:

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

请注意exponent是十进制数而非十六进制数，它给出要与系数相乘的2的幂次。例如，十六进制数字符串0x3.a7p10表示浮点数(3 + 10./16 + 7./162) * 2.010即3740.0:

In [21]: float.fromhex('0x3.a7p10')
Out[21]: 3740.0

对3740.0应用反向转换会得到另一个代表相同数值的十六进制数字符串:

In [22]: float.hex(3740.0)
Out[22]: '0x1.d380000000000p+11'

数字类型的哈希运算

对于可能为不同类型的数字x和y，要求x == y时必定hash(x) == hash(y)(详情参见__hash__()方法的文档)。为了便于在各种数字类型(包括int,float,decimal.Decimal和fractions.Fraction)上实现并保证效率，Python对数字类型的哈希运算是基于为任意有理数定义统一的数学函数，因此该运算对int和fractions.Fraction的全部实例，以及float和decimal.Decimal的全部有限实例均可用。从本质上说，此函数是通过以一个固定质数P进行P降模给出的。P的值在Python中可以sys.hash_info的modulus属性的形式被访问。

In [24]: import sys

In [25]: sys.hash_info
Out[25]: sys.hash_info(width=64, modulus=2305843009213693951, inf=314159, nan=0, imag=1000003, algorithm='siphash24', hash_bits=64, seed_bits=128, cutoff=0)

CPython implementation detail:目前所用的质数设定，在C long为32位的机器上P = 231 - 1而在C long为64位的机器上P = 261 - 1。详细规则如下所述:
•如果x = m / n是一个非负的有理数且n不可被P整除，则定义hash(x)为m * invmod(n,P) % P，其中invmod(n, P)是对n模P取反。
•如果x = m / n是一个非负的有理数且n可被P整除（但m不能）则n不能对P降模，以上规则不适用；在此情况下则定义hash(x)为常数值sys.hash_info.inf。
•如果x = m / n是一个负的有理数则定义hash(x)为-hash(-x)。如果结果哈希值为-1则将其替换为-2。
•特定值sys.hash_info.inf,-sys.hash_info.inf和sys.hash_info.nan被用作正无穷、负无穷和空值（所分别对应的）哈希值。（所有可哈希的空值都具有相同的哈希值。）
•对于一个complex值z，会通过计算hash(z.real) + sys.hash_info.imag * hash(z.imag)将实部和虚部的哈希值结合起来，并进行降模2sys.hash_info.width以使其处于range(-2(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))范围之内。同样地，如果结果为-1则将其替换为-2。
为了阐明上述规则，这里有一些等价于内置哈希算法的Python代码示例，可用于计算有理数、float或complex的哈希值:

importsys,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_value=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_value=(abs(m)%P)*pow(n, P-2, P)%P
	if m<0:
		hash_value=-hash_value
	if hash_value==-1:
		hash_value=-2
	return hash_value
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_value=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_value=(hash_value&(M-1))-(hash_value&M)
	if hash_value==-1:
		hash_value=-2
	return hash_value