El Rincón de Ealdor

[A] Literales numéricos

Tabla que muestra los literales numéricos en Python cuando son escritos en un programa:

A parte de los literales numéricos mostrados en la tabla, Python provee un conjunto de herramientas para procesar objetos numéricos:

- Operadores de expresión: +, *, >>, **, etc.
- Funciones matemáticas: pow, abs, etc.
- Modulos de utilidad: random, math, etc.

Finalmente, si necesitas hacer cálculos numéricos serios, una extensión óptima para Python llamada 'NumPy' provee avanzadas operaciones de programación numérica, como un tipo de dato matriz, procesamiento de vectores, y librerías de computación sofisticadas.

[B] Operadores de expresión en Python

Operadores de expresión en Python:

[C] Precedencia de los operadores mezclados

¿Cómo sabe Python que operación realizar primero?, la respuesta a esta pregunta reside en la precedencia de operadores, Cuando escribes una expresión con mas de un operador, Python agrupa en partes acorde con lo que se llama reglas de precedencia, y este agrupamiento determina el orden en el cual las expresiones de las partes se computan. En la anterior tabla, los operadores mas abajo en la tabla tiene mayor precedencia.

Tambien puedes olvidarte de la precedencia completamente si eres cuidadoso en agrupar partes de expresiones con paréntesis. Cuando encierras subexpresiones entre paréntesis, anulas las reglas de precedencia de Python; Python siempre evalúa las expresiones entre paréntesis primero.

[D] Los tipos mezclados son convertidos

A parte de mezclar operadores en las expresiones, tambien puedes mezclar tipos numéricos. Python primero convierte los operandos al tipo del operando mas complicado, y luego realiza la operación matemática.

El rango de complejidad de los tipos en Python es: enteros son más simples que entero largo, los cuales son más simples que los números reales, los cuales son más simples que los números complejos. Puedes forzar el asunto llamando a funciones para convertir el tipo manualmente:

>>> int(3.1415)
3
>>> float(3)
3.0
>>> long(4)
4L

[E] Variables y expresiones básicas

Las variables son simplemente nombres (creados por tí o por Python) que son usadas para mantener un rastro de la información en tu programa. En otras palabras, estos asignamientos provocan que las variables 'a' y 'b' broten a la vida automaticamente:

% python
>>> a = 3
>>> b = 4

Ahora, vamos a usar nuestros nuevos objetos enteros en expresiones. En este punto, los valores de 'a' y 'b' son aún '3' y '4', respectivamente:

>>> a + 1, a - 1
(4, 2)
>>> b * 3, b / 2
(12, 2)
>>> a % 2, b ** 2
(1, 16)
>>> 2 + 4.0, 2.0 ** b
(6.0, 16.0)
>>> b / 2 + a
5

[F] Formato de visualización numérico

Tecnicamente, la diferencia entre el "echo" interactivo por defecto y el 'prints' corresponde a la diferencia entre las funciones 'repr' y 'str':

>>> (repr)
0.33333333333333331
>>> str(num)
0.333333333333

Ambas convierten arbitrariamente objetos a su representacion de cadena: 'repr' (y el "echo" interactivo por defecto) producen resultados que se muestran como fueron codificados; 'str' (y la sentencia 'print') convierten a un formato típico usuario-amistoso.

>>> b / (2.0 + a)
0.80000000000000004
>>> print b / (2.0 + a)
0.8

>>> 1 / 2.0
0.5
>>> num = 1/ 3.0
>>> num
0.33333333333333331
>>> print num
0.333333333333

>>> "%e" % num
'3.333333e-001'
>>> "%2.2f" % num
'0.33'

[G] División

División exacta (nuevo en Python 3.0): división que siempre conserva el resto, incluso para enteros. En Python 2.5 se le llama división clásica, la cual trunca el resultado para enteros y conserva el resto para números reales:

>>> (5 / 2), (5 / 2.0), (5 / -2.0), (5 / -2), (9 / 3), (9.0 / 3)
(2.5, 2.5, -2.5, -2.5, 3.0, 3.0)

División suelo: este operador siempre trunca el resto a su suelo, a pesar de su tipo:

>>> (5 // 2), (5 // 2.0), (5 // -2.0), (5 // -2), (9 // 3), (9 // 3.0)
(2, 2.0, -3.0, -3, 3, 3.0)

[H] Operaciones sobre bits

A parte de la operaciones númericas normales (adición, substracción, y demás), Python soporta la mayoría de las expresiones numéricas disponibles en el lenguaje C. Por ejemplo:

>>> x = 1
>>> x << 2
4
>>> x | 2
3
>>> x & 1
1

[I] Enteros largos y complejos

Cuando un literal entero termina con la letra 'L' (o en minúsculas 'l'), Python crea un entero largo. En Python un entero largo puede ser arbitrariamente largo. Esto es, puede tener tantos digitos como espacio tengas en memoria. La 'L' indica a Python a crear un objeto entero largo con precisión ilimitada. La letra 'L' es opcional, ya que Python automaticamente convierte un entero normal en un entero largo cuando su valor es demasiado largo para meterlo en un entero normal (normalmente 32 bits):

>>> 9999999999999999999999999999999999999L + 1
10000000000000000000000000000000000000L
>>> 9999999999999999999999999999999999999 + 1
10000000000000000000000000000000000000L

>>> 2L ** 200
1606938044258990275541962092341162602522202993782792835301376L
>>> 2 ** 200
1606938044258990275541962092341162602522202993782792835301376L

Los números complejos se representan como dos números reales (la parte real y la imaginaria), y son codificados añadiendo una 'j' o 'J' a la parte imaginaria. Tambien podemos escribir los números complejos con una parte real distinta de cero, añadiendo las dos partes con un símbolo '+':

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2 + 1j) * 3
(6+3j)

[J] Notación hexadecimal y octal

Los literales en octal empiezan por un '0', seguidos por una cadena de dígitos en octal 0-7, cada uno de los cuales representan tres bits.

>>> 01, 010, 0100
(1, 8, 64)

Los literales en hexadecimal empiezan por '0x' o '0X', seguidos de una cadena de dígitos en hexadecimal 0-9 y A-F (en mayúscula o minúscula), cada uno de los cuales representan cuatro bits.

>>> 0x01, 0x10, 0xFF
(1, 16, 255)

Distintos tipos de convertir los enteros en sus cadenas hexadecimales y octales y viceversa:

>>> oct(64), hex(64), hex(255)
('0100', '0x40', '0xff')

>>> int('0100'), int('0100', 8), int('0x40', 16)
(100, 64, 64)

>>> eval('100'), eval('0100'), eval('0x40')
(100, 64, 64)

>>> "%o %x %X" % (64, 64, 255)
'100 40 FF'

[K] Otras herramientas numéricas

Python provee funciones y modulos para el procesamiento numérico:

>>> import math
>>> math.pi, math.e
(3.1415926535897931, 2.7182818284590451)

>>> math.sin(2 * math.pi / 180)
0.034899496702500969

>>> math.sqrt(144), math.sqrt(2)
(12.0, 1.4142135623730951)

>>> abs(-42), 2**4, pow(2, 4)
(42, 16, 16)

>>> int(2.567), round(2.567), round(2.567), round(2.567,2)
(2, 3.0, 2.5699999999999998)

La librería estandar 'random' debe ser importada tambien. Este módulo provee herramientas para cojer un número real aleatorio entre 0 y 1, seleccionar un entero aleatorio entre dos números, escojer un elemento aleatorio de una secuencia, y más:

>>> import random
>>> random.random( )
0.49741978338014803
>>> random.random( )
0.49354866439625611

>>> random.randint(1, 10)
5
>>> random.randint(1, 10)
4

>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Life of Brian'
>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Holy Grail'

[L] Otros tipos numéricos

Conjuntos: para crear un objeto conjunto pasamos una secuencia o un objeto iterable a la funcion 'set'.

>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
set(['a', 'c', 'b', 'e', 'd'])

>>> 'e' in x
True
>>> x - y
set(['a', 'c', 'e'])
>>> x | y
set(['a', 'c', 'b', 'e', 'd', 'y', 'x', 'z'])
>>> x & y
set(['b', 'd'])

>>> engineers = set(['bob', 'sue', 'ann', 'vic'])
>>> managers = set(['tom', 'sue'])
>>> engineers & managers
set(['sue'])
>>> engineers | managers
set(['vic', 'sue', 'tom', 'bob', 'ann'])
>>> engineers - managers
set(['vic', 'bob', 'ann'])

Booleanos.

Números decimales.