Resumen Completo de Python 3 | JL Iglesias Feria

Resumen Completo de Python 3

Generalidades

Línea de Comandos:

python archivo [args]* # Ejecuta el código python de un archivo.
En este caso, la variable __name__ tiene el valor '__main__'.
if __name__ == '__main__': … # Para hacer pruebas.
Cuando se importa como módulo, __name__ tiene el nombre del módulo.
python -c comando [args]* # Ejecuta un comando.
python -m módulo [args]* # Ejecuta un módulo. (__name__ vale también '__main__').

En modo interactivo, el último resultado mostrado se asigna a la variable '_' (guión bajo).
>>> a=2; b=3; a+b
5
>>> _+10
15

Para salir del modo interactivo se usa CTRL+D, quit() o exit().

Todo es un objeto, se puede usar cualquier cosa como variables o pasarla como parámetro a una función. Todo posee varios métodos útiles:

obj.__doc__ # Documentación del objeto.
obj.__name__ # Nombre de la clase o del tipo del objeto.
obj.__file__ # Ruta completa al archivo con el módulo del objeto.
obj.__package__ # Nombre del paquete al que pertenece el objeto.
obj.__spec__ # Información sobre el módulo.

Es un lenguaje de variables dinámicas (no hay que indicar el tipo de dato), pero fuertemente tipado (no permite realizar operaciones implícitas en los datos).
Para definir varias sentencias en una línea, se separan con punto y coma:
import sys; x=sys.argv[1]; sys.stdout.write(x+'\n')
Para declarar sentencias en varias líneas se usa la barra invertida al final (salvo en las listas, diccionarios y conjuntos, que no hace falta):

resultado = objeto \
.metodo() # Los comentarios, al final. No pueden ir tras la barra invertida.
params = {"clave1" : "valor1", # En listas, diccionarios y conjuntos no hace falta poner '\'.
"clave2" : "valor2" }
texto = ('esto es el inicio del texto, ' # En textos, tampoco hace falta poner '\' si va entre '()'.
'aquí sigue el texto')

No se podrá usar variables que hayan sido declaradas pero no se les haya asignado ningún valor.
No existen las constantes en Python.
Identificadores: sólo letras ASCII mayúsculas y minúsculas, guión bajo y números.
_* # Variables no cargadas al hacer import (variables internas de un módulo).
__*__ # Variables del sistema, propias de Python.
__* # Atributos privados de una clase.
En sistemas GNU/Linux se pueden crear scripts Python si en las primeras líneas se escribe:

#!/usr/bin/env python3
# -*- coding: utf-8 -*- # Obligatorio en 2.7, opcional en 3.4 (UTF-8 por defecto).

Si además se hace chmod +x archivo.py, se puede ejecutar con ./archivo.py

Extensiones de Archivo:

.py: código fuente del programa, que puede ser interpretado.
.pyc: código máquina intermedio (bytecode) creado automáticamente.
.pyw: programa Python que no muestra línea de comandos al ejecutarse en Windows.
.pyz: programa Python comprimido con ZIP.

Comentarios

Para introducir comentarios se hacen con el carácter almohadilla:

# Esto es un comentario.

# No hay una forma especial para varias líneas como en C, C++, C#, Java, etc.
# Hay que ir poniendo almohadillas delante de cada línea.

Tipos Básicos

El tipo de dato nulo es None (equivalente al null de otros lenguajes) y si algún dato no posee un operador o función puede devolver el tipo de dato NotImplemented.

Booleanos (bool)

Valores: True (verdadero), False (falso). Internamente, son un subtipo de entero.
Otros tipos de datos:

Números: cero es falso, distinto de cero es verdadero.
Cadenas: una cadena vacía es falso, el resto es verdadero.
Secuencias: una lista, tupla, conjunto o diccionario vacío es falso, el resto es verdadero.
Objetos: None es falso, aunque pueden definir el método __bool__() para indicarlo.

Números

Entero (int): var = 23 # Son todos enteros largos, y no tienen límites en longitud.
# Guiones bajos para mejorar lectura de números largos: var = 1_000_000_000

Octal: var = 0o23 # oct(int); Antes: var=023
Hexadecimal: var = 0x23 # hex(int);
Binario: var = 0b10111 # bin(int);

int.bit_length() # nº de bits para representar el entero.
int.to_bytes(nº, length, byteorder, signed) # convierte un entero en bytes.

Real (float): var = 0.23 # Todos de doble precisión; f.is_integer(), f.hex(), f.fromhex()

Científico: var = 0.23e–3

Decimales: var = decimal.Decimal(2.3) # Para operaciones financieras, precisión definida.
Fracciones: var = fractions.Fraction(4, 6) # Lo convierte sólo a Fraction(2, 3).

var.from_float(2.567) # Devuelve la fracción correspondiente a un nº real.

Complejos (complex):
var = 2.3 + 1.4j # Para obtener sus partes usar var.real y var.imag
var2 = complex(2.3, 1.4) # var2.real → 2.3, var2.imag → 1.4
var3 = var2.conjugate()

Cadenas de Texto (str)

Comillas Simples: var = 'texto' # Dos textos seguidos se muestran juntos: 'py' 'thon' → 'python'
Comillas Dobles: var = "texto" # str es una secuencia inmutable de caracteres Unicode.
Unicode: todas los textos son ahora Unicode: var = "texto" # Antes: var = u"texto"
Escape: \n (salto de línea), \t (tabulación)
Cadena en crudo: var = r"\n" # No expande \n, \t, etc.;
Permitir saltos de línea (comillas simples o dobles):
"""
primera línea
segunda línea
"""

Para evitar que al mostrarse se apliquen saltos de línea, poner una '\' (barra invertida) al final:

""" \
primera línea \
segunda línea \
"""

Métodos (admite todos los métodos y operadores de las secuencias):

str.count(sub, ini, fin) # Nº veces que aparece la subcadena.
str.find(sub, ini, fin), str.rfind(sub, ini, fin) # Búsqueda de subcadenas (–1 si no existe).
sep.join(secuencia) # Concatena la secuencia de cadenas separadas por el carácter 'sep'.
str.partition(sep), str.rpartition(sep) # Tupla con 3 elementos: 1ª parte, separador y resto.
str.replace(viejo, nuevo, cant) # Reemplazo de subcadena por otra.
str.split(sep, max), str.rsplit(sep, max) # Lista de subcadenas, partidas por el carácter sep.
str.splitlines() # Lista de líneas de un texto.
str.translate(dicc) # Realiza los cambios indicados en el diccionario dentro de la cadena.
str.maketrans(desde, a) # Crea un diccionario de traslaciones para str.translate(dicc).
str.upper(), str.lower(), str.capitalize(), str.title(), str.swapcase(), str.casefold() # Mayús/Minúsc.
str.isalnum(), str.isalpha(), str.isdecimal(), str.isdigit(), str.isidentifier(), str.islower(), str.isnumeric(), str.isprintable(), str.isspace(), str.istitle(), str.isupper() # Comprobaciones.
str.startswith(tupla), str.endswith(tupla) # Si empieza o termina por ciertos caracteres.
str.strip(), str.lstrip(), str.rstrip() # Quita los espacios en blanco iniciales y/o finales.
str.zfill(cant) # Rellena con ceros a la izquierda hasta una cantidad.
str.expandtabs(ancho) # Convierte tabuladores en espacios en blanco.
str.rjust(ancho), str.ljust(ancho), str.center(ancho) # Justificación de texto.

Codificación y Configuración Local:

bin = str.encode('latin-1') # Transforma cadena de texto en otra codificación.
str = bin.decode('ascii') # Trasforma los datos binarios a la codificación indicada.
bin = codecs.encode(str, 'latin-1') # Transforma cadena de texto en otra codificación.
str = codecs.decode(bin, 'ascii') # Trasforma los datos binarios a la codificación indicada.
locale.getpreferredencoding() # Devuelve la codificación por defecto del sistema.
locale.setlocale(locale.LC_ALL, "Spanish_Spain.utf-8") # Cambia la configuración local.
locale.localeconv() # Devuelve las particularidades de una configuración local.
locale.format_string("formato", datos) # Formateo de datos en configuración local.

Formateo: para una descripción más detallada usar help("FORMATTING"):

"Texto %s" % var # Sustituye %s por el valor de var (formato printf).
"%s %d %f" % ("uno", 2, 3.4,) # Sustitución múltiple con tuplas.
"%(var1) %(var2)" % {"var1":"uno", "var2":"dos",} # Sustitución múltiple.

"{0} = {1:.2f}".format("valor", 2.345) # Nuevo formateo en Python 3 (valor = 2,36).

