Internet Solutions www.codesyntax.com

Azitain industrialdea, 3-KE-20600 EibarTel.: +34 943821780

Introducción a la programación en Python

Aitzol Naberan - @aitzol

Índice1.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

Índice3.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

Python 3.2.3 (default, Feb 14 2013, 22:44:55) [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwinType "help", "copyright", "credits" or "license" for more information.>>> print("¡Hola mundo!")¡Hola mundo!>>> 

Shell interactiva

Fichero de script

Ceia:Introduccion Python >echo 'print("¡Hola Mundo!")' > primero.pyCeia: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>>> x3>>> x == 4False>>> yTraceback (most recent call last):  File "<stdin>", line 1, in <module>NameError: name 'y' is not defined>>> X = 5>>> x == XFalse>>> 2aa = 6  File "<stdin>", line 1    2aa = 6      ^SyntaxError: invalid syntax>>> def = 5  File "<stdin>", line 1    def = 5        ^SyntaxError: invalid syntax

Tipos de datos

Numéricos

>>> 2 + 24>>> 50 ­ 5*620>>> (50 ­ 5*6) / 45.0>>> 8 / 5  # la división siempre devuelve un valor de coma flotante1.6

La sintaxis no tiene misterio: los operadores +,-,* y / funcionan como en cualquier otrolenguaje. Para las agrupaciones se utilizan los paréntesis.

>>> 17 // 3  # floor division discards the fractional part5>>> 17 % 3  # the % operator returns the remainder of the division2>>> 5 * 3 + 2  # result * divisor + remainder17

Para quedarnos con la parte entera de una división podemos utilizar el operador // y para conseguir el resto utilizaremos el operador %

Tipos de datos

Numéricos

>>> 5 ** 2  # cuadrado de 525>>> 2 ** 7  # 2 elevado a 7128

El operador de potencia es **.

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 especialesescapados 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ínea\nSeguna línea">>> s #No usamos la función print()'Primera línea\nSeguna línea'>>> print(s) #Usando la función print()Primera líneaSeguna línea

Tipos de datos

Cadenas de caracteres (Strings)●Si queremos evitar que print interprete los caracteres especiales, podemos usar raw strings>>> print("c:\algún\nombre")c:lgúnombre>>> print(r"c:\algún\nombre") # carácter r antes del stringc:\algún\nombre

●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

Cadenas de caracteres (Strings)●Los strings pueden ser indexados, siendo el primer Índice el 0. El número de Índices esn-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 elsegundo 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

Cadenas de caracteres (Strings)●Intentar acceder a un Índice inexistente provocará un error

>>> palabra[42]Traceback (most recent call last):  File "<stdin>", line 1, in <module>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'Traceback (most recent call last):  File "<stdin>", line 1, in <module>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 elementosituado 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

>>> palabras = ['gato', 'ventana', 'remolacha']>>> for p in palabras:...     print(p, len(p))... gato 4ventana 7remolacha 9

●El bloque for itera sobre todos los elementos de cualquier secuencia dada

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+b112358

Ejercicio 2

Calcular el IVA 2.0

Se trata de recoger valores que introduzca el usuario, para después calcular el IVA de cadauno de los valores. Mientras el usuario no teclee la palabra fin ser recogerán valores. Parafinalizar 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 primo3 es un número primo4 igual a 2 * 25 es un número primo6 igual a 2 * 37 es un número primo8 igual a 2 * 49 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 parEncontrado el número 34 es un número parEncontrado el número 56 es un número parEncontrado el número 78 es un número parEncontrado el número 9

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 dosfunciones: 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)

Estructuras de datos

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

Estructuras de datos

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.

Estructuras de datos

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)]  File "<stdin>", line 1    [x,x**2 for x in range(10)]              ^SyntaxError: invalid syntax>>> # 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]

Estructuras de datos

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 cestaTrue>>> 'fresa' in cestaFalse

Estructuras de datos

>>> #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'}

Estructuras de datos

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.

Estructuras de datos

>>> 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 telefonosTrue>>> 'mikel' in telefonosFalse>>> 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 dosargumentos: 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()'Este es el contenido completo del fichero.\n'>>> f.read()''

●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 elcontenido del fichero.

●Al llegar al final del fichero read() devuelve un string vacio

●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 salidaTrabajando con objetos tipo File

>>> f = open('test', 'w')>>> value = ('La respuesta', 42)>>> s = str(value)>>> f.write(s)

●Para las escrituras se utiliza f.write(string)●Para escribir algo que no sea un string tendremos que convertirlo primero

●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 fichero5>>> f.read(1)b'5'>>> f.seek(­3, 2) # volver al 3er byte antes del fin del fichero13>>> 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 trabajarcon 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 porjson 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 ypermite la serialización de datos arbitrarios

Errores y excepcionesErrores 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')                   ^SyntaxError: invalid syntax

●Son errores que se producen en tiempo de ejecución, son el resultado de condiciones inesperadas o imposibles

Excepciones

>>> 10 * (1/0)Traceback (most recent call last):  File "<stdin>", line 1, in ?ZeroDivisionError: division by zero>>> 4 + spam*3Traceback (most recent call last):  File "<stdin>", line 1, in ?NameError: name 'spam' is not defined>>> '2' + 2Traceback (most recent call last):  File "<stdin>", line 1, in ?TypeError: Can't convert 'int' object to str implicitly

Errores y excepciones

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

Errores y excepciones

Manejo de excepciones>>> 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

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

Errores y excepciones

Manejo de excepciones

... except (RuntimeError, TypeError, NameError):

...     pass

●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

●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])

Errores y excepciones

Manejo de excepciones

●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()

Errores y excepciones

Lanzar excepciones

●Con la sentencía raise podemos forzar una excepción

>>> raise NameError('HiThere')Traceback (most recent call last):  File "<stdin>", line 1, in ?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

●Con la sentencía raise podemos forzar una excepción

>>> try:...     raise NameError('HiThere')... except NameError:...     print('An exception flew by!')...     raise...An exception flew by!Traceback (most recent call last):  File "<stdin>", line 2, in ?NameError: HiThere

Errores y excepciones

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

Errores y excepciones

>>> 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.0executing finally clause>>> divide(2, 0)division by zero!executing finally clause>>> divide("2", "1")executing finally clauseTraceback (most recent call last):  File "<stdin>", line 1, in ?  File "<stdin>", line 3, in divideTypeError: unsupported operand type(s) for /: 'str' and 'str'

Aitzol Naberan

anaberan@codesyntax.com

@aitzol