Tipos numéricos y bool – int, float, complex y bool
Los números en Python son uno de los tipos básicos más completos de todos los lenguajes de programación. En Python están modelados los tipos numéricos: enteros, punto flotante y hasta los números complejos, además de los booleanos. Vamos a verlos 😉
Contenido
Operaciones sobre números en Python
Para los números existen unos operadores disponibles y a continuación se pueden ver ejemplos.
| Operador | Descripción |
|---|---|
| + | Operador de suma |
| * | Operador de multiplicación |
| / | Operador de división |
| // | Operador de división entera |
| – | Operador de resta |
| % | Operador de módulo |
| ** | Operador de elevado |
>>> entero = 4
>>> entero + 9
13
>>> puntof = 9.48
>>> entero * puntof
37.92
>>> entero += 4
>>> entero
8
>>> complejo = 8 + 4j
>>> complejo + puntof
(17.48+4j)
>>> complejo + puntof / entero
(9.185+4j)
>>> 5 / 89
0.056179775280898875
>>> 5 // 89
0
>>> 3 % 1
0
>>> 3 % 2
1
>>> entero ** 10
1073741824
>>> 2 ** 4
16
>>> 2 ** 4 ** 2
65536Números enteros – int
Los números enteros representan a los números naturales más el 0 pudiendo ser positivos o negativos y tienen las siguientes características:
- Están en una base concreta (por defecto base 10).
- Pueden ser negativos o positivos o cero (0).
- Pueden realizarse operaciones entre ellos.
- Son el tipo base, por lo que se pueden realizar operaciones con otros tipos fácilmente.
- En Python 3 no hay límite de tamaño de estos números.
Ejemplos de números enteros
>>> -1
-1
>>> type(-1)
<class 'int'>
>>> int(483_702_2351)
4837022351
>>> int(483_702_231)
483702231
>>> 483_702_231
483702231
>>> -3945
-3945
>>> 523 - 421 * 9
-3266
>>> 573 / 251
2.2828685258964145
>>> 574 // 21
27Métodos sobre int
Los métodos sobre variables tipo int son las siguientes:
>>> dir(1)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__',
'__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__',
'__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__',
'__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__',
'__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__',
'__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__',
'__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__',
'__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
'__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__',
'__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio',
'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']| Método | Descripción | Ejemplo |
|---|---|---|
| as_integer_ratio | Devuelve un par de números representando el ratio del entero. | # int.as_integer_ratio()>>> (15).as_integer_ratio() |
| bit_length | El número de bits necesario para representar el número en binario. | # int.bit_length()>>> bin(-5), (-5).bit_length() |
| conjugate | Devuelve el número conjugado del entero. En enteros el propio entero. | # int.conjugate()>>> (10).conjugate() |
| denominator | El denominador del número racional. | # int.denominator>>> (10).denominator |
| from_bytes | Devuelve el entero representado por un array de bytes. | # int.from_bytes()>>> int.from_bytes(b'4f2', 'little') |
| imag | Devuelve la parte imaginaria de un número. (0 en enteros) | # int.imag>>> (10).imag |
| numerator | Devuelve el numerador del número racional. (El número en enteros). | # int.numerator>>> (4).numerator |
| real | Devuelve la parte real del número. (El número en enteros). | # int.real>>> (4).real |
| to_bytes | Devuelve un array de bytes representando el número entero. | # int.to_bytes()>>> (453).to_bytes(2, 'little') |
Casting y cambios de base sobre enteros
Gracias a que el constructor de la clase soport como segundo argumento la base del número entero se pueden hacer las siguientes operaciones:
>>> int('523')
523
>>> int('523', base=10)
523
>>> int('10101011101111001', base=2)
87929
>>> int('523', base=6)
195
>>> int('523', base=7)
262
>>> int('523', base=8)
339
>>> int('523', base=31)
4870
>>> int('ff', base=16)
255
>>> int('ack', base=32)
10644Números punto flotante – float
Los números en punto flotante se componen de dos parte, la parte entera y la parte decimal. En Python tienen las siguientes características:
- Pueden ser positivos, negativos ó
0. - El separador de las partes es el carácter punto (
'.'). - Se pueden representar como un punto y la parte decimal para decir 0.decimales.
- Se pueden utilizar con otros tipos de números como los enteros.
- La precisión máxima está limitada por 53 bits.
Ejemplos de números punto flotante
>>> 45.32
45.32
>>> float(234.21 / 45.32)
5.1679170344218885
>>> .453
0.453
>>> .23 * 9
2.0700000000000003
>>>
>>> float('3.421')
3.421
>>> .53 + .32 + 12.342
13.192Métodos sobre float
>>> dir(float)
['__abs__', '__add__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__',
'__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__',
'__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__',
'__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__',
'__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__',
'__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__',
'__rsub__', '__rtruediv__', '__set_format__', '__setattr__', '__sizeof__', '__str__',
'__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate',
'fromhex', 'hex', 'imag', 'is_integer', 'real']| Método | Descripción | Ejemplo |
|---|---|---|
| as_integer_ratio | Devuelve un par de números representando el ratio entero del float. | # float.as_integer_ratio()>>> (15.23).as_integer_ratio() |
| conjugate | Devuelve el número conjugado del float. En floats el propio número. | # float.conjugate()>>>(45.2).conjugate() |
| fromhex | Crea un número punto flotante desde una cadena hexadecimal. | # float.fromhex()>>> float.fromhex('4ed.f') |
| hex | Devuelve una cadena representando el número float en hexadecimal. | # float.hex()>>> (56.32).hex() |
| imag | Devuelve la parte imaginaria de un número. (0.0 en floats) | # float.imag>>> (3.4).imag |
| is_integer | Devuelve True si el valor en float es un entero. | # float.is_integer()>>> (4.0).is_integer() |
| real | Devuelve la parte real del número. (El número en floats). | # float.real>>> (3.4).real |
Precisión de los números punto flotante
Dado que los números se guardan en binario, la precisión no es óptima, por lo que si se pretenden hacer operaciones con decimales se recomienda usar el paquete decimal.
>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125783e-17
>>> from decimal import Decimal
>>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)
Decimal('2.775557561565156540423631668E-17')
>>> d = Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)
>>> round(d, 2)
Decimal('0.00')Números complejos en Python – complex
Python es de los pocos lenguajes de programación que soportan números complejos en su librería estandar con el tipo complex.
Las características de este tipo son las siguientes:
- Tienen una parte real y una parte imaginaria.
- El carácter utilizado para definir la parte imaginaria es
'j'. - Se pueden utilizar con otros tipos numéricos.
Ejemplos de números complejos en Python
>>> 4 + 3j
(4+3j)
>>> 4 + 3j - 2j +54
(58+1j)
>>> 4 + 3j - 2j + 54
(58+1j)
>>> 4 + 3j - 2j + 54 * 2
(112+1j)
>>> 4 + 3j - 2j / 54j * 2
(3.925925925925926+3j)
>>> 4 + 3j - 2j / - 54j * 2
(4.074074074074074+3j)
>>> 4 + 3j - 2j / - 54j * -2
(3.925925925925926+3j)
>>> 56j * (-3)
(-0-168j)
>>> 564.56j * (-3)
(-0-1693.6799999999998j)Métodos sobre complex
>>> dir(4j)
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', '__divmod__',
'__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__',
'__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__',
'__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__',
'__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__',
'__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__',
'__str__', '__sub__', '__subclasshook__', '__truediv__', 'conjugate', 'imag', 'real']| Método | Descripción | Ejemplo |
|---|---|---|
| conjugate | Devuelve el número conjugado. | # complex.conjugate()>>> (4 + 8j).conjugate() |
| imag | Devuelve la parte imaginaria del número. | # complex.imag>>> (8+2j).imag |
| real | Devuelve la parte real del número. | # complex.real>>> (8+2j).real |
Booleanos en Python – bool
El modelo booleano de Python se compone de 3 componentes:
- True: valor verdadero modelado como un entero con número 1.
- False: valor falso modelado como un entero con número 0.
- None: valor vacío modelado con un tipo propio llamado NoneType.
Dado que los valores de verdadero y falso se modelan en Python como enteros se ha incluido en esta sección.
Evaluación de bool
Todo los objetos en Python tienen un valor booleano, que por defecto se evalua como True salvo que sean 0 o vacío.
>>> bool(1)
True
>>> bool(0)
False
>>> True
True
>>> False
False
>>> type(None)
<class 'NoneType'>
>>> type(False)
<class 'bool'>
>>> type(1)
<class 'int'>
>>> True + True * False
1
>>> True + True + False
2
>>> bool('')
False
>>> bool([])
False
>>> bool('hola')
TrueLibros recomendados para aprender Python
Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.
