Introducción a la Computación. Python avanzado. Maximiliano Geier. Facultad de Ciencias Exactas y Naturales, UBA 24/06/2015

Transcripción

1 Introducción a la Computación Python avanzado Maximiliano Geier Facultad de Ciencias Exactas y Naturales, UBA 24/06/2015 Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

2 Programando a lo Python Cada lenguaje de programación tiene múltiples formas de escribir las mismas cosas. Recursión for, while Clases Estructuras de datos Ciertas construcciones son más comunes que otras, se habla de idioms. En Python el código idiomático se lo conoce como pythónico 1. Lo que se intenta es mejorar la legibilidad del código. No necesariamente más ĺıneas (ni menos) implica más legible, el criterio depende mucho del lenguaje. Vamos a ver algunos ejemplos de idioms en Python (y otros truquitos varios). 1 Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

3 Manejo de strings tradicional Python es muy cómodo para procesar cadenas de caracteres. Algunos ejemplos de cosas que se pueden hacer: Construir una lista separando una cadena por algún separador: >>> e.jem.plo.split(. ) [ e, jem, plo ] Volver a armarla: >>> -.join( e.jem.plo.split(. )) e-jem-plo Particionar por un separador: >>> primero:segundo:tercero.partition( : ) ( primero, :, segundo:tercero ) Separar el nombre de un archivo: >>> /home/mgeier/laberinto.txt.rpartition( / ) ( /home/mgeier, /, laberinto.txt ) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

4 Manejo de strings tradicional (continuación) Reemplazar texto: >>> sarasa.replace( s, z ) zaraza Prefijo: >>> preprefijo.startswith( pre ) True >>> preprefijo.startswith( prefi ) False Eliminar un final de ĺınea: >>> ejemplo\n.rstrip( \n ) ejemplo Espacios delante y detrás: >>> muchos espacios.strip() muchos espacios Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

5 Context managers Podemos separar en un bloque con with el código que hace uso de un recurso, como ser un archivo. with open( ejemplo_tp.txt, r ) as f: dim = f.readline() cargardimension(dim) laberinto = f.readlines() cargarlaberinto(laberinto) Al salir del bloque with, el archivo f quedó cerrado (no hace falta llamar a f.close() expĺıcitamente). Podemos definir nuestros propios context managers en una clase: enter (self) end (self) Los objetos que definen sus propios context managers son en general los que modelan recursos que se piden y liberan (un archivo, una conexión de red, etc). Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

6 Listas por comprensión Es una construcción que permite aplicar una función a cada elemento de una lista y almacenar su resultado en una lista nueva todo en una sola ĺınea. a = [fn(x) for x in lista] Esto es equivalente al siguiente código: a = [] for x in lista: a.append(fn(x)) Un uso interesante es anidarlas : with open( tp_ej1.txt, r ) as f: puntos = [tuple(float(y) for y in x.split()) for x in f] O filtrar elementos ( los x de lista tales que sean pares ): pares = [x for x in lista if x % 2 == 0] Ojo con la legibilidad: a = [(float(x), float(y)) for x, y in [( {:.4f}.format( \ random.random()*10), {:.4f}.format( \ random.random()*10)) for _ in range(10)]] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

7 Regular expressions Regular expressions (o regexp) es la forma moderna de procesar cadenas de caracteres. Usamos un lenguaje muy sucinto para describir patrones en las cadenas de caracteres. Cada lenguaje de programación tiene su variante de lenguaje para describir expresiones regulares, pero son bastante parecidos entre sí. En Python esto está implementado en el módulo re. Podemos dar una definición recursiva de expresiones regulares: Un símbolo (que puede ser una letra, número o signo) es una expresión regular. Los caracteres especiales se escapan con una barra invertida (\). Los símbolos ^ y $ corresponden a principio y final de ĺınea respectivamente. El punto. es una expresión regular que corresponde a cualquier caracter. [c 1 c 2 c 3 ] es una expresión regular ( cualquier caracter que sea c 1, c 2 o c 3 ). \d [0-9] [ ] (cualquier dígito decimal). [^\d] corresponde a cualquier caracter que no sea un dígito decimal. \w [a-za-z] (cualquier letra). Si a y b son expresiones regulares, ab es una expresión regular. ( a y después b ). a b es una expresión regular ( a o b ). a* es una expresión regular ( a repetido 0 o más veces ). a+ es una expresión regular ( a repetido 1 o más veces ). Podemos capturar en grupos partes del match usando los paréntesis. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

