Issuu on Google+

Programaci贸n en Python Parte 1 Mariano Reingart reingart@gmail.com


Introducción: ¿Que es Python? Lenguaje de Programación creado por GvR en '90 Sintaxis clara y limpia => código legible Lenguaje interpretado ("script"), no compilado código nativo, flexibilidad vs velocidad, pseudocódigo intermedio (bytecode) Tipado dinámico: sin declaración previa Fuertemente tipado: conversión explícita Multiplataforma: unix, windows, mac, etc. Multiparadigma: estructurado, funcional, orientado a objetos, orientado a aspectos


Introducción: ¿Por qué Python? Lenguaje natural, agrupación por identación sin {} Dinámico, al no declarar variables ni argumentos Tipos de datos de alto nivel Gestión de memoria automática Gran cantidad de librerias disponibles, extensibilidad Fácil de aprender Desarrollo rápido de aplicaciones Código fácil de mantener No recomendable: bajo nivel o rendimiento crítico


Introducción: Instalación Implementacion estándar: CPython (rápida y estable) Alternativas: Jython (java), IronPython (.net) CPython: preinstalado Linux y Mac Instaladores: http://www.python.org/download/ Versiones disponibles: 2.5.4: final - solo bugfix - mayor compatibilidad 2.6.2: estable actual - características 3.x 3.1: estable, levemente incompatible hacia atras


Introducción: Herramientas básicas Interprete (línea de comandos) Ejecutar scripts IPython: interprete mejorado (autocompletado, ?) IDLE: Interprete/IDE gráfica: Autocompletado Calltips (parámetros) Edición de código fuente, con identación Depuración básica IDEs: PyDev, SPE, Eric, Boa, Komodo, WingIDE


Introducci贸n: Hola Mundo Ingresar al interprete, escribir: >>> print "hola mundo!" hola mundo!

Ingresar al editor, crear un archivo hola.py Ejecutar el archivo: python hola.py


Introducci贸n: Interprete Python 2.5.4 (r254:67916, Dec 23 2008, 15:10:54) [MSC v.1310 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> a = """ ... hola ... """ >>> a '\nhola\n' >>> print a hola

>>>


Introducción: Estructura básica Palabras claves: and as assert break class continue def del elif else except exec finally for from global if import in is lambda not or pass print raise return try while with yield Operadores: + - * ** / // % << >> & | ^ ~ < > <= >= == != <> Separadores: , : . ` = ; += -= *= /= //= %= &= |= ^= >>= <<= **= ( ) [ ] { } @ Built-in: funciones, objetos y clases incorporadas en el lenguaje por defecto Identación, espaciado y unión de líneas (\)


Introducción: Sentencias Simples Instrucciones básicas útiles: print: imprimir por pantalla o salida estándar raw_input(mensaje) / input(mensaje): entrada de datos por teclado o entrada estándar help(identificador): devuelve ayuda, argumentos, valor de vuelto, etc. dir(identificador): devuelve los atributos del objeto, módulo o nombres accesibles type(identificador): devuelve el tipo isinstance(indetificador, tipo): devuelve verdadero si es una instancia del tipo dado


Introducci贸n: Programa b谩sico #!/usr/bin/python # -*- coding: latin1 -*# sumo dos variables a=2 # entero b = 1.5 # punto flotante print a+b # pregunto el nombre, imprimo saludo nombre = raw_input("ingrese su nombre") mensaje = "hola" print mensaje, nombre


Introducción: Tipos de datos básicos Números: Enteros (int/long): 3 De coma flotante (float): 15.57 Complejos (complex): 7 + 5j Cadenas de texto: Strings (str): "Hola Mundo" Unicodes (unicode): u"año" Valores booleanos: (bool): True (verdadero) y False (falso)


Tipos de datos básicos: Enteros Tipos: int: números enteros de 32 o 64 bits long: números de cualquier precisión (prefijo L) Conversión automática int a long División devuelve enteros! >>> e = 31 >>> l = 1234567891234567L >>> e * 100000000 3100000000L >>> 7/2 3


Tipos de datos básicos: Punto Flotante Tipo: float: números reales (coma flotante de 64 bits) IEEE 754: 1 bit para el signo, 11 bits para el exponente, 52 bits para la mantisa () Notación científica: 0.1e-3 (exponente base 10) Almacenamiento binario (base 2): ocasional impresición al representar valores sin redondeo >>> f = 0.1e-3 >>> f 0.0001 >>> 0.2 0.20000000000000001


Tipos de datos básicos: Complejos Tipo: complex: números reales e imaginarios parte real e imaginaria: float (internamente) Notación: 2.1 + 7.8j >>> (0+1j)**2 (-1+0j) >>> a=3.0+4.0j # complex(3.0, 4.0) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0


Tipos de datos básicos: Operaciones Operadores aritméticos: Suma: +, resta: -, multiplicación: *, división: / Negación: -1 Potenciación: ** Módulo (resto): % Operadores a nivel de bits: Y (and): & O (or): | O exclusivo (xor) ^ No (not): ~) Desplazamiento: << y >>


