Aprendiendo Python: NÚMEROS

Los números en Python se entienden como ENTEROS, de coma FLOTANTE, COMPLEJOS, pero dentro de cada uno pueden haber conversiones, por ejemplo de entero a octal, hexadecimal o binario, o en notación científica, etc. Veamos.

Cuando creamos un número, phyton, según sea escrito le da su nomenclatura.

Para darle formato a los nñumeros es necesario pasarse por el capítulo donde se explica la orden format(), más adelante.

1.- Enteros: Son los que no tienen decimales, pueden ser positivos o negativos y se nombran con int()

Se puede pasar de un tipo a otro, anteponiendo el tipo a su utilización, ejemplo:

int(numero)

2.- De coma flotante, es decir, decimales.

float(numero)

Dentro de ellos se pueden representar de diferentes bases, como la hexadecimal, la octal y la binaria, o con notaciones científicas.

Sus sinaxis serían

hex(numero)

bin(numero)

oct(numero)

o bien por la notación:

Científica es 1e2 = 100

Hexadecimal empezaría por 0x, el octal empezaría por 0o y el binario en 0b. Estas notaciones dejan de ser número enteros y pasar a ser del tipo str.

numeroprueba = 258print(f"El número {numeroprueba} es del tipo{type(numeroprueba)}")
print(f"lo paso a hexadecimal y es = {hex(numeroprueba)} que es del tipo {type(hex(numeroprueba))}")
print(f"lo paso a octal y es = {oct(numeroprueba)} que es del tipo {type(oct(numeroprueba))}")
print(f"lo paso a binario y es = {bin(numeroprueba)} que es del tipo {type(bin(numeroprueba))}")      
El número 258 es del tipo<class 'int'>
lo paso a hexadecimal y es = 0x102 que es del tipo <class 'str'>
lo paso a octal y es = 0o402 que es del tipo <class 'str'>
lo paso a binario y es = 0b100000010 que es del tipo <class 'str'>

Se puede pasar un nñumero de un tipo a otro de esta manera:

por ejemplo, 258 es del tipo int

Pasarlo a hexadecimal: hex(258) nos daría 0x102 y pasarlo a entero sería int(0x102, 16) = 258

Pasarlo a octal: oct(258) nos daría 0o402 y pasarlo a entero sería int(0o402, 8) = 258

Pasarlo a binario: bin(258) nos daría 0b100000010 y pasarlo a entero sería int(0b100000010, 2) = 258

Como se ve para pasarlo a su origen hay que decirle la base en la que queremos hacerlo; 16, 8 ó 2

3.- Complejos. Son los que pertenecen al mundo de los número complejos. Se verá si es necesario.

https://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/

Operaciones con múmeros:

Las habituales de Suma, Resta, Multiplicación y División se pueden hacer directamente

2+3 daría = 8

1-7 daría = -6

5*-7 daría = -35

4/5 daría = 0.8

esto se puede hace con variables a las que se les asigna los valores:

a = 2
a1 = 3
b = 1
b1 = -7
c = 5
c1 = -7
d = 4
d1 = 5
print(a+a1)
print(b+b1)
print(c*c1)
print(d/d1)

5
-6
-35
0.8

La POTENCIA y RAICES tiene dos formas de hacerlo:

Tienen prioridad sobre las multiplicaciones y divisiones.

Forma1: ** Casi en desuso en favor de la más versatil pow.

2**3 = 8

Forma 2: con la orden pow(base, exponente)

pow(2, 2) = 4

la raíz cuadrada de 4 es dos y como el exponente de la raíz es 2 y 1/2 = 0.5

pow(4,0.5) -- > 2

pow(425,0.5) es averiguar la raíz cuadrada de 425 = 20.615....

pow(5,3) = 125 # esto es 5 al cubo o a la tres

pow(125,(1/3)) = 4.999999... # esto es la raíz cúbica de 125

La potencia inversa es la raíz n-ésima así que, la poetencia negativa es la raís de la potencia del número:

DIVISIONES en Python:

En una división cualquiera hay dividendo, divisor, cociente y resto.

PArtamos de la dividión 20/7 que da como cociente 2.857... y resto:

En Python podemos obternerlo con las siguientes ordenes:

COCIENTE: Se represente así // y siempre es un número entero o decimal y tiene la misma prioridad que la división.

