Introducción a la programación en Python

Introducción a la programación
Internet Solutions
www.codesyntax.com
Azitain industrialdea, 3-K
E-20600 Eibar
Tel.: +34 943821780
en Python
Aitzol Naberan - @aitzol

Índice
1.Introducción a Python
2.Presentación del lenguaje
1.Hola mundo
2.Variables
3.Tipos de datos
4.Estructuras de control
5.Control del flujo
6.Estructuras de datos
7.Entrada/salida
8.Errores y excepciones

Índice
3.Programación Orientada a Objetos
4.Módulos
5.Logging y debuging
6.UnitTesting
7.Virtualenv y pypi
8.Librerías de terceros

Introducción
● Alto nivel
● Interpretado
● Es procesado en tiempo de ejecución por el
interprete. No hay que compilar. Similar a PERL o
PHP
● Orientado a objetos
● Python soporta la programación orientada a objetos
para encapsular código dentro de objetos.
● Scripting
● Interactivo
● Es posible utilizar una shell de Python y programar
directamente en ella.

Introducción
● Desarrollado por Guido Van Rossum (actualmente trabajando
en Dropbox) a finales de los 80
● Incorpora conceptos presentes en distintos lenguajes como
ABC, Modula-3, C, C++, Algol, Smalltalk, incluso la shell de
Unix
● Liberado bajo licencia GNU General Public License (GPL)
● Actualmente es mantenido por un core de desarrolladores,
pero Guido sigue manteniendo un rol muy importante en la
dirección del desarrollo
● El nombre se debe al grupo británico Monty Python

Introducción
● Fácil de aprender: tiene relativamente pocas keywords y
una sintaxis clara
● Código legible: la estructura de los programas en Python
hace que se puedan leer fácilmente
● Mantenible
● Modo interactivo: este modo permite probar código,
consultar documentación o hacer debugging
● Portable: Python puede correr en una gran variedad de
plataformas manteniendo el mismo interfaz.
● Extensible: Es posible añadir módulos al interprete. Estos
módulos permiten añadir funcionalidades al interprete.
● Escalable: ofrece una mejor estructura para programas
largos que el puro shell scripting.

Introducción
Python 2 vs Python 3
● Python 3 es publicado a finales de 2008
● Última versión de Python 2 es la 2.7 a medidos de 2010
● Python 2.7 no recibe nuevas características
● El soporte de librerías externas en Python 3 es menor que en
Python 2 (empieza a cambiar)
● ¿Cuál elegir?
● Python 3 si todas las librerías a utilizar lo soportan
● Python 2 si no es así
● https://wiki.python.org/moin/Python2orPython3
● Utilizaremos Python 3

Hola mundo
Shell interactiva
Python 3.2.3 (default, Feb 14 2013, 22:44:55)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print("¡Hola mundo!")
¡Hola mundo!
>>>
Fichero de script
Ceia:Introduccion Python >echo 'print("¡Hola Mundo!")' > primero.py
Ceia:Introduccion Python >python primero.py
¡Hola Mundo!

Variables
● Las variables se crean al asignarles un valor
● No es necesario especificar el tipo
● El operador de asignación es = y el de comparación ==
● Intentar acceder a un valor antes de que sea creado provoca un error
● Python distingue mayúsculas y minúsculas
● No pueden comenzar por un número
● Pueden contener letras, números y guiones bajos
● No pueden ser ninguna de las palabras reservadas
and, assert, break, class, continue, del, del, elif, else, except, exec,
finally, for, from, global, if, import, in, is, lambda, not, or, pass, print,
raise, return, try, while

Variables
>>> x = 3 #La variable x se crea en este momento
>>> x
3
>>> x == 4
False
>>> y
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> X = 5
>>> x == X
False
>>> 2aa = 6
File "<stdin>", line 1
2aa = 6
^
SyntaxError: invalid syntax
>>> def = 5
def = 5
^

