Alle Typen können verglichen, logische Werte erkannt, Zeichenfolgen konvertiert und alle Datentypen können mathematische Operationen ausführen.
Logische Werterkennung
Jeder Datentyp oder jedes Objekt kann auf logischen Wert getestet werden. Standardmäßig wird er als wahrer Wert angesehen, es sei denn, das Objekt oder seine Klasse definiert die bool () -Methode neu und gibt zurück False oder das Objekt definiert die len () -Methode und gibt Null zurück.
Die folgenden Objekte werden bei der Logikerkennung als falsche Werte betrachtet:
Als falsche Werte definierte Konstanten:None 和 False
Null eines beliebigen numerischen Typs:0，0.0，0j,Decimal(0),Fraction(0,1)
Leere Sequenzen und multinomiale Mengen:''，()，{}，set(),range(0)
Bool-Operation
Bool-Operationen umfassen and、or、notnicht> und> oder in der Reihenfolge ihrer Priorität
| Berechnung | Ergebnis | Anmerkung |
|---|---|---|
| x oder y | Wenn x falsch ist, geben Sie y zurück, andernfalls geben Sie x zurück | oder ist ein Kurzschlussoperator, wird der zweite Parameter nur ausgewertet, wenn der erste Parameter ein falscher Wert ist |
| x und y | Wenn x falsch ist, geben Sie x zurück, andernfalls geben Sie y zurück | und ist auch ein Kurzschlussoperator. Der zweite Parameter wird nur ausgewertet, wenn der erste Parameter wahr ist. |
| nicht x | Wenn x falsch ist, geben Sie True zurück, andernfalls False | Die Priorität ist niedriger als die von nicht-booleschen Operatoren, daher not a == bwird sie als interpretiert not (a==b)und a == not bführt zu Syntaxfehlern |
Vergleichsoperation
In Python gibt es acht Vergleichsoperatoren mit derselben Priorität, aber alle haben eine höhere Priorität als Boolesche Operationen, und die Vergleichsoperatoren können beliebig in Reihe geschaltet werden. Zum Beispiel ist es x<y<=zäquivalent zu dem x< y and y <=zUnterschied, dass das erstere y nur einmal und das letztere zweimal ausgewertet wird. Der gleiche Punkt ist, dass z nicht ausgewertet wird, wenn das Ergebnis von x <y falsch ist.
Die acht Vergleichsoperatoren lauten wie folgt:
| Operator | Bedeutung |
|---|---|
| < | Weniger als |
| <= | weniger als oder gleich |
| > | mehr als die |
| > = | größer oder gleich |
| == | gleich |
| ! = | Nicht gleichzusetzen mit |
| ist | Objekt Identifikation |
| ist nicht | Negative Objektidentifikation |
Punkte, die bei Vergleichsoperationen zu beachten sind
Unterschiedliche Zahlen und Objekte unterschiedlichen Typs sind im Vergleich niemals gleich
Der Funktionstyp unterstützt nur den vereinfachten Formularvergleich
. <, <=,>,> = Operator beim Vergleichen komplexer Zahlen und anderer numerischer Typen oder wenn zwei Objekte unterschiedliche Typen haben, die nicht verglichen werden können, oder in anderen Situationen, in denen die Reihenfolge nicht definiert ist, führen alle oben genannten TypeErroeAusnahmen aus
Instanzen verschiedener Identifikationsklassen sind nur dann gleich, wenn die Methode eq () definiert ist
Klasseninstanzen können nicht mit derselben Klasse oder anderen Instanzen oder anderen Objekttypen sortiert werden, es sei denn, es sind (), le (), gt (), ge () definiert
. is Und is notkann nicht angepasst werden kann , ohne Auslösen einer Ausnahme auf zwei beliebige Objekte angewendet werden.
. in Und not in vor acht Arten von Vergleichsoperatoren die gleiche Priorität haben, sondern nur unterstützen Iterable (Iterables) oder Geräte enthält Typ () -Methode
Numerische Operationen
Alle numerischen Typen mit Ausnahme komplexer Zahlentypen unterstützen die folgenden Operationen: Die Priorität aller numerischen Operationen ist höher als die der Vergleichsoperationen. Die folgenden sind in aufsteigender Reihenfolge der Priorität angeordnet :
| Berechnung | Bedeutung |
|---|---|
| + | Summe zweier Zahlen |
| - - | Unterschied zwischen zwei Zahlen |
| $ \ times $ | Produkt aus zwei Zahlen |
| /. | Teilen Sie zwei Zahlen, das Ergebnis wird an den Quotienten zurückgegeben |
| // // | Teilen Sie zwei Zahlen, das Ergebnis gibt den Quotienten zurück |
| %. | Teilen Sie zwei Zahlen und nehmen Sie den Rest |
| -x | x negiert |
| + x | x positiv |
| abs (x) | absoluter Wert von x |
| int (x) | Konvertiere x in eine Ganzzahl |
| float (x) | Konvertiere x in Gleitkomma |
| komplex (re, im) | Eine komplexe Zahl mit Realteil re und Imaginärteil im, im ist standardmäßig 0 |
| c.conjugate () | Konjugat der komplexen Zahl c |
| divmod (x, y) | Führen Sie x // yx% y aus, um den Quotienten und den Rest zu erhalten, nachdem x durch y geteilt wurde |
| pow (x, y) | x hoch y |
| x ** y | Stellt auch x hoch y dar |
| 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()等函数方法。
参考文献：