Tipos de datos básicos: Cadenas Tipos: str: texto ascii puro (bytes) unicode: texto codificado (ej. utf8): u"áéí" Caracteres "escapados": '\xe1' (código hexadecimal: á), '\n' (salto de linea), '\t' (tabulación), '\\' (barra invertida) , '\'' (comilla) Comillas simples ('), dobles ("). Multilinea (comillas triples: """ o ''') Texto crudo (raw): r'C:\' es "C:\\" (sin escapar)


Tipos de datos b谩sicos: Cadenas Operadores: Concatenaci贸n (+), Multiplicaci贸n (*) Indexar [pos] y Recortar [pos1:pos2] (rebanada) No pueden ser modificadas: palabra[0] = 'x' >>> palabra = 'Ayuda' + 'A' >>> palabra 'AyudaA' >>> '<' + palabra*5 + '>' '<AyudaAAyudaAAyudaAAyudaAAyudaA>' >>> palabra[4] 'a' >>> palabra[0:2] 'Ay'


Tipos de datos básicos: Cadenas Métodos: strip(caracter): "limpiar" caracteres(espacios) split(caracter): dividir un texto find(substring, inicio, final): encontrar cadena startswith(prefijo, inicio, final): ¿empieza con? endswith(sufijo, inicio, final): ¿termina con? lower(): convertir en minúsculas upper(): convertir en minúsculas isdigit(): ¿es numérico? isalpha(): ¿es alfanumérico? islower(): ¿está en minúsculas? isupper(): ¿está en mayúsculas?


Tipos de datos básicos: Cadenas Codificación (Unicode): encode(codificación): codifica un unicode decode(codificación): codifica un string >>> u=u"äöü" >>> u.encode("latin1") '\xe4\xf6\xfc' >>> s = u.encode("utf-8") >>> s '\xc3\xa4\xc3\xb6\xc3\xbc' >>> s.decode("utf8") u'\xe4\xf6\xfc' >>> unicode('\xe4\xf6\xfc','latin1') u'\xe4\xf6\xfc'


Tipos de datos bรกsicos: Booleanos Tipo: bool: clases True (verdadero), False (falso) Caso especial de tipo int (0: falso, 1: true) Objetos vacios: falso Operadores lรณgicos: Y lรณgico: and O lรณgico: or NO lรณgico: not >>> True and False False


Tipos de datos bรกsicos: Booleanos Operadores relacionales: a Igual b: a == b a Distinto b: a != b a Mayor/Menor b: a > b , a < b a Mayor/Menor o igual b: a >= b , a <= b >>> 1 == 2 False

>>> not 'ab' > 'ba'

True