Especificación de Sustitución con % (formato printf/percent):
1 %: inicio del formateo (obligatorio).
2 (clave): cuando se usa con diccionarios (opcional).
3 flags: altera algunos tipos (opcional).
'#' forma alternativa de algunos tipos.
'0' relleno con ceros.
'–' ajustado a la izquierda.
' ' relleno con espacios.
'+' poner siempre delante signo (+/–).
4 ancho: ancho mínimo para parte entera (opcional).
5 .precisión: ancho mínimo para parte decimal (opcional).
6 modificador: del ancho (opcional).
7 tipo: de dato (obligatorio).
Especificación str.format():
formato ::= '{'[nombre][':'spec]'}'
nombre ::= [ID|integer]('.'atributo|'['índice']')*
spec ::= [[relleno]alineado][signo]['#']['0'][ancho][',']['.'precision][tipo]
relleno ::= <carácter de relleno>
alineado ::= '<'|'>'|'='|'^'
signo ::= '+'|'–'|' '
tipo ::= <tabla de tipos>|!a|!s|!r
#: mostrar 0x (hexadecimal), 0o (octal), 0b (binario) delante del número.
0: se usa con la alineación '='
, : usar la coma como separador de miles.
!a = ascii(dato), !s = str(dato), !r = repr(dato)
Tipo de Datos:
i, d: entero decimal con signo.
o: octal con signo.
x, X: hexadecimal en minúsculas o mayúsculas.
e, E: coma flotante con exponencial en minúsculas o mayúsculas.
f, F: coma flotante decimal.
g, G: coma flotante mixta.
c: un único carácter.
r, s, a: cadenas de texto a mostrar con repr(), str() o ascii().
%: carácter porcentaje (escape).
Cadenas Formateadas:
nombre="José"; print(f"Su nombre es {nombre}")

Datos Binarios

bytes: secuencia inmutable de bytes. Se definen como textos ASCII con una b delante:
bin = b'abc'; bin = b"abc" # Comillas simples y dobles.
bin = b"""abc"""; var b='''abc''' # comillas múltiples simples y dobles.
bin = rb'abc' # También admite texto en crudo anteponiendo una r.
bin = bytes.fromhex('F3C5 AA67') # Desde texto en hexadecimal.
bin[0] # Devuelve un entero.
bin[0:1] # Devuelve un bytes de longitud 1.
list(bin) # Devuelve una lista de números que se corresponden con cada uno de los bytes.
bytearray: secuencia mutable de bytes y, por lo tanto, admite los operadores y métodos de las secuencias mutables, pero no se puede definir como textos, sólo con constructor:
bin = bytearray(b'abc')
bin = bytearray.fromhex('F3C5 AA67') # Desde texto en hexadecimal.
bin[0] # Devuelve un entero.
bin[0:1] # Devuelve un bytearray de longitud 1.
list(bin) # Devuelve una lista de números que se corresponden con cada uno de los bytes.
Métodos:

bin.count(obj, ini, fin) # Número de veces que aparece obj. ini y fin son opcionales.
bin.find(sub, ini, fin), bin.rfind(sub, ini, fin) # Búsqueda de bytes (–1 si no existe).
sep.join(bytes) # Concatena la secuencia de bytes separados por el bytes sep.
bin.partition(sep), bin.rpartition(sep) # Tupla con 3 elementos: 1a parte, separador y resto.
bin.replace(old, new, count) # Reemplazo de bytes por otros.
bin.split(sep, max), bin.rsplit(sep, max) # Lista de bytes, partidas por el byte sep.
bin.splitlines() # Divide según los saltos de línea.
bin.translate(dicc) # Realiza los cambios indicados en el diccionario.
bin.maketrans(desde, a) # Crea un diccionario de traslaciones para bin.translate(dicc).
bin.upper(), bin.lower(), bin.capitalize(), bin.title(), bin.swapcase(), bin.casfold() # May/Min.
bin.isalnum(), bin.isalpha(), bin.isdigit(), bin.islower(), bin.isspace(), bin.istitle(), bin.isupper()
bin.startswith(obj, ini, fin), bin.endswith(obj, ini, fin) # Si empieza o termina por ciertos bytes.
bin.strip(), bin.lstrip(), bin.rstrip() # Quita los espacios en blanco iniciales y/o finales.
str.zfill(cant) # Rellena con ceros a la izquierda hasta una cantidad.
bin.expandtabs(ancho) # Convierte tabuladores en espacios en blanco.
bin.rjust(ancho), bin.ljust(ancho), bin.center(ancho) # Justificación de bytes.
bin.decode(encoding='utf-8') # Texto Unicode a partir de los bytes. str.encode() al contrario.

memoryview: permite manejar bytes de un objeto binario en memoria:
mem = memoryview(bin) # Acceso a los bytes de bin.
mem[2:10] # Permite el particionado.

Atributos:

mem.obj # Referencia al objeto binario que está manejando.
mem.nbytes # Espacio en bytes ocupados en memoria. No es igual a len(mem)
mem.readonly # Si los bytes son de sólo lectura o no.
mem.format # Formato en los que están representados los bytes.
mem.itemsize # El tamaño en bytes que ocupa cada elemento.
mem.ndim # Nº de dimensiones si es un array de bytes.
mem.shape # Forma de cada dimensión.
mem.strides # Tamaño de acceso a cada elemento de cada dimensión.
mem.contiguous # Si la memoria es contigua.

Métodos:

mem.tobytes() # Convierte a objeto tipo bytes, igual a bytes(mem)
mem.tolist() # Devuelve una lista de enteros representando los bytes.
mem.release() # Libera los bytes manejados, mientras están bloqueados.
mem.cast(formato) # Convierte los bytes a un nuevo formato.

Operadores

Aritméticos: + (suma), – (resta, negación), * (multiplicación), ** (exponenciación), / (división con decimales), // (división entera), % (módulo), @ (multiplicación de matrices) [no existe: ++ o – –].
Bit: & (AND), | (OR), ^ (XOR), ~ (NOT), <<, >> (desplazamientos).
Texto: + (concatenar), * (concatenar varias veces), % (formateo).
Asignación: = (simple), +=, –=, *=, **=, /=, //=, %= (compactas). Admite la asignación múltiple:
x, y, z = 1, 2, 3
v = (1, 2, 3,); x, y, z = v
def foo(){ return (1, 2, 3,) }; x, y, z = foo()
i, lista[i] = 2, 20 # i=2; lista[2]=20
if(n:=len(a)) > 10: print("longitud: {0}".format(n)) # Expresiones de asignación con ':='.
Lógicos: and (Y), or (O), not (negación), == (igualdad), != (distinción), <, >, <= ,>= (orden), in, not in (inclusión). En las condiciones:

No se podrá realizar asignaciones en condiciones: evita el problema entre = y ==.

Walrus Operator: ahora lo permite si se usa := en vez de =.

Y/O: se evalúa hasta la primera condición que devuelva False:
a AND b OR c # Si b es False, no se evalúa c.

AND: devuelve el último elemento que sea True:
val = a AND b # val valdrá b si es True, en caso contrario, a si es True, o None si ninguno.
OR: devuelve el primer elemento que sea True:
val = a OR b # val valdrá b si es True, en caso contrario, a si es True, o None si ninguno.
val = var OR defecto # Permite asignar valor por defecto si var es False.

Encadenamiento: está permitido hacer: a < b < c # Equivale a: a < b AND b < c
Colecciones: se pueden comparar listas con tuplas sin problemas.
Clases: definir funciones __eq__(), __ne__(), __lt__(), __le__(), __gt__() y __ge__()

Funciones Built-in (Incorporadas)

