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

2. 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

3. 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

4. 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

5. 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

6. 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

7. 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
'nholan'
>>> print a
hola
>>>

8. 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 ()

9. 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

10. 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

11. 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)

12. 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

13. 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

14. 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

15. 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 >>

16. 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)

17. 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'

18. 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?

19. 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")
'xe4xf6xfc'
>>> s = u.encode("utf-8")
>>> s
'xc3xa4xc3xb6xc3xbc'
>>> s.decode("utf8")
u'xe4xf6xfc'
>>> unicode('xe4xf6xfc','latin1')
u'xe4xf6xfc'

20. 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

21. 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

22. 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}

23. 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]

24. 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]

25. 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

26. 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]

27. 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()

28. 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)

29. 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
[]

30. 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',)

31. 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'])

32. 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}

33. 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

34. 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

35. 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, '%': %, ...

36. 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"

37. 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'

38. 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)

39. 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

40. 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 ")

41. 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 ")

42. 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]

43. 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()

44. 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

45. 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]

46. 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

47. 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

48. 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

49. 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

50. 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)

51. 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

52. 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

53. 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")

54. 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

55. 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()

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