8 Regular expressions (ejemplos) Para procesar un timestamp: >>> re.match( (\d{4})-(\d{2})-(\d{2})t(\d{2}):(\d{2}):(\d{2}), \ T10:56:04 ).groups() ( 2015, 05, 06, 10, 56, 04 ) Para procesar el laberinto: with open( laberinto.txt, r ) as f: dim = [int(x) for x in re.match( Dim\((\d+),(\d+)\), \ f.readline()).groups()] # dim = [4, 4] grid = [] for linea in f: grid.append([[bool(int(y)) for y in x.split(, )] for x in \ [x for x in re.split( [\[\]], linea.rstrip( \n )) \ if len(x) > 0]]) # grid[0] = [[True,True,False,False],[False,True,True,False], \ # [True,True,False,True],[False,True,False,True]] Buscar todos los números decimales truncando hasta un dígito fraccionario: >>> s = {2, [4, 5]; 6; { }} >>> re.findall( ([^\d] ^)((\- )\d+(\.\d )), s) [( {, 2,, ),( [, 4,, ),(, 5,, ),(, 6,, ), ( {, 3.1,,.1 ),(, -0.3, -,.3 )] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

9 Ordenamiento Python incluye un algoritmo de ordenamiento que es una variante del mergesort. Para usarlo existen dos formas: Sobre la misma lista (in place): >>> a = [1,5,7,23,0,-4,3,7,4,4,2] >>> a.sort() >>> a [-4, 0, 1, 2, 3, 4, 4, 5, 7, 7, 23] En una lista nueva: >>> a = [1,5,7,23,0,-4,3,7,4,4,2] >>> b = sorted(a) >>> b [-4, 0, 1, 2, 3, 4, 4, 5, 7, 7, 23] >>> a [1, 5, 7, 23, 0, -4, 3, 7, 4, 4, 2] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

10 Formas de iterar listas Con range (iterar los índices): for i in range(len(a)): print(a[i]) Con in lista (iterar los elementos): for x in a: print(x) Esta forma funciona con cualquier iterable (cualquier estructura que uno pueda recorrer) Se puede definir cómo funciona el in para tipos propios definiendo el método especial iter (self) enumerate (índices y elementos al mismo tiempo): for i, x in enumerate(a): print(i, x) Dos (o más) listas al mismo tiempo (ojo con las longitudes de a y de b): for x, y in zip(a, b): print(x, y) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

11 Definiendo nuestro iter Recorrer filas y columnas en un tablero de ajedrez: class Celda(object): def init (self): self.c = False class Tablero(object): def init (self, n): self.tab = [[Celda() for _ in range(n)] for _ in range(n)] def iter (self): for f in self.tab: for c in f: yield c Luego, recorremos con for celda in Tablero(n). Árbol Binario: class ArbolBinario(object):... def iter (self): for r in self.inorder(): yield r Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

12 Otras formas de iterar Recorrer en orden inverso: >>> for x in reversed(a):... print(x, end= ) Recorrer una lista de forma ascendente en los índices pares y luego descendente en los impares: def asc_desc(a): r = [] for n, x in enumerate(a): if n % 2 == 1: r.append(x) else: yield x for x in reversed(r): yield x Luego recorremos con un for normal: >>> a = [1, 4, 8, 3, 7, 0] >>> for x in asc_desc(a):... print(x, end= ) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

13 itertools Hay muchas formas de iterar ya definidas en el módulo itertools 2 : >>> [.join(x) for x in itertools.permutations( HOLA, 2)] [ HO, HL, HA, OH, OL, OA, LH, LO, LA, AH, AO, AL ] Los iteradores se pueden componer: >>> a = [1, 4, 8, 3, 7, 0] >>> list(itertools.chain(itertools.islice(a, 0, None, 2), \... reversed(a[1::2]))) [1, 8, 7, 0, 3, 4] Ojo con la legibilidad (bis): for n, elem in enumerate(lst): for comb in itertools.imap(lambda x: (elem,) + x, \ itertools.combinations(itertools.compress(lst, \ repeat_except(1, size, 0, n)), r_tail)): yield comb 2 Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