Booleanos:
bool(objeto) # Convierte objeto a booleano.
Números:
int(objeto, base=10) # Convierte un objeto a un número según una base [__int__()].
hex(numero) # Convierte un número en hexadecimal.
oct(numero) # Convierte un número en octal.
float(objeto) # Convierte objeto a float [__float__()].
complex(objeto) # Convierte un objeto en número complejo.
Textos:
ascii(objeto) # Representación en ASCII del objeto.
chr(entero) # Devuelve el carácter cuyo Unicode es el entero indicado.
ord(caracter) # Devuelve el entero asociado al caracter Unicode indicado.
str(objeto, encoding) # Convierte un objeto a cadena de texto.
format(objeto, formato) # Devuelve texto formateado del objeto [__format_()].
Binarios:
bin(entero) # Convierte entero en un carácter binario [__index__()].
bytes(objeto) # Trata el objeto como bytes.
bytearray(binarios) # Convierte objeto binario en una lista de bytes.
memoryview(objeto) # Maneja un objeto binario en memoria.
Secuencias:
list(objeto) # Convierte un objeto en una lista.
tuple(objeto) # Convierte un objeto en una tupla.
set(objeto) # Convierte un objeto en un conjunto.
forzenset(objeto) # Convierte un objeto en un conjunto inmutable.
dict(objeto) # Convierte el objeto en un diccionario.
len(secuencia) # Devuelve el número de elementos de una secuencia.
all(secuencia) # Si todos los elementos de la secuencia son True.
any(secuencia) # Si alguno de los elementos de la secuencia es True.
enumerate(secuencia) # Devuelve lista de tuplas (número, elemento) [__next__()].
iter(secuencia) # Devuelve un iterador para la secuencia [__iter__(), __next__(), __getitem__()].
next(iterador, defecto) # Devuelve el siguiente elemento según un iterador [__next__()].
sorted(secuencia, key, reverse) # Ordena una secuencia.
reversed(secuencia) # Da la vuelta a una secuencia [__reversed__(), __len__(), __getitem__()].
Clases:
isinstance(objeto, clase) # Indica si un objeto es instancia de una clase.
issubclass(clase, padre) # Indica si una clase hereda de otra clase.
super(clase, objeto) # Obtiene la instancia padre del objeto actual.
property(func_get, func_set, func_del, doc) # Define una propiedad [@property].
classmethod(funcion) # Define una función como método de clase [@classmethod].
staticmethod(funcion) # Define una función como un método estático de clase [@staticmethod].
hash(objeto) # Devuelve un hash del objeto [__hash__()].
id(objeto) # Devuelve un identificativo único del objeto.
repr(objeto) # Devuelve una representación en texto del objeto [__repr__()].
Entrada/Salida:
input(pregunta) # Pregunta al usuario y devuelve la respuesta en texto.
print(objetos, end, file) # Imprime los objetos por pantalla o en un archivo.
open(ruta, modo, encoding) # Devuelve el contenido de un archivo de texto.
Matemáticas:
abs(numero) # Valor absoluto de un número.
round(numero, decimales) # Redondea un número a una cantidad de decimales.
divmod(dividendo, divisor) # Divide a entre b y devuelve la tupla (cociente, resto).
max(números), min(números) # Devuelve el número mayor o menor, admite valor por defecto.
sum(números) # Devuelve la suma de los números.
range(incio, fin, salto) # Devuelve una secuencia de números.
slice(inicio, fin, salto) # Devuelve un objeto tipo slice.
pow(base, potencia, modulo) # Devuelve base**potencia o base**potencia % modulo.
Programación Funcional:
filter(funcion, secuencia) # Nueva secuencia filtrando elementos con la función indicada.
map(funcion, secuencia) # Nueva secuencia aplicando a cada elemento la función indicada.
zip(secuencias) # Lista de tuplas con los elementos que ocupan la misma posición.
Introspección:
help(objeto) # Muestra la ayuda asociada a un objeto.
dir(objeto) # Muestra una lista con todos los atributos del objeto [__dir__()].
vars(objeto) # Devuelve la lista de elementos definidos en __dict__.
globals() # Devuelve una lista con todas las variables globales.
locals() # Devuelve una lista con todas las variables locales. Similar a dir().
callable(object) # Si el objeto puede ser invocado como una función [__call__()].
setattr(objeto, nombre) # Agrega un nuevo atributo en un objeto [__setattr__()].
delattr(objeto, nombre) # Elimina un atributo de un objeto [__delattr__()].
getattr(objeto, nombre) # Obtiene el valor de un atributo [__getattr__()].
hasattr(objeto, nombre) # Indica si el objeto tiene un atributo [__hasattr__()].
type(objeto) # Devuelve el tipo de objeto.
del(objeto) # Elimina una variable, objeto, clase, módulo. Equivale a: del objeto.
compile(codigo) # Compila un código para ser ejecutado con exec() o eval().
eval(codigo), exec(código) # Ejecuta código Python. ¡Evitar!
Manejadores de Contexto (archivos, hilos):
with obj as nombre: nombre.atributo # Se encarga de liberar el objeto al final.
obj.__enter__() # Método invocado al principio del contexto.
obj.__exit__() # Método invocado al final del contexto, que se encarga de liberar.

Colecciones

Tipos

Secuencias: list, tuple, range, bytes, bytearray, memoryview, str
Conjuntos: set, frozenset
Mapeados: dict, namedtuple

Operadores

Pertenencia:
elemento in colección
elemento not in colección
Desempaquetado:
v=[1,2,3]
def foo(a, b, c): …
foo(*v) # * para listas, tuplas o conjuntos; ** para colecciones.
Concatenación:
colección1 + colección2
colección * número
Particionado (Slice): colecc[inicio:fin:salto], por ejemplo: otra_colecc = colecc[3:10:2].
Se puede omitir algunos o todos, y el rango va desde el primero, incluido, hasta el segundo, sin incluir (admite también índices negativos). Si no se indica un valor, se sobreentiende, por lo que copiar una lista se hace con: copia = lista[:].
colecc = ['a', 'b', 'c', 'd', 'e',]
colecc[1:3] → ['b', 'c',]
colecc[2:–2] → ['c', 'd',]
colecc[:4] → ['a', 'b', 'c', 'd',]
colecc[3:] → ['d', 'e',]

También permiten la modificación de una secuencia (si es mutable):
colecc[1:3] = ['B', 'C'] → colecc = ['a', 'B', 'C', 'd', 'e',]
colecc[2:4] = [] → colecc = ['a', 'B', 'e',]
colecc[:] = [] → colecc = []

Listas (list)

Secuencia ordenada y mutable de elementos, no tienen que ser del mismo tipo de dato.
Definición: lista = [1, "a", True, [1, 2,],]; lista = list(); lista = []
Elementos:

Acceso: var = lista[0] # Mediante un índice numérico.
Modificación: lista[0] = 12
Eliminación: del lista[0]

Los índices negativos comienzan a contar desde el final, siendo -1 el último elemento de la lista, -2 el penúltimo, etc. (lista[-n] = lista[len(lista) – n])

Métodos:

lista.append(obj) # Añadir objetos al final, equivalente a: lista[len(lista):]=[obj]
lista.extend(otra) # Concatena al final otra lista, equivalente a: lista[len(lista):] = otra
lista.insert(índice, obj) # Inserta elemento en la posición indicada (puede ser negativo).
lista.remove(obj) # Elimina primera ocurrencia de obj.
lista.pop(índice) # Devuelve el elemento de la lista. Si no se indica índice, devuelve el último.
lista.index(obj, inicio, fin) # Primera posición del elemento buscado. Si no existe, arroja excepción: para evitarlo, se puede usar 'obj in lista'.
lista.count(obj) # Devuelve el número de veces que aparece obj entre los elementos.
lista.clear() # Borra todos los elementos de la lista.
lista.copy() # Crea una copia de la lista, equivalente a: lista[:]
lista.reverse() # Le da la vuelta a la lista.
lista.sort(cmp=None, key=None, reverse=False) # Ordena la lista: cmp es la función de comparación y key es una función que se aplica a cada elemento antes de compararlo.

Tuplas (tuple)

Secuencia ordenada e inmutable de elementos (una vez creada no se puede modificar) y no tienen por qué ser del mismo tipo. Su ventaja frente a las listas es que son más ligeras.
Definición: tupla = (1, "a", True); tuple = tuple(); tupla = () # Alternativa: tupla = 1, "a", True
Para definir tuplas de sólo 1 elemento, hay que añadirle una coma final: tupla=(1,) # tupla=1,
Elementos:

Acceso: var = tupla[0]
Modificación o Eliminación: no admite, al ser una colección fija.

Métodos: no tiene, porque es inmutable.

Conjuntos (set)

Colección no ordenada y mutable de elementos únicos e inmutables, que no tienen que ser del mismo tipo (para conjuntos inmutables se usa frozenset()).
Definición: conjunto = {1, 2, 3}; conjunto = set() # dicc = {} sería un diccionario vacío.
Operaciones: a | b (unión), a & b (intersección), a – b (diferencia), a ^ b (diferencia simétrica).
Métodos:

conjunto.add(obj) # Agrega un elemento al conjunto.
conjunto.update(conj) # Agrega los elementos de otros conjuntos o listas al actual.
conjunto.discard(elem) # Quita un elemento del conjunto, no falla si no existe.
conjunto.remove(elem) # Quita un elemento del conjunto, falla si no existe.
conjunto.pop() # Quita y devuelve un elemento aleatorio del conjunto.
conjunto.clear() # Quita todos los elementos, dejando al conjunto vacío.
conjunto.copy() # Crea una copia del conjunto.
conjunto.issubset(otro) # Indica si el conjunto es subconjunto de otro.
conjunto.issuperset(otro) # Indica si el conjunto engloba a otro.
conjunto.isdisjoint(otro) # Si no tienen elementos en común.
conjunto.union(otros); # Equivale a: conjunto1 | conjunto2 | conjunto3 | ...
conjunto.intersection(otros); # Equivale a: conjunto1 & conjunto2 & conjunto3 & ...
conjunto.difference(otros); # Equivale a: conjunto1 – conjunto2 – conjunto3 – ...
conjunto.symmetric_difference(otros) # Equivale a: conjunto1 ^ conjunto2 ^ conjunto3 ^ ...
conjunto.intersection_update(otros) # Actualiza con la intersección de los otros.
conjunto.difference_update(otros) # Actualiza con la diferencia de los otros.
conjunto.symmetric_difference(otros) # Actualiza con la diferencia simétrica de los otros.

Diccionarios (dict)

Colecciones no ordenadas y mutable de elementos, donde se asocia una clave con un valor (mapeados). La clave debe ser de tipo inmutable (números, cadenas, booleanos o tuplas).
Definición: dicc = {"clave1": 1 , "clave2": 2,}; dicc = dict(); dicc = {}
Elementos:

Acceso: var = dicc["clave1"] # Da un error si no existe clave1 [__missing__()].
Modificación: dicc["clave1"] = 3 # Si no existe la clave, la agrega sin dar error.
Eliminación: del dicc["clave1"] # Si no existe, da un error.

Métodos:

dicc.has_key(k) # Si el diccionario posee la clave k, similar a 'k in dicc'.
dicc.get(k, d) # Similar a 'dicc[k]', pero si no existe k se devuelve d por defecto.
dicc.setdefault(k, d) # Devuelve un valor de la clave k pero, si no existe, lo agrega con valor d.
dicc.items() # Devuelve lista de tuplas tipo clave-valor: [(clav1, val1), (clav2, val2)].
dicc.keys() # Devuelve una lista con las claves.
dicc.values() # Devuelve una lista con los valores.
dicc.pop(k, d) # Quita la clave k y devuelve su valor. Si no existe k devuelve d.
dicc.popitem() # Quita y devuelve un par clave-valor aleatorio del diccionario.
dicc.clear() # Vacía el diccionario de elementos.
dicc.copy() # Crea una copia del diccionario.
dicc.fromkeys(k, inicial) # Crea diccionario con las claves de k y cada una con valor inicial.
dicc.update(**datos) # Actualización masiva de elementos: dicc(uno=1, dos=2, tres=3)

Enumeraciones

Módulos:
from enum import Enum # Enumeraciones normales de texto.
from enum import IntEnum # Enumeraciones sólo de números (similares a otros lenguajes).
Definición:

Normal:
class Valores(Enum):
uno=1
dos=2
tres=3
Compacta:
val = Enum('Valores', 'uno dos tres', start=10) # Les asigna automáticamente el 10, 11 y 12.
Lista de Tuplas:
val = Enum('Valores', [('uno', 1), ('dos', 2), ('tres', 3),])
Diccionario:
val = Enum('Valores', {'uno': 1, 'dos': 2, 'tres': 3,})
Valores Únicos:
from enum import Enum, unique
@unique # Los valores de las claves no se pueden repetir.
class Valores(Enum):
uno=1
dos=2
tres=3

Uso:
Valores.uno # Devuelve par clave-valor.
Valores.uno.name # Devuelve el nombre de la clave: 'uno'.
Valores.uno.value # Devuelve el valor de la clave: 1.
Valores(1) # Acceso como lista, devuelve el enum de la primera clave.
Valores['uno'] # Acceso como diccionario, devuelve el enum asociado a la clave.
Valores.dos == 2 # False con Enum, True con IntEnum.

Otros

Colas: clase Queue del módulo queue. Sus métodos más usados son put(valor) y get().
También existe un implementación en colecctions.deque.
Tuplas con Nombre: en collections.namedtuple, sustituyen los struct de C.
namedtuple('Punto', 'x y'); punto = Punto(1, 2); punto.x; punto.y
Clases: UserList, UserDict y UserString sirven como clases bases de objetos que funcionan como listas, diccionarios o cadenas de texto, pero con funcionalidad adicional y potenciada.

Control de Flujo

Los bloques de sentencias se definen por indentación (4 espacios en blanco o 1 tabulador) en vez de con llaves.

Atención: no mezclar nunca tabuladores con espacios, es mejor usar siempre espacios.

Condicionales

Definición: if condicion : … elif condicion : … else : … # Si la condición es muy larga, ponerla dentro de unos paréntesis permite escribirla en varias líneas.
Forma compacta: var = "valor1" if condicion else "valor2"

Si es muy larga, se puede indicar en varias líneas de la siguiente forma:
variable = algo_bastante_largo \
if condición_larga \
else otro_valor_bastante_largo

Switch-Case: no existen porque pueden emularse con diccionarios:

dicc = {'a': func1, 'b': func2, 'c': func3}; dicc[clave]()

Aseveraciones: assert condicion, 'mensaje error' [AssertionError]

Bucles

Definición: while condicion: instrucciones
Secuencias: sólo opera en secuencias (similar a foreach):
for elemento in secuencia:
instrucciones

No se puede modificar la secuencia que está iterando, para eso hay que iterar en una copia:
for elem in lista[:]: # Iteración sobre una copia de la lista
if condicion: lista.remove(elem) # Modificación de lista si se cumple condición.

Para iterar sobre una secuencia de números, se usa range(inicio, fin, paso):
for i in range(10, 20, 2): # Itera sobre 10, 12, 14, 16 y 18.
print(i)

Alteración del Bucle: con break y continue.

Si se agrega un else al final de un bucle while o for, se ejecuta si llega al final del bucle sin haberse ejecutado un break:
for elem in lista:
if condicion: break # Si la lista está vacía, nunca se ejecuta el break.
else:
instrucción # Sólo se ejecuta esto si no se ejecuta el break.

Funciones

Sólo existen funciones, no procedimientos: si no se indica nada devuelve None.
Los datos inmutables se pasan por valor y el resto se pasan por referencia.
Docstring: cadena de texto que sirve como documentación de la función. Debe ir justo después de su declaración y es de la forma """ documentación """. Se muestra con funcion.__doc__.
Para indicar que no se hace nada, se usa pass. Se utiliza cuando se está creando nuevo código.
Definición:
def funcion (param1, param2) : … return valor
def funcion (param1, param2, param3=defecto) : … # valores por defecto, al final siempre.
def funcion2 (param1, *otros) : ... # nº variable de parámetros (tupla)
def funcion2 (param1, **otros) : … # nº variable de parámetros (diccionario)
def funcion2(*params, param2=defecto) # Tras nº variable, argumentos con nombre y defecto.
Llamada:
funcion(val1, val2, val3) # Los parámetros, internamente, son diccionarios.
funcion(val1, val2) # val3 tendrá el valor por defecto.
funcion(param2=val2, param1=val1) # Se pueden invocar en cualquier orden.
funcion2(val1, val2, val3, val4) # con tupla (val2, val3, val4)
funcion2(val1, dos=2, tres=3) # con diccionario { dos: 2 , tres: 3, }
Alcance de Variables: para modificarlas dentro de una función, hay que redefinirlas con global:
a = 123
def foo():
global a # Sin esto, cuando termina de ejecutarse la función, a vale 123. Con esto, vale 234.
a = 234

Para referenciar una variable que está en una función padre, se debe redefinir con nonlocal:
def padre():
a = 123
def hija():
nonlocal a # Con esto, cuando termina la función hija, se ha modificado a = 234.
a = 234

Paso de Secuencias de Argumentos (con Desempaquetado):
lista = [10, 20, 2]; range(*lista)
dicc = {start:10, stop:20, step: 2,}; range(**dicc)
[*range(4)] → [0, 1, 2, 3]
Anotaciones: sirve para indicar los tipos de los parámetros y el tipo de dato devuelto.
def foo(param1: str, param2: str = defecto) -> str:
print(foo.__annotations__) # Muestra los tipos de los parámetros y el del valor devuelto.
Forzado de Posiciones de Parámetros: no se podrán invocar indicando su nombre.
def foo(a,b,/,c,d) # Son los que van antes de la barra /.
foo(1,2,d=12,c=23) # Los dos primeros son siempre a y b en ese orden.
foo(a=1, b=2) # Esto da un error, no pueden invocarse con nombres aunque cumplan orden.
Atributos de las Funciones:

__defaults__ # Valores por defecto de los argumentos.
__kwdefaults__ # Valores por defecto de los argumentos pasados por clave.
__dict__ # Todos los atributos de la función.
__globals__ # Variables globales de la función.
__annotations__ # Los tipos de los parámetros y el del valor devuelto por la función.
__code__ # Código compilado de la función.
__closure__ # Información de la clausura de la función.

Metadatos: se pueden asociar atributos a la función:
def foo(): … foo.atributo="valor"; # Si el atributo no existe se agrega como metadato.

Clases

Definición:
class Clase:
"""Documentación de la clase"""
def __init__(self):
"""Documentación del inicializador, que es una especie de constructor"""
…
# Lo primero que no esté tabulado marca el final de la clase.
Métodos/Variables:
def metodo (self, param): # todos deben llevar el self como primer parámetro.
self.var = param # Dentro de la clase, los métodos y las variables llevan self delante.
self.otro_metodo() # Para llamar a métodos o variables siempre hay que anteponer self.
def __init__(self, dato):
self.var = dato # Los atributos de instancia se definen siempre dentro de __init__.
metodo.__self__ # Referencia al objeto en el que opera el método.
metodo.__func__ # Referencia a la función asociada al método.
metodo.__func__.atributo="valor" # Se permite agregar atributos a los métodos.
Atributos de Clase (compartidos por todas las instancias de la clase):
class Clase:
atrib = "..." # Definidas a nivel de clase, no en __init__ (compartidas por todas las instancias).
def __init__(self): self.__class__.atrib # Se acceden mediante self.__class__ dentro de la clase.
class Clase: pass; c = Clase(); c.attrib = 2 # Funciona, los atributos son dinámicos.
Instancia:
objeto = Clase() # No hay 'new'.
objeto.atributo # Acceso a un atributo del objeto.
objeto.var # Acceso a una variable del objeto. Si no existe la variable, la crea.
objeto.metodo() # Esto es lo mismo que Clase.metodo(objeto), de ahí el self en la definición.
Herencia: class Hijo(Padre) : … # Si no se indica, el padre es la clase object.
Herencia Múltiple: class Hijo(Padre1, Padre2) : … # el de la izquierda tiene preferencia.
Metaclases: class Clase(metaclass=meta): … # Personalización de implementaciones. La instancia de una metaclase es una clase.
Sobrescritura de Métodos: class B(A): def f(self): super(B, self).f() … # No existen como tal.
Encapsulación: def __func(self): … # Métodos y atributos con __ al principio son "privados".
Métodos Estáticos y de Clase:
func = staticmethod(func) # Convierte una función (sin 'self') en estática.
func = classmethod(func) # Convierte una función (con 'cls') en un método de la clase.
Propiedades: prop = property(getFunc, setFunc, delFunc) # Las propiedades son descriptores.
Atributos Especiales:

__dict__ # Devuelve los atributos y métodos definidos en un objeto (o módulo).
__slots__ # Alternativa al __dict__ para almacenar información (más ligero).
__class__ # Clase del objeto.
__bases__ # Clases de las que hereda el objeto.
__subclasses__ # Clases que heredan de la actual.
__mro__ # Clases en las que se buscarán los atributos del objeto.

Métodos Especiales:

__new__(cls, args) # Constructor estático de la clase, se llama antes que __init__. Se usa para personalizar la creación de instancias, en especial cuando hay metaclases.
__init__(self, args) # Inicialización, personaliza una instancia de la clase.
__prepare__(metacls, args) # Método de clase para asignar metaclases.
__del__(self) # Eliminación de una instancia y liberación de recursos.
__repr__(self) # Representación en texto del objeto, para depuración [repr()].
__str__(self) # Conversión del objeto a cadena de texto [str(), format(), print()].
__bytes__(self) # Representación en bytes del objeto [bytes()].
__format__(self, formato) # Representación en texto de los datos del objeto [format()].
__eq__(self, otro), __ne__(self, otro) # Comparación de objetos: igual y distinto.
__lt__(self, otro), __le__(self, otro) # Comparación de objetos: menor y menor o igual que.
__gt__(self, otro), __ge__(self, otro) # Comparación de objetos: mayor y mayor o igual que.
__hash__(self) # Representación numérica (entero) del objeto, para comparación.
__bool__(self) # Representación booleana del objeto, devuelve True o False.
__len__(self) # Longitud del objeto cuando es una clase contenedor [len()].
__getitem__(self, clave), __setitem__(self, clave, val) # Acceso a elementos: objeto[clave].
__delitem__(self, clave) # Eliminación de un elemento de una clase contenedor [del()].
__contains__(self, instancia) # Indica si instancia pertenece a los elementos de la clase contenedor.
__reversed__(self) # Da la vuelta a una clase contenedor [reversed()].
__iter__(self) # Devuelve un iterador para una clase contenedor [iter()].
__next__(self) # Devuelve el siguiente elemento es iterable [next()].
__dir__(self) # Devuelve la lista de atributos del objeto [dir()].
__instancecheck__(self, inst) # Comprobar si inst es instancia de la clase [isinstance()].
__subclasscheck__(self, inst) # Comprobar si inst es subclase de la clase [issubclass()].
__get__(self, inst, dueño), __set__(self, inst, valor), __delete__(self, inst) # Descriptores.
__call__(self) # Hace que la instancia de una clase actúe como una función.
__add__(self, otro), __sub__(self, otro), __mul__(self, otro), __pow__(self, otro), __truediv__(self, otro), __floordiv__(self, otro), __mod__(self, otro), __divmod__(self, otro), __lshift__(self, otro), __rshift__(self, otro), __and__(self, otro), __or__(self, otro), __xor__(self, otro) # Operaciones aritméticas binarias (definir también las que empiezan por 'r' y por 'i': __radd__(), __iadd__()).
__neg__(self), __pos__(self), __abs__(self), __invert__(self) # Operaciones aritméticas unarias.
__matmul__(), __rmatmul__(), __imatmul__() # Multiplicación de matrices (op. @).
__int__(self), __float__(self), __complex__(self), __round__(self) # Conversiones a números.
__enter__(self), __exit__(self) # Manejadores de contexto [with].

Módulos y Paquetes

Módulos

Cada archivo físico .py representa un módulo. Su nombre será el nombre del archivo físico.
La importación se puede realizar en cualquier parte del código, no sólo al inicio del mismo.
Importación:
import modulo # Sin la extensión, el archivo físico sería modulo.py
import mod1, mod2, mod3 # Importación de varios módulos.
from modulo import func1, func2 # Importar funciones concretas de un módulo.
from modulo import * # Importa todo el módulo (menos lo que empieza con '_').
import modulo as otro # Importa un módulo con otro nombre (evita conflictos).
from modulo import funcion1 as f1 # Permite acortar nombres largos importados.
Uso:
modulo.funcion() # Función del módulo, debe llevar el nombre por delante.
funcion() # Se puede usar directamente si se importó con from modulo import funcion.
modulo.__file__ # Ruta del archivo en el que está definido el módulo.
objeto.__module__ # Devuelve el nombre del módulo al que pertenece el objeto.
Módulos Importantes:

builtins: módulo principal del lenguaje Python con las clases y funciones por defecto.
importlib: manejo de importaciones: importlib.reload(modulo) # Recarga de módulo.
os: datos del sistema e instrucciones del mismo (chdir, mkdir, etc.)
os.name # Nombre del sistema: posix, nt, ce, java.
os.environ # Variables de entorno.
os.getenv(clave, defecto); os.putenv(clave, valor) # Obtener/Establecer variable de entorno.
os.uname() # Datos del sistema y la máquina.
os.getcwd() # Devuelve el directorio actual.
os.chdir("ruta") # Cambia el directorio actual a la ruta indicada.
os.chmod("ruta", "modo") # Cambio los permisos de la ruta indicada.
os.chown("ruta", uid, gid) # Cambia el propietario de la ruta indicada.
os.stat("archivo") # Metadatos y atributos del archivo.
os.listdir("directorio") # Devuelve lista con los archivos y directorios hijos.
os.scandir("directorio") # Devuelve iterador que recorre archivos/directorios hijos.
os.system("comando") # ejecuta comandos en el sistema.

os.path: manejo de rutas, directorios y archivos:
os.path.exists("ruta") # Indica si la ruta existe o no.
os.path.join("ruta", "al", "archivo.txt") # Devuelve /ruta/al/archivo.txt
os.path.split("/ruta/al/archivo.txt") # Devuelve ('/ruta/al', 'archivo.txt')
os.path.splitext("archivo.txt") # Devuelve ('archivo', '.txt')
os.path.splitdrive("ruta") # Devuelve ('unidad', 'resto')
os.path.realpath("archivo") # Devuelve la ruta completa al archivo.
os.path.basename("/ruta/al/archivo.txt") # Devuelve 'archivo.txt'
os.path.dirname("/ruta/al/archivo.txt") # Devuelve '/ruta/al'
os.path.expanduser("~") # Devuelve la ruta a la carpeta del usuario (home).
os.path.isfile("ruta") # Indica si es un archivo o no.
os.path.isdir("ruta") # Indica si es un directorio o no.
os.path.islink("ruta") # indica si es un enlace o no.
glob.glob("ruta/*.py") # Lista con rutas que coincidan con la búsqueda con comodines.

shutil: copia de archivos y directorios.
shutil.copy('origen', 'destino') # Destino puede ser un archivo o un directorio.
shutil.copy2('origen', 'destino') # Igual que copy() pero también mantiene metadatos.
shutil.copyfile('origen', 'destino') # Origen y destino son directorios.
shutil.copymode('origen', 'destino') # Copia los permisos.
shutil.copystat('origen', 'destino') # Copia los atributos.
shutil.copytree('origen', 'destino') # Copia un directorio de forma recursiva.
shutil.move('origen', 'destino') # Mueve un archivo a otro o un directorio.
shutil.rmtree('ruta') # Elimina de forma recursiva un directorio.
copy: copia de objetos cuando no son del mismo tipo (herencias y similares).
copia = copy.copy(original)
math: operaciones matemáticas.
sys: funciones útiles en Python y su interprete:
sys.argv # lista de argumentos pasados por línea de comandos (ver: getopt y argparse).
sys.argv[0] # Nombre del programa o del módulo.
sys.argv[1], sys.argv[2], etc. # Primer, segundo, etc. parámetros pasados.
sys.stdin, sys.stdout, sys.stderr # Entrada y salidas estándar.
sys.exit() # Fuerza la terminación de un script Python.
sys.path # rutas donde buscar módulos: 1. Dir. actual, 2. PYTHONPATH, 3. Instalación Python.
sys.modules # diccionario con los módulos cargados.
sys.version # Versión de Python.
sys.platform # sistema operativo (sys.winver para obtener versión de Windows).
datetime y calendar: manejo de fechas, horas y calendarios.
from datetime import date, datetime, time, timedelta, tzinfo, timezone
dia = date(año, mes, día); dia.year; dia.month; dia.day; dia.weekday
hoy = date.today()
fch = datetime(año, mes, día, hora, minutos, segundos); fch.hour; fch.minutes; fch.seconds
ahora = datetime.now()