print(20 //7) -- > 2

print(20/7) --> 2.8571....

RESTO: Se representa así % y siempre es un número entero o decimal y tiene la misma prioridad que la división.

print(20%7) -- > 6

Función integrada: Se usa la orden divmod( dividendo, divisor )

Devuelve la tupla fgormada por el cociente y el resto de esa división.

divmod(20,7) -- > (2,6)

Redondeo: Se usa la función round(a , b ), donde a es el número a redondear y b es la posición hasta la que ha de legar.

# este programa es para analizar los redondeos

a = 1
b = 1.5
c = 1.75
d = 5.9255
print("Round con un sólo parámetro round(a) ")
print(f"El redondeo de a = {a} es {round(a)} y su negativo es {round(-a)}")
print(f"El redondeo de a = {b} es {round(b)} y su negativo es {round(-b)}")
print(f"El redondeo de a = {c} es {round(c)} y su negativo es {round(-c)}")
print(f"El redondeo de a = {d} es {round(d)} y su negativo es {round(-d)}")

print(f"round con dos parámetros round(a,b) ")
print(f"el redondeo de {d} con b = 0 es {round(d,0)} y con b negativo {round(d,-0)}")
print(f"el redondeo de {d} con b = 1 es {round(d,1)} y con b negativo {round(d,-1)}")
print(f"el redondeo de {d} con b = 2 es {round(d,2)} y con b negativo {round(d,-2)}")
print(f"el redondeo de {d} con b = 3 es {round(d,3)} y con b negativo {round(d,-3)}")
print(f"el redondeo de {d} con b = 4 es {round(d,4)} y con b negativo {round(d,-4)}")

print(f"round con dos parámetros round(a,b) ")
print(f"el redondeo de {-d} con b = 0 es {round(-d,0)} y con b negativo {round(-d,-0)}")
print(f"el redondeo de {-d} con b = 1 es {round(-d,1)} y con b negativo {round(-d,-1)}")
print(f"el redondeo de {-d} con b = 2 es {round(-d,2)} y con b negativo {round(-d,-2)}")
print(f"el redondeo de {-d} con b = 3 es {round(-d,3)} y con b negativo {round(-d,-3)}")
print(f"el redondeo de {-d} con b = 4 es {round(-d,4)} y con b negativo {round(-d,-4)}")

Round con un sólo parámetro round(a) 
El redondeo de a = 1 es 1 y su negativo es -1
El redondeo de a = 1.5 es 2 y su negativo es -2
El redondeo de a = 1.75 es 2 y su negativo es -2
El redondeo de a = 5.9255 es 6 y su negativo es -6
round con dos parámetros round(a,b) 
el redondeo de 5.9255 con b = 0 es 6.0 y con b negativo 6.0
el redondeo de 5.9255 con b = 1 es 5.9 y con b negativo 10.0
el redondeo de 5.9255 con b = 2 es 5.93 y con b negativo 0.0
el redondeo de 5.9255 con b = 3 es 5.926 y con b negativo 0.0
el redondeo de 5.9255 con b = 4 es 5.9255 y con b negativo 0.0
round con dos parámetros round(a,b) 
el redondeo de -5.9255 con b = 0 es -6.0 y con b negativo -6.0
el redondeo de -5.9255 con b = 1 es -5.9 y con b negativo -10.0
el redondeo de -5.9255 con b = 2 es -5.93 y con b negativo -0.0
el redondeo de -5.9255 con b = 3 es -5.926 y con b negativo -0.0
el redondeo de -5.9255 con b = 4 es -5.9255 y con b negativo -0.0

Desde aquí es corta y pega de:

https://www.mclibre.org/consultar/python/lecciones/python-operaciones-matematicas.html

Redondear al entero anterior o posterior: las funciones floor() y ceil()

Para redondear un número al entero anterior o posterior, se pueden utilizar las funciones floor() y ceil(), que están incluidas en la biblioteca math. Estas funciones sólo admiten un argumento (el número o el cálculo a redondear) y devuelven valores enteros.

Antes de utilizar estas funciones, hay que importarlas, o se generará un error.

>>> from math import floor
>>> floor(5 / 2)
2
>>> floor(2.9999)
2
>>> from math import ceil
>>> ceil(5 / 2)
3
>>> ceil(2.0001)
3

Representación de números decimales en binario

En Python los números decimales se almacenan internamente en binario con 53 bits de precisión (en concreto, se trata del formato de coma flotante de doble precisión de la norma IEEE-754). Cuando un programa pide a Python un cálculo con números decimales, Python convierte esos números decimales a binario, realiza la operación en binario y convierte el resultado de nuevo en decimal para mostrárselo al usuario.

El problema es que muchos números decimales no se pueden representarse de forma exacta en binario, por lo que los resultados no pueden ser exactos. Eso explica, por ejemplo, los resultados del ejemplo anterior:

>>> round(3.45, 1)
3.5
>>> round(3.55, 1)
3.5

En el primer ejemplo, al convertir 3.45 a binario con 53 bits de precisión, el valor obtenido es realmente 3.45000000000000017763568394002504646778106689453125, es decir, ligeramente mayor que 3.45, por lo que al redondear con décimas, Python muestra el valor 3.5.

En el segundo ejemplo, al convertir 3.55 a binario con 53 bits de precisión, el valor obtenido es realmente 3.54999999999999982236431605997495353221893310546875, es decir, ligeramente inferior a 3.55, por lo que al redondear con décimas, Python muestra también el valor 3.5.

Nota:

Para ver el valor que se obtiene al convertir un número decimal a binario se puede utilizar el tipo Decimal de la biblioteca decimal:

>>> from decimal import Decimal
>>> Decimal(3.45)
Decimal('3.45000000000000017763568394002504646778106689453125')
>>> Decimal(3.55)
Decimal('3.54999999999999982236431605997495353221893310546875')

El problema del redondeo se agudiza cuando se hacen operaciones, puesto que los errores pueden acumularse (aunque a veces se compensan y pasan desapercibidos).

En algunos casos extremos, el error es apreciable en cálculos muy sencillos:

>>> 0.1 + 0.1 + 0.1
0.30000000000000004

En la mayoría de situaciones, estos errores no tienen consecuencias importantes en los resultados finales, pero si en una aplicación concreta se necesita total exactitud, se deben utilizar bibliotecas específicas. Python incluye la biblioteca decimal y existen bibliotecas como mpmath que admiten precisión arbitraria.

Aprendiendo Python

NÚMEROS

Desde aquí es corta y pega de:

Redondear al entero anterior o posterior: las funciones floor() y ceil()

Representación de números decimales en binario

No hay comentarios:

Publicar un comentario