Python3 tiene seis tipos de datos estándar:
. Tipos de datos inmutables: Número (número), Cadena (cadena), Tupla (tupla)
.Tipos de datos variables: Lista (lista), Diccionario (diccionario), Conjunto (colección)
Hay algunos otros tipos de derivadas bajo cada tipo de datos básicos. Los seis anteriores son tipos de datos básicos. Además de los tipos de datos básicos, otros tipos de datos incluyen: Fecha y hora (hora), Calendario (calendario), Colección (contenedor), enum (enumeración), etc.
Este artículo describe la aplicación de los distintos tipos de Número , los tipos de derivada Tipo decimal y tipo Fracciones , y las reglas de operación para los tipos de datos.
Número :
Python3 admite int, float, bool, complext, Decimal, Fraction, otro tipo numérico, el tipo numérico puede +、-、*、/operar directamente ()para el paquete. La función incorporada type()y isinstance()el tipo de objeto al que se refiere la variable son aplicables a todos los tipos de datos . La diferencia entre los dos es type()que la subclase no se considera como el tipo de superclase isinstance()y la subclase se considera como el tipo de superclase.
int (entero)
El tipo entero (por ejemplo 4，5，6) es el tipo int . Después de Python3, solo hay un tipo entero int, que representa un entero largo, y ya no existe el tipo largo anterior . Python 2 representado por el número 0 False, está representado por un número True, pero Python3 directamente Truey Falsese define como una palabra clave, que representa un valor de 0 o 1, y. Los valores booleanos son subtipos de números enteros y los números enteros tienen una precisión ilimitada.
>>> a = 1; b=2
>>> isinstance(a, int)
True
>>> type(b)
<class 'int'>
#以上两个函数同样适用于其它Number类型以及String等
Métodos adicionales de tipo entero
El tipo int implementa la clase base abstracta y también proporciona otros métodosnumbers.Integral
bit_length ()
int.bit_length()Devuelve el número de bits necesarios para representar un número entero en binario, excluyendo el bit de signo y el cero anterior.
>>> a = -13
>>>#转换成二进制
>>> bin(a)
'-0b1101'
>>> a.bit_length()
4
Si el valor de a es 0, la bit_length(función devuelve 0, si el valor de a no es 0, bit_length()es 2**(k-1) <= abs(x)< 2 **kel único entero positivo k que hace que abs (a) sea lo suficientemente pequeño como para tener el logaritmo de redondeo correcto, entonces k = 1 + int(log(abs(x),2)).
Equivalente a:
>>> def bit_length(self):
s = bin(self) #将整数转换为二进制
s = s.lstrip('-0b') #将二进制的前缀去掉
return len(s) #返回二进制位的长度
to_bytes ()
int. to_bytes (longitud, orden de bytes, *, firmado = Falso) devuelve una matriz de bytes enteros, que es una función recién agregada de Python 3.1
Significado del parámetro:
longitud: número entero de bytes, si no puede ser representado por el número dado de bytes, se generará OverflowError
byteorder: determina el orden de bytes utilizado para representar el número entero, el byteorder es 'grande', lo que significa que el byte más significativo se coloca al principio de la posición del byte. Un orden de bytes de "pequeño" significa que el byte más significativo se coloca al final de la matriz de bytes.
firmado: si se usa el complemento a dos para representar un número entero, si el signo es Falso y se da un número entero negativo, se elevará OverflowError. El valor predeterminado es falso.
>>> a = 1024
>>> a.to_bytes(2, byteorder='big')
b'\x04\x00'
>>> a.to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> a.to_bytes(10, byteorder='big', signed=True)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> b = -1024
>>> b.to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> c = 1000
>>> c.to_bytes((c.bit_length()+7)//8, byteorder='little')
b'\xe8\x03'
from_bytes ()
int.from_bytes (bytes, byteorder, *, firmado = False) devuelve el número entero representado por la matriz de bytes dada, que es una característica agregada por Python 3.2.
Significado del parámetro:
bytes: debe ser un objeto de tipo bytes o un objeto iterable que genere bytes
byteorder: Indica el orden de bytes del entero. Si byteorder es "big", el byte más significativo se coloca al principio de la matriz de bytes. Si byteorder es "little", el byte más significativo se coloca al final de la matriz de bytes.
firmado: si se debe utilizar la representación del complemento a dos
>>> int.from_bytes(b'\x04\x00',byteorder='big')
1024
>>> int.from_bytes(b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00', byteorder='big')
1024
>>> int.from_bytes(b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00', byteorder='big',signed=True)
-1024
float (número de coma flotante)
Los números con decimales (como :)4.5，6.78 son de tipo flotante . float()Las funciones pueden convertir números en tipos flotantes . Los números de punto flotante generalmente se implementan usando doble en C.La precisión y la representación interna de los números de punto flotante se pueden versys.float_info
>>> float(8)
8.0
Métodos adicionales de tipo de punto flotante
El tipo flotante implementa la clase base abstracta . float tiene los siguientes métodos adicionales.numbers.Real
as_integer_ratio ()
float.as_integer_ratio () devuelve un par de enteros cuyo certificado de razón es igual al número de punto flotante original y el denominador es un entero. Si es infinito OverflowError , se elevará NaN ValueError
>>> 2.5.as_integer_ratio()
(5, 2)
is_integer ()
float.is_integer () Si la instancia de float puede ser representada por un entero finito, regresa True, de lo contrario regresaFalse
>>> 2.0.is_integer()
True
>>> 3.3.is_integer()
False
Nota :
Los dos métodos anteriores admiten la conversión entre números hexadecimales y cadenas. Dado que los números de coma flotante de Python se almacenan internamente como números binarios, la conversión entre números de coma flotante y cadenas de números decimales a menudo resulta en errores de redondeo menores. La cadena de números hexadecimales permite una representación y descripción precisas de números de punto flotante. Esto es muy útil para la depuración y el trabajo numérico.
maleficio()
float.hex() Devuelve un número de punto flotante en forma de cadena hexadecimal. Si es un número de punto flotante finito, esta representación incluirá exponentes 0x iniciales y finales pmás. Este método es un método de ejemplo
>>> 4.7.hex()
'0x1.2cccccccccccdp+2'
>>> 3.3.hex()
'0x1.a666666666666p+1'
fromhex ()
float.fromhex()Es un método de clase que devuelve un número de punto flotante representado por una cadena hexadecimal s . La cadena devuelta puede tener espacios iniciales y finales
>>> float.fromhex('0x1.a666666666666p+1')
3.3
>>> float.fromhex('0x1.2cccccccccccdp+2')
4.7
complejo
El complemento consta de una parte real re y una parte imaginaria im. Las partes real e imaginaria son de tipo coma flotante. Los sufijos j y J se utilizan para representar la parte imaginaria, expresada como a + bj. La función complex(re,im)también puede construir números complejos.
>>> complex(4.5, 1.2)
(4.5+1.2j)
Coordenadas polares complejas
El número complejo en Python se implementa esencialmente como un sistema de coordenadas rectangular o se almacena en un sistema de coordenadas cartesiano. Se define como las partes real e imaginaria:
z=z.real + z.imag*1j
El sistema de coordenadas polares proporciona una forma alternativa de expresar números complejos En el sistema de coordenadas polares, el número complejo z se define como compuesto por el módulo r y el ángulo de bit phi . El módulo r es la distancia desde z al origen, y el ángulo de bit phi es el ángulo en sentido antihorario calculado en radianes desde el eje x positivo hasta el segmento de línea que conecta el origen y el eje z.
The modulus r is the distance from z to the origin, while the phase phi is the counterclockwise angle, measured in radians, from the positive x-axis to the line segment that joins the origin to z
Para la función de conversión de coordenadas polares complejas, puede ver: Operación Python (3) módulo cmath
Decimal (decimal punto fijo y número de punto flotante)
Decimal puede redondear rápida y correctamente a decimal, proporcionando soporte para operaciones de coma flotante decimal. Decimal se basa en el modelo de punto flotante, que facilita el cálculo científico de números decimales de punto flotante y mejora la precisión. Mantisa retención decimal cero, tales como 1.30 + 1.70 = 3.00, 1.20 *1.40 =1.6800 ;
En programas contables o financieros con invariantes estrictamente iguales, se prefiere el tipo Decimal. Por ejemplo, el 1.0-1.0 resultado es exactamente 0, pero el resultado en un valor binario es 5.5511151231257827e-017que, aunque está infinitamente cerca de 0, todavía hay un error. Si Decimal se utiliza, no habrá tal error, el resultado es 0; decimal como un número de coma flotante decimal se puede establecer precisión (el valor predeterminado es 28 precisión)
Decimal se compone de números decimales , señales y contextos aritméticos .
Composición decimal-número decimal
Tenga en cuenta que el número decimal en Decimal no es exactamente el mismo que el número decimal entero. El número decimal en Decimal se compone de signo, número de coeficiente y exponente. El número de coeficiente no se trunca con el cero final, y el número decimal incluye caracteres especiales (tales como: Infinity, -Infinityy NaN), y además diferenciar -0 y + 0que representa 0, pero son igualmente -0y +0 son dos números diferentes en el decimal.
Por ejemplo, use números enteros, cadenas, flotantes o tuplas (estos tipos se discutirán más adelante) para construir una instancia decimal. NaN aquí no significa un valor nulo, pero significa "no un número" .
>>> getcontext().prec = 6
>>> Decimal(10)
Decimal('10')
>>> Decimal('3.1415')
Decimal('3.1415')
>>> Decimal(3.14)
Decimal('3.140000000000000124344978758017532527446746826171875')
>>> Decimal((0,(3,1,4),-2))
Decimal('3.14')
>>> Decimal(str(2.0**0.5))
Decimal('1.4142135623730951')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.41421')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
Si no se asigna ningún valor al valor en decimal (valor), se devolverá Decimal('0').
Si el valor es una tupla, hay tres componentes, un símbolo, una tupla numérica y un exponente entero, como el código anterior Decimal((0,(3,1,4),-2)) , returnDecimal('3.14')
Si el valor es un flotante, el valor de coma flotante binario se convierte sin pérdidas a su equivalente decimal exacto. Esta conversión generalmente requiere 50 dígitos de precisión o una conversión de mayor precisión, por ejemplo, el código anterior se Decimal(3.14)convierte aDecimal('3.140000000000000124344978758017532527446746826171875')
Señal de composición decimal
Las señales son condiciones anormales que ocurren durante los cálculos. De acuerdo con las necesidades del programa, la señal a veces se ignora, a veces se considera información y puede considerarse anormal. Cada señal consta de una bandera y un habilitador de trampas. Cuando se encuentra una señal, su bandera se establece en 1. Si el habilitador de trampas se establece en 1, se genera una excepción y el usuario debe restablecer la bandera antes de monitorear los cálculos. Hay señales Clamped , InvalidOperation , DivisionByZero , Inexact , Rounded , Subnormal , Overflow , Underflow y FloatOperation.
Si se captura la señal FloatOperation, si se usan números de punto flotante para construir números decimales o de punto flotante para operaciones de clasificación y comparación, se lanzará una excepción, pero la comparación igual no causará una excepción.
>>> context = getcontext()
>>> context.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
Decimal(3.14)
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.4') < 3.5
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
Decimal('3.4') < 3.5
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.5')==3.5
True
Composición decimal-contexto aritmético
El contexto aritmético se refiere al entorno en el que la precisión, las reglas de redondeo, los límites de exponentes, las banderas que indican el resultado de las operaciones y los iniciadores de trampas donde las señales se consideran anormales.
Opciones de redondeo incluyen ROUND_CEILING , ROUND_DOWN , ROUND_FLOOR , ROUND_HALF_DOWN, ROUND_HALF_EVEN , ROUND_HALF_UP , ROUND_UP y ROUND_05UP. Utilice la función getcontext () para acceder al contexto actual y cambiar la configuración. La función Context () puede crear un contexto aritmético. Si el contexto alternativo está habilitado, se requiere la función setcontext ().
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 6
Decimal proporciona dos contextos listos para usar , BasicContext y ExtendedContext . BasicContext permite que muchas trampas jueguen un papel importante en la depuración. Otra función del contexto aritmético es monitorear las señales de señales de condiciones anormales encontradas durante el cálculo. Para un ejemplo, vea el ejemplo de la sección de señales arriba.
Constante decimal
Las constantes son módulos de lenguaje C, pero pueden coexistir armoniosamente con Python. Las constantes de Decimal son:
| Nombre constante | 32 bits | 64 bits |
|---|---|---|
| decimal.MAX_PREC | 425000000 | 999999999999999999 |
| decimal.MAX_EMAX | 425000000 | 999999999999999999 |
| decimal.MIN_EMIN | -425000000 | -999999999999999999 |
| decimal.MIN_ETINY | -849999999 | -1999999999999999997 |
Además, hay una constante especial decimal.HAVE_THREADS, el valor predeterminado es True, pero si Python se compila sin subprocesos, C matará automáticamente los subprocesos más caros en el entorno de ejecución local, en este caso, el valor esFalse
Método decimal
Además de los atributos numéricos estándar, Decimal también tiene muchos métodos especializados, y hay muchos métodos
| Nombre del método | sentido | Ejemplo de código |
|---|---|---|
| ajustado () | Después de eliminar el dígito más a la derecha del coeficiente, regrese al exponente ajustado hasta que solo quede el dígito principal | |
| as_integer_ratio () | Devuelve un par de números enteros (n, d), lo que significa que la instancia Decimal se usa como la forma más simple de una fracción con un denominador positivo. | >>> Decimal ('- 3.14'). As_integer_ratio () (-157, 50) |
| as_tuple () | Devuelve el valor representado por una tupla. | DecimalTuple (signo, dígitos, exponente) |
| canónico() | Devuelve la codificación canónica del parámetro. | |
| comparar() | Compara los valores de dos instancias decimales | a o b es un NaN ==> Decimal ('NaN') a <b ==> Decimal ('- 1') a == b ==> Decimal ('0') a> b ==> Decimal (' 1 ') |
| compare_signal () | Excepto por todas las señales NaN, esta operación es la misma que el método compare () | |
| compare_total () | Utilice la representación abstracta para comparar dos operandos | |
| compare_total_mag | Utilice la representación abstracta para comparar, pero ignore el signo del operando | |
| conjugado() | Regresar solo, solo de acuerdo con la especificación Decimal | |
| copy_abs () | Devuelve el valor absoluto del parámetro, la operación no se ve afectada por el contexto, no se realiza ningún redondeo | |
| copy_negate () | Devuelve el valor negativo del parámetro, la configuración del signo es el mismo que el signo del segundo operando | >>> Decimal ('2.3'). Copy_sign (Decimal ('- 1.5')) Decimal ('- 2.3') |
| exp (contexto = Ninguno) | Devuelve la función exponencial de un número dado, el resultado se redondea usando el modo ROUND_HALF_EVEN | >>> Decimal (1) .exp () Decimal ('2.718281828459045235360287471') >>> Decimal (321) .exp () Decimal ('2.561702493119680037517373933E + 139') |
| from_float () | Convierta un número de punto flotante en un número decimal, que se puede construir directamente con float después de Python 3.2 | |
| fma (otro, tercero, contexto = Ninguno) | Multiplicación y suma mixtas, devuelva uno mismo * otro + tercero, el producto no se redondeará | >>> Decimal (2) .fma (3, 5) Decimal ('11 ') |
| is_canonical () | Si el parámetro es estándar, devolverá [ True], de lo contrario será [ False] |
|
| is_finite () | 参数是有限数 则返回True，否则返回Fasle | |
| is_infinite() | 参数为正负无穷大，则返回True，否则为False | |
| is_nan() | 如果参数为Nan，则返回True，否则返回False | |
| is_normal(context=None) | 如果参数是一个有限正规数，返回 True，如果参数是0、次正规数、无穷大或是NaN，返回 False |
|
| is_qnan() | 同is_nan() | |
| is_signed() | 如果参数带有负数，返回True，否则返回False | |
| is_snan() | 如果参数为显示NaN，则返回True，否则返回False | |
| is_subnormal(context=None) | 如果参数为低于给定值，则返回 True，否则返回 False。 | |
| is_zero() | 如果参数是0(正负皆可)，则返回True，否则返回False |
Decimal参数很多，这里不一一列举了，更多函数可以参考Deccimal标准库
Decimal 注意点
新版本Python3.3之后，congtext精度不会影响存储的位数，完全由value中的位数决定，context精度和舍入仅在算数期间发挥作用。context参数的目的是确定value是格式错误的字符串时该怎么做，如果context陷阱InvalidOperation则引发 异常，否则构造函数返回一个新的Decimal，其值为NaN。构造完成后Decimal对象是不可变的。Python3.6之后允许下划线进行分组。
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal('3.1415926535')
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85988')
Fraction(分数)：
Fraction分数类型可以由一系列整型数值，或其它数字类型，又或者是string(字符串)构造。
Fraction构建方式
Fraction构建形式为:
Fraction(numerator=0, denominator=1)
Fraction(other_fraction)
Fraction(float)
Fraction(decimal)
Fraction(string)
第一种构建方式，需要一个符合数字类型的数值当分子，和一个符合数字类型的数值当分母，构造函数会返回一个分子/分母值的Fraction实例。众所周知，分数分母不能为0，如果分母为0，会出现ZeroDivisionError的错误。
第二种构建方式也必须要求是一个符合数字类型的数值当分子，返回同样值的一个fraction分数实例。
第三种和第四种构建方式接受数字类型为float类型和Decimal类型，返回一个精确的具有同样数值大小的Fraction分数实例。不过由于二进制浮点数问题，类似于Fraction(1.1)并不能准确地返回类似于Fration(11,10)这样的分数实例。具体的构建规则，由函数limit_denominator()决定(该函数后面会涉及)。
最后一种构建方式用string字符串类型或unicode类型构建，一般形式为:
[符号] 分子'/'分母 如:Fraction('-3/7')
>>> from fractions import Fraction
>>>#第一种构建方式
>>> Fraction(-4, 5)
Fraction(-4, 5)
>>> Fraction(3, 8)
Fraction(3, 8)
>>>#第二种构建方式
>>> Fraction()
Fraction(0, 1)
>>>#第三种构建方式
>>> Fraction(2.30)
Fraction(2589569785738035, 1125899906842624)
>>> Fraction(Decimal ('1.1'))
Fraction(11, 10)
>>>#第四种构建方式
>>> Fraction('-3/7')
Fraction(-3, 7)
>>> Fraction('7e-6')
Fraction(7, 1000000)
Fraction类型继承字基本数据类型(numbers.Rational)，并继承了基类中的方法和操作。Fraction类型能够进行哈希运算，并且是不可变类型。
Fraction属性和方法
属性：
numerator： 分子
denominator: 分母
方法：
| 方法名 | 含义 | 代码 |
|---|---|---|
| from_float(flt) | 类方法，用float构建Fraction实例 Python3.2之后的方法 | |
| from_decimal(dec) | 类方法，用Decimal构建Fraction实例，同样是Python3.2之后才有 | |
| limit_denominator (max_denominator=100000) | 查找并返回一个和构造Fraction类数值接近，且分母是不超过设置的max_denominator的最大分母；该方法用来寻找与给定浮点数相近比例数，以及纠正一个近似float类型的比例数值 | >>> from fractions import Fraction >>> Fraction(‘3.1415926’).limit_denominator(1000) Fraction(355, 113) >>> from math import pi, cos >>> Fraction(cos(pi/3)) Fraction(4503599627370497, 9007199254740992) >>> Fraction(cos(pi/3)).limit_denominator() Fraction(1, 2) >>> Fraction(1.1).limit_denominator() Fraction(11, 10) >>> |
| floor() | 返回一个<= 分数自身的 int类型值，也可用数学模块中的math.floor() | >>> from math import floor >>> floor(Fraction(335,113)) 2 |
| ceil() | 返回一个>=分数自身的最小int值，同样可以用数学模块中的math.ceil() | |
| round() /round(ndigits) | round()返回Fraction的四舍五入最接近的int值; round(ndigits)返回Fraction(1, 10*ndigits)最接近的倍数数 | >>> round(Fraction(4.8)) 5 >>> round(Fraction(4.5)) 4 >>> round(Fraction(4.3)) 4 >>> round(Fraction(4.389089), 3) Fraction(4389, 1000) |
| fractions.gcd(a,b) | 返回整数a和b最大公约数, Python3.5之后用math.gcd()代替 | >>> import fractions >>> fractions.gcd(2,3) 1 >>> fractions.gcd(36, 24) 12 |
round()函数注意点
round()默认会进行四舍五入，但我们发现在上面的代码中
>>> round(Fraction(4.5))
4
4.5四舍五入值应该为5，但是给出的结果是4。
这是因为Python3.5 之后round()函数如果遇到浮点距离两边一样远，会保留到偶数那一边，doc中的原话为：”values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice.”
因为4.5 距离4 和距离5 都是0.5的距离，但因为4是偶数，所以最后结果是偶数4。如果是5.5的话，结果就是6
>>> round(5.5)
6
不过在Pyton2 中就不会有这个问题，round()函数会保留到离上一位更近的一端，即远离0的一端。
瞬间是不是觉得有点坑，如果代码从Python2 迁移到Python3 涉及到了大量round()函数的话，就比较坑，所以建议如果是要进行数据运算，还是尽量使用math或cmath模块中的函数。
此外，除来以上问题之外，还存在着一个问题：浮点数精度问题
例如代码
>>> round (2.565, 2)
2.56
无论是Python2 还算Python3 以上代码得到的结果都是2.56，显然这不符合常理。这是因为数字的存储都是用二进制，如果换算成二进制后一串1和0后可能是无限位数的，机器已经做出了截断处理，那么2565这个数字就比实际数字要小一点点。这一点点就导致了它离2.56要更近一点点，所以保留两位小数时就近似到了2.56。
那round()函数对精度把控不准，有替代函数吗？
1.像上面提到的，使用math中函数替代 ，如math.ceiling
2.Python自带整除//
3.可以将浮点型做截断转成字符串
有关具体的各类Number运算，详见：Python运算(-)数值、哈希、布尔等运算