Programación en Python

Parte 1Mariano Reingart

reingart@gmail.com

Introducción: ¿Que es Python?

Lenguaje de Programación creado por GvR en '90Sintaxis clara y limpia => código legibleLenguaje interpretado ("script"), no compilado código nativo, flexibilidad vs velocidad, pseudocódigo intermedio (bytecode)Tipado dinámico: sin declaración previaFuertemente tipado: conversión explícitaMultiplataforma: 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 argumentosTipos de datos de alto nivelGestión de memoria automáticaGran cantidad de librerias disponibles, extensibilidad

Fácil de aprenderDesarrollo rápido de aplicacionesCó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 MacInstaladores: http://www.python.org/download/ Versiones disponibles:

2.5.4: final - solo bugfix - mayor compatibilidad2.6.2: estable actual - características 3.x3.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:

AutocompletadoCalltips (parámetros)Edición de código fuente, con identaciónDepuració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.pyEjecutar el archivo:

python hola.py

Introducción: InterpretePython 2.5.4 (r254:67916, Dec 23 2008, 15:10:54) [MSC v.1310 32 bit (Intel)] on win32Type "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 yieldOperadores: + - * ** / // % << >> & | ^ ~ < > <= >= == != <>Separadores: , : . ` = ; += -= *= /= //= %= &= |= ^= >>= <<= **= ( ) [ ] { } @ Built-in: funciones, objetos y clases incorporadas en el lenguaje por defectoIdentación, espaciado y unión de líneas (\)

Introducción: Sentencias Simples

Instrucciones básicas útiles:print: imprimir por pantalla o salida estándarraw_input(mensaje) / input(mensaje): entrada de datos por teclado o entrada estándarhelp(identificador): devuelve ayuda, argumentos, valor de vuelto, etc.dir(identificador): devuelve los atributos del objeto, módulo o nombres accesiblestype(identificador): devuelve el tipoisinstance(indetificador, tipo): devuelve verdadero si es una instancia del tipo dado

Introducción: Programa básico#!/usr/bin/python# -*- coding: latin1 -*-

# sumo dos variablesa = 2 # enterob = 1.5 # punto flotanteprint a+b

# pregunto el nombre, imprimo saludonombre = raw_input("ingrese su nombre")mensaje = "hola" print mensaje, nombre

Introducción: Tipos de datos básicos

