内置类型之真值测试、数字类型、布尔运算等(4) – Python语言(必读进阶学习教程)(参考资料)

整数类型的按位运算

按位运算仅对整数有意义。计算按位运算的结果，就好像用无穷多个符号位的二进制补码进行计算一样。

二进制按位运算的优先级都低于数值运算，高于比较; 一元操作~与其他一元数字操作具有相同的优先级（+和-）。

此表列出按升序排序的按位操作：

笔记：

1. 负移位计数是非法的并导致ValueError提升。
2. 左移n位相当于 没有溢出检查的乘法。pow(2, n)
3. 右移n位相当于没有溢出检查的除法。pow(2, n)
4. 在有限二进制补码表示（工作位宽或更大）中使用至少一个额外符号扩展位执行这些计算 足以得到与无限数量的符号位相同的结果。1 + max(x.bit_length(), y.bit_length())

整数类型的其他方法

int类型实现抽象基类。此外，它还提供了一些方法：numbers.Integral

int.bit_length( ) 

返回表示二进制整数所需的位数，不包括符号和前导零：

>>>
>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

更确切地说，如果x不为零，则x.bit_length()是唯一的正整数k这样。等价地，当小到足以具有正确的圆对数时，那么。如果为零，则返回。2**(k-1) <= abs(x) < 2**kabs(x)k = 1 + int(log(abs(x),2))xx.bit_length()0

相当于：

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

3.1版中的新功能。

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

返回表示整数的字节数组。

>>> (1024).to_bytes(2, byteorder='big') 
b'\x04\x00' 
>>> (1024).to_bytes(10, byteorder='big') 
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' 
>>> (-1024).to_bytes(10, byteorder='big', signed=True) 
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' 
>>> x = 1000 
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little') 
b'\xe8\x03'

整数用长度字节表示。OverflowError 如果整数不能用给定的字节数表示，则引发An 。

的字节顺序参数确定用于表示整数的字节顺序。如果字节顺序是"big"，最显著字节在字节数组的开始。如果字节顺序是"little"，最显著字节在字节数组的末尾。要请求主机系统的本机字节顺序，请使用sys.byteorder字节顺序值。

在签署参数确定补是否被用来表示整数。如果signed是False并且给出了一个负整数，OverflowError则引发a。signed的默认值 是False。

版本3.2中的新功能。

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

返回给定的字节数组表示的整数。

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

 

参数bytes必须是类字节对象或可迭代生成字节。

的字节顺序参数确定用于表示整数的字节顺序。如果字节顺序是"big"，最显著字节在字节数组的开始。如果字节顺序是"little"，最显著字节在字节数组的末尾。要请求主机系统的本机字节顺序，请使用sys.byteorder字节顺序值。

在签署参数指示补是否被用来表示整数。

版本3.2中的新功能。

Float上的其他方法

float类型实现抽象基类。float还有以下附加方法。numbers.Real

float.as_integer_ratio()

返回一对整数，其比率与原始浮点数完全相等，并带有正分母。提高 OverflowError无限和ValueErrorNaNs。

float.is_integer()

返回True如果浮子实例是有限的与积分值，并False以其他方式：

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

两种方法支持十六进制字符串的转换。由于Python的浮点数在内部存储为二进制数，因此将浮点数转换为十进制字符串或从 十进制字符串转换通常会导致小的舍入错误。相反，十六进制字符串允许精确表示和指定浮点数。这在调试和数值工作时非常有用。

float.hex()

将浮点数的表示形式返回为十六进制字符串。对于有限浮点数，此表示将始终包括前导0x和尾随p和指数。

classmethod float.fromhex(s)

返回由十六进制字符串s表示的float的类方法。字符串s可以具有前导和尾随空格。

注意，这float.hex()是一个实例方法， float.fromhex()而是一个类方法。

十六进制字符串采用以下形式：

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

其中，可选的sign由5任一+或-，integer 和fraction是十六进制数字串，以及exponent 是具有任选的前导符号十进制整数。大小写并不重要，并且整数或小数必须至少有一个十六进制数字。此语法类似于C99标准的6.4.4.2节中指定的语法，也类似于Java 1.5及更高版本中使用的语法。特别是，输出 float.hex()可用作C或Java代码中的十六进制浮点文字，并且由C的%a格式字符或Java 生成的十六进制字符串Double.toHexString被接受float.fromhex()。

注意，指数是用十进制而不是十六进制写的，并且它给出2的幂乘以系数。例如，十六进制字符串0x3.a7p10表示浮点数，或 ：

(3 + 10./16 + 7./16**2) * 2.0**103740.0
>>>
>>> float.fromhex('0x3.a7p10')
3740.0

应用反向转换以3740.0提供表示相同数字的不同十六进制字符串：

>>>
>>> float.hex(3740.0)
'0x1.d380000000000p+11'

哈希数值类型

对于数字x和y可能不同类型的，它是一个要求，只要（见 更多细节方法的文档）。为了便于实施和效率在各种的数字类型的（包括， ，和）Python的数字类型的散列是基于对于任何合理的数目来定义，因此，一个单一的数学函数将应用于的所有实例 和所有的有限的情况下，和中 和。本质上，此函数由固定素数的减少模数给出。Python 的值可以作为Python的属性使用 。hash(x) == hash(y)x ==y__hash__()intfloatdecimal.Decimalfractions.Fractionintfractions.Fractionfloatdecimal.DecimalPPPmodulussys.hash_info

以下是详细规则：

• 如果是非负有理数并且不能被整除，则定义为，其中给出模数的倒数。x = m / nnPhash(x)m * invmod(n,P) % Pinvmod(n, P)nP
• 如果是非负有理数并且可以被（但不是）整除，那么就没有逆模，并且上面的规则不适用; 在这种情况下，定义 为常量值。x = m / nnPmnPhash(x)sys.hash_info.inf
• 如果是负有理数定义 为。如果生成的哈希是，请将其替换为 。x = m / nhash(x)-hash(-x)-1-2
• 特定值sys.hash_info.inf，-sys.hash_info.inf 并sys.hash_info.nan用作正无穷大，负无穷大或分别为nans的散列值。（所有可清洗的nans都具有相同的哈希值。）
• 对于一个complex数字z，实部和虚部的哈希值通过计算，减少的模数组合， 以便它位于其中 。再次，如果结果是，它被替换为。hash(z.real) + sys.hash_info.imag *hash(z.imag)2**sys.hash_info.widthrange(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width -1))-1-2

为了澄清上述规则，这里有一些示例Python代码，相当于内置哈希，用于计算有理数的哈希float，或complex：

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