Tipos de datos
Numéricos
La sintaxis no tiene misterio: los operadores +,-,* y / funcionan como en cualquier otro
lenguaje. Para las agrupaciones se utilizan los paréntesis.
>>> 2 + 2
4
>>> 50 5*
6
20
>>> (50 5*
6) / 4
5.0
>>> 8 / 5 # la división siempre devuelve un valor de coma flotante
1.6
Para quedarnos con la parte entera de una división podemos utilizar el operador // y
para conseguir el resto utilizaremos el operador %
>>> 17 // 3 # floor division discards the fractional part
5
>>> 17 % 3 # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2 # result * divisor + remainder
17

Tipos de datos
Numéricos
El operador de potencia es **.
>>> 5 ** 2 # cuadrado de 5
25
>>> 2 ** 7 # 2 elevado a 7
128
Tipos numéricos
● Enteros: int
● Coma flotante: float
● Números complejos: sufijo 'j' para la parte compleja
● 3+5j
● Decimal
● Fraction
● Los dos últimos no están disponibles en el namespace por defecto
(necesitan ser importados para poder ser utilizados)

Ejercicio 1
Calcular el IVA
Se trata de recoger un valor desde la linea de comandos y calcular el IVA que le
corresponde (para este primer ejemplo supondremos un tipo único de IVA del 21%)
Tips
● Para la entrada de datos desde la shell utilizaremos la función input
>>> valor = input("Introduce el valor:")
● Para hacer cast de una cadena a entero utilizaremos int()
>>> int(cadena)
Tiempo: 10 min

Tipos de datos
Cadenas de caracteres (Strings)
●Se definen indistintamente con comillas simples (‘...’) o comillas dobles (“...”)
●Se utiliza para escapar las comillas y caracteres especiales
>>> 'comillas sencillas'
'comillas sencillas'
>>> "comillas dobles"
'comillas dobles'
>>> ""escapando las comillas""
'"escapando las comillas"'
●En el modo interactivo los string se muestran entre comillas y los caracteres especiales
escapados con backslash
●Pueden mostrarse distintos a la entrada, pero tanto entrada como salida son equivalentes
●La función print() muestra una salida mucho mas legible, omitiendo las comillas e
imprimiendo los caracteres especiales
>>> s = "Primera líneanSeguna línea"
>>> s #No usamos la función print()
'Primera líneanSeguna línea'
>>> print(s) #Usando la función print()
Primera línea
Seguna línea

Tipos de datos
●Si queremos evitar que print interprete los caracteres especiales, podemos usar
raw strings
>>> print("c:algúnnombre")
c:lgún
ombre
>>> print(r"c:algúnnombre") # carácter r antes del string
c:algúnnombre
●Podemos tener strings multi linea usando triples comillas “””...””” o ‘’’...’’’
●Los saltos de linea se incluyen automáticamente. Esto se puede cambiar usando al
finalizar la linea (que no queremos que se convierta en un salto)
>>> print("""
... Uso: prueba [OPTIONS]
... h
Muestra este mensaje
... v
Muestra la versión
... """)
Uso: prueba [OPTIONS]
h
Muestra este mensaje
v
Muestra la versión
# salto de línea final

Tipos de datos
●Los strings pueden ser indexados, siendo el primer Índice el 0. El número de Índices es
n-1 siendo n el número total de elementos que componen el string.
●No existe el tipo char; un carácter es un string de tamaño 1
>>> palabra = "Python"
>>> palabra[0]
'P'
>>> palabra[5]
'n'
●Se pueden usar Índices negativo para acceder a los elementos desde la derecha
●Podemos usar el slicing para obtener subcadenas
>>> palabra[0:2]#caracteres desde la posición 0 (incluido) a la 2
'Py' #(excluido)
>>> palabra[2:5]#caracteres desde la posición 2 (incluido) a la 5
'tho' #(excluido)
●El elemento indicado en el primer Índice siempre se incluye, mientras que el indicado en el
segundo siempre se excluye
●No indicar el primer elemento equivale a 0
●No indicar el segundo elemento equivale el tamaño total del string