14 Formas de iterar diccionarios También podemos usar el for variable in para iterar diccionarios: >>> d = {1: Esteban, 2: Maria Elena, 3: Maximiliano, 4: Zombie } >>> for k in d:... print(k, end= ) >>> for v in d.values():... print(v, end= ) Esteban Maria Elena Maximiliano Zombie >>> for t in d.items():... print(t, end= ) (1, Esteban ) (2, Maria Elena ) (3, Maximiliano ) (4, Zombie ) Cada contenedor en Python (listas, tuplas, diccionarios, etc.) tiene definida su forma de recorrerse. El uso del for nos abstrae esta noción sin que tengamos que preocuparnos por qué estamos recorriendo. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

15 Otros métodos especiales Además de init, enter, leave y iter, otros métodos con nombres especiales permiten definir cómo funcionan ciertas operaciones entre objetos de esa clase. eq (self, b): igualdad entre self y b (devuelve un booleano). del (self): destructor de la clase (no devuelve nada). str (self): conversión de self a string (devuelve una cadena de caracteres). Ejemplo: str (self) para ArbolBinario. def str (self): return,.join(self.inorder()) Uso: >>> print(ab) 1, 3, 2 repr (self): representación textual para self. def repr (self): return str(self) Uso: >>> print([ab]) [ 1, 3, 2 ] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

16 Equivalencias entre formas de iterar a lo Python y el while for x in obj: try: i = iter(obj) while True: x = next(i) # hago algo except StopIteration: pass Para que esto funcione, tiene que estar definido iter (self) para el tipo de obj. if x in obj: try: found = False i = iter(obj) while not next(i) == x: pass except StopIteration: pass else: found = True if found: # hago algo Este if requiere además que esté definido eq (self, b) para el tipo de x. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

17 Tuple unpacking Pasar tuplas como listas de argumentos a funciones: def f(x1, x2, x3): return x1 + x2 + x3 x = (4, 5, 6) print(f(*x)) También permite asignar los elementos de una tupla a variables separadas en una ĺınea: x1, x2, x3 = x Swap: >>> a = 1; b = 2 >>> b, a = a, b >>> print(a, b) 2 1 Trasponer una matriz: >>> a = [[0,4], [1,-1], [2,5], [3,0]] >>> print(list(zip(*a))) [(0, 1, 2, 3), (4, -1, 5, 0)] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

18 Keyword arguments Permite identificar parámetros de funciones por nombre en lugar de por su posición. De esta manera algún argumento (o muchos o todos) podrían ser opcionales. Se pueden mezclar con argumentos posicionales. Los keyword arguments se acceden como un diccionario, donde la clave es el nombre del parámetro. def fn(*args, **kwargs): if arg1 in kwargs: print( me pasaron el argumento arg1 ) fn2(kwargs[ arg1 ], args[0]) else: fn3(**kwargs) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

19 Funciones como parámetros de otras funciones Las funciones en Python también son objetos (de la clase function), y como tales tienen sus propios atributos y se los puede pasar como parámetro a otras funciones. Factorización de código: def tomartiempos(fn, *args, **kwargs): inicio = time.time() res = fn(*args, **kwargs) fin = time.time() print( función: {0} tiempo: {1}.format(fn. name, fin-inicio)) return res # llama a mitp(param1, param2, param3) tomartiempos(mitp, param1, param2, param3) Funciones anónimas: >>> a = [(2, segundo ),(3, tercero ),(4, cuarto ),(1, primero )] >>> sorted(a, key=lambda x: x[0]) [(1, primero ), (2, segundo ), (3, tercero ), (4, cuarto )] >>> sorted(a, key=lambda x: x[1]) [(4, cuarto ), (1, primero ), (2, segundo ), (3, tercero )] Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

