El Rincón de Ealdor

[A] Tipos de datos básicos

Tabla con los tipos de objetos built-in en Python y algunas de la sintaxis usada para codificar sus literales, esto es, las expresiones que generan estos objetos:

Una vez que creas un objeto, estás forzado a utilizar su conjunto de instrucciones todo el tiempo. Solo puedes realizar operaciones de cadenas en una cadena y operaciones de listas en una lista. Python es 'tipado dinámico' (dynamically typed) y 'fuertemente tipado' (strongly typed).

[B] Inmutabilidad

Todos los objetos en Python están clasificados en inmutables (no pueden cambiar una vez creados) o no. Los números, cadenas, y tuplas son inmutables; las listas y diccionarios no lo son (pueden ser modificados libremente). Entre otras cosas, la inmutabilidad puede ser usada para garantizar que un objeto permanece constante a lo largo de tu programa.

[C] Números

Los números en Python soportan las operaciones matemáticas normales. Por ejemplo, el signo más (+) realiza la suma, una estrella (*) es usada para la multiplicación, y dos estrellas (**) son usadas para la exponenciación:

>>> 123 + 222
345
>>> 1.5 * 4
6.0
>>> 2 ** 100
1267650600228229401496703205376L

Observa la L al final del resultado de la última operación: Python automaticamente convierte en un tipo entero largo cuando es necesaria precisión extra. Mira que ocurre cuando algunos números en punto flotante se muestran:

>>> 3.1415 * 2
6.2830000000000004
>>> print 3.1415 * 2
6.283

Hay dos maneras de mostrar cada objeto: con precisión entera (como en el primer resultado de arriba), y en una forma usuario-amistosa (como en el segundo resultado).

Además de expresiones, hay un puñado de modulos númericos útiles que vienen con Python (math, random, etc).

[D] Cadenas

Como secuencias, las cadenas suportan operaciones que asumen un ordenamiento posicional entre objetos. Por ejemplo, si tenemos una cadena de cuatro caracteres, podemos verificar su longitud con la función 'len' y traer sus componentes con expresiones de indexado:

>>> S = 'Spam'
>>> len(S)
4
>>> S[0]
'S'
>>> S[1]
'p'

En Python, los índices empiezan en 0. También podemos indexar desde el final:

>>> S[-1]
'm'
>>> S[-2]
'a'
>>> S[len(S)-1]
'm'

Las secuencias también soportan una forma más general de indexado conocida como 'slicing', la cual es una manera de extraer un sección entera:

>>> S
'Spam'
>>> S[1:3]
'pa'
>>> S[1:]
'pam'
>>> S
'Spam'
>>> S[0:3]
'Spa'
>>> S[:3]
'Spa'
>>> S[:-1]
'Spa'
>>> S[:]
'Spam'

Finalmente, como secuencias, las cadenas tambien soportan la concatenación mediante el signo más, y la repetición mediante el signo estrella:

>>> S
'Spam'
>>> S + 'xyz'
'Spamxyz'
>>> S
'Spam'
>>> S * 8
'SpamSpamSpamSpamSpamSpamSpamSpam'

[E] Listas

Debido a que las listas son secuencias, la listas soportan todas las operaciones de secuencias que vimos para las cadenas; la única diferencia es que los resultados son normalmente listas en vez de cadenas. Por ejemplo:

>>> L = [123, 'spam', 1.23]
>>> len(L)
3
>>> L[0]
123
>>> L + [4, 5, 6]
[123, 'spam', 1.23, 4, 5, 6]
>>> L
[123, 'spam', 1.23]

Las listas no tienen limitación fija de tipos y no tienen tamaño fijado (pueden encoger y aumentar con la demanda), en respuesta a las operaciones especificas de las listas.

Aunque las listas no tengan un tamaño fijado, Python aún no permite referenciar a objetos que no están presentes.

Una de las cosas buenas de los tipos de datos básicos en Python es que soportan anidamiento arbitrario, podemos anidarlos en cualquier combinación (por ejemplo, podemos tener una lista que contiene un diccionario, el cual contiene otra lista, y así). Una de la aplicaciones inmediatas de esta característica es la representación de matrices, o "arrays multidimensionales" en Python:

>>> M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> M[1]
[4, 5, 6]
>>> M[1][2]
6

Python incluye una operación conocida como 'expresión de comprensión de listas', lo cual es una forma poderosa de procesar structuras como las matrices:

>>> col2 = [row[1] for row in M]
[2, 5, 8]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> [row[1] + 1 for row in M]
[3, 6, 9]
>>> [row[1] for row in M if row[1] % 2 == 0]
[2, 8]
>>> diag = [M[i][i] for i in [0, 1, 2]]
>>> diag
[1, 5, 9]
>>> doubles = [c * 2 for c in 'spam']
>>> doubles
['ss', 'pp', 'aa', 'mm']

Cualquier comprensión de listas puede ser codificada como un equivalente de un bucle 'for' que construye la lista resultante manualmente mediante la adición en cada iteración.

[F] Diccionarios

Los diccionarios son codificados entre llaves, y consisten en un serie de pares de "llave:valor". Los diccionarios son útiles cuando necesitamos asociar un conjunto de valores con claves:

>>> D = {'food': 'Spam', 'quantity': 4, 'color': 'pink'}
>>> D['food']
'Spam'
>>> D['quantity'] += 1
>>> D
{'food': 'Spam', 'color': 'pink', 'quantity': 5}
>>> D = {}
>>> D['name'] = 'Bob'
>>> D['job'] = 'dev'
>>> D['age'] = 40
>>> D
{'age': 40, 'job': dev', 'name': 'Bob'}
>>> print D['name']
Bob

Anidamiento en los diccionarios:

>>> rec = {'name': {'first': 'Bob', 'last': 'Smith'}, 'job': ['dev', 'mgr'], 'age': 40.5}
>>> rec['name']
{'last': 'Smith', 'first': 'Bob'}
>>> rec['name']['last']
'Smith'
>>> rec['job']
['dev', 'mgr']
>>> rec['job'][-1]
'mgr'

[G] Tuplas

El objeto tupla es aproximadamente como una lista que no puede ser modificada (son secuencias, como las listas, pero son inmutables, como las cadenas). Sintacticamente, son codificadas entre paréntesis en vez de corchetes, y soportan tipos arbitrarios, anidamiento, y las usuales operaciones de secuencias:

>>> T = (1, 2, 3, 4)
>>> len(T)
4
>>> T + (5, 6)
(1, 2, 3, 4, 5, 6)
>>> T[0]
1
T[0] = 2
...error text omitted...
TypeError: 'tuple' object does not support item assignment

[H] Archivos

No hay una sintaxis para crear un fichero. Mejor dicho, para crear un objeto archivo, se llama a la funcio 'open', pasando como cadena el nombre de un archivo externo, y el modo de procesamiento. Por ejemplo, para crear un archivo de salida:

>>> f = open('data.txt', 'w')
>>> f.write('Hello\n')
>>> f.write('wordl\n')
>>> f.close()

Esto crea un archivo en el directorio actual, y escribe texto en el. Para leer lo que acabas de escribir, reabre el archivo en modo de procesamiento 'r'. Luego lee el contenido del archivo en una cadena de bytes, y la muestra. El contenido de un archivo siempre es una cadena de bytes:

>>> f = open('data.txt')
>>> bytes = f.read()
>>> bytes
'Hello\nworld\n'
>>> print bytes
Hello
world

[I] Otros tipos básicos

Los conjuntos son contenedores de otros objetos, y soportan las operaciones matemáticas de conjunto:

>>> X = set('spam')
>>> Y = set(['h', 'a', 'm'])
>>> X, Y
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

>>> X & Y
set(['a', 'm'])
>>> X | Y
set(['a', 'p', 's', 'h', 'm'])
>>> X - Y
set(['p', 's'])

Booleanos:

>>> 1 > 2, 1 < 2
(False, True)
>>> bool('spam')
True

Números decimales.