Tipos de datos
●Intentar acceder a un Índice inexistente provocará un error
>>> palabra[42]
IndexError: string index out of range
●En cambio, se usarán valores por defecto cuando estemos haciendo slicing
>>> palabra[4:42]
'on'
>>> palabra[42:]
''
●Los strings son inmutables. Es decir, intentar asignar un valor en un Índice del string
provocará un error
●Para poder modificar un string ya creado se tiene que crear uno nuevo
>>> palabra[0] = 'J'
TypeError: 'str' object does not support item assignment
>>> 'J' + palabra[1:]
'Jython'
>>> palabra[:2] + 'py'
'Pypy'

Tipos de datos
Listas
●Son colecciones de elementos que se escriben entre corchetes separados por comas
●Los elementos pueden ser de distintos tipos, aunque normalmente suelen ser del mismo
●Como los strings son indexables
●También podemos utilizar el slicing para acceder a sublistas
●Las operaciones de slicing devuelven una nueva lista
●A diferencia de los strings, las listas son mutables. Es decir se puede cambiar el elemento
situado en un Índice
●Es posible añadir elementos al final de la lista con el método append()
●Podemos asignar nuevos valores directamente a slices, con esta operación es posible
cambiar el tamaño de la lista o eliminar todos sus elementos

Tipos de datos
Listas
>> pares = [0,2,4,6,8,10]
>>> pares
[0, 2, 4, 6, 8, 10]
>>> pares[0]
0
>>> pares[1]
10
>>> pares[3:]
[6, 8, 10]
>>> pares + pares[:]
[0, 2, 4, 6, 8, 10, 0, 2, 4, 6, 8, 10]
>>> pares.append(13)
>>> pares
[0, 2, 4, 6, 8, 10, 13]
>>> pares[1]
= 12
>>> pares
[0, 2, 4, 6, 8, 10, 12]
>>> pares[2:4] = [1,2,3]
>>> pares
[0, 2, 1, 2, 3, 8, 10, 12]
>>> pares[:] = []
>>> pares
[]

Estructuras de control
If
>>> x = int(input("Introduce un entero: "))
Introduce un entero: 42
>>> if x < 0:
... x = 0
... print('Negativo, cambiado a cero')
... elif x == 0:
... print('Cero')
... elif x == 1:
... print('Uno')
... else:
... print('Mayor')
...
●Tanto el bloque else como los bloques elif son opcionales
●En el caso de elif puede haber más de uno
●El bloque elif es sustuto de else if: y se utiliza para evitar el exceso de indentación
●Indentación:
● No existe ningún carácter para marcar los bloques ({})
● Los bloques se marcan con niveles de indentación
● Por convención se utilizan 4 espacios por nivel de indentación

Estructuras de control
For
●El bloque for itera sobre todos los elementos de cualquier secuencia dada
>>> palabras = ['gato', 'ventana', 'remolacha']
>>> for p in palabras:
... print(p, len(p))
...
gato 4
ventana 7
remolacha 9
While
●Repite el bloque mientras se cumpla la condición sea verdadera
>>> a, b = 0, 1 #Notese la asignación múltiple
>>> while b < 10:
... print(b)
... a, b = b, a+b
1
1
2
3
5
8

Ejercicio 2
Calcular el IVA 2.0
Se trata de recoger valores que introduzca el usuario, para después calcular el IVA de cada
uno de los valores. Mientras el usuario no teclee la palabra fin ser recogerán valores. Para
finalizar se mostrará en pantalla tanto el valor introducido como el IVA correspondiente.
Continuamos suponiendo un IVA común del 21%
Tips
●Tendremos que utilizar listas
●Bucles for y while
●Y la solución al ejercicio anterior
●Es buen momento para empezar a escribir el código en un editor. Se puede
seguir utilizando la consola para probar.
Tiempo: 20 min