20 Funciones como parámetros de otras funciones (continuación) Decorators: def tomartiempos(fn): def f(*args, **kwargs): inicio = time.time() res = fn(*args, **kwargs) fin = time.time() print( función: {0} tiempo: {1}.format(fn. name, fin-inicio)) return res return def mitp(param1, param2): # hacer el TP return 0 Notar el def anidado. Llamar a mitp definido con el decorator es equivalente al siguiente código: f = tomartiempos(mitp) f(param1, param2) # f va a llamar a mitp Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

21 Esquemas de recursión Muchos programas recursivos tienen estructuras parecidas. Utilizando alto orden (funciones como parámetro), se pueden generalizar ciertas funciones recursivas para que sean más fáciles de escribir y de entender. Los tres esquemas de recursión que trae Python son map, filter y reduce. 3 map(fn, lista): devuelve una lista como resultado de aplicar la función fn a cada elemento de lista. def map(fn, a): if len(a) == 0: return [] else: return [fn(a[0])] + map(fn, a[1:]) 3 Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

22 Esquemas de recursión (continuación) filter(fn, a): devuelve una lista con todos los elementos de lista donde la función fn devuelva True. def filter(fn, a): if len(a) == 0: return [] else: if fn(a[0]): return [a[0]] + filter(fn, a[1:]) else: return filter(fn, a[1:]) reduce(fn, a): aplica una función fn de dos parámetros a cada elemento de a y el resultado de reducir el resto de la lista. def reduce(fn, a): if len(a) == 1: return a[0] else: return fn(a[0], reduce(fn, a[1:])) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

23 Esquemas de recursión (ejemplos) Lista con los cuadrados de cada elemento: def cuadrados(a): return map(lambda x: x**2, a) Lista de valores absolutos: def listadeabs(a): return map(abs, a) Buscar y eliminar: def buscaryeliminar(a, x): return filter(lambda y: y!= x, a) Suma de todos los elementos de a: def suma(a): return reduce(lambda x, y: x + y, a) Cantidad de apariciones: def cantidadapariciones(a, x): return suma(map(lambda w: 1 if w == x else 0, a)) Todos los elementos de a son True: def todostrue(a): return reduce(lambda x, y: x and y, a) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

24 Esquemas de recursión (más ejemplos) Todos pares: def todospares(a): return todostrue(map(lambda x: x % 2 == 0, a)) Máximo de una lista: def maximo(a): return reduce(lambda x, y: x if x > y else y, a) Suma de los valores absolutos de cada elemento de a: def sumaabsolutos(a): return suma(listadeabs(a)) Nota de implementación: en Python 3 map y filter no devuelven listas sino generadores. Los generadores son estructuras iterables (con for), pero su ventaja es que no se construyen los resultados hasta que se intenta acceder a ellos, mientras que su desventaja es que no vamos a obtener todos los elementos hasta que no hagamos un for. Para lograr este efecto hay que usar listas por comprensión. Finalmente, para usar reduce hay que importarla del módulo functools. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

25 MapReduce El concepto de map se aplica a la programación paralela para resolver problemas del tipo embarrassingly parallel. Map, combinado con los pasos de shuffle y reduce, inspiraron un modelo de cómputo para procesar distribuidamente grandes volúmenes de datos que se llama MapReduce 4. Este modelo, sumado a un filesystem distribuido para obtener los datos, permite utilizar clusters para procesar enormes cantidades de datos en poco tiempo. Hadoop es una plataforma libre de MapReduce muy utilizada. Hay aplicaciones de MapReduce para Hadoop en múltiples campos del conocimiento 5, siempre que se necesite procesar muchos datos. Si bien Hadoop es una plataforma escrita en Java, los mappers y reducers de una aplicación los podemos escribir en Python Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

26 Equivalencia entre listas por comprensión y esquemas recursivos map: [fn(x) for x in a] map(fn, a) filter: [x for x in a if fn(x)] filter(fn, a) reduce no tiene una equivalencia en listas por comprensión: # versión Pythónica acc = a[0] for x in a[1:]: acc = fn(acc, x) # reduce acc = reduce(fn, a) La forma preferida del creador de Python es el uso de listas por comprensión, o for expĺıcitos en caso de que no se pueda. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