Tipos de datos compuestos Colecciones de datos: Listas (list): [1, 'a', 3.0, 1] Tuplas (tuple): (1, 'a', 3.0, 1) (no modificables) Conjuntos (set): set(1, 'a', 3.0) (sin repetidos) Diccionarios (dict): {clave: valor}


Tipos de datos compuestos: Listas list: colección ordenada, modificable. Equivalente a arrays, o vectores en otros lenguajes Pueden contener cualquier tipo de dato: números, cadenas, booleanos, … y también listas. Indicar entre corchetes, y separados por comas, los valores a incluir en la lista: >>> a = ['pan', 'huevos', 100, 1234] >>> a ['pan', 'huevos', 100, 1234]


Tipos de datos compuestos: Listas Operaciones: Acceder por 铆ndice: lista[posici贸n] Recortar: lista[inicio:final] >>> a = ['pan', 'huevos', 100, 1234] >>> a[0] 'pan' >>> a[3] 1234 >>> a[-2] 100 >>> a[1:-1] ['huevos', 100]


Tipos de datos compuestos: Listas Operaciones: Acceder por 铆ndice: lista[posici贸n] Rebanar o Recortar: lista[inicio:final] Comprobar pertenencia de un elemento: in >>> a[0] 'pan' >>> a[-2] 100 >>> a[1:-1] ['huevos', 100] >>> 'huevos' in a True


Tipos de datos compuestos: Listas Modificaciones: Por 铆ndice: lista[posici贸n] = nuevo Por "rebanada": lista[inicio:final] = nuevo Borrar con del o [] (lista vacia) >>> a[0:2] = [1, 12] # cambiar elementos >>> a [1, 12, 123, 1234] >>> a[0:2] = [] # Borrar elementos >>> a [123, 1234] # Insertar elementos >>> a[1:1] = ['bruja', 'xyzzy'] >>> a [123, 'bruja', 'xyzzy', 1234]


Tipos de datos compuestos: Listas Métodos: sort(clave): ordenar la lista (en su lugar) reverse(): revertir el órden pop(posición): extraer un elemento append(item): agrega un elemento insert(posición, item): inserta un elemento remove(item): elimina la primer ocurrencia count(item): cuenta las ocurrencias index(item): devuelve la posición del elemento extend(lista): extiende la lista con otra lista >>> a.pop()


Tipos de datos compuestos: Listas Funciones incorporadas: sorted(lista): crea una nueva lista ordenada max(lista) / min(lista) / sum(lista): devuelve el máximo, mínimo o la suma de una lista any(lista) / all(lista): verifica si algún/todos los elementos son verdaderos map(función, lista): aplica una función a los elementos de la lista filter(función, listra): filtra una lista reduce(función, lista): aplica acumulativamente una función a una lista (devuelve un valor)


Tipos de datos compuestos: Listas Definición por comprensión: crea una nueva lista aplicando una expresión (cálculo) a los elementos de otra lista que cumplan una determinada condición: [expresión for variables in iterable if condición] >>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18] >>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x []


Tipos de datos compuestos: Tuplas tuple: colección ordenada inmutable. Similar a las listas, pero no modificables Pueden accederse por posición y recortarse No tienen métodos especiales Son más "ligeras" que las listas Separar elementos por comas, (opcionalmente entre paréntesis). Incluir coma tuplas de un elemento: >>> 'pan', 'huevos' ('pan', 'huevos') >>> 'pan', ('pan',)


Tipos de datos compuestos: Conjuntos set: colección no ordenada sin elementos repetidos Similar a las listas, pero no se pueden acceder por posición (no indizadas) Soportan operaciones matemáticas como la unión (+), intersección (&), diferencia (-), y diferencia simétrica (^). >>> a = set('abracadabra') >>> b = set('alacazam') >>> a set(['a', 'r', 'b', 'c', 'd']) >>> a & b set(['a', 'c'])