dateutil: operaciones con fechas (relativedelta, rrule, easter y parser). [Labix.org]
Formateo de Fechas y Horas datetime.strptime()
%a Día de la semana abreviado (texto).
%A Día de semana (texto).
%b Mes del año abreviado (texto).
%B Mes del año (texto).
%c Fecha y hora en formato local.
%d Día del mes (número) [01–31].
%f Microsegundos (decimal)
%H Hora 24 [01–24].
%I Hora 12 [01–12].
%j Día del año (número) [001–366].
%m Mes del año (número) [01–12].
%M Minutos [00–59].
%p AM/PM.
%S segundos [00–59].
%U número de semana en el año [00–53] empezando en Domingo.
%w Día de la semana (número) [0–6]
%W número de semana en el año [00–53] empezando en Lunes.
%x Fecha local.
%X Hora local.
%y Año con 2 dígitos [00–99].
%Y Año con 4 dígitos.
%z UTC ±HHMM.
%z nombre UTC (texto).
%% Literal porcentaje (escape).

random: generación aleatoria de números.
random.random() # Número aleatorio en coma flotante entre 0 y 1.
random.randrange(6) # Número entero aleatorio entre 0 y 5.
random.randint(6) # Número entero aleatorio entre 0 y 6.
random.choice(['a','b','c']) # Elige aleatoriamente un elemento de la lista.
random.sample(range(100), 10) # Elige 10 números aleatorios entre el 0 y el 99.
random.shuffle(secuencia) # Baraja la secuencia y la coloca en un orden aleatorio.
itertools: mejora de iteradores y uso de combinatoria con los mismos.

Paquetes

Agrupación de módulos, y se corresponden con los directorios físicos.
Será necesario crear un archivo __init__.py, normalmente vacío, en el directorio para que sea reconocido. Dentro, se puede incluir el código de inicialización del paquete.
La variable __path__ de un paquete devuelve la ruta física al mismo.
Importación:
import paquete.subpaquete.modulo
paquete.subpaquete.modulo.func()

from paquete.subpaquete import modulo
modulo.func()

from paquete.subpaquete.modulo import func()
func()

from . import modulo # Importa el módulo desde el paquete actual (hermano).
from .. import modulo # Importa el módulo desde el paquete que contiene al actual (padre).
from … import modulo # Cada punto adicional al primero sube un nivel más (abuelo).
from ..paquete import modulo # Importa un módulo desde un paquete hermano del actual.

import paquete.subpaquete # No carga subpaquetes o módulos.
from paquete import * # Importa todo el paquete (subpaquetes y módulos). En el __init__.py, se puede definir una variable '__all__' con la lista de módulos a cargar en este caso (sino, todos).

from __future__ import modulo # Uso de una funcionalidad futura aun en preparación. Facilita la posterior migración a la misma.

Programación Funcional

Funciones Orden Superior: permite anidar funciones, usar funciones como si de otro valor se tratara, pasar funciones como parámetros o devolverlas como valor de retorno:
def uno() : print("uno")
def dos() : print("dos")
func = { "uno" : uno , "dos" : dos }
f = func["dos"]
f() # Llamada a dos() a través de variable.
func["uno"]() # Llamada directa a uno()
Iteraciones de Orden Superior sobre Listas:

map(funcion, secuencias) # Aplica la función a cada elemento de la secuencia y devuelve una lista con los resultados: def cuad(n) : return n**2 … lista=[1,2,3] ... list2=map(cuad, lista)
filter(funcion, secuencia) # Devuelve una lista con los elementos que cumplen una condición, definida por la función: def par(n) : return (n%2==0) … lista=[1,2,3] … list2 = filter(par, lista)

Funciones Lambda: creación de funciones anónimas en línea:
lista=[1, 2, 3] … list2 = filter(lambda n: n % 2 == 0, lista)
foo = lambda x, y, z: x + y == z # Se pueden pasar más de 1 parámetro.
Comprensión de Secuencias: construcción de secuencias a partir de otras secuencias:

Listas: list2 = [n**2 for n in lista if n > 15]
Diccionarios: dicc2 = {n : n**2 for n in lista if n > 15}
dicc2 = {a : a**b for a, b in dicc.items() if a > b}
dicc2 = {valor : clave for clave, valor in dicc.items()}
Conjuntos: conj2= {n**2 for n in conj if n > 15}

Generadores: funciones que generan valores sobre los que iterar. En vez de return utiliza yield. Cada vez que es llamado devuelve el elemento siguiente de los valores iterativos.

def gen(a, b, c):
while(a <= b):
yield a
a+=c
for n in gen(0, 5, 1):
print(n)

lst2 = (n**2 for n in lista) # Devuelve un generador. Igual que la comprensión de listas pero con paréntesis.
sum(i*i for in in range(10)) # Se pueden usar directamente en funciones que esperan secuencias.

lista = list(gen) # Crea una lista a partir de un generador.

Decoradores: funciones que reciben una función como parámetro y devuelve otra como salida. Suelen servir para ampliar el código de una función sin modificar a esta:

def decor(funcion):
def nueva(*args):
print("Llamada a la función", funcion.__name__)
retorno = funcion(*args)
return retorno
return nueva

decor(func)("param")

Se puede hacer más trasparente, de forma que al llamar a una función se llame realmente a la función decorada, que es la que amplia el código de esta de forma transparente:

@decor:
def func(s): # equivale a: func=decor(func)
print(s)

@decor1
@decor2
def func(): ... # equivale a: func=decor1(decor2(func))

La función que amplía el código puede tener argumentos:

def decor(funcion, argumento): …

@decor("valor")
def func(): ... # equivale a: func=decor(func)("valor")

Excepciones

Definición:

try: … except: … finally: … # finally se ejecuta siempre, de error o no.
try: … except: … else: … finally: ... # else se ejecuta si no se producen errores.
try: … except TipoError: …
try: … except TipoError as e: type(e); e.args; e.message
try: … except Tipo1Error: … except Tipo2Error: …
try: … except (Tipo1Error, Tipo2Error): … # agrupar tipos de errores en tuplas.

Lanzar excepciones:
raise TipoError # TipoError debe heredar de la clase Exception (suelen acabar en 'Error').
raise TipoError("parametro") # Paso de parámetros a la excepción.
raise # Relanzar una excepción.
Se pueden definir excepciones personalizadas heredando de la clase Exception.
Lista Completa: https://docs.python.org/3.4/library/exceptions.html

Entrada y Salida

Entrada Estándar

sys.stdin: entrada estándar.
raw_input(prompt): nombre = raw_input("¿Nombre?") # el prompt es opcional.
input(prompt): lee un texto y lo evalúa como código Python: eval(raw_input(prompt))

Salida Estándar

sys.stdout: salida estándar, se puede redireccionar a un fichero: sys.stdout = fsock
sys.stderr: salida estándar, se puede redireccionar a un fichero: sys.stderr = fsock
print: muestra información en la salida estándar, normalmente la pantalla:

print("texto", 2, a) # Las comas concatenan variables y datos a mostrar.
print("texto", file=sys.stderr) # Redirigir la salida de print hacia un fichero.
print("texto1", "texto2", end=",") # Permite indicar el texto de separación.

Archivos

Apertura:

f = open('ruta/archivo', encoding='utf-8') # f es un objeto de tipo file (UTF-8 por defecto).
f = open('ruta/archivo', mode='wb')
# Modos: r (lectura), w (escritura), r+ (lectura y escritura),
# a (agregar), b (binario, se puede combinar con los demás: rb+).

f.name # Devuelve el nombre del fichero.
f.mode # Devuelve el modo en que se abrió el fichero.
f.encoding # Devuelve la codificación del fichero.

datos = file('ruta/archivo', encoding='utf-8') # Abre un fichero, lo lee, y devuelve su contenido.

with open('ruta/archivo', encoding='utf-8') as f: … # Cierra automáticamente el archivo.

Cierre:

f.close() # Cierra el fichero f.
f.closed # Indica si el fichero está cerrado o no.

Lectura:

completo = f.read() # Lee el archivo completo.
parte = f.read(512) # Lee parte del archivo.
linea = f.readline() # Lee una línea del archivo, si es de texto.
lineas = f.readlines() # Devuelve lista con todas las líneas del archivo.
for linea in f: … # Bucle para leer líneas directamente, ya que file es también un iterador.

Escritura:

f.write("texto") # Escribe cadena de texto en el archivo y devuelve la cantidad escrita.
f.writelines(lista) # Escribe lista de cadenas de texto en el archivo.
f.flush() # Fuerza el guardado de lo que haya en el buffer intermedio.
f.truncate(tam) # Parte el archivo para que tenga como máximo tam bytes.

