====== resumen ======
<code python>

terminar las sentencias con ; es opcional
print "string", expr1, expr2, "string2", ...  # python2
print ("format string" % (arg1, arg2, arg3, ...)) # también para hacer cadenas normales sin print
# % es el operador sustitución en format strings
"Hello, {}. You are {}.".format(name, age), "Hello, {1}. You are {0}.".format(age, name)
"Hello, {name}. You are {age}.".format(name="Julian", age=22)
# También funciona con diccionarios:
person = {'name': 'Eric', 'age': 74}
"Hello, {name}. You are {age}.".format(**person)
# Desde python 3.6, f-strings. Se interpreta como código lo de dentro de {}
f"Hello, {name}. You are {age}."
f"{2 * 37}"

** exponenciación, * repeticion(listas), + concatenar(listas)
# comentario
var = input("texto") # python3
var = raw_input("texto") # python2
and en vez de &&, or en vez de ||, not en vez de !
las sentencias de control se reconocen por la indentación

while condicion:
    sentencias  
    
if condicion:
    codigo_if
else:
    codigo_else
    
elif

for i in range(0, 99, 1) # Desde 0 hasta 99 con incremento de 1
    sentencias           # for es en realidad un for each y range es una lista 
    
list = [func(x) for x in anotherlist] # Sintaxis abreviada

break, continue

def my_func (arg1, arg2 = 0): 
    return [loquesea]
    yield [loquesea] # Esto permite que la función devuelva un valor pero se siga ejecutando en la siguiente línea, por ejemplo para devolver una lista

my_array = [1,2,3,4,5]
my_array.append(6)
my_array.index(2) # Busca el (los) indice(s) que corresponden a 2 (en este caso, 1)
my_array[1] # vale 2

Una lista es parecida a un array, solo que 
my_array.sort()
len(my_array)
del (list[2])


Diccionarios

Las claves suelen ser strings, pero pueden ser int, ...
dicty = {'key1':val1, 'key2':val2, 'key3':val3}
dicty.has_key('key1')
dicty['key'] = value
dicty.keys() devuelve una lista de las claves (se puede usar como iterador para for)
dicty['key1'] devuelve val1. Tambien asigna: dicty['key1'] = foo
Para hacer un diccionario vacío dicty = {}

E/S ficheros (no hace falta librería)
fid = open("path", "modo") # modo como en C
fid.write("Foobar\n")
fid.read([max]) # max es el numero maximo de bytes que lee, si se omite hasta que se acabe
fid.close()


z = complex(1, 1) # z = 1 + i
z = 1.0 - 1.0J
z = 1.0 - 1.0j
True False
round(x, digitos)

#!/usr/bin/python

int, float

#Tanto tuples como listas pueden tener datos de distintos tipos, así que por cada entrada python tiene que
#guardar el dato y el tipo de dato. Para arrays grandes del mismo tipo, es mucho más eficiente np.array

tuples = ROM arrays
lista[inicio:fin]
lista[inicio:fin:incremento]
#Si se omite inicio o fin, se llega hasta el primer o último elemento respectivamente
#Si se omite el incremento, se asume +1
lista = [1, 2, 3, 4, 5]
lista[-1] es el último elemento, [-2] el penúltimo, etc
lista[::-1] invierte la lista
#Para indicar inicio, final o incremento con una variable
slice(inicio, fin, incremento)

tuple = ("123", 123, 123.0)
conversion
int(x[, base]) float(x) complex(real[, imag]) str(x) tuple(x)
list(x) set(x) dic(x) chr(x) unichr(x) oct(x) hex(x) oct(x)

librerias
import lib # hay que usar lib.metodo()
from lib import * # namespace = lib, puedes poner metodo()
import longlibraryname as lib # hace un alias para poder usar lib.metodo()

from random import *
randrange([start,] stop[, step])
shuffle(list)
choice(list) # devuelve un componente aleatorio de list

""" strings de 
varias lineas """

Strings (metodos y atributos)
string str
.capitalize() .count(substr, inicio, fin) # cuantas veces aparece substr en str[inicio:fin]
len(str) .find(substr, inicio, fin) igual a .index(mismos arg), pero index da excepción si no se encuentra
.isalnum() .isalpha() .isdigit() .islower() .isnumeric .isspace() .istitle() .isupper() .len
.replace(substr, nueva[, max]) remplaza las primeras max ocurrencias de substr por nueva

from os import *
rename ("actual", "nuevo")
remove("fichero")
mkdir(...), rmdir(...), chdir(...)
getwd()

try: 
    codigo
except ex1:
    codigo_excepcion_1
    raise BaseException("Ha pasado algo")
    # python tiene definidos distintos tipos básicos de excepciones
.
.
.
except exN:
    codigo_excepcion_N
else:
    code
finally:
    # siempre se ejecuta, haya excepcion o no
    
    
class name ([clases padres])
    def __init__(self, arg1, arg2) # constructor
    def __del__(self, arg1) # destructor
    __privado = 0 # atributo privado, aunque en realidad se sigue pudiendo acceder
    def __cmp__ (self, x)
    def __add__, __sub__, ...


import re # expresiones regulares
</code>