Secuencias de control
Sentencias break, continue y else dentro de iteraciones
●La sentencia break termina con la ejecución del bloque while o for en el que se encuentra
●Los bloques de iteración pueden contener una sentencia else que se ejecuta cuando
se agotan los elementos de una lista (for) o cuando la condición se convierte en false,
pero no cuando el bucle termina con un break
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'igual a', x, '*', n//x)
... break
... else:
... #El bucle a terminado sin encontrar factores
... print(n, 'es un número primo')
...
2 es un número primo
4 igual a 2 * 2
6 igual a 2 * 3
8 igual a 2 * 4
9 igual a 3 * 3

Secuencias de control
Sentencias break, continue y else dentro de iteraciones
●La sentencia continue corta la ejecución de la iteración y pasa a la siguiente
>>> for num in range(2, 10):
... if num % 2 == 0:
... print(num, 'es un número par')
... continue
... print('Encontrado el número', num)
...
2 es un número par
Encontrado el número 3
4 es un número par
6 es un número par
8 es un número par
Sentencias pass
●La sentencia pass no hace nada:). Se utiliza cuando es sintácticamente necesaria, pero
el programa no requiere acción, o para crear clases mínimas, o como recordatorio de
implementar algo

Funciones
●Las funciones se definen mediante la palabra clave def (que viene de definition)
● Después de def viene el nombre de la función
● Seguidamente entre paréntesis la lista de parémetros formales
● La definición finaliza con el caracter :
● El cuerpo comienza en la siguiente linea y tiene que estar indentado
●Las funciones en Python siempre devuelven valor
● El valor se devuelve con la sentencia return (el tipo de lo devuelto no se especifica)
● Si la función no devuelve ningún valor explícitamente se devuelve el valor nulo
● Este valor nulo es None y viene definido por defecto en el lenguaje
●Para documentar una función es posible añadir un string como primera linea de la función
(a este string se le llama Docstring y es posible utilizar herramientas para generar
documentación automáticamente)
●El paso de parámetros: “Call By-Sharing”
● Los parámetros son referencias a las variables enviadas
● Si la variable enviada es inmutable, se llama “por valor”
● Si la variable es mutable, se llama “por referencia”
● Si a la variable se le asigna otra referencia, ej una nueva lista, la referencia original no
se pierde, funciona como llamada “por valor”

Funciones
>>> def fib(n):
... """Imprime los elementos menores que n de la serie
... de Fibonacci"""
... a,b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Ejercicio 3
Calcular el IVA 2.1
Vamos a modificar el ejemplo 2 para utilizar funciones. Se trata de utilizar por lo menos dos
funciones: una para recoger los datos del usuario y otra para hacer los cálculos
Tips
●No hay tips
Tiempo: 10 min

Funciones
Argumentos por defecto
●Tenemos la opción de asignar valores por defecto a algunos argumentos al definir la
función
>>> def preguntar(msg, reintentos=4, msg_error='Por favor, si o no'):
... while True:
... ok = input(msg)
... if ok in ('s', 'si', 'sí'):
... return True
... if ok in ('n','no'):
... return False
... reintentos = reintentos 1
... if reintentos < 0:
... raise OSError('El usuario no coopera')
... print(msg_error)
● Distintas opciones para llamar a esta función
● Solo con el argumento obligatorio: preguntar(‘¿Salimos?’)
● Con uno de los argumentos opcionales: preguntar(‘¿Salimos?’, 2)
● Con todos los argumentos: preguntar(‘¿Salimos?’, 2, ‘Veengaa, si o no’)

Funciones
Argumentos por defecto
●Los argumentos por defecto se evalúan en el momento de definir la función
>>> i = 5
>>> def f(arg=i):
... print(arg)
...
>>> i = 6
>>> f()
5
Importante:
● El valor por defecto se evalúa solamente una vez. Esto es importante cuando el
argumento es mutable
def f(a, L=[]):
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
¡LAS MANOS FUERA DEL TECLADO!