Posición (ficheros binarios):

f.seek(offset, p) # Se posiciona a una distancia offset del inicio (p=0), fin (p=2), actual (p=1).
f.tell() # Indica la posición actual.

Cadenas

El módulo StringIO permite manejar cadenas de texto como si fueran ficheros:

ssock=StringIO.StringIO(cadena) # Convierte una cadena a tipo de dato fichero.
ssock.read() # Se puede usar cualquier método que se use con los ficheros.
ssock.close() # Al final hay que cerrarlo, como cualquier otro fichero.

Depuración (pdb, ipdb)

pdb:

help cmd Listar todos los comandos y buscar ayuda sobre un comando.
quit/exit Salir del depurador y terminar programa.
continue Salir del depurador y seguir ejecutando programa.
list Mostrar líneas actuales de ejecución del programa. list [first [, last]]
next Ejecutar siguiente línea.
until Ejecutar hasta la línea actual.
print var Mostrar el valor de una variable.
args Muestra los parámetros de la función actual.
whatis var Indica el tipo de dato.
step func Entrar dentro de una función.
return Ejecutar resto de función y salir de ella.
break Establecer punto de parada. break ([file:]lineno | func) [, condition]
clear Quitar punto de parada. clear (file:lineno | [bpnumber]*)
disable Deshabilita puntos de parada. disable bpnumber [bpnumber]*
enable Habilita puntos de parada. enable bpnumber [bpnumber]*
ignore Ignorar punto de parada un nº de veces. ignore bpnumber count
tbreak Punto de parada de un sólo uso.
jump Indicar siguiente línea de código a ejecutar. jump lineno
where/bt Muestra la pila de funciones.
up/down Moverse por pila de funciones.
exec/! Ejecutar código Python dentro del depurador.
alias/unalias Manejo de alias para listas de comandos.

ipdb: mejora la salida y la colorea.

Expresiones Regulares

Para trabajar con expresiones regulares (tipo Perl) se usará el módulo re, y servirá para:

Definir un patrón de búsqueda para el resto de funciones:
patron = re.compile(r"patron", flags=0) # Los flags son opcionales: re.I | re.L | re.M | re.S | re.X
match = patron.search(cadena)
match = patron.match(cadena)
match = patron.fullmatch(cadena)
lista = patron.split(cadena)
lista = patron.findall(cadena)
str = patron.sub(cadena, reemplazo, cantidad=0)
str, cantidad = patron.subn(cadena, reemplazo, cantidad=0)
patron.pattern # Patrón pasado en la definición.
patron.flags # flags pasados en la definición.
patron.groups # Número de grupos capturados.
patron.groupindex # Diccionario con los grupos con nombre.
Búsqueda de patrones dentro de una cadena:
match = re.search(patron, cadena, flags=0) # Devuelve None si no lo encuentra.
Comprobar la validez de una cadena y si se ajusta a un patrón (Devuelve None si falla):
match = re.match(patron, cadena, flags=0) # Coincide el inicio de la cadena.
match = re.fullmatch(patron, cadena, flags=0) # Coincide toda la cadena.
División de cadenas buscando ocurrencias de patrones:
lista = re.split(patron, cadena, flags=0) # Si se usa grupos en patrón, también los devuelve.
Sustitución ocurrencias dentro de una cadena:
str = re.sub(patron, cadena, reemplazo, cantidad=0, flags=0)
str, cantidad = re.subn(patron, cadena, reemplazo, cantidad=0, flags=0)
Lista con todas las subcadenas que cumplen un patrón:
lista = re.findall(patron, cadena, flags)
Concidencias (MatchObject):
match.group(0) # La coincidencia encontrada al completo.
match.group(1) # El primer grupo dentro de la coincidencia encontrada.
match.group(1,2) # Tupla con los dos primeros grupos.
match.groups() # Tupla con todos los grupos.
match.groupdict() # Diccionario con todos los grupos con nombre.
match.start(grupo) # Inicio del grupo indicado. Si no se indica grupo, inicio de la coincidencia.
match.end(grupo) # Fin del grupo indicado. Si no se indica grupo, fin de la coincidencia.
match.span(grupo) # Tupla con el inicio y el fin.
match.lastindex # Índice del último grupo capturado.
match.lastgroup # Nombre del último grupo capturado.
match.re # Expresión regular asociada.
match.string # Cadena sobre la que se ha operado.

Hilos (Threads)

Se usarán los módulos thread (más bajo nivel) y threading (más alto nivel):

Creación: threading.Thread # Clase a extender para crear hilos propios.
Ejecución:
t = NuevoThread(i); t.start(); t.join() # Lanza hilo hijo y espera al padre.
Sincronización: existen locks (mutex), locks reentrantes, semáforos, condiciones y eventos.
Datos Locales: datos = threading.local() # Crea repositorio de datos en cada thread.
Corrutinas: programación asíncrona marcando los métodos con async:
async def foo():
lista = await obj.metodo()
async for elemento en lista:
…

Dentro se puede usar async for y async with.
Se puede suspender la ejecución hasta que el resultado de un método esté disponible anteponiendo await (el método debe pertenecer a un objeto que implemente __await__()).

Serialización

Se usan los módulos pickle (cPickle ha quedado obsoleto) y json:

pickle: mejorado en la versión Python 3, sobre todo en su soporte para datos binarios. Los objetos serializados no se pueden compartir con otros lenguajes:

pickle.dump(datos, fichero) # Serializa los datos en el fichero.
datos = pickle.load(fichero) # Carga los datos a partir de un fichero.
mem = pickle.dump(datos) # Serializa los datos en memoria.
datos = pickle.load(mem) # Carga los datos a partir de la memoria.

json: permite compartir los objetos serializados con otros lenguajes, aunque no tiene soporte nativo para bytes o tuplas:

json.dumps(datos) # Convierte los datos a representación JSON.
json.dump(datos, fichero) # Serializa los datos en un fichero de texto Unicode.
datos = json.load(fichero) # Carga los datos a partir de un fichero.

Bases de Datos