Tipos de datos compuestos: Diccionarios dict: colecci贸n no ordenada asociando valor y clave. Se indexan por las claves 煤nicas. Las claves pueden ser cualquier inmutable Forma {clave:valor, clave:valor, ... } Constructor: dict( (clave, valor), (clave, valor) ...) >>> tel = {'jack': 4098, 'sape': 4139} >>> tel['guido'] = 4127 >>> tel {'sape': 4139, 'jack': 4098, 'guido': 4127}


Tipos de datos compuestos: Diccionarios Asignaci贸n y Modificaci贸n: Acceso por clave: dic[clave] (error si la clave no existe) Asignaci贸n: dic[clave] = valor (sobreescribe si la clave ya existe) Eliminar un elemento: del dic[clave] Consultar si la clave pertenece al diccionario: clave in dic


Tipos de datos compuestos: Diccionarios MĂŠtodos: keys(): devuelve una lista de las claves values(): devuelve una lista de los valores items(): devuelve una lista de tuplas (clave, valor) get(clave, valor por defecto): devuelve el valor para la clave, o el valor por defecto si no existe pop(clave, valor por defecto): similar a get, pero remueve el elemento setdefault(clave, valor por defecto): similar a get, pero establece el elemento si no existe update(dic): actualiza con otro diccionario


Formateo de Strings Ej: "%06.2f, %-20s" % (2.2, 'hola') Caracter '%', marca el inicio del especificador Clave de mapeo (opcional): Ej (somename) Flags (opcional): '#' (alternativo), '0' (rellenar con 0), '-' (ajustar a la izq.), ' ' (espacio para el signo), '+' (signo '+' o '-') Ancho mínimo (opcional). '*' (lee próx. elemento) Precisión (opcional), '.' + cant. decimales. '*' (lee próx. elemento) Ancho (opcional). Tipo de conversión: 'd': decimal, 'f': float, 's': string, 'e': notación científica, '%': %, ...


Control de flujo: condicionales if if condici贸n1: bloque si se cumple condici贸n1 elif condici贸n2: bloque si se cumple condici贸n2 else: bloque en caso contrario if numero < 0: print "Negativo" elif numero > 0: print "Positivo" else: print "Cero"


Control de flujo: condicional if compacta Similar al operador ? o iif Permite evaluar una condici贸n en una expresi贸n A if condici贸n else B >>> a = 10 >>> print 'si' if a==10 else 'no' 'si'


Control de flujo: bucles while while condici贸n: bloque si se cumple condici贸n continue # vuelve al comienzo break # interrumpo el ciclo else: bloque si no se ha interrumpido edad = 0 while edad < 18: edad = edad + 1 print "Felicidades, tienes " + str(edad)


Control de flujo: iteraciones for for elemento in secuencia: bloque continue # vuelve al comienzo break # interrumpo el ciclo else: bloque si no se ha interrumpido for elemento in ["uno", "dos", "tres"]: print elemento for i in xrange(0, 100, 2): print i


Funciones: Fragmentos de c贸digo (con o sin nombre*) Pueden recibir argumentos y devuelven un valor (o None) def funcion(argumento1,argumento2=100): "Esta funci贸n hace..." bloque return valor def saludar(nombre, saludo="hola "): print saludo, nombre saludar("Mariano", saludo="Buenos d铆as ")


Funciones: argumentos Lista de argumentos por posici贸n (*) Diccionario de argumentos (**) def funcion(*args,**kwargs): "Esta funci贸n hace..." print "primer argumento", args[0] print "argumento 'xyz'", kwargs['xyz'] def saludar(*arg, **kwargs): print kwargs['saludo'], arg[0] saludar("Mariano", saludo="Buenos d铆as ")


Funciones: argumentos SegĂşn el tipo de datos: Inmutables: no se modifican ("por valor") Mutables: se modifican externamente ("por referencia"), por ej. listas y diccionarios def agregar(a, b): a.append(b) >>> x = [1, 2] >>> agregar(x, 3) >>> x [1, 2, 3]