Funciones
Solución
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L

Funciones
Argumentos por nombre
●Es posible llamar a la función especificando el nombre del argumento, con el formato
nombre=valor
●Casos de llamadas erroneas a la función
>>>def ejemplo(obligatorio, opcional1=1, opcional2=2):
... ...
>>> ejemplo() #Falta argumento obligatorio
>>> ejemplo(opcional1=4, ‘un_valor’) #Argumento nominal seguido
#de posicional
>>> ejemplo(opcional3=’otro_valor’) #Argumento desconocido
Lista de parámetros posicionales
●Si en la definición de la función añadimos un argumento de formato *nombre, al
llamar a la función nombre será una tupla (especie de lista inmutable) con
argumentos posicionales
Diccionario de parámetros nominales
●Si en la definición de la función añadimos un argumento de formato **nombre, este
contendrá un diccionario (estructura clave/valor) con argumentos nominales no
definidos formalmente

Estructuras de datos
Más operaciones con listas
● list.extend(L): equivalente a l[len(a):] = L
● list.insert(i, x): inserta el item x en la posición i
● list.remove(x): elimina la primera aparición de x
● list.pop([i]): elimina el elemento en la posición dada y lo devuelve. Si no se
especifica un Índice se devuelve y elimina el último elemento
(Nota: en este caso los corchetes hacen referencia a un
atributo opcional, no a una lista)
● list.index(x): devuelve el Índice del primer elemento con valor x. Lanza un
error en caso de que no exista el elemento
● list.count(x): cuenta el número de apariciones del elemento x
● list.sort(): ordena la lista (no devuelve una nueva lista)
● list.reverse(): revierte los elementos de la lista (no devuelve una nueva
lista)

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, 1)
>>> a.append(333)
>>> a
[66.25, 333, 1,
333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, 1,
333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, 1,
66.25]
>>> a.sort()
>>> a
[1,
1, 66.25, 333, 333, 1234.5]

Ejercicio 4
Implementar Pilas con listas
Hay que implementar la estructura de datos de Pila utilizando listas. Será suficiente con
Implementarlo en el shell interactivo
Tips
●Las pilas son estructuras de datos donde los elementos se añaden y se
recuperan desde la parte de 'arriba' de la estructura (last-in, first-out)
●Para consultar los metodos y atributos de disponibles para un objeto, se puede
utilizar la funcion dir()
Tiempo: 10 min

Ejercicio 5
Implementar Colas con listas
Hay que implementar la estructura de datos de Colas utilizando listas. Será suficiente con
Implementarlo en el shell interactivo
Tips
●Las colas son estructuras de datos donde los elementos se devuelven en el
mismo orden de inserción (first-in, first-out)
● Las listas no son muy eficientes para implementar colas (existen estructuras
mas apropiadas), dado que al eliminar el primer elemento hay que mover los
restantes
Tiempo: 10 min