Python viene con una implementación de SQLite 3 integrada (módulo sqlite3).
Para trabajar con MySQL usar MySQLdb (http://mysql-python.sourceforge.net).
Parámetros: la forma de los parámetros nos lo indica sqlite3.paramstyle:

qmark: interrogaciones (select * from tabla where id=?) Por defecto para sqlite3.
numeric: número de posición (select * from tabla where id=:1)
named: nominados (select * from tabla where id=:id)
format: similares a C (select * from tabla where id=%s)
pyformat: similares a C, pero nominados (select * from tabla where id=%(id))

Conexión: se hace con sqlite3.connect(), pero los parámetros dependen de la BD. Normalmente necesita de una cadena de conexión, o ":memory:" para usar la memoria en lugar del disco:

bd = sqlite3.connect("bd.dat") # Se conecta a una base de datos.
bd.close() # Cierra la conexión con la BD.
bd.commit() y bd.rollback() para confirmar y desechar transacciones.

Operaciones: todas se realizan mediante un objeto Cursor:

c = bd.cursor() # Crea un nuevo cursor para operar con la BD.
c.close() # Cierre de un cursor.
c.execute("""select a from t where id=1""") # Lanza una sentencia SQL contra la BD.
for tupla in c.fetchall() : print(tupla) # Los resultados se guardan como colecciones de tuplas.
tupla = c.fetchone() # Devuelve el siguiente resultado.
c.execute("""select a from t where id=? and n=?""", (id, n)) # Paso de parámetros con tupla.

Documentación

Docstrings: La variable __doc__ guarda la documentación de un objeto, siendo modificable. Se define con una cadena de texto envuelta entre 3 dobles comillas: """comentario""".

PEP-257 (http://www.python.org/peps/pep-0257.html) define las convenciones para los docstring.

Pydoc: módulo que genera automáticamente la documentación en Python a partir de __doc__.
Otros: docutils, epydoc (más usado) y sphinx.

Pruebas Unitarias

Se usan los módulos unittest y doctest, propios del Python.

Doctest: cuando encuentra en la documentación una línea que comience por el prefijo ">>>" lo interpreta como código a probar, y la respuesta estará en las siguientes líneas sin el prefijo:

def cuadrados(lista) :
"""Calcula los cuadrados
>>> cuadrados([0,1,2,3])
[0,1,4,9]
"""
return [n**2 for n in lista]

def _test() :
import doctest
doctest.testmod() # Lanza los test del módulo.

if __name__ == "__main__" : _test() # Realiza los test al lanzar el módulo, no al cargarlo.

Si se tuviera que hacer varias llamadas con distintos valores, se indica el prefijo '. . .' en la línea de la llamada a la función:

""" Calcula los cuadrados
>>> for n in [0,1,2,3] :
. . . cuadrados(n)
[0,1,4,6]
"""

Unittest/PyUnit: para cada grupo de pruebas se crea una clase heredada de unittest.TestCase y se añadirán una serie de métodos que comienzan por “test”. Para hacer las pruebas se llama al método unittest.main(). La clase también posee algunos métodos que facilitan las pruebas.

También existen 2 métodos, que se podrán sobrescribir, para manejar el entorno (test fixture; introducir algún registro en una BD, crear algún fichero, etc.) con el que realizar las pruebas:

def setUp(self) : # Prepara el entorno, preparando unos datos de prueba.
def tearDown(self) : # Elimina los datos de prueba.

Distribución de Aplicaciones

Por ahora, sólo existe un módulo para empaquetado y distribución:

distutils: deberá existir un archivo setup.py que llamará al método setup de distutils.core:

from distutils.core import setup
setup(name="Programa",
version="1.0",
description="Descripción del Programa",
author="Autor",
author_email="autor@servidor.com",
url="http://www.programa.com",
license="GPL",
scripts=["programa.py"],
py_modules=["modulo"],
packages=["bd"])

Para instalar los archivos se llama a: python setup.py install

Para crear un archivo de distribución ".tar.gz" se llama a: python setup.py sdist

Para crear un archivo binario se llama a: python setup.py bdist

Tkinter

import tkinter as tk

ventana = tk.Tk()
ventana.title("Título App")
ventana.geometry("400x200")
ventana.configure(background="#000")
ventana.mainloop()
ventana.quit(); ventana.destroy()
ventana.iconify(); venana.deiconify() # Minimizar y maximizar la ventana.

class App(tk.Frame): … # Crear ventanas heredando clases.
app = App(master=ventana)
app.mainloop()

varTxt = tk.StringVar(); varEnt=tk.IntVar(); varReal=tk.DoubleVar(); varBool=tk.BooleanVar()
variable.get(); variable.set(valor)

etiqueta = tk.Label(ventana, text="Texto", fg="#F00", bg="#00F", font=("Fuente", 16))
boton = tk.Button(ventana, text="Salir", width=10, height=5, command=ventana.quit)
boton = tk.Button(ventana, text="Ejecutar", command=lambda: funcion(1)) # Pasar params.
boton.invoke() # Ejecuta la función asociada a command.
textbox = tk.Entry(ventana, textvariable=varTxt)
caja = tk.Text(ventana, width=80, height=15)
caja.insert(tk.INSERT, "Texto")
radio1 = tk.Radiobutton(ventana, text="Opción 1", value=1, variable=varEnt)
radio2 = tk.Radiobutton(ventana, text="Opción 2", value=2, variable=varEnt) # ¡Misma var!
spin = tk.Spinbox(ventana, values=(1,2,3,), textvariable=varEnt)
spin = tk.Spinbox(ventana, from_=1, to=10, textvariable=varEnt)

elemento[‘texto’]="Texto"; elemento[‘bg’]="#00F"; …
elemento.config(text="Texto"); elemento.config(bg="#00F"); …

elemento.bind("<evento>", funcion) # Control de eventos.
def funcion(event): event.widget[‘bg’]=’#F00’

elemento.pack(side=tk.LEFT) # Posicionamiento relativo.
elemento.place(x=10, y=10) #Posicionamiento absoluto.
elemento.grid(row=0, column=0) # Posicionamiento en rejilla.

imagen = tk.PhotoImage(file="imagen.png")
botonImg = tk.Button(ventana, …, image=imagen) # Puede ser cualquier control.

canvas = tk.Canvas(ventana, width=200, height=200)
canvas.create_oval(x, y, w, h, fill="#00F")
canvas.create_rect(x, y, w, h, fill="#00F")
canvas.create_line(x1, y1, x2, y2, width=2.0)
canvas.create_polygon(x1, y1, x2, y2, …, fill="#00F")

from tkinter import ttk # Librerías con más controles y más potentes.
from tkinter.ttk import * # Reemplaza los controles Tk por los Ttk.
estilo = ttk.Style()
estilo.configure("Estilo-1", foreground="#000", background="#FFF")
etiqueta = ttk.Label(ventana, text="Texto", style="Estilo-1")
notebook = ttk.Notebook(ventana)
notebook.pack(fill="both", expand="yes")
pest = ttk.Frame(notebook)
notebook.add(pest1, text="Título Pestaña")
boton = Button(pest, text="Botón en Pestaña")
combo = ttk.Combobox(ventana, values=(1,2,3,))
combo.current(2)

from tkinter import messagebox as mb
mb.showinfo("Título", "Mensaje")
mb.showwarning("Advertencia", "Mensaje")
mb.askquestion("Título", "Pregunta")
mb.askyesno("Título", "Pregunta")
mb.askokcancel("Título", "Pregunta")
mb.askretrycancel("Título", "Pregunta")

from tkinter import simpledialog as sd
sd.askstring("Título", "Mensaje")

VirtualEnv

Instalar: pip install virtualenv
Crear: virtualenv entorno # Crea la carpeta entorno para guardar librerías del entorno virtual.
Activar: source entorno/bin/activate # En Windows sería: .\entorno\Scripts\activate
Desactivar: deactivate # Estando dentro de un entorno.

Bibliografía

Web Oficial [http://www.python.org]

Python Tutorial [http://www.python.org/doc/current/tut/]
Python Reference Manual [http://www.python.org/doc/current/ref/]
Python Library Reference [http://www.python.org/doc/current/lib/]
Python Style Guide [http://www.python.org/doc/essays/styleguide.html]
Python PyPI [http://www.pypi.python.org/] Índice de paquetes.

Python Para Todos (Raúl González Duque) [http://mundogeek.net/tutorial-python/]
Dive Into Python (Mark Pilgrim) [http://diveintopython3.org/]

Módulos Interesantes

Cadenas de Texto:

re: expresiones regulares.
difflib: diferencias entre archivos.
formatter: formateo avanzado (obsoleto).

Tipos de Datos:

datetime: fechas y horas.
calendar: días, semanas, meses y años del calendario.
collections: namedtuple, deque, Counter, OrderedDict, defaultDict.
headq: cola de prioridad.
array: listas homogéneas de tipos básicos.
sched: programador de tareas.
UserList, UserDict: clases base para listas y diccionarios personalizados.
copy: copia de objetos no básicos.
pprint: mostrar listas de forma tabulada (prettyprint)

Matemáticas:

math: funciones matemáticas típicas.
decimal, fractions: decimales y fracciones.
random: números aleatorios.
itertools: utilidades de permutación y combinación.

Archivos y Directorios:

os.path: manejo de rutas.
shutil: copia de archivos y directorios.
filecmp: comparación de archivos y directorios.
tempfile: archivos temporales.
glob: búsqueda avanzada de archivos y directorios.
linecache: acceso aleatorio a archivos de texto.

Serialización: pickle, shelve, sqlite3, json.
Compresión: zlib, gzip, bz2, lzma, zipfile, tarfile.
Base de Datos: csv
Criptografía: hashlib (incluye md5 y sha).
Sistema Operativo:

os: gestiones del sistema operativo.
time: hora de la máquina.
optparse: argumentos por línea de comandos.
loggin: registro de operaciones (archivos LOG).
curses: librería de 'recuadros' para consola.
platform: arquitectura, máquina, plataforma, etc.
errno: errores del sistema.
threading: multihilo.
subprocess: gestión de procesos.
socket: gestión de puertos.
signal: gestión de señales.
winreg: registro de Windows (Microsfot).

Internet: email, mimetypes, html, xml.dom, xml.sax, webbrowser, urllib, http, ftplib, poplib, ipaddress, ssl, xmlrpc.
Multimedia: audioop, imageop, wave, colorsys, imghdr (tipo de imagen), sndhdr (tipo de sonido), pillow (antiguo PIL).
Internacionalización: gettext, locale, codecs.
GUI: Tkinter, PyGTK, PyQT, wxPython.
Desarrollo: doctest, unittest, pydoc.
Depuración: bdb, pdb, timeit, trace, inspect, imp, profile, pstats.
Python:

sys: parámetros y funciones.
abc: clases base abstractas.
gc: recolector de basura.
distutils: distribución de paquetes.
typing: herramientas para manejar anotaciones de funciones.
zipapp: crear y ejecutar aplicaciones python comprimidas con ZIP.




He leído y acepto los Términos y Condiciones Legales

Generalidades

Comentarios

Tipos Básicos

Booleanos (bool)

Números

Cadenas de Texto (str)

Datos Binarios

Operadores

Funciones Built-in (Incorporadas)

Colecciones

Tipos

Operadores

Listas (list)

Tuplas (tuple)

Conjuntos (set)

Diccionarios (dict)

Enumeraciones

Otros

Control de Flujo

Condicionales

Bucles

Funciones

Clases

Módulos y Paquetes

Módulos

Paquetes

Programación Funcional

Excepciones

Entrada y Salida

Entrada Estándar

Salida Estándar

Archivos

Cadenas

Depuración (pdb, ipdb)

Expresiones Regulares

Hilos (Threads)

Serialización

Bases de Datos

Documentación

Pruebas Unitarias

Distribución de Aplicaciones

Tkinter

VirtualEnv

Bibliografía

Módulos Interesantes