Números:Enteros (int/long): 3De coma flotante (float): 15.57Complejos (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 bitslong: números de cualquier precisión (prefijo L)Conversión automática int a longDivisión devuelve enteros!

>>> e = 31>>> l = 1234567891234567L>>> e * 1000000003100000000L>>> 7/23

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>>> f0.0001>>> 0.20.20000000000000001

Tipos de datos básicos: Complejos

Tipo:complex: números reales e imaginariosparte 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.real3.0>>> a.imag4.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: -1Potenciació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: CadenasOperadores:

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: CadenasMétodos:

strip(caracter): "limpiar" caracteres(espacios)split(caracter): dividir un textofind(substring, inicio, final): encontrar cadenastartswith(prefijo, inicio, final): ¿empieza con?endswith(sufijo, inicio, final): ¿termina con?lower(): convertir en minúsculasupper(): convertir en minúsculasisdigit(): ¿es numérico?isalpha(): ¿es alfanumérico?islower(): ¿está en minúsculas?isupper(): ¿está en mayúsculas?

Tipos de datos básicos: CadenasCodificación (Unicode):

encode(codificación): codifica un unicodedecode(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: orNO lógico: not

>>> True and FalseFalse

Tipos de datos básicos: Booleanos

Operadores relacionales:a Igual b: a == ba Distinto b: a != ba Mayor/Menor b: a > b , a < ba Mayor/Menor o igual b: a >= b , a <= b

>>> 1 == 2False>>> not 'ab' > 'ba'True

Tipos de datos compuestosColecciones 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 lenguajesPueden 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: ListasOperaciones:

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: ListasOperaciones:

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 aTrue

Tipos de datos compuestos: ListasModificaciones:

Por índice: lista[posición] = nuevoPor "rebanada": lista[inicio:final] = nuevoBorrar 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: ListasMétodos:

sort(clave): ordenar la lista (en su lugar)reverse(): revertir el órdenpop(posición): extraer un elementoappend(item): agrega un elementoinsert(posición, item): inserta un elementoremove(item): elimina la primer ocurrenciacount(item): cuenta las ocurrenciasindex(item): devuelve la posición del elementoextend(lista): extiende la lista con otra lista

>>> a.pop()

Tipos de datos compuestos: ListasFunciones incorporadas:

sorted(lista): crea una nueva lista ordenadamax(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 verdaderosmap(función, lista): aplica una función a los elementos de la listafilter(función, listra): filtra una listareduce(función, lista): aplica acumulativamente una función a una lista (devuelve un valor)

Tipos de datos compuestos: ListasDefinició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: Tuplastuple: colección ordenada inmutable. Similar a las listas, pero no modificablesPueden accederse por posición y recortarseNo tienen métodos especiales Son más "ligeras" que las listasSeparar elementos por comas, (opcionalmente entre paréntesis). Incluir coma tuplas de un elemento:

>>> 'pan', 'huevos'('pan', 'huevos')>>> 'pan',('pan',)

Tipos de datos compuestos: Conjuntosset: colección no ordenada sin elementos repetidosSimilar 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')>>> aset(['a', 'r', 'b', 'c', 'd'])>>> a & bset(['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 inmutableForma {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: DiccionariosAsignació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: DiccionariosMétodos:

keys(): devuelve una lista de las clavesvalues(): devuelve una lista de los valoresitems(): 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 existepop(clave, valor por defecto): similar a get, pero remueve el elementosetdefault(clave, valor por defecto): similar a get, pero establece el elemento si no existeupdate(dic): actualiza con otro diccionario

Formateo de StringsEj: "%06.2f, %-20s" % (2.2, 'hola')

Caracter '%', marca el inicio del especificadorClave 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 ifif condición1: bloque si se cumple condición1elif condición2: bloque si se cumple condición2else: 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 iifPermite 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 whilewhile condición: bloque si se cumple condición continue # vuelve al comienzo break # interrumpo el ciclo

else: bloque si no se ha interrumpido

edad = 0while edad < 18: edad = edad + 1 print "Felicidades, tienes " + str(edad)

Control de flujo: iteraciones forfor 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: argumentosLista 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: argumentosSegú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ónglobal: fuera de la función

cont = 0def prueba(): "Esta función suma 1 a cont" global cont # variable glbal incremento = 1 # variable local cont = cont + incremento

prueba()

Funciones: generadoresyield: 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: GeneradoresDefinició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: lambdaFunicones "de una línea" anónimasPueden 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 ObjetosEncapsulan datos y comportamientoSe definen con classSe instancian llamándolosLos métodos reciben la instancia implícita: selfLas 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 mixinsPermiten reutilizar datos y comportamiento de as clases basesEs 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étodosLos métodos pueden ser estáticos, de clase o de instanciaLos 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: propiedadesPermiten 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)

ExcepcionesCondiciones de error, advertencias, etc.Se lanzan con raise

try: bloque a probarexcept tipo de exepcion, instancia: bloque si ocurre la excepciónelse: bloque si no ocurre excepciónfinally: 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 nombresAgrupan código y datosMódulos: archivos individualesPaquetes: directoriosSe accede importandolos: import

import os.path

print os.path.join("C:/","Python2.5")

ArchivosSe 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ñoUtilizar with para asegurarse cerrar el archivo

with open("prueba.txt", "r") as archivo: for linea in archivo: print linea

Archivos: métodosread(cantidad): leer una cadena del archivowrite(str): escribir la cadena en el archivoflush(): grabar inmediatamente al discoclose(): 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 todosPython Argentina: Aprendiendo Python