Funciones: 谩mbitos (espacio de nombres) local: dentro de la funci贸n global: fuera de la funci贸n cont = 0 def prueba(): "Esta funci贸n suma 1 a cont" global cont # variable glbal incremento = 1 # variable local cont = cont + incremento prueba()


Funciones: generadores yield: devuelven un valor, manteniendo el estado interno de la funci贸n def fibonacci(limite): a, b = 0, 1 while b < limite: yield b a, b = b, a+b >>> fibonacci(10) <generator object at 0x00D79558> >>> for i in fibonacci(10): >>> print i


Funciones: Generadores Definición por comprensión: crea un generador que aplica una expresión (cálculo) a los elementos de otro iterable que cumplan una determinada condición: (expresión for variables in iterable if condición) >>> vec = [2, 4, 6] >>> g = (3*x for x in vec) >>> g <generator object at 0x00E10378> >>> list(g) [6, 12, 18]


Funciones anonimas: lambda Funicones "de una l铆nea" an贸nimas Pueden recibir argumentos y devuelven un valor (o None) No pueden tener instrucciones ni bloques (print, if, while, for, etc.) funcion = lambda argumento: argumento+1


Clases y Objetos Encapsulan datos y comportamiento Se definen con class Se instancian llamĂĄndolos Los mĂŠtodos reciben la instancia implĂ­cita: self Las clases se ejecutan! class MiClase: atributo_de_clase = 123 def __init__(self, valor): # constructor self.atributo_de_instancia = valor mi_objeto = MiClase(567) # creo la instancia


Clases y Objetos: herencia y mixins Permiten reutilizar datos y comportamiento de as clases bases Es posible heredar de mĂşltiples clases class ClaseBase: atributo_de_clase = 123 class ClaseMostrar: def mostrar(self): print self.atributo_de_clase class MiClase(ClaseBase, ClaseMostrar): pass


Clases y Objetos: atributos y mĂŠtodos Los mĂŠtodos pueden ser estĂĄticos, de clase o de instancia Los atributos pueden ser de clase o de instancia class MiClase: @staticmethod def estatico(): # no recibo clase/inst. print "hola!" atributo_de_clase = 1234 @classmethod def de_clase(clase): # recibo la clase! print clase.atributo_de_clase


Clases y Objetos: propiedades Permiten controlar el comportamiento de atributos class MiClase: def obtener(self): return self.x def establecer(self, y): self.x = y + 1 propiedad = property(obtener, establecer)


Excepciones Condiciones de error, advertencias, etc. Se lanzan con raise try: bloque a probar except tipo de exepcion, instancia: bloque si ocurre la excepci贸n else: bloque si no ocurre excepci贸n finally: bloque que se ejecuta indistintamente


Excepciones del Usuario: Derivan de Exception o clases hijas class MiExcepcion(Exception): def __init__(self, mensaje): self.mensaje = mensaje try: raise MiExcepcion("hola!") except MiExcepcion as e: print e.mensaje


M贸dulos, paquetes y espacio de nombres Agrupan c贸digo y datos M贸dulos: archivos individuales Paquetes: directorios Se accede importandolos: import import os.path print os.path.join("C:/","Python2.5")


Archivos Se abren utilizando open(ruta, modo, buffer) Modos: r (lectura), w (escritura), 'a' (agregar), b (binario), 'U' (salto de linea "universal") Buffer: 0 (sin buffer), 1 (una linea), o tama単o Utilizar with para asegurarse cerrar el archivo with open("prueba.txt", "r") as archivo: for linea in archivo: print linea


Archivos: mĂŠtodos read(cantidad): leer una cadena del archivo write(str): escribir la cadena en el archivo flush(): grabar inmediatamente al disco close(): cerrar el archivo archivo = open("prueba.bin","wb") archivo.write("hola") # escribe "hola" archivo.flush() archivo.close()


Documentaci贸n y Ayuda Documentaci贸n Oficial: http://docs.python.org/ Libro Python para todos Python Argentina: Aprendiendo Python


Programacion en python parte 1