Todos los tipos se pueden comparar, detectar valores lógicos, convertir cadenas y todos los tipos de datos pueden realizar operaciones matemáticas.
Detección de valor lógico
Se puede probar cualquier tipo de datos u objeto para determinar su valor lógico, y se considera un valor verdadero por defecto, a menos que el objeto o su clase redefinan el método bool () y devuelvan False o el objeto defina el método len () y devuelva cero.
Los siguientes son los objetos que se consideran valores falsos durante la detección lógica:
. Constantes definidas como valores falsos:None 和 False
. Cero de cualquier tipo numérico:0，0.0，0j,Decimal(0),Fraction(0,1)
. Secuencias vacías y conjuntos multinomiales:''，()，{}，set(),range(0)
Operación bool
Las operaciones bool incluyen and、or、notno> y> o en orden de prioridad
| Cálculo | resultado | Anotación |
|---|---|---|
| xoy | Si x es falso, devuelve y; de lo contrario, devuelve x | o es un operador de cortocircuito, el segundo parámetro se evaluará solo cuando el primer parámetro sea un valor falso |
| X y Y | Si x es falso, devuelve x, de lo contrario devuelve y | y también es un operador de cortocircuito El segundo parámetro se evaluará solo cuando el primer parámetro sea verdadero. |
| no x | Si x es falso, devuelve True; de lo contrario, devuelve False | La precedencia es menor que la de los operadores no booleanos, por lo not a == bque se interpretará como not (a==b)y a == not bprovocará errores de sintaxis. |
Operación de comparación
Hay ocho operadores de comparación en Python, con la misma precedencia, pero todos tienen mayor precedencia que las operaciones booleanas, y los operadores de comparación se pueden conectar arbitrariamente en serie. Por ejemplo, x<y<=zequivale a la x< y and y <=zdiferencia de que la primera y solo se evalúa una vez y la segunda dos veces, lo mismo es que no se evaluará z cuando el resultado de x <y sea falso.
Los ocho operadores de comparación son los siguientes:
| Operador | sentido |
|---|---|
| < | Menos que |
| <= | Menos que o igual a |
| > | mas que el |
| > = | mayor o igual a |
| == | igual |
| ! = | no igual a |
| es | ID de objeto |
| no es | Identificación de objetos negativos |
Puntos a tener en cuenta en las operaciones de comparación
. Diferentes números y objetos de diferentes tipos nunca son iguales cuando se comparan
. El tipo de función solo admite la comparación de formularios simplificada
. <, <=,>,> = operador al comparar números complejos y otros tipos numéricos, o cuando dos objetos tienen tipos diferentes que no se pueden comparar, o en otras situaciones donde el orden no está definido, todo lo anterior producirá TypeErroeexcepciones
. Las instancias de diferentes clases de identificación no son iguales a menos que se defina el método eq ()
. Las instancias de clase no se pueden ordenar con la misma clase u otras instancias u otros tipos de objetos, a menos que (), le (), gt (), ge () estén definidos
. is Y is notno se puede personalizar, se puede aplicar a cualquiera de los dos objetos sin lanzar una excepción.
. in Y not in , los ocho tipos de operadores de comparación anteriores tienen la misma prioridad, pero solo admiten el método Iterable (iterables) o los implementos contienen el método Type ()
Operaciones numéricas
Todos los tipos numéricos, excepto los tipos de números complejos, admiten las siguientes operaciones. La prioridad de todas las operaciones numéricas es mayor que la de las operaciones de comparación. Las siguientes están organizadas en orden ascendente de prioridad :
| Cálculo | sentido |
|---|---|
| + | Suma de dos números |
| - | Diferencia entre dos números |
| $ \ veces $ | Producto de dos números |
| / | Dividir dos números, el resultado se devuelve al cociente. |
| // | Dividir dos números, el resultado devuelve el cociente. |
| % | Divide dos números y toma el resto |
| -X | x negado |
| + x | x positivo |
| abs (x) | valor absoluto de x |
| int (x) | Convertir x en entero |
| flotar (x) | Convertir x en punto flotante |
| complejo (re, im) | Un número complejo con parte real y parte imaginaria im, el valor predeterminado es 0 |
| c.conjugar () | Conjugado de número complejo c |
| divmod(x,y) | Ejecute x // yx% y para obtener el cociente y el resto después de que x se divide por y |
| pow(x,y) | x elevado a y |
| x **y | También representa x elevado a y |
| invmod(x,y) | 对x模y取反 |
数字运算注意点：
. / 除法运算返回的永远是一个浮点数
.// 整除结果值是一个整数，但结果的类型不一定是int。 运算结果永远向负无穷方向舍入， 1//2 为0, (-1)//2 为-1，1//(-2)为-1,(-1)//(-2)为0。
. % 不能用于复数
. int() 若从浮点数转换为整数会被舍入或被截断，原因在前面文章数字类型中提到过，因为二进制浮点数问题
数字类型还能进行数学函数运算，具体会在后面math和cmath模块讲到。
整数类型按位运算
按位运算只对整数有意义，按位运算优先级低于数字运算，高于比较运算，但一元运算~与其它一元算术运算符优先级相同。
| 运算 | 含义 | 说明 | |
|---|---|---|---|
| x\ | y | x和y按位或 | |
| x^y | x和y按位异或 | ||
| x&y | x和y按位与 | ||
| x<<n | x左移n位 | 负的移位会引发ValueError，左移n位等价于不带溢出检测的乘以pow(2,n) | |
| x>>n | x右移n位 | 负的移位同样会引发ValueErroe，右移n位等价于不带溢出检测的除以pow(2,n) | |
| ~x | x按位取反 |
数字类型的哈希运算
不同数字类型的两个数，要做== 比较运算时，必须转成哈希值，即hash(x)==hash(y)。为便于在各种数字类型上实现并保证效率，Python对数字类型的哈希运算是基于任意有理数定义统一的数学函数，本质上hash()是通过以一个固定质数P进行P降模。P的值在 Python 中可以 sys.hash_info 的 modulus 属性的形式被访问。
CPython implementation detail: 所用质数设定，在 C long 为 32 位的机器上 P = 2**31 - 1 而在 C long 为 64 位的机器上 P = 2**61 - 1
运算规则如下：
- 如果
x = m / n是一个非负比例数，且n不能被P整除，则定义hash(x)为m * invmod(n, P) % 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)将实部和虚部的哈希值结合起来，并进行降模2**sys.hash_info.width以使其处于range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))范围之内。 同样地，如果结果为-1则将其替换为-2
为了更好的理解运算规则，用代码实现如下:
对分数求哈希值：
>>> import sys,math
>>> def hash_fraction(m,n):
'''计算比例数m/n的哈希值，m和n为整数，n为正数'''
P = sys.hash_info.modulus
#去掉P的公因数，除非m和n互质
while m%P == n%P ==0:
m,n = m//P, n//P
#如果n能被P整除，hash值为固定值
if n % P == 0:
hash_value = sys.hash_info.inf
else:
#如果n不能被P整除，则对P进行降模处理
hash_value = (abs(m)%P)*pow(n,P-2,P)%P
#判断m是否是负数，对负数求hash
if m < 0:
hash_value = -hash_value
if hash_value == -1:
hash_value = -2
return hash_value
对float浮点数类型求哈希值：
>>> def hash_float(x):
#计算浮点数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())
对复数类型求哈希值：
#计算复数z的哈希值
hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
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
Decimal运算实例
Decimal 进行 $+ 、- 、\times 、/$ 运算
>>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))
>>> sum (data)
Decimal('19.29')
>>> min(data)
Decimal('0.03')
>>> max(data)
Decimal('9.25')
>>> min(data)
Decimal('0.03')
>>> a,b,c = data[:3]
>>> a * 5
Decimal('6.70')
>>> a * b
Decimal('2.5058')
>>> c % a
Decimal('0.77')
>>> a + b + c
Decimal('6.66')
>>> a - b
Decimal('-0.53')
>>>
当余数运算%应用于Decimal对象时，结果的符号是被除数的符号，而不是除数的符号
>>> -5 % 8
3
>>> Decimal(-5) % Decimal(8)
Decimal('-5')
>>> Decimal(8) % Decimal(-5)
Decimal('3')
同样Decimal也可以进行一些数学函数运算
>>> Decimal(2).sqrt()
Decimal('1.41421')
>>> Decimal(1).exp()
Decimal('2.71828')
>>> Decimal(10).ln
<built-in method ln of decimal.Decimal object at 0x1073b04a8>
>>> Decimal(10).ln()
Decimal('2.30259')
>>> Decimal('10').log10()
Decimal('1')
关于四舍五入，Decimal的quantize()方法可以将数字四舍五入为固定函数
>>> Decimal('7.325').quantize(Decimal('0.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')
Fraction运算实例
Fraction同样可以进行$+、-、\times /$ 四则运算和%运算等
>>> from fractions import Fraction
>>> import math
>>> Fraction(2,3) + Fraction(3,5)
Fraction(19, 15)
>>> Fraction(2,3) - Fraction(3,5)
Fraction(1, 15)
>>> Fraction(2,3) * Fraction(3,5)
Fraction(2, 5)
>>> Fraction(2,3) / Fraction(3,5)
Fraction(10, 9)
>>> Fraction(2,3) % Fraction(-3, 5)
Fraction(-8, 15)
>>> Fraction(2,3) % Fraction(3,5)
Fraction(1, 15)
Fraction没有sqrt()、exp()等函数方法。
参考文献：