27 Duck Typing When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck. James Whitcomb Riley ( ). El sistema de tipos de Python permite que una función pensada para operar con un tipo de datos en particular, pueda funcionar con otro diferente siempre y cuando las operaciones que dicha función tiene que hacer sobre los operandos estén soportadas por ambos tipos de datos. Estas reglas sobre los tipos se las conoce como Duck Typing. En lenguajes que no hacen uso de Duck Typing, es necesario establecer otro tipo de mecanismos para que objetos de diferentes clases puedan funcionar como parámetros de una misma función. class Pato(object): def quack(): return Cuac class Persona(object): def quack(): return Imito a un pato def duckify(d): return d.quack() >>> p1 = Persona() >>> p2 = Pato() >>> duckify(p1) Imito a un pato >>> duckify(p2) Cuac Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

28 Introspection A diferencia de ciertos lenguajes, Python nos permite pedir información del sistema de tipos a los objetos del lenguaje: isinstance(obj, cls): devuelve True si obj es una instancia de la clase cls (o de alguna de sus subclases). >>> l = Laberinto() >>> isinstance(l, object) True issubclass(subcls, cls): devuelve True si subcls es una subclase de cls. >>> issubclass(typeerror, Exception) True getattr(obj, s): devuelve el atributo o el método del objeto obj con nombre s: >>> m = getattr(l, resuelto ) >>> m <bound method Laberinto.resuelto of <Laberinto object at 0x7f23a7f217f0>> >>> m() False setattr(obj, k, v): define un atributo de nombre k en obj, con el valor v: >>> setattr(obj, resuelto, lambda: True) >>> obj.resuelto() True Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

29 Evaluación de código definido en runtime eval ejecuta código definido en una cadena de caracteres (no se pueden asignar variables nuevas): >>> a = " import ( time ).time()" >>> eval(a) >>> import ( time ).time() >>> eval( 2**4 ) 16 >>> eval( r = 2**4 ) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1 r = 2**4 ^ SyntaxError: invalid syntax El código se evalúa como una cadena de texto, así que podría venir de cualquier lado: la consola, un archivo, Internet. Ojo si no se tiene control de qué ejecutamos: >>> eval( import ("os").system("rm -rf /") ) Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

30 Ejecutando programas externos Podemos utilizar Python para sistematizar la ejecución de experimentos computacionales, es decir, una serie de comandos tediosos y repetitivos que tenemos que ejecutar secuencialmente para obtener nuestro resultado. Estas funciones están incluidas en el módulo subprocess. Para ejecutar programas y capturar su salida: >>> subprocess.check_output( echo Hello, world!, shell=true) b Hello, world!\n También podemos usar programas interactivos: >>> with subprocess.popen(shlex.split( mkpasswd -s ), \... stdin=subprocess.pipe, stdout=subprocess.pipe) as p:... password, err = p.communicate(b hola\n )... >>> password b m11/.t/.ugjjy\n Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

31 Pidiendo ayuda dir(obj): devuelve una lista con todos los métodos o atributos que tiene definido el objeto obj. >>> l = Laberinto() >>> dir(l) [ class, delattr, dict, dir, doc, eq, format, ge, getattribute, gt, hash, init, le, lt, module, ne, new, reduce, reduce_ex, repr, setattr, sizeof, str, subclasshook, weakref, cargar, esposicionqueso, esposicionrata, get, getinfocelda, getposicionqueso, getposicionrata, parent, resetear, resolver, resuelto ] También se puede usar la tecla Tab para autocompletar nombres de métodos o clases desde el intérprete de Python (no funciona en Python 2). help(obj): muestra en un formato amigable el texto escrito en obj. doc. Ejecutando desde la terminal pydoc3 -b, se abre un browser con la documentación de los help de cada módulo que haya instalado en el sistema (incluyendo los de la carpeta desde la que se ejecutó pydoc), vistos como una página web. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32

32 Terminando >>> import hello Hello world! >>> import antigravity >>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren t special enough to break the rules. Although practicality beats purity. If the implementation is hard to explain, it s a bad idea. If the implementation is easy to explain, it may be a good idea. Maximiliano Geier (UBA) Python avanzado 24/06/ / 32