Comprensión de listas
● Se utiliza para crear una nueva lista como resultado de aplicarle una función a los
elementos de otra lista
>>> cuadrados = []
>>> for x in range(10):
... cuadrados.append(x**2)
...
>>> cuadrados
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> #Se puede implementar como:
... [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
● Definición: La comprensión de listas consiste en unos corchetes que contienen una
expresión seguida de una sentencia for, seguida de cero o mas sentencias for o if. El
resultado será una nueva lista resultante de aplicar la expresión a cada uno de los
elementos resultantes de la combinación de cláusulas if y for.

Comprensión de listas: ejemplos
>>> vec = [4,
2,
0, 2, 4]
>>> # Filtrar la lista para eliminar valores negativos
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # Aplicar una función a todos los elementos
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # llamar a una función para cada elemento
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # crear una lista de tuplas de la forma(numero, cuadrado)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # para generar tuplas son necesarias la parentesis
>>> >>> [x,x**2 for x in range(10)]
[x,x**2 for x in range(10)]
^
>>> # aplanar la lista usando dos sentencias 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Tuplas
●Las tuplas son similares a las listas, pero...
● Se definen entre paréntesis
● Son inmutables
●Comparten las características de indexado y slicing
Sets
●Colección de elementos no ordenada donde no se repite ninguno de sus
elementos
●Se definen entre llaves ( { ) o mediante la función set()
● Nota: Para crear un set vacío es necesario utilizar la función set, ya que el
par de llaves vacías creará un diccionario (se estudiaran en la siguiente
sección)
>>> cesta = {'naranja', 'manzana', 'naranja', 'pera', 'platano'}
>>> cesta
{'platano', 'manzana', 'pera', 'naranja'}
>>> 'naranja' in cesta
True
>>> 'fresa' in cesta
False

>>> #operaciones sobre dos sets
... a = set('abracadabra')
>>> b = set('alacazam')
>>> a # letras únicas en a
{'a', 'r', 'b', 'c', 'd'}
>>> a b
# letras en a pero no en b
{'r', 'b', 'd'}
>>> a | b # letras en a o en b
{'a', 'c', 'b', 'd', 'm', 'l', 'r', 'z'}
>>> a & b # letras en a y en b
{'a', 'c'}
>>> a ^ b # letras en a o en b, pero no en los dos
{'b', 'd', 'm', 'l', 'r', 'z'}

Diccionarios
●Son un conjunto de elementos clave:valor no ordenados
●Podemos usar cualquier tipo inmutable para la clave
● Tiene que ser inmutable en todos los niveles, no sirve una tupla de listas
● Lo mas típico es usar números o strings
●A diferencia de tuplas y listas que se indexan por un rango de números, los
diccionarios se indexan usando la clave
●Las operaciones principales sobre los diccionarios son almacenar y acceder a
valores
●Los valores pueden ser de cualquier tipo
●Escribir en una clave existente elimina el valor antiguo y almacena el nuevo (de
lo que se deduce que las claves tienen que ser únicas dentro del diccionario)
●Podemos construir diccionarios vacíos con la función dict() o con dos llaves {}
●Tambien podemos usar dict, para crear diccionarios directamente desde
secuencias de pares clave-valor.

>>> telefonos = {'mikel': 4098, 'aitor': 4199}
>>> telefonos['patxi'] = 9999
>>> telefonos
{'mikel': 4098, 'aitor': 4199, 'patxi': 9999}
>>> del telefonos['mikel']
>>> telefonos['urtzi'] = 3232
>>> telefonos
{'aitor': 4199, 'urtzi': 3232, 'patxi': 9999}
>>> list(telefonos.keys())
['aitor', 'urtzi', 'patxi']
>>> sorted(telefonos.keys())
['aitor', 'patxi', 'urtzi']
>>> 'patxi' in telefonos
True
>>> 'mikel' in telefonos
False
>>> dict([('mikel',4098),('aitor', 4199), ('urtzi', 3232)])
{'mikel': 4098, 'aitor': 4199, 'urtzi': 3232}
>>> dict(mikel=4098, aitor=4199, urtzi=3232)
{'mikel': 4098, 'aitor': 4199, 'urtzi': 3232}
>>> {x:x**2 for x in (2,4,6)}
{2: 4, 4: 16, 6: 36}

Ejercicio 6
Imprimir un tamaño de fichero con el sufijo correspondiente
El objetivo de este ejercicio es implementar una función que dado un tamaño de fichero
(un entero) en bytes, imprima la versión amigable (con el sufijo correspondiente).
La función tiene que aceptar un parámetro que permita elegir el múltiplo con el que se
calcularan las versiones amigables (múltiplos de 1000, o múltiplos de 1024)
Tips
●Los sufijos para múltiplos de 1000 son ‘KB’,’MB’,’GB’,’TB’,’PB’,’EB’,’ZB’, ‘YB’
●Los sufijos para múltiplos de 1024 son ‘KiB’, ‘MiB’, ‘GiB’,’TiB’,’PiB’,’EiB’,’ZiB’,’YiB’
Tiempo: 30 - 45 min

Entrada salida
Ficheros
●La función básica para trabajar con ficheros es open(), y normalmente se utiliza con dos
argumentos: open(filename, mode)
●open devuelve un objeto de tipo file
●Modos
● ‘r’: solo lectura
● ‘w’: escritura - si existe un fichero del mismo nombre será borrado
● ‘a’: añadir - las escrituras se añaden al final del ficherp abierto
● ‘r+’:abre el fichero para lectura y escritura
●Por defecto el modo de apertura es ‘r’
●Normalmente los ficheros se abren en modo texto (por defecto el encoding es UTF8)
●Si añadimos una ‘b’ al modo de apertura, se abrira el fichero en modo binario
● En modo binario se leen cadenas de bytes
● Este modo se debería utilizar siempre que abramos ficheros que no contengan texto
(por ejemplo imagenes JPEG)

Entrada salida
Trabajando con objetos tipo File
Supongamos para los ejemplos, que f es un objeto de tipo file
●f.read(size) - Lee cierta cantida de información del fichero y lo devuelve como string o objeto
bytes. El parámetro size es opcional, y en caso de que no se proporcione se leera todo el
contenido del fichero.
●Al llegar al final del fichero read() devuelve un string vacio
>>> f.read()
'Este es el contenido completo del fichero.n'
>>> f.read()
''
●Podemos usar f.readline() para leer contenido hasta el final de line (busca el caracter n)
●readline no omite el caracter n devuelto, de esta manera sabemos que aún no hemos
llegado al final del fichero mientras no se devuelva ‘’
●También podemos iterar sobre el objeto file para leer el fichero linea a linea
>>> f.read()
'Este es el contenido completo del fichero.n'
>>> f.read()
''
●Tambien podemos usar el contenido del fichero como si de una lista se tratase con list(f) o
f.readlines()

Entrada salida
Trabajando con objetos tipo File
●Para las escrituras se utiliza f.write(string)
●Para escribir algo que no sea un string tendremos que convertirlo primero
>>> f = open('test', 'w')
>>> value = ('La respuesta', 42)
>>> s = str(value)
>>> f.write(s)
●Para conocer la posición en la que se encuentra el fichero podemos utiliza f.tell()
●f.seek(offset, from_what) nos permitira mover esta posición.
● La posición se calcula sumando el offset al valor from_what
● from_what puede ser cualquiera de estos valores:
● 0 : inicio del fichero (por defecto)
● 1 : posición actual
● 2 : final del fichero
>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # Ir al 6º byte del fichero
5
>>> f.read(1)
b'5'
>>> f.seek(3,
2) # volver al 3er byte antes del fin del fichero
13
>>> f.read(1)
b'd'

Entrada salida
Guardar datos estructurados
● Guardar strings es sencillo
● Tratar con números es algo mas complejo, ya que read devuelve siempre strings y
tendriamos que hacer algún tipo de casting
● Pero al tratar con datos mas complejos, com listas anidadas, diccionarios, ... la
serialización y deserializacion, se combierte en algo mas complicado.
● serializar: convertir objetos a representación string
● deserializar: convertir strings en objetos
● Python permita utilizar el conocido formato de intercambio de archivos JSON para trabajar
con datos estructurados
●Para serializar datos utilizaremos json.dumps()
●Para deserializar utilizaremos json.loads(f)
●El modulo json sirve para serializar/deserializar listas y diccionarios, pero para poder
utilizarlo con clases custom creadas por nosotros tendremos que hacer algo mas de trabajo
(basicamente, proporcionar un método que convierta nuestra clase a algo manejable por
json y otro metodo que se encargue de leer un json y lo convierta en una instancia de
nuestro objeto)
●Python también proporciona el protocolo Pickle Este protocolo es especifico de python y
permite la serialización de datos arbitrarios

Errores y excepciones
Errores sintácticos
●Los errores sintacticos los encuentra el interprete cuando trata de ejecutar alguna
sentencia que no cumple con las normas de sintactica de Python
●Son relativamente sencillos de corregir
>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
Excepciones
●Son errores que se producen en tiempo de ejecución, son el resultado de condiciones
inesperadas o imposibles
>>> 10 * (1/0)
ZeroDivisionError: division by zero
>>> 4 + spam*3
NameError: name 'spam' is not defined
>>> '2' + 2
TypeError: Can't convert 'int' object to str implicitly

Manejo de excepciones
●Una excepción que no tratada probocará la detención del programa
●Para el manejo de excepciones tenemos el bloque try/except
>>> while True:
... try:
... x = int(input("Introduce un número: "))
... break
... except ValueError:
... print("Oops! Eso no es un número. Prueba otra vez...")

>>> while True:
... try:
... x = int(input("Introduce un número: "))
... break
... except ValueError:
... print("Oops! Eso no es un número. Prueba otra vez...")
●Se trata de ejecutar todo lo que esté entre el bloque
●Si no ocurre ninguna excepción, el bloque except no se ejecuta
●Si ocurre alguna excepción, la ejecucion salta directamente al bloque except. Entonces, si
la excepción esta listada en el bloque except, se ejecuta el bloque except y la ejecución
vuelve al siguiente linea del bloque try
●Si ocurre una excepcion que no esta listada en el bloque except, la excepción se propaga
fuera del bloque try tratando de buscar algún except que la capture. Si no encuentra ningun
bloque que se encargue de la excepción, se la denomina ‘unhandled exception’ y detiene la
ejecución del programa mostrando un mensaje de error

●Podemos tener mas de un bloque except por cada sentencia try
●Cada bloque except puede ocuparse de distintas excepciones
●Es posible que un mismo bloque except se encargue de mas de un tipo de excepción
● Es necesario listar lo tipos de excepción entre paréntesis
... except (RuntimeError, TypeError, NameError):
... pass
●Se puede omitir el tipo de excepción para tratar todas las excepciones
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])

●Los bloques try/except aceptan un bloque else opcional
●Se ejecuta después del except
●Es util si se quiere añadir código que se tenga que ejecutar si el bloque try no lanza
ninguna excepción
●El usoi de else ayuda a que no se capturen por error excepciones que no se han lanzado
desde el bloque que se quería proteger
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('no se puede abrir', arg)
else:
print(arg, 'tiene', len(f.readlines()), 'lineas')
f.close()

Lanzar excepciones
●Con la sentencía raise podemos forzar una excepción
>>> raise NameError('HiThere')
NameError: HiThere
●El único argumento de raise indica la excepción que se tiene que lanzar
●Este argumento tiene que ser una instacia de excepción o una clase que herede de
Exception
●Si es necesario propagar la excepción (por que no se va a tratar) se puede hacer con una
versión simplificada de raise
>>> try:
... raise NameError('HiThere')
... except NameError:
... print('An exception flew by!')
... raise
...
An exception flew by!
NameError: HiThere

La clausula finally
●Para definir código que se ejecute siempre utilizaremos la clausula finally
●El código de la clausula finally se ejecuta tanto si ocurre una excepción como si no
●Si una excepción no es tratada por nuestro código, vuelve a ser lanzada depués de llamar
a finally

>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
>>> divide("2", "1")
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Aitzol Naberan
anaberan@codesyntax.com
@aitzol

Introducción a la programación en Python

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Introducción a la programación en Python

Último

Introducción a la programación en Python

Notas del editor