Python

Python es un lenguaje de programación muy utilizado actualmente en entornos relacionados con Data Science y Big Data

Su uso en librerías creadas por Google y otros gigantes tecnológicos ha hecho que en los últimos años se haya convertido en uno de los lenguajes más utilizados

Dentro de los lenguajes de programación, sus características son:

• Interpretado

  El proceso de compilado es el de traducción del lenguaje de programación que estemos utilizando (por ejemplo C++) a código máquina que el ordenador puede ejecutar

  Además, en este proceso se crea un archivo ejecutable que puede utilizarse en otros ordenadores

  Hay lenguajes de programación que no utilizan un proceso de compilado sino un intérprete, que añade significado a las sentencias programadas

  Python es un lenguaje interpretado

• Tipado dinámico

  El tipado de un lenguaje de programación es la forma que tiene el lenguaje de gestionar las variables y sus tipos

  Por lo general, en un lenguaje de programación se pueden crear variables de diferentes tipos (numero entero, número real, carácter, listas…)

  Existen lenguajes en los que antes de poder utilizar una variable tenemos que definirla y asignarle un tipo concreto de variable

  En un lenguaje no formal sería algo como: Quiero una variable entera que se llame Hermanos y Asigna a la variable casa el valor 3

  Sin embargo en Python no es necesario realizar esta asignación, dado que es un lenguaje con tipado dinámico y, en general, no es necesario definir una variable para poder utilizarla

  En Python escribiríamos directamente La variable hermanos tiene un valor de 2 y sería el interprete quien vería que queremos utilizar una variable que no existe, con el nombre Hermanos y asignarle el valor 2

• Multi paradigma

  Existen varias formas de programar; con programación orientada a objetos como programación funcional

  Python admite ambos tipos

• Multi plataforma

  Existen intérpretes de Python para múltiples plataformas, tales como MS Windows, Mac OS o Linux

Tanto el intérprete de Python como su extensa biblioteca estándar están a libre disposición en forma de código fuente y archivo ejecutable para las principales plataformas desde el sitio web de Python

Detrás de Python existe una amplia comunidad que provee amplio soporte a la vez que desarrolla y actualiza constantemente una miriada de librerías centralizado en un repositorio llamado Pypi

Ademas existe un código de buenas prácticas de programación en Python así como una guía de estilo, a fin de que el código sea de fácil lectura y comprensión

Instalación y modos de uso de Python

Python puede instalarse en nuestro ordenador desde la página de Python (recomendado instalar la última versión de Python)

Sin embargo, es más cómodo realizar la instalación mediante una distribución como Anaconda, que nos descarga el intérprete, diferentes editores y los paquetes y librerías más utilizados

Para instalar esta distribución tendríamos que:

1. Ir a la página de descargas de Anaconda y descargar el paquete que se ajusta a tu sistema operativo y versión de Python deseada

   Se recomienda instalar la correspondiente a la versión más actual de Python

2. Ejecutar el paquete y dejar que se instale completamente en el sistema

3. Tras la instalación sería recomendable actualizar los paquetes

   Para ello abre un terminal y ejecuta:

   conda update --all

   Mostrará una lista de librerías que van a a ser actualizadas

   Si estás conforme, acepta e iniciará la descarga y la instalación de las librerías

4. En el caso de querer instalar una librería concreta, en el terminal ejecutaremos:

   conda install <nombre_librería>

   Instalará la última versión de la librería presente en el repositorio de Anaconda que corresponda a nuestro sistema operativo y a nuestra versión de Python

En caso de que no esté presente en los repositorios, opcionalmente podemos instalar la librerías con pip

Para ello abre un terminal y ejecuta:

python -m pip install --upgrade pip
python -m pip install anaconda

Para más información consultar la documentación de Anaconda

La forma más rápida de utilizar Python es mediante línea de comandos

Una vez tenemos un intérprete instalado en nuestro ordenador, abriríamos un terminal y escribiríamos

python

Esto abre una consola sobre la que podemos escribir y ejecutar código Python

Cada línea que ejecutásemos se realizaría la operación solicitada

Es una forma muy rápida para testear código pero es muy poco práctica, ya que perdemos la reutilización del código ejecutado

Es decir, si quisiésemos ejecutarlo de nuevo, tendríamos que escribir linea a linea el código otra vez

Lo más común es utilizar un editor como Spyder (se instala junto a Anaconda) o Jupyter notebooks, que es el que voy a utilizar yo para los ejemplos

Jupyter Notebook

Jupyter Notebook (anteriormente, IPython Notebook) es una aplicación web de código abierto que te permite crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y texto narrativo

Además, es una aplicación muy utilizada en el campo de la Ciencia de Datos (Data Science) para crear y compartir documentos que incluyen: limpieza y transformación de datos, simulación numérica, modelado estadístico, visualización de datos, aprendizaje automático y mucho más

Te permite editar y ejecutar documentos de notebook a través de cualquier navegador web de tu elección; y puede ejecutarse en un escritorio local que no requiere acceso a Internet o puede instalarse en un servidor remoto y acceder a través de Internet

También podemos ejecutar Jupyter Notebook sin ninguna instalación desde la página web del proyecto

O instalarlo usando pip, para ello abre un terminal y ejecuta:

python -m pip install --upgrade pip
python -m pip install jupyterlab

Utilizar Jupyter Notebook

Una vez lo tengamos instalado, abriremos un terminal y ejecutaremos:

jupyter notebook

Esto imprimirá cierta información sobre el servidor de notebook en nuestro terminal, incluida la URL de la aplicación web (de forma predeterminada, http://localhost:8888)

En caso de necesitar conocer la ruta en la que tenemos instalado Jupyter, podemos ejecutar en el terminal:

where jupyter

En caso de necesitar conocer la versión de Python que tenemos instalado, podemos ejecutar en el terminal:

python -V

Antes de ejecutar este comando de una línea, se recomienda que verifiquemos que nuestro directorio de Anaconda PATH se haya agregado correctamente a las Variables de entorno, y si no es así, debemos ubicar nuestra ruta de directorio / archivo de Anaconda y agregarlo a las Variables de entorno, o si no podrías obtener un error:

jupyter no se reconoce como un comando interno o externo

Si el lanzamiento ha funcionado correctamente, se abrirá nuestro navegador por defecto con el Notebook abierto en el puerto 8888

Una vez ya dentro del Notebook, observaremos un botón llamado New que, al hacer clic, nos permite seleccionar un kernel de Python (las opciones dependen de lo que esté instalado en nuestro servidor local) del menú desplegable

Se recomienda seleccionar la última versión de Python que nos aparezca en el desplegable, a no ser que sea necesario usar otra por motivos de compatibilidad

Una vez seleccionado y aceptado, se nos abrirá nuestro primer cuaderno para escribir nuestros programas en Python

Nuestro primer script Python

Vamos a escribir un pequeño script de ejemplo para mostrar lo sencillo que es ejecutar un script Python desde Jupyter

Python tiene definido un sistema de almacenamiento y gestión de variables

En las variables podemos guardar información que queramos utilizar más adelante en el código con un nombre que nos sea fácil de recordar

En nuestro ejemplo, queremos calcular el área y el volumen de una esfera

Las ecuaciones que necesitamos son:

• A = 4\pi \cdot r^2 para el área
• V = \frac{4}{3}\pi \cdot r^3 para el volumen

En concreto, queremos calcular estos valores para una esfera de 7 de radio

Vamos a definir tres variables:

• r

  Contiene el valor del radio, en este caso 7

• A

  Contiene el valor del área calculada

• V

  Contiene el valor del volumen calculado

¿Qué ventajas obtenemos definiendo variables?

Si cambiamos de idea y en vez de un radio 7 queremos que sea 6, tendríamos que cambiar el número de dos sitios (que en el caso de un programa en producción podrían ser cientos)

O queremos que sea el usuario quien indique el valor, de forma que no podemos saberlo a priori

Para escribirlo en Python usaremos una celda del cuaderno a la que le asignaremos en el menú desplegable (lo veremos a la izquierda del icono que parece un teclado) el valor Code

Una vez dentro de la celda, la usaremos como un editor de texto escribiendo:

import math

r = 6
A = 4 * math.pi * r ** 2
V = 4 / 3 * math.pi * r ** 3

Para ejecutarlo podemos usar el botón run o dejando pulsada la tecla de mayúsculas y después pulsando enter

El resultado de las variables permanecerá en memoria, pero nosotros no podremos verlo

Ahora vamos a usar la función print (similar a la función de C++) para poder ver el resultado de nuestro script Python

Para poder usar la constante Pi, se ha importado el módulo math con la sentencia import math y luego la hemos usado con math.pi

Como puede verse, para definir una variable escribimos el nombre con el que queremos bautizarla, el signo = y la expresión que queremos que sea asignada a esa variable

import math

r = 6
A = 4 * math.pi * r ** 2
V = 4 / 3 * math.pi * r ** 3

print("El radio era %d" %(r) )
print("El área de la esfera era %f" %(A) )
print("La superficie de la esfera era %f" %(V) )

Comentarios en Python

Python soporta comentarios tipo Shell de Unix

print("Prueba") #Comentario tipo Shell de Unix

Operadores en Python

Python posee operadores aritméticos, relacionales, lógicos, bit a bit, de asignación, pertenencia e identidad

Operadores aritméticos

Python suministra las operaciones básicas con los únicos añadidos de los operadores resto, cociente entero y exponenciación

Nota En Python, usar el operador + aplicado a strings, concatena ambas strings en una sola

a = 5
b = 3

suma = a + b #ejemplo de suma
print(suma) #nos devolverá 8

resta = a - b #ejemplo de resta
print(resta) #nos devolverá 2

mult = a * b #ejemplo de multiplicación
print(mult) #nos devolverá 15

div = a / b #ejemplo de división
print(div) #nos devolverá 1.6667
#hay que tener en cuenta que no hay tipado de datos y nos devolverá por defecto un valor float

rest = a % b #ejemplo de resto de la división
print(rest) #nos devolverá 2

coc = a // b #ejemplo de cociente entero
print(coc) #nos devolverá 1

pot = a ** b #ejemplo de exponenciación
print(pot) #nos devolverá 125

Operadores relacionales

Se emplean típicamente en las expresiones condicionales

Los operadores relacionales devuelven valores booleanos

Los operandos pueden ser tanto numéricos como strings

Los objetos de diferentes tipos, excepto los tipos numéricos, nunca se comparan igual

El operador == siempre está definido, pero para algunos tipos de objetos (por ejemplo, objetos de clase) es equivalente a is

Las instancias no idénticas de una clase normalmente se comparan como no iguales a menos que la clase defina el método __eq__()

Las instancias de una clase no se pueden ordenar con respecto a otras instancias de la misma clase u otros tipos de objeto, a menos que la clase defina los métodos __lt__() y __gt__()

a = 20
b = 30
c = '20'

if a > b:
   print("a es mayor que b") #ejemplo de mayor, no se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso
if a > c:
   print("a es mayor que c") #ejemplo de mayor, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos
if a < b:
   print("a es menor que b") #ejemplo de menor, no se tiene en cuenta los tipos
#en este caso mostrará el mensaje por ser verdadero
if a < c:
   print("a es menor que c") #ejemplo de menor, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos
if a >= b:
   print("a es mayor o igual que b") #ejemplo de mayor o igual, no se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso
if a >= c:
   print("a es mayor o igual que c") #ejemplo de mayor o igual, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos
if a <= b:
   print("a es menor o igual que b") #ejemplo de menor o igual, no se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso
if a <= c:
   print("a es menor o igual que c") #ejemplo de menor o igual, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos
if a != b:
   print("a es distinto que b") #ejemplo de distinto, no se tiene en cuenta los tipos
#en este caso mostrará el mensaje por ser verdadero
if a != c:
   print("a es distinto que c"); #ejemplo de distinto, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos
if a == b:
   print("a es igual que b") #ejemplo de igual, no se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso
if a == c:
   print("a es igual que c") #ejemplo de igual, se tiene en cuenta los tipos
#en este caso no mostrará el mensaje por ser falso al ser de distintos tipos

Operadores lógicos

Los operandos lógicos está relacionados con los relacionales ya que normalmente los operandos que usan son resultado de expresiones relacionales

Los valores resultantes son booleanos

a = True
b = False

if a AND b:
    print("a y b son los dos verdaderos")
else:
    print("a o b son falsos, o los dos son falsos")

if a OR b:
    print("a o b son verdaderos, o los dos son verdaderos")
else:
    print("Los dos son falsos")

if NOT a:
    print("Era falso")
else:
    print("Era verdadero")

Operadores bit a bit

La forma de trabajar de estos operadores es convertir a binario los operandos y luego operar con ellos bit a bit

Nota Los operadores de propagación toman dos operandos: el primero es la variable a propagar y el segundo es el número de posiciones a propagar

a = 4 #en binario es 0100
b = 5 #en binario es 0101

c = a & b #ejemplo de AND
print(c) #devolverá el valor 4 que en binario es  0100

c = a | b #ejemplo de OR
print(c) #devolverá el valor 5 que en binario es 0101

c = a ^ b #ejemplo de XOR
print(c) #devolverá el valor 1 que en binario es 0001

c = a << b #ejemplo de propagación a la izquierda
print(c) #devolverá el valor 128 que en binario es ‭1000 0000‬

c = a >> b #ejemplo de propagación a la derecha
print(c) #devolverá el valor 0 que en binario es 0000

a = ~a #ejemplo de NOT
print(a) #devolverá el valor -5 que en binario es -0101

c = a << b; #ejemplo de propagación a la izquierda de un número negativo
print(c) #devolverá el valor -160 que en binario es -0101 0000

c = a >> b; #ejemplo de propagación a la derecha de un número negativo
print(c) #devolverá el valor -1 que en binario es -0001

Operadores de asignación

La asignación también es un operador que devuelve la variable modificada

El operador de asignación en Python es =

Los operadores de asignación que se muestran a continuación no son sino abreviaturas que hacen más cómoda y simples las expresiones, aunque a veces sean más ilegibles

Operadores de pertenencia

Los operadores de pertenencia se utilizan para comprobar si un valor o variable se encuentran en una secuencia (list, tuple, dict, set o str)

listas = [1, 3, 2, 7, 9, 8, 6]

if 4 in listas:
    print("4 estaba en la lista")
else:
    print("4 no estaba en la lista")

if 5 not in listas:
    print("5 no estaba en la lista")
else:
    print("5 estaba en la lista")

Operadores de identidad

Estos operadores se van a utilizar para comprobar si dos variables son, o no, el mismo objeto

x = 5
listas = [1, 5]

if x is lista:
    print("x era igual que lista") #no la mostrará porque x no tiene la misma referencia que listas
else:
    print("x no era igual que lista") #la mostrará porque x no tiene la misma referencia que listas

if x is not listas[1]:
    print("x no era igual que lista") #no la mostrará porque x tiene la misma referencia que el elemento contenido en listas[1]
else:
    print("x era igual que lista") #la mostrará porque x tiene la misma referencia que el elemento contenido en listas[1]

Preferencia

La preferencia de los operadores va a determinar el orden en que se ejecuten en una expresión determinada

Usando paréntesis controlaremos que las operaciones se lleven a cabo según nosotros queramos

En Python la preferencia de los operadores de mayor a menor es la siguiente:

Tipos de datos en Python

Los tipos en Python son una representación de los datos, ya que no requiere que las variables declaren su tipo, porque todos los tipos se convierten de forma automática

Podemos utilizar la función type para conocer el tipo de una variable

Tipo booleano

El tipo booleano simplemente distingue entre dos estados, un estado de éxito o de activado, valor verdadero, True, y un estado de fracaso o de desactivado, valor falso, False

Ambos estados no son susceptibles a mayúsculas y minúsculas

foo = True #asigna el valor True a la variable foo

Normalmente, el resultado de operadores que devuelven un valor de tipo booleano son pasados a las estructura de control

mostrar_separadores = True #declaramos la variable con un booleano

#esto no es necesario...
if mostrar_separadores == True:
    print("<hr>\n")

#...porque podemos ahorrar código escribiendo:
if mostrar_separadores:
    print("<hr>\n")

print( type(mostrar_separadores) ) #devolverá <class 'bool'>

Tipos numéricos

En Python existen 4 tipos diferentes de variables numéricas:

• int

  número entero con precisión fija

• long

  número entero en caso de sobrepasar el tamaño de un int

• float

  número en coma flotante de doble precisión

• complex

  número complejo (parte real + j parte imaginaria)

entero = 1
print( type(entero) ) #devolverá <class 'int'> 

real = 1.23
print( type(real) ) #devolverá <class 'float'> 

complejo = 1 + 2j
print( type(complejo) ) #devolverá <class 'complex'>

Es el intérprete el que decide el tipo de variable según lo que definimos

Sin embargo, podemos querer forzarlo nosotros mediante un cast

entero = int(1)
print( type(entero) ) #devolverá <class 'int'> 

real = float(1.23)
print( type(real) ) #devolverá <class 'float'> 

complejo = complex(1 + 2j)
print( type(complejo) ) #devolverá <class 'complex'>

Tipo string

Un string es una cadena de caracteres delimitadas por comillas

Un literal de tipo string se puede especificar de dos formas diferentes:

• entrecomillado simple

  se especifican entre los carácteres ‘ de apertura y ‘ de cierre

  Para especificar una comilla simple literal, se ha de escapar con una barra invertida (\). Para especificar una barra invertida literal, se duplica (\\)

  Todas las demás instancias de barras invertidas serán tratadas como una barra invertida literal: esto significa que otras secuencias de escape que podrían utilizarse, tales como \r o \n, serán mostradas literalmente tal y como se especifican, en lugar de tener cualquier otro significado especial

  print('Esto es una cadena sencilla')
  
  #Resultado: Arnold una vez dijo: "Volveré"
  print('Arnold una vez dijo: "Volveré"')
  
  #Resultado: Ha borrado C:\*.*?
  print('Ha borrado C:\\*.*?')
  
  #Resultado: Ha borrado C\:*.*?
  print('Ha borrado C:\*.*?')
  
  #Resultado:
  #Esto se expandirá:
  #una nueva línea
  print('Esto se expandirá:\nuna nueva línea')

• entrecomillado doble

  se especifican entre los carácteres " de apertura y " de cierre

  Python interpretará las siguientes secuencias de escape como caracteres especiales:

  Código	Descripción
  \n	avance de línea (LF o 0x0A (10) en ASCII)
  \r	retorno de carro (CR o 0x0D (13) en ASCII)
  \t	tabulador horizontal (HT o 0x09 (9) en ASCII)
  \\	barra invertida
  \"	comillas dobles

  print("Esto es una cadena sencilla")
  
  #Resultado: Arnold una vez dijo: "Volveré"
  print("Arnold una vez dijo: \"Volveré\"")
  
  #Resultado: Ha borrado C:\*.*?
  print("Ha borrado C:\\*.*?")
  
  #Resultado: Ha borrado C\:*.*?
  print("Ha borrado C:\*.*?")
  
  #Resultado:
  #Esto se expandirá:
  #una nueva línea
  print("Esto se expandirá:\nuna nueva línea")

Métodos

Vamos a ver algunos de los métodos para cadenas de uso más cotidiano

Métodos de formato

Afectan al formato del texto contenido en la cadena

• capitalize()

  Realiza una copia de la cadena con la primera letra en mayúsculas

• lower()

  Devuelve una copia de la cadena en minúsculas

• upper()

  Devuelve una copia de la cadena en mayúsculas

• swapcase()

  Devuelve una copia de la cadena en la que las mayúsculas son minúsculas y viceversa

• title()

  Devuelve una copia de la cadena en la que la primera letra de cada palabra es mayúscula y las demás minúsculas

• center(longitud, ‘caracter de relleno’)

  Devuelve una copia de la cadena de entrada centrada en la longitud indicada y entre el caracter de relleno que se indique

• ljust(longitud, ‘caracter de relleno’): Devuelve una copia de la cadena alineada a la izquierda

• rjust(longitud, ‘caracter de relleno’)

  Devuelve una copia de la cadena alineada a la izda/derecha

• zfill(longitud)

  Devuelve una copia de la cadena rellenada con ceros a la izda hasta alcanzar la longitud indicada

numero_factura = 892
cadena = 'tEngO UNa caSa aZUL'

print( cadena.capitalize() ) #devuelve 'Tengo una casa azul'
print( cadena.lower() ) #devuelve 'tengo una casa azul'
print( cadena.upper() ) #devuelve 'TENGO UNA CASA AZUL'
print( cadena.swapcase() ) #devuelve 'TeNGo unA CAsA Azul'
print( cadena.title() ) #devuelve 'Tengo Una Casa Azul'
print( cadena.center(40, '=') ) #devuelve '==========tEngO UNa caSa aZUL==========='
print( cadena.capitalize().center(40, '=') ) #devuelve '==========Tengo una casa azul==========='
print( cadena.rjust(40, '=') ) #devuelve '=====================tEngO UNa caSa aZUL'
print( str(numero_factura).zfill(12) ) #devuelve '000000000892'

Métodos de búsqueda

Nos permiten buscar dentro de una determinada cadena para comprobar si una subcadena está contenida en la cadena o cuántas veces aparece una subcadena

• count(‘subcadena’)

  Devuelve un entero representando la cantidad de apariciones de la subcadena dentro de la cadena

• find(‘subcadena’)

  Devuelve un entero representando la posición en la que empieza la subcadena dentro de la cadena

cadena = 'las elecciONES Generales A LA presidenCIA del gobierno son EL 28 de abril'

print( cadena.count('la') ) #devuelve 1
print( cadena.lower().count('la') ) #devuelve 2
print( cadena.lower().find('elecciones') ) #devuelve 4
print( cadena.lower()[4:] ) #devuelve 'elecciones generales a la presidencia del gobierno son el 28 de abril'
print( cadena.lower()[cadena.lower().find('elecciones'):] ) #devuelve 'elecciones generales a la presidencia del gobierno son el 28 de abril'

Métodos de validación

Nos devuelven siempre un booleano, es decir, True o False

Sirven para comprobar si una cadena cumple una determinada condición

• startswith(‘subcadena’)

  Nos dice si una cadena comienza por una cadena determinada

• endswith(‘subcadena’)

  Nos dice si una cadena termina por una cadena determinada

• isalnum()

  Nos dice si una subcadena es alfanumérica

• isalpha()

  Nos dice si una cadena es alfabética

• isdigit()

  Nos dice si una cadena es numértica

• islower()

  Nos dice si una cadena contiene sólo minúsculas

• isupper()

  Nos dice si una cadena contiene sólo mayúsculas

• isspace()

  Nos dice si una cadena contiene sólo espacios en blanco

• istitle()

  Nos dice si una cadena tiene formato de título

cadena = 'las elecciONES Generales A LA presidenCIA del gobierno son EL 28 de abril'

print( cadena.startswith('las') ) #devuelve True
print( cadena.endswith('las') ) #devuelve False
print( cadena.isalnum() ) #devuelve False
print( cadena.isalpha() ) #devuelve False
print( cadena.isdigit() ) #devuelve False
print( cadena.islower() ) #devuelve False
print( cadena.isupper() ) #devuelve False
print( cadena.isspace() ) #devuelve False
print( cadena.istitle() ) #devuelve False

Métodos de sustitución

Nos permiten sustituir texto para unificar el formato de diferentes cadenas que nos han llegado por vías diferentes

• format(argumentos)

  Podemos tener una cadena que esté preparada para recibir una cierta cantidad de argumentos

  Al llamar a esta función e introducir los argumentos necesarios nos devuelve una copia de la cadena ya formateada

• replace(‘subcadena buscada’, ‘subcadena que poner’)

  Busca dentro de la cadena una subcadena y la sustituye por la cadena indicada

• strip()

  Elimina el carácter que indiquemos de la derecha y de la izquierda de la cadena

  Por defecto busca el carácter espacio

• lstrip()

  Elimina los caracteres a la izquierda de una cadena

  Si introducimos como argumento una subcadena, busca esa subcadena y las combinaciones de los caracteres de la subcadena desde la izquierda hasta que no encuentre ninguno más

• rstrip()

  Elimina los caracteres a la a derecha de una cadena

  Si introducimos como argumento una subcadena, busca esa subcadena y las combinaciones de los caracteres de la subcadena desde la derecha hasta que no encuentre ninguno más

usuario = " pedro"
dominio = "proveedor.net "
mail = usuario + "@" + dominio

print( mail.replace("pedro", "juan") ) #muestra ' juan@proveedor.net '
print( mail.strip() ) #muestra 'pedro@proveedor.net'
print( mail.lstrip(usuario) ) #muestra '@proveedor.net '
print( mail.rstrip(dominio) ) #muestra ' pedro@

Métodos de unión y división

Nos permiten sustituir texto para unificar diferentes cadenas que nos han llegado por vías diferentes o para separar una cadena en varias

• join(iterable)

  Recibe como argumento un iterable y devuelve como resultado los elementos del iterable unidos por el carácter de la cadena sobre la que se aplica

• partition(‘separador’)

  Devuelve una tupla de 3 elementos

  El primer elemento es lo que hay a la izquierda del ‘separador’, el segundo elemento es el separador y el tercer elemento es lo que hay a la derecha del separador

• split(‘separador’)

  Devuelve una lista con todos los elementos encontrados al dividir la cadena por el separador

• splitlines()

  Devuelve una lista donde cada elemento es una fracción de la cadena dividida en líneas

caracter = ", "
listas =  ['pan', 'lechuga', 'tomates', 'peras', 'manzanas']
usuario = "pedro"
dominio = "proveedor.net"
separador = "@"
mail = usuario + separador + dominio
compra = "pan, lechuga, tomates, peras, manzanas"

print( caracter.join(listas) ) #devuelve "pan, lechuga, tomates, peras, manzanas"
print( mail.partition(separador) ) #devuelve "('pedro', '@', 'proveedor.net')"
print( mail.partition(separador)[0] ) #devuelve "pedro"
print( mail.partition(separador)[2] ) #devuelve "proveedor.net"
print( compra.split(caracter) ) #devuelve "['pan', 'lechuga', 'tomates', 'peras', 'manzanas']"
print( compra.splitlines() ) #devuelve "['pan, lechuga, tomates, peras, manzanas']"

Listas

Se definen poniendo el contenido de la lista entre corchetes, separando cada uno de los elementos mediante una coma

Cada posición de la lista puede contener elementos de distinto tipo

Las listas son mutables, es decir, sus elementos pueden ser modificados

En Python los elementos de una lista se numeran desde 0 hasta longitud – 1

Para acceder al elemento de una lista se pone el nombre de la lista y a continuación el índice al que queremos acceder (si ponemos el índice con signo negativo empezará por el final de la lista)

Para acceder a un rango dentro de una lista tenemos diferentes opciones:

• Tomar elementos desde el inicio: lista[:a]
• Tomar elementos desde la posición a (incluida) hasta el final: lista[a:]
• Tomar elementos desde a hasta b (sin incluir b): lista[a:b]

El inicio del rango siempre incluye el elemento en esa posición, pero no el final del rango

listas = [1, 2, 3, 4, 5, 6]

print( len(listas) ) #devuelve 6, que es la longitud de la lista
print( listas[0] ) #devuelve 1
print( listas[-1] ) #devuelve 6
print( listas[:2] ) #devuelve [1, 2]
print( listas[2:] ) #devuelve [3, 4, 5, 6]
print( listas[1:4] ) #devuelve [2, 3, 4]

Métodos

Vamos a ver algunos de los métodos para listas de uso más cotidiano

• append()

  añade un elemento al final de la lista

• insert()

  se usa para insertar un elemento en el índice asignado

• pop()

  elimina y devuelve el valor en la posición del índice asignado

• reverse()

  reordena la lista de forma reversa

• sort()

  reordena la lista de forma ascendente

mi_lista = [1, 3, 5, 4, 2]

print(mi_lista) #devuelve [1, 3, 5, 4, 2]
mi_lista.append(6)
print(mi_lista) #devuelve [1, 3, 5, 4, 2, 6]
mi_lista.insert(0, 8)
print(mi_lista) #devuelve [8, 1, 3, 5, 4, 2, 6]
valor = mi_lista.pop(0)
print(mi_lista, valor) #devuelve [1, 3, 5, 4, 2, 6] 8
mi_lista.reverse()
print(mi_lista) #devuelve [6, 2, 4, 5, 3, 1]
mi_lista.sort()
print(mi_lista) #devuelve [1, 2, 3, 4, 5, 6]

Podemos encontrar todos los métodos en su documentación

Tuplas

Las tuplas son similares a las listas, se definen con paréntesis en vez de corchetes

Tienen la peculiaridad de ser inmutables

mi_tupla = (1, 2, 3, 4, 5, 6)

print( len(mi_tupla) ) #devuelve 6, que es la longitud de la tupla
print( mi_tupla[0] ) #devuelve 1
print( mi_tupla[-1] ) #devuelve 6
print( mi_tupla[:2] ) #devuelve [1, 2]
print( mi_tupla[2:] ) #devuelve [3, 4, 5, 6]
print( mi_tupla[1:4] ) #devuelve [2, 3, 4]

Como puede verse, se accede a los elementos de igual forma que con las listas

Diccionarios

Los diccionarios definen una relación de uno a uno entre clave valor entre {} y son mutables

Se definen colocando una lista separada por comas de pares clave:valor

Una vez definido, podemos acceder al valor asociado a una clave buscando por clave

Además, podemos buscar si una determinada clave existe o no en nuestro diccionario

Los diccionarios son un tipo de colección en Python que, a diferencia de las listas, están indexadas por palabras y no por números

Los valores pueden ser de cualquier tipo

Podemos pensar en un diccionario como un conjunto no ordenado de pares clave:valor con el requisito de que las claves tienen que ser únicas

diccionario = {
    'int':'Número entero',
    'float':'Número real',
    'complex':'Número complejo'    
}

print( type(diccionario) ) #devuelve <class 'dict'>
print( diccionario['int'] ) #devuelve Número entero
print( 'int' in diccionario) #comprobamos si la clave 'int' existe en el diccionario, devuelve True
print( 'long' in diccionario) #comprobamos si la clave 'long' existe en el diccionario, devuelve False

Métodos

Vamos a ver algunos de los métodos para diccionarios de uso más cotidiano

• keys()

  nos devuelve un iterable que contiene las claves del diccionario

• values()

  nos devuelve un iterable que contiene los valores del diccionario

• items()

  nos devuelve un iterable con los pares clave:valor del diccionario

diccionario = {
    'int':'Número entero',
    'float':'Número real',
    'complex':'Número complejo'    
}

print( diccionario.keys() ) #devuelve dict_keys(['int', 'float', 'complex'])
print( diccionario.values() ) #devuelve dict_values(['Número entero', 'Número real', 'Número complejo'])
print( diccionario.items() ) #devuelve dict_items([('int', 'Número entero'), ('float', 'Número real'), ('complex', 'Número complejo')])

Objetos

Los objetos se componen de un conjunto de valores, propiedades y un conjunto de métodos aplicados a esos valores

Son estos métodos los que nos permiten modificar el estado de dicho objeto, es decir, el valor de sus propiedades

En Python los objetos tiene las siguientes particularidades:

• Todo es un objeto, incluyendo los tipos y clases
• Permite herencia múltiple
• No existen métodos ni atributos privados
• Los atributos pueden ser modificados directamente

• Permite monkey patching

  Las clases se crean en tiempo de ejecución pero pueden modificarse tras ser creadas

• Permite duck typing

  El estilo de tipificación dinámica de datos en que el conjunto actual de métodos y propiedades determina la validez semántica, en vez de que lo hagan la herencia de una clase

• Permite la sobrecarga de operadores
• Permite la creación de nuevos tipos de datos

Vamos a crear un objeto Universitario de ejemplo en el que tendremos las propiedades: Nombre, Apellido, Edad y Dni

La instancia del objeto la crearemos mediante la asignación a una variable de la siguiente forma:

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""

alumno = Univers() #La instancia del objeto

Es posible consultar la clase de un objeto con la función type, pero también se puede consultar a través de su atributo especial __class__

print(alumno) #devuelve <__main__.Univers object at 0x054A01B0> que es una referencia al objeto
print( type(alumno) ) #devuelve <class '__main__.Univers'>
print(alumno.__class__) #devuelve <class '__main__.Univers'>

A su vez las clases tienen un atributo especial __name__ que nos devuelve su nombre en forma de cadena sin adornos:

print(Univers.__name__) #devuelve Univers
print( type(alumno).__name__ ) #devuelve Univers
print(alumno.__class__.__name__) #devuelve Univers

Es posible inicializar todas las variables para que tengan el tipo que queremos, para ello usaremos el constructor de la clase pasándole los argumentos que necesitemos

El constructor es un método que se llama automáticamente al crear un objeto y se define con el nombre __init__ y mediante la palabra reservada self podremos referenciar al objeto actual

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto

Si existe un constructor también debe existir un destructor que se llame al eliminar el objeto para que encargue de las tareas de limpieza como vaciar la memoria

Todos los objetos se borran automáticamente de la memoria al finalizar el programa, aunque para eliminarlos automáticamente disponemos del método especial __del__

No es aconsejable sobreescribir este método porque se maneja automáticamente, pero es interesante saber que es posible

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
del(alumno) #Borramos el alumno de la memoria

El método __str__ es el que devuelve la representación de un objeto en forma de cadena

Se llama automáticamente es cuando imprimirmos una variable por pantalla con la función print

Por defecto los objetos imprimen su clase y una dirección de memoria, pero podemos cambiarlo sobreescribiendo su comportamiento

Por ejemplo, para el objeto universitario sobreescribimos el método __str__ para que nos muestre el nombre, edad, apellidos y dni

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789

Un método especial interesante es el que devuelve la longitud

Normalmente está ligado a colecciones, pero nada impide definirlo en una clase y no redefinirlo, porque por defecto no existe en los objetos aunque sea el que se ejecuta al pasarlos a la función __len__

En nuestro ejemplo del objeto universitario no tiene mucho sentido contar su longitud, pero lo incluyo para mostrar su uso

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"
    def __len__(self):
       return 1

alumno = Univers("Juan", "Delgado", 12, 44565789) #La instancia del objeto
print( len(alumno) ) #muestra 1

Las propiedades de un objeto pueden describirse mediante otros objetos o incluso colecciones de ellos

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
        self.expediente = expediente
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"
    def __len__(self):
       return 1

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Univers("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto

La definición de métodos asociados a un objeto puede precisarse en la definición del objeto

Por ejemplo, para el objeto universitario sobreescribimos el método __str__ para que muestre el nombre, edad, apellidos, dni y notas medias del alumno

Para acceder a las propiedades o a los métodos usaremos el operador .

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final

class Univers():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
        self.expediente = expediente
    def __del__(self):
        print("El alumno %s se está borrando de la memoria" %(self.nom) )
    def __str__(self):
       return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} Curso1: {self.expediente.curso1} Curso2: {self.expediente.curso2} Curso3: {self.expediente.curso3} Final: {self.expediente.final}"
    def __len__(self):
       return 1

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Univers("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789 Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23

Herencia

La herencia es la capacidad que tiene una clase de heredar los atributos y métodos de otra, algo que nos permite reutilizar código

Para ver su utilidad, vamos a desarrollar un ejemplo modificando el objeto universidad

Partiremos de una clase base que hará de padre (superclase) de otras hijas que heredaran de ella (subclases)

Partimos de una clase Persona que contendrá todos los atributos comunes y dos clases hijas Alumno y Profesor que heredan de ella y tienen atributos o métodos propios

Para heredar los atributos y métodos de una clase en otra sólo tenemos que pasarla entre paréntesis durante su definición

Es posible utilizar el comportamiento de una superclase sin definir nada en la subclase, aunque en nuestro ejemplo si que les daremos comportamiento

class Persona():
    nom = ""
    apell = ""
    edad = ""
    dni = ""
    def __init__(self, nom, apell, edad, dni):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni
    def __str__(self):
       return f"Persona: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni}"

class Nota_M():
    curso1 = 0.00
    curso2 = 0.00
    curso3 = 0.00
    final = 0.00
    def __init__(self,  curso1, curso2, curso3, final):
        self.curso1 = curso1
        self.curso2 = curso2
        self.curso3 = curso3
        self.final = final
    def __str__(self):
       return f"Curso1: {self.curso1} Curso2: {self.curso2} Curso3: {self.curso3} Final: {self.final}"
        
class Alumno(Persona):
    expediente = Nota_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, apell, edad, dni, expediente):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni       
        self.expediente = expediente
    def __str__(self):
        return f"Alumno: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} {str(self.expediente)}"

class Profesor(Persona):
    asignatura = ""
    def __init__(self, nom, apell, edad, dni, asignatura):
        self.nom = nom
        self.apell = apell
        self.edad = edad
        self.dni = dni       
        self.asignatura = asignatura
    def __str__(self):
        return f"Profesor: {self.nom} Apellido: {self.apell} Edad: {self.edad} DNI: {self.dni} Asignatura: {self.asignatura}"

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
profesor = Profesor("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #La instancia del objeto
print( str(alumno) ) #muestra Alumno: Juan Apellido: Delgado Edad: 12 DNI: 44565789 Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23
print( str(profesor) ) #muestra Profesor: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Ciencias naturales

Gracias a la flexibilidad de Python podemos manejar objetos de distintas clases masivamente de una forma muy simple

Vamos a empezar creando una lista con nuestros dos Personas de subclases distintas

personas = [alumno, profesor]
#Recorremos todos los elementos de la lista con un bucle for
for persona in personas:
    print(persona, "\n")
#También podemos acceder a los atributos, siempre que sean compartidos entre todos los objetos
for persona in personas:
    print(persona.nom, "\n")
#Si un objeto no tiene el atributo al que queremos acceder nos dará error
for persona in personas:
    #Usando la función isinstance() podemos comprobar si el atributo pertenece o no a un objeto concreto y evitar el error
    if( isinstance(persona, Profesor) ):
        print(persona.asignatura, "\n")

Uno de los pocos fallos de Python es que si modificamos los valores dentro de un objeto, estos cambios se verán reflejados fuera del mismo

De la misma forma que en las colecciones, los objetos se pasan a las funciones por referencia

Afecta a la hora de hacer copias, creándose en su lugar un acceso al objeto en lugar de uno nuevo con sus valores anteriores

Para realizar una copia a partir de sus valores podemos utilizar la función copy del módulo con el mismo nombre

alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto original
alumno2 = alumno
alumno2.nom = "Prueba"
print(alumno2 == alumno)  #¿Son el mismo objeto? Si, porque nos duelve True, el atributo nom debería ser igual en ambos objetos

try:
    print(alumno.nom) #devuelve 'Prueba'
    print(alumno2.nom) #devuelve 'Prueba'
except Exception as e:
    print(e)
    
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #volvemos a cargar la instancia del objeto original

from copy import copy

alumno2 = copy(alumno)
alumno2.nom = "Prueba"
print(alumno2 == alumno)  #¿Son el mismo objeto? No, porque nos devuelve False, el atributo nom debería ser distinto en ambos objetos

try:
    print(alumno.nom) #devuelve 'Juan'
    print(alumno2.nom) #devuelve 'Prueba'
except Exception as e:
    print(e)

La función copy se puede utilizar también para copiar colecciones

from copy import copy

lista1 = [1,2,3]
lista2 = copy(lista1)
lista1 = None

print(lista1) #devuelve None
print(lista2) #devuelve [1, 2, 3]

La herencia múltiple permite a una subclase heredar de múltiples superclases

Esto conlleva un problema, y es que si varias superclases tienen los mismos atributos o métodos, la subclase sólo podrá heredar de una de ellas

Además de superclases también puede heredar de forma múltiple de subclases

En estos casos Python dará prioridad a las clases más a la izquierda en el momento de la declaración de la subclase

class Profesor_Alumno(Profesor, Alumno):
    pass

nota_media = Nota_M(6.5, 7.95, 8.12, 7.23) #La instancia del objeto
alumno = Alumno("Juan", "Delgado", 12, 44565789, nota_media) #La instancia del objeto
profesor = Profesor("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #La instancia del objeto
profesor_alumno = Profesor_Alumno("Pedro", "Del Río", 38, 19587426, "Ciencias naturales") #Usará como superclase Profesor
print(profesor_alumno) #Devuelve Alumno: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Ciencias naturales
profesor_alumno = Profesor_Alumno("Pedro", "Del Río", 38, 19587426, nota_media) #Usará como superclase Alumno
print(profesor_alumno) #devuelve Alumno: Pedro Apellido: Del Río Edad: 38 DNI: 19587426 Asignatura: Curso1: 6.5 Curso2: 7.95 Curso3: 8.12 Final: 7.23

Hemos usado la palabra reservada pass para indicarle al intérprete que ignore el código del cuerpo y utilice el de la clase object o el de las superclases (subclases) que le indiquemos

Valor nulo

En Python a las variables se les puede asignar un valor que indica el valor vacío, este valor es el valor NULL

Una variable es considerada None si:

• se le ha asignado la constante None
• no se le ha pasado un atributo a una función

La constante None es insensible a mayúsculas o minúsculas

var = None

print(var) #devuelve None

Estructuras de control en Python

Para las estructuras de control, Python posee las sentencias de control típicas de los lenguajes de alto nivel

Declaración de variables

A las variables en Python no se les asigna un tipo predefinido

En Python el tipo de las variables depende del valor que contengan las mismas en cada momento

Por tanto se realiza una conversión automática de tipos

Python reconoce los siguientes tipos de valores:

• Números
• Valores booleanos

  true y false

• Strings
• Listas

  tipo de datos que asocia valores con un valor numérico poniendo el contenido de la lista entre corchetes, separando cada uno de los elementos mediante una coma

• Tuplas

  tipo de datos que asocia valores con un valor numérico poniendo el contenido de la lista entre paréntesis, separando cada uno de los elementos mediante una coma

  Tienen la peculiaridad de ser inmutables

• Diccionarios

  tipo de datos que asocia un valor a una clave y permite buscar por esas claves

• Objetos

  Creados por el programador o predefinidos por el lenguaje

Al tratarse de un lenguaje con tipado dinámico, no es necesario decirle al intérprete su tipo de variable, sino que es él quien decide el tipo que asignará

Los nombres con los que podemos nombrar variables en Python siguen varias normas:

• Los nombres empiezan siempre por letra
• Dentro del nombre se puede usar cualquier letra o número dentro de la codificación utf-8

• No se pueden usar las palabras reservadas de Python, que son usadas en su sintaxis de su código

  Para más información sobre estos nombres consultar en la documentación de Python

Notar que Python distingue entre mayúsculas y minúsculas, por lo que dos variables con el mismo nombre pero que contenga una letra en mayúscula serán entendidas como dos variables distintas

Por ejemplo Variable es diferente de variable

Además existen ciertos convenios para reducir errores y mejorar la legibilidad

Para evitar errores se recomienda no usar ciertos caracteres:

• No usar ni l (ele minúscula) ni I (i mayuscula), ya que dependiendo del tipo de fuente que se use pueden confundirse entre si o con el número 1
• No usar O (o mayúscula) ya que dependiendo del tipo de fuente que se use puede llevar a confusión con el número 0

A fin de favorecer la legibilidad se hacen las siguientes sugerencias:

• nombredevarible es poco legible, por estar todo junto y puede dificultar su legibilidad
• nombreDeVarible es un poco más legible, al aplicar letra mayúscula al iniciar palabra
• nombre_de_variable es la que mejor legibilidad aporta, al aplicar guión bajo al iniciar palabra, que es la forma más recomendada

La sentencia if

La sentencia if tiene la forma:

if Condición:
    Instrucción 1 o bloque de instrucciones
[else:
    Instrucción 2 o bloque de instrucciones
]

En caso de que la condición sea verdadera se ejecutará la instrucción 1; en caso contrario se ejecuta si existe la instrucción 2

El uso de la sentencia else es opcional, por eso en la definición se han utilizado los corchetes

Si se omite, sólo se tendrá en cuenta el bloque de instrucciones cuando la condición sea verdadera

Un bloque de instrucciones es un conjunto de instrucciones tabulaciones después de la sentencia if, al saltar de línea después del símbolo :

if Condición:
    Instrucción 1
    Instrucción 2
    ...
    Instrucción N
}

Son obligatorias ya que le dicen al interprete que el bloque de instrucciones pertenece a la sentencia if

Si se omiten y la condición era verdadera, se ejecutará la siguiente instrucción

En caso contrario, se ejecutará la subsiguiente instrucción, de forma independiente al estado de la condición

De este modo, la omisión de las tabulaciones después de la sentencia if nos permitirá escribirlo todo en una única línea después del símbolo :

if Condición: Instrucción del if
Subsiguiente Instrucción

La sentencia elif

También podemos utilizar sentencias if anidades mediante la sentencia elif

Las sentencias elif funcionan igual que una sentencia if

Pero sólo se ejecutarán en caso de que la condición de la sentencia if fuese falsa

Podemos añadir opcionalmente una sentencia else al final pero sólo se ejecutará si todas las condiciones anteriores fuesen falsas

if Condición:
    Bloque de instrucciones del if
[elif Condición:
    Bloque de instrucciones del elif
]
[else:
    Bloque de instrucciones del else
]

La sentencia while

La sentencia while tiene la forma

while Condición:
    Instrucción o bloque de instrucciones

Si se cumple la condición, se ejecuta la instrucción o el bloque de instrucciones y se repite el proceso hasta que deje de cumplirse la condición

La sentencia for

Este bucle, tiene una sintaxis muy parecida al for-each de Java

Itera una variable var sobre todas las propiedades de un objeto obj que se le pasa

Así para cada valor de var se ejecutaran las sentencias del bucle

Por lo tanto, el bucle tendrá tantas iteraciones como propiedades el objeto y en cada iteración la variable tendrá el valor de la propiedad del objeto correspondiente con dicha iteración

Su sintaxis es:

for var in obj:
    Instrucción o bloque de instrucciones

Iteradores

En Python existen diferentes estructuras que son conjuntos de elementos, son las llamadas colecciones

Este tipo de estructuras son iterables, es decir, se pueden recorrer elemento por elemento

Algunos tipos de variable que son iterables son:

• Cadena de caracteres (str)
• Lista (list)
• Tupla (tuple)
• Diccionario (dict)

Su uso es útil para recorrer elementos de colección como las listas, las tuplas o los objetos

#ejemplo de recorrido de cadena de caracteres
cad = "cadena"

for c in cad:
    print(c)
#muestra
#c
#a
#d
#e
#n
#a

#ejemplo de recorrido de lista
lista = [10, 2, 3, 8, 9, 1]

for i in lista:
    if i > 5:
        print(i)
#muestra
#10
#8
#9

#ejemplo de recorrido de tupla
tupla = (10, 2, 3, 8, 9, 1)

for i in tupla:
    if i > 5:
        print(i)
#muestra
#10
#8
#9

#ejemplo de recorrido de diccionario
ciudades = {
    'Madrid': 3223334,
    'Valencia': 791413,
    'Zaragoza':666880,
    'Sevilla':688711,
    'Barcelona':1620343,
    'Prueba':1620343
}

for clave in ciudades:
    print ('%s: %s' %(clave, ciudades[clave]) )
#muestra
#Madrid: 3223334
#Valencia: 791413
#Zaragoza: 666880
#Sevilla: 688711
#Barcelona: 1620343
#Prueba: 1620343

Además, muchas veces queremos repetir un bucle un número determinado de veces

Para esto puede ser útil la función range(n)

Esta función genera un iterable que va desde 0 hasta n – 1

for i in range(3):
    print(i)
#muestra
#0
#1
#2

La sentencia break

La sentencia break se puede colocar dentro de un bucle o bucles anidados

Cuando se ejecuta la sentencia break se abandona el bucle más interno

A todos los efectos la sentencia break actúa como un salto a la instrucción siguiente al bucle en el que se ejecuta

La sentencia continue

La sentencia continue, no abandona el bucle si no que hace que se ejecute la siguiente iteración

En el bucle while la ejecución del continue hace que el flujo del programa salte a la condición

En el bucle for la ejecución del continue hace que se ejecute la expresión de incremento, para después continuar normalmente con la condición

Es decir, la ejecución del continue evita que se ejecute el resto del cuerpo del bucle

Funciones en Python

Para definir funciones en Python disponemos de la instrucción def

Después de esta palabra reservada va el nombre de la función junto con una lista de argumentos delimitados por paréntesis y separados por comas, finalizando con el símbolo :

def nombre( param1, param2,..., paramn ):
    ["""DOCSTRING_DE_FUNCION"""]
    instrucciones en Python
    [return expresión]

La definición de una función no ejecuta el cuerpo de la función

Solamente será ejecutada cuando la función sea llamada

Su ejecución enlaza el nombre de la función con el namespace local actual a un objecto función (un envoltorio alrededor del código ejecutable para la función)

Este objeto función contiene una referencia al namespace local global como el namespace global para ser usado cuando la función sea llamada

De forma opcional puede añadirse una expresión que será devuelta por la función

La expresión puede será un tipo válido de Python precedida por la sentencia return

El DOCSTRING es un texto descriptivo de la función encerrado entre tres comillas dobles de apertura y cierre, antes de la primera instrucción

Es opcional, así que si no queremos añadir una descripción, podemos omitirlo

Pero se recomienda su uso para que cuando revisemos después de un tiempo nuestro código, recordemos qué hacía nuestra función

Argumentos

El paso de argumentos es opcional y en algunos casos puede haber funciones que carezcan de ellos

Tipo de los argumentos

Admite los tipos str, int, float, complex,bool, list, tuple, dic y class

Argumentos con valor por posición

Cuando enviamos argumentos a una función, estos se reciben por orden en los parámetros definidos

def resta(a, b):
     return a - b

resta(30, 10) #mostrará 20, sin necesidad de usar la función print

Argumentos con valor por nombre

Es posible evadir el orden de los parámetros si indicamos durante la llamada el valor que tiene cada parámetro a partir de su nombre

def resta(a, b):
     return a - b

resta(b=30, a=10) #mostrará -20, sin necesidad de usar la función print

Sin Argumentos

Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los argumentos correctamente provocará una excepción TypeError

def resta(a, b):
     return a - b

resta() #lanza una excepción TypeError

Argumentos con valor por defecto

En ocasiones necesitamos que un argumento tenga un valor, para evitar un error (que provocaría el lanzamiento de la excepción TypeError), aunque el usuario de la función no lo introduzca

Hay que tener en cuenta, que los argumentos con valor por defecto pasan a ser opcionales y que todos los argumentos a la izquierda del primer valor por defecto, son obligatorios

def resta(a=None, b=None):
     if a == None or b == None:
         print("Error, debes enviar dos números a la función")
         return
     return a - b

resta(30) #Sólo hemos pasado un argumento, muestra: 'Error, debes enviar dos números a la función'
resta() #No hemos pasado argumentos, muestra: 'Error, debes enviar dos números a la función'

En el ejemplo se ha utilizado el valor nulo (None) para expresar que no se habían pasado argumentos

Pero podríamos utilizar cualquier tipo que precisemos como valor por defecto

Argumentos indeterminados

En algunas ocasiones no sabremos previamente cuantos elementos necesitamos enviar a una función

Para estos casos podemos utilizar los parámetros indeterminados por posición o por nombre

Argumentos por posición

Como argumento usaremos un tipo tuple precediendolo con el símbolo *

De esta forma todos los argumentos serán recibidos por posición, pudiendo recorrerlos cómodamente con un bucle for

def ind_pos(*args):
     for arg in args:
         print( type(arg) )
         print(arg)

ind_pos(5, "Hola", [1,2,3,4,5] )

#devuelve
#<class 'int'>
#5
#<class 'str'>
#Hola
#<class 'list'>
#[1, 2, 3, 4, 5]

Argumentos por nombre

Como argumento usaremos un tipo dict precediendolo con los símbolos **

De esta forma todos los argumentos serán recibidos por el nombre de la clave del diccionario, pudiendo recorrerlos cómodamente con un bucle for

def ind_nom(**kwargs):
    print(kwargs)
    for kwarg in kwargs:
        print(kwarg, "=>", kwargs[kwarg])

ind_nom(n=5, c="Hola", l=[1,2,3,4,5])

#devuelve
#{'n': 5, 'c': 'Hola', 'l': [1, 2, 3, 4, 5]}
#n => 5
#c => Hola
#l => [1, 2, 3, 4, 5]

Argumentos por posición y nombre

En alguna ocasión puede necesitar utilizar ambos tipos de parámetros simultáneamente en una función, entonces debe crear ambas colecciones dinámicas

Primero los argumentos indeterminados por valor y luego por nombre

def pos_nom(*args,**kwargs):
     total = 0
     for arg in args:
         total += arg
     print("sumatorio => ", total)
     for kwarg in kwargs:
         print(kwarg, "=>", kwargs[kwarg])

pos_nom(50, -1, 1.56, 10, 20, 300, nombre="Raúl", edad=38)

#devuelve
#sumatorio =>  380.56
#nombre => Raúl
#edad => 38

En todos los ejemplos se han utilizado los nombres args y kwargs pero no son obligatorios

Muchos frameworks y librerías los utilizan por lo que es una buena practica llamarlos así, por convención

La sentencia pass

Es una operación nula, cuando la ejecutamos, parece que nada sucede

Es útil como un contenedor cuando una sentencia es requerida sintácticamente, pero no es necesario ejecutar código

#una función que no hace nada
def consultar(letra): 
    pass

type(consultar)

La sentencia return

La sentencia return es la que permite devolver el resultado de una función

Admite los tipos str, int, float, complex,bool, list, tuple, dic y class

def suma(numero1, numero2):
    '''Suma dos números'''
    print(numero1 + numero2)
    print("\n")

La setencia return es opcional, pero si se omite, por defecto devolverá el valor nulo (None)

Retorno múltiple

Una característica interesante de las funciones en Python, es la posibilidad de devolver valores múltiples separados por comas

def prueba():
     return "Raúl", 20, [1,2,3]
cadena, numero, lista = prueba()
print (cadena, type(cadena) ) #devuelve Raúl <class 'str'>
print (numero, type(numero) ) #devuelve 20 <class 'int'>
print (lista, type(lista) ) #devuelve [1, 2, 3] <class 'list'>

Funciones predefinidas por el lenguaje

Las funciones predefinidas por el lenguaje están ordenadas por módulos

Un módulo es un conjunto de clases y funciones almacenadas en un archivo que pueden ser utilizadas posteriormente

Podemos crear nuestros propios módulos e importarlos a los nuevos programas que hagamos

Sin embargo, es aconsejable reutilizar los módulos ya existentes

Para importar un módulo utilizaremos la sentencia import

De esta forma estaremos manejando un namespace, de forma similar a como lo hace C++ (using namespaces) o Java

Que tiene la siguiente sintaxis

import nombre_modulo [as alias]

Para llamar a una función concreta del módulo utilizaremos nombre.funcion() o alias.funcion en caso de que le hayamos dado un alias al módulo

En caso de no querer utilizar todas la funciones del módulo pero si una concreta, utilizaremos la sentencia from

Que tiene la siguiente sintaxis

from nombre_modulo import nombre_funcion

Módulo sys

Este módulo es el encargado de proveer variables y funcionalidades relacionadas con el intérprete

Las variables del módulo sys son:

• sys.executable

  Retorna el directorio absoluto del archivo binario ejecutable del intérprete de Python

• sys.platform

  Retorna la plataforma sobre la cual se está ejecutando el intérprete

• sys.version

  Retorna el número de versión de Python con información adicional

Los métodos más destacados del módulo sys son los siguientes:

• sys.exit()

  Forzar la salida del intérprete

• sys.getdefaultencoding()

  Retorna la codificación de caracteres por defecto

• sys.getfilesystemencoding()

  Retorna la codificación de caracteres que se utiliza para convertir los nombres de archivos unicode en nombres de archivos del sistema

• sys.getsizeof()

  Retorna el tamaño del objeto pasado como parámetro

import sys

cad = 'El perro de San Roque no tiene rabo'

print( sys.executable ) #devuelve c:\python.exe, ya que estoy usando el sistema de archivos de Windows
print( sys.platform ) #devuelve win32, ya que estoy usando un sistema Windows de 32 bits
print( sys.version ) #devuelve 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 21:26:53) [MSC v.1916 32 bit (Intel)]
print( sys.getdefaultencoding() ) #devuelve utf-8
print( sys.getfilesystemencoding() ) #devuelve utf-8
print( sys.getsizeof(cad) ) #devuelve 60

Módulo os

Este módulo nos permite acceder a funcionalidades dependientes del SO

Sobre todo, aquellas que nos dan información sobre el entorno del mismo y nos permiten manipular la estructura de directorios

Algunos de los métodos más utilizados son:

• os.getcwd()

  Nos informa de cuál es el directorio actual

• os.chdir(ruta)

  Cambia el directorio de trabajo a la ruta pasada como argumento

• os.chroot()

  Cambia al directorio raiz

• os.mkdir(directorio)

  Crea el directorio pasado como argumento

• os.rmdir(directorio)

  Elimina el directorio pasado como argumento

• os.remove(fichero)

  Eliminar el archivo pasado como argumento

• os.rename(actual, nuevo)

  Renombra el archivo actual por el nombre del archivo nuevo, pasados como argumentos

Módulo math

Este módulo nos provee de funciones y constantes matemáticas

Podemos encontrar todas las funciones y atributos en su documentación

Algunas de los variables más utilizadas son:

• math.pi

  Representa el valor de la variable \pi (número Pi)

• math.e

  Representa el valor de la variable e (número de Euler o constante de Napier)

• math.tau

  Representa el valor de la variable \tau = 2\cdot\pi (constante Tau, propuesta por Bob Palais, Peter Harremoes, Hermann Laurent, Fred Hoyle, Michael Hartl, Nicolás Atanes, entre otros)

Algunos de los métodos más utilizados son:

• math.ceil(x)

  Devuelve el entero menor que sea mayor o igual que x

• math.floor(x)

  Devuelve el entero mayor menor o igual a x

• math.exp(x)

  Devuelve el número e elevado a la potencia x

• math.log2(x)

  Devuelve el logaritmo en base 2 de x

• math.sin(x)

  Devuelve el seno de x radianes

• math.cos(x)

  Devuelve el coseno de x radianes

• math.tan(x)

  Devuelve la tangente de x radianes

• math.degrees(x)

  Convierte el ángulo x de radianes a grados

import math

a = 4.5786
b = 2.873

print( math.ceil(a) ) #devuelve 5
print( math.floor(a) ) #devuelve 4
print( math.exp(a) ) #devuelve 97.37796957468944
print( math.log2(a) ) #devuelve 2.194906532422851
print( math.sin(a) ) #devuelve -0.9910635960591139
print( math.cos(a) ) #devuelve -0.133390211658793
print( math.tan(a) ) #devuelve 7.429807507871837
print( math.degrees(a) ) #devuelve 262.3344560785987
print( math.pi ) #devuelve 3.141592653589793
print( math.e ) #devuelve 2.718281828459045
print( math.tau ) #devuelve 6.283185307179586

Módulo random

El módulo random se utiliza para todo lo relacionado con números aleatorios

Algunos de los métodos más utilizados son:

• shuffle(col)

  Reordena aleatoriamente los elementos de una colección

• sample(col, k)

  Toma n elementos sin reemplazo de una coleccion

• random()

  Genera un número aleatorio en el intervalo [0, 1)

• uniform(a, b)

  Genera un número aleatorio en el intervalo [a, b]

• randint(a, b)

  Genera un número aleatorio entero en el intervalo [a, b]

• gauss(media, sigma)

  Genera un número aleatorio siguiendo una distribución gaussiana con media y sigma dadas

import random

list = [1, 2, 3]

print( random.shuffle(list) ) #devuelve None
print( random.sample(list, 2) ) #devuelve [1, 2]
print( random.random() ) #devuelve 0.06298135634914415
print( random.uniform(0, 10) ) #devuelve 3.304708273440835
print( random.randint(0, 10) ) #devuelve 6
print( random.gauss(50, 1.28) ) #devuelve 50.28864476388755

Módulo NumPy

Numpy nos proporciona una gran cantidad de funciones matemáticas y el tipo de variable NumPy array

Por lo general el paquete NumPy suele importarse con el alias np

Este módulo nos permite trabajar con estructuras matemáticas de una forma muy cómoda (producto de matrices, números aleatorios, operaciones sobre matrices…)

Es un módulo que no viene instalado por defecto

Para ello abre un terminal y ejecuta:

python -m pip install numpy

Podemos encontrar todas las funciones y atributos en su documentación

Algunos de los métodos más utilizados son:

• random.rand()

  Nos devuelve valores aleatorios con la forma deseada

• empty()

  Crea un array vacío con la forma indicada

• zeros()

  Crea un array de ceros con la forma indicada

• dot()

  Calcula el producto matricial entre dos arrays

• sum()

  Calcula la suma de los elementos de un array

import numpy as np

np.random.seed(3)
A = np.random.rand(3,3) * 2
B = np.random.rand(3,3) * 2
A = np.round(A, 2)
B = np.round(B, 2)

print("A = ", A)
#devuelve
#A =  [[1.1  1.42 0.58]
# [1.02 1.79 1.79]
# [0.25 0.41 0.1 ]]

print("B = ", B)
#devuelve
#B =  [[0.88 0.06 0.91]
# [1.3  0.56 1.35]
# [1.18 0.05 1.12]]

print("A * B = ", np.round(np.dot(A, B), 2) )
#devuelve
#A * B =  [[3.5  0.89 3.57]
# [5.34 1.15 5.35]
# [0.87 0.25 0.89]]

print("Suma de A: ", np.sum(A) )
#devuelve
#Suma de A:  8.459999999999999

print("Suma de A: ", np.sum(A, axis = 0) )
#devuelve
#Suma de A:  [2.37 3.62 2.47]

C = A[A>1]
print(C) #devuelve [1.1  1.42 1.02 1.79 1.79]

Módulo Pandas

El paquete pandas es muy utilizado en el Data Scientists

Es uno de los paquetes sobre el que deberíamos centrarnos para aprender sobre análisis de datos

A través de pandas podemos familiarizarnos con nuestro set de datos limpiándolo, transformándolo y analizándolo

Por ejemplo, con pandas podemos leer un fichero CSV de nuestro ordenador, pasarlo a un DataFrame (una tabla, en esencia) y hacer cosas como:

• Calcular estadísticas y responder preguntas sobre los datos como sacar el máximo, minimo y media de cada columna, saber cómo de correlacionadas están las columnas A y B o conocer la distribución estadística de la columna C
• Limpiar los datos haciendo cosas como eliminar los valores faltantes o filtrando filas y columnas de acuerdo a algún criterio
• Visualizar los datos con la ayuda de matplotlib
• Guardar los datos ya limpiados de vuelta en un CSV o una base de datos

Pandas se basa en NumPy, por lo que debemos tener ese módulo instalado previamente

Jupyter Notebooks es una aplicación que se complementa muy bien con Pandas, ya que podemos ejecutar el código por celdas en vez que de forma completa, lo cual es útil si trabajamos con grandes datasets

Los componentes primarios de Pandas son series y DataFrame, siendo el primer tipo una columna y el segundo una table

Por lo general el paquete pandas suele importarse con el alias np

Es un módulo que no viene instalado por defecto

Para ello abre un terminal y ejecuta:

python -m pip install pandas

Podemos encontrar todas las funciones y atributos en su documentación

Ahora vamos a crear un ejemplo sencillo para mostrar el uso de pandas usando una serie que contendrá a los integrantes de la selección Española de fútbol que ganó el mundial del año 2010

Para crear la serie utilizamos el método pd.Series que recibirá una lista con los nombres de los jugadores y una lista con el número de dorsal de los jugadores

Después lo mostraremos por pantalla

import pandas as pd

jugadoresEspañoles = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7] )
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#dtype: object

Ahora no le vamos a indicar los índices de forma explícita, entonces generará los índices de forma automática empezando desde el valor cero

import pandas as pd

jugadoresEspañoles= pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'] )
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#0           Casillas
#1             Ramos
#2              Pique
#3              Puyol
#4         Capdevila
#5       Xabi Alonso
#6          Busquets
#7     Xavi Hernandez
#8           Pedrito
#9            Iniesta
#10              Villa
#dtype: object

Ahora vamos a introducir en la serie un diccionario en vez de una lista y le vamos a añadir un jugador más

import pandas as pd

jugadoresEspañoles = pd.Series( {1: 'Casillas', 15: 'Ramos', 3: 'Pique', 5: 'Puyol', 11: 'Capdevila', 14: 'Xabi Alonso', 16: 'Busquets', 8: 'Xavi Hernandez', 18: 'Pedrito', 6: 'Iniesta', 7: 'Villa'} )
jugadoresEspañoles[10] = 'Cesc' #añadimos un jugador
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#10              Cesc
#dtype: object

Ahora vamos a crear un ejemplo sencillo para mostrar el uso de pandas usando un DataFrame que contendrá a los integrantes de la selección Española de fútbol que ganó el mundial del año 2010

Para crear el DataFrame utilizamos el método pd.DataFrame que recibirá un diccionario con los datos de los jugadores, una lista con el nombre de la columna y una lista con el número de dorsal de los jugadores

Añadiremos un jugador más utilizando el método loc del objeto DataFrame

Después lo mostraremos por pantalla

import pandas as pd

jugadoresEspañoles= pd.DataFrame(
    {
        'name': ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez',
                 'Pedrito', 'Iniesta', 'Villa'],
        'demarcation': ['Portero', 'Defensa lateral derecho', 'Defensa', 'Defensa', 'Defensa lateral izquierdo', 'Centrocampista defensivo', 'Centrocampista defensivo', 'Centrocampista', 'Extremo izquierdo', 'Extremo derecho', 'Delantero centro'],
        'team': ['Real Madrid', 'Real Madrid', 'FC Barcelona', 'FC Barcelona', 'Villareal', 'Real Madrid',
                 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona']
    }, columns=['nombre', 'demarcación', 'equipo'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7]
)
jugadoresEspañoles.loc[10] = ['Cesc', 'Delantero', 'Arsenal'] #añadimos un jugador
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#            nombre                demarcación          equipo
#1         Casillas                    Portero     Real Madrid
#15           Ramos    Defensa lateral derecho     Real Madrid
#3            Pique                    Defensa    FC Barcelona
#5            Puyol                    Defensa    FC Barcelona
#11       Capdevila  Defensa lateral izquierdo       Villareal
#14     Xabi Alonso   Centrocampista defensivo     Real Madrid
#16        Busquets   Centrocampista defensivo    FC Barcelona
#8   Xavi Hernandez             Centrocampista    FC Barcelona
#18         Pedrito          Extremo izquierdo    FC Barcelona
#6          Iniesta            Extremo derecho    FC Barcelona
#7            Villa           Delantero centro    FC Barcelona
#10            Cesc                  Delantero         Arsenal

Funciones de visualización

print

La función print sirve para enviar la salida de sus argumentos al navegador con un formato

Operador %

El operador % también se puede utilizar para el formato de la cadena

Interpreta el argumento izquierdo de manera muy parecida a una cadena de formato de estilo de la función printf de C++, que se aplica al argumento derecho

En Python, no hay una función printf pero se le ha dotado de su funcionalidad a print

Para este propósito, el operador % está sobrecargado para cadenas para mostrar el formato de la cadena

A menudo se le llama operador de módulo de cadena (o, a veces, incluso, módulo)

Tiene el formato:

print( texto_formateado %(variable1 [, variable2, ..., variableN] )

Para formatear un texto deberemos introducir los siguientes caracteres de formato precedidos por el símbolo %:

Caracteres de formato para texto
Caracter	Descripción
c	El argumento es tratado como un valor de tipo string y recoge un único carácter
d	El argumento es tratado como un valor de tipo int y presentado como un número entero
e	El argumento es tratado con notación científica (por ejemplo 1.2e+2)
E	Como %e pero utiliza la letra mayúscula (por ejemplo 1.2E+2)
f	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (considerando la configuración regional)
F	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (sin considerar la configuración regional)
g	Igual que %e y %f
G	Igual que %E y %f
o	El argumento es tratado como un valor de tipo integer y presentado como un número octal
s	El argumento es tratado como un valor de tipo string y recoge una cadena de caracteres
u	El argumento es tratado como un valor de tipo int y presentado como un número decimal sin signo
x	El argumento es tratado como un valor de tipo integer y presentado como un número hexadecimal
X	El argumento es tratado como un valor de tipo integer y presentado como un número hexadecimal en mayúsculas

n =  int (43951789) #cast para que el valor de n sea entero
u = int(-43951789) #cast para que el valor de u sea entero
c = str("A") #cast para que el valor de c sea una cadena

print("%c" %(c) ) # c para valor ASCII del número, muestra 'A'
print("%d" %(n) ) # d para número entero, muestra '43951789'
print("%+d" %(n) ) # +d para número entero positivo con signo, muestra '+43951789'
print("%+d" %(u) ) # +d para número entero negativo con signo, muestra '-43951789'
print("%e" %(n) ) # e para notación científica del número entero, muestra '4.39518e+7'
print("%E" %(n) ) # E para notación científica del número entero, muestra '4.39518E+7'
print("%f" %(n) ) # f para número decimal (considerando configuración regional), muestra '43951789.000000'
print("%F" %(n) ) # F para número decimal (sin considerar la configuración regional), muestra '43951789.000000'
print("%g" %(n) ) # g igual que e y f
print("%G" %(n) ) # G igual que E y f
print("%o" %(n) ) # o para número octal, muestra '247523255'
print("%s" %(n) ) # s como una cadena, muestra '43951789'
print("%u" %(n) ) # u para número entero positivo, muestra '43951789'
print("%u" %(u) ) # u para número entero negativo, muestra '-43951789'
print("%x" %(u) ) # x para número hexadecimal, muestra '-29ea6ad'
print("%X" %(n) ) # X para número hexadecimal en mayúsculas, muestra '29EA6AD'

Método format

El método format se añadió a los tipos string en Python 2.6

Permite el uso de los caracteres {} para marcar dónde se sustituirá una variable y utiliza directivas de formato detalladas usadas para formatear

Este método nos permite concatenar elementos dentro de una salida a través del formato posicional

Los corchetes y los caracteres dentro de ellos (llamados campos de formato) se reemplazan con los objetos pasados al método format

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {} es {}".format(texto, valor) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

Se puede usar un número entre paréntesis para referirse a la posición del argumento pasado al método format

Hay que tener en cuenta que el primer argumento empieza en cero

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {0} es {1}".format(texto, valor) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

También se puede usar un identificador clave cuando el argumento sea pasado por nombre

Esta opción nos será útil cuando trabajemos con diccionarios o cuando queramos reducir algo el código

dic = dict(texto="raíz cuadrada de dos",  valor=2**0.5)

print("el resultado de {texto} es {valor}".format(**dic) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'
print("el resultado de {texto} es {valor}".format(texto="raíz cuadrada de dos", valor=2**0.5) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

Opcionalmente se puede poner el símbolo : después del número o nombre, y explicitar el tipo del objeto:

Caracteres de formato para texto
Caracter	Descripción
s	El argumento es tratado como un valor de tipo string y recoge una cadena de caracteres
d	El argumento es tratado como un valor de tipo int y presentado como un número decimal (con signo)
f	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (considerando la configuración regional)

import math

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {} es {:4d}".format(texto, math.ceil(valor) ) ) #con 4 espacios de relleno devuelve 'el resultado de raíz cuadrada de dos es    2'
print("el resultado de {} es {:04d}".format(texto, math.ceil(valor) ) ) #con 4 espacios de relleno y poniendo 0 a su izquierda devuelve 'el resultado de raíz cuadrada de dos es 0002'
print("el resultado de {} es {:.4f}".format(texto, valor) ) #con 4 valores decimales devuelve 'el resultado de raíz cuadrada de dos es 1.4142'
print("el resultado de {} es {:7.3f}".format(texto, valor) ) #con 7 espacios y 3 valores decimales devuelve 'el resultado de raíz cuadrada de dos es   1.414'
print("el resultado de {} es {:07.3f}".format(texto, valor) ) #con 7 espacios, 3 valores decimales y poniendo 0 a su izquierda devuelve devuelve 'el resultado de raíz cuadrada de dos es 001.414'

Funciones de orden superior

En matemáticas y ciencias de la computación, las funciones de orden superior son funciones que cumplen al menos una de las siguientes condiciones:

• Tomar una o más funciones como entrada
• Devolver una función como salida

def funcion_doble(f): #la función va a realizar lo que en matemáticas se llama composición
    def resultado(x):
        return f( f(x) ) #la función se llama a si misma, es una función recursiva
    return resultado #devuelve el resultado final de la composición

def cuadrado(x):
    return x * x #calcula el cuadrado de x

g = funcion_doble(cuadrado) #La composición se ejecuta de la función más interior (cuadrado) a la más exterior (funcion_doble)
g(3) #devuelve 81

Funciones lambda

Las funciones lambda son funciones anónimas, es decir, funciones sin nombre

Sólo se utilizan en el lugar en el que se han creado (aunque se les puede asignar un nombre y usarlas más adelante)

Se utilizan por lo general junto a las funciones map, filter y reduce

Por lo general se utilizan para crear funciones que son pasadas como argumentos a otras funciones

En Python la sintaxis de una función lamdba es:

lambda variable1<, variable2, ..., variableN>: expresión

Donde la expresión puede ser cualquier operación que haríamos al realizar una asignación

multiplica = lambda x, y: x * y

print( multiplica(2, 3) ) #devuelve 6

Funcion map

Nos permite aplicar una función sobre cada uno de los elementos de un iterable

Nos devuelve un map object, que podemos transformar fácilmente en una lista

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = map(lambda x: x * x, lista)

print( resultado ) #devuelve <map object at 0x04E889B0>
print( list(resultado) ) #devuelve [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Funcion filter

Nos permite filtrar los elementos de una colección (por ejemplo una lista)

Es una función muy utilizada en el tratamiento de colecciones

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = map(lambda x:x*x, lista)
filtrado = filter(lambda x:x>30, resultado)

print( list(filtrado) ) #devuelve [36, 49, 64, 81, 100]

Función reduce

Toma una función y una colección reduciéndola a un solo valor

Sería equivalente a una función de agregación

Pertenece al módulo functools, por lo que deberá ser importado antes de poder usar reduce

from functools import reduce

La función que pasemos debe tomar al menos dos parámetros y uno opcional

El primero es el parámetro del agregado que se va acumulado en cada iteración sobre los elementos de la colección

El segundo el elemento corresponde al paso de la iteración

El tercero es en caso que se necesite un valor inicial

from functools import reduce

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print( reduce(lambda acumulador, numero: acumulador + numero, lista) ) #devuelve 55

Excepciones en Python

Si una operación no puede completarse debido a un error, el programa deberá:

• volver a un estado estable y permitir otras operaciones

• intentar guardar el trabajo y finalizar

Esta tarea es difícil debido a que generalmente el código que detecta el error no es el que puede realizar dichas tareas por eso debe informar al que pueda manejarlo

La solución más habitual son los códigos de error

Python ofrece otra forma de tratar con los errores en condiciones excepcionales: las excepciones

Una condición excepcional es aquella que impide la continuación de una operación

No se sabe como manejarla, pero no se puede continuar

En Python se lanza una excepción para que alguien que sepa manejarla la trate en un contexto superior

f = open('readme.txt') #el archivo readme.txt no existe en el sistema, lanzará una excepción de tipo FileNotFoundError
texto = f.readlines()
f.close()

En el ejemplo la función open comprueba si el fichero readme.txt existía en el sistema y en caso de no existir se lanza la excepción FileNotFoundError que de momento está sin tratar

Cuando el intérprete detecta el lanzamiento de la excepción finaliza el método actual y lanza un objeto que facilite información sobre el error ocurrido

Normalmente se gestionará cada tipo de error de forma individual

Manejo de la excepciones

Una vez detectado el error hace falta indicar quien se encarga de tratarlo

Un manejador de excepciones tiene el siguiente formato:

try:
    operaciones que pueden generar excepciones
except:
    tratamiento de la excepción
[else:
    operaciones ejecutadas cuando no se ha generado una excepción]
[finally:
    operaciones comunes ejecutadas tanto si se producen excepciones como si no]

Bloque try

El bloque try delimita el grupo de operaciones que puede producir excepciones

Bloque except

El bloque except es el lugar al que se transfiere el control si alguna de las operaciones produce una excepción

try:
    f = open('readme.txt') #el archivo readme.txt no existe en el sistema, lanzará una excepción de tipo FileNotFoundError
    texto = f.readlines()
    f.close()
except:
    print("Error de E/S") #mostrará Error de E/S cuando se produzca la excepción

En el ejemplo se ha usado un bloque try con su bloque except para gestionar los errores del ejemplo anterior

Si alguna de las operaciones del bloque produce una excepción, se interrumpe el bloque try y se ejecuta el except

Al finalizar este, se continua normalmente

Si no se produce ninguna excepción, el bloque except se ignora

Excepciones múltiples

También existe la posibilidad de utilizar un nombre de excepción para tratar errores específicos

Algunos de los cuales ya son reconocidos por el sistema, como la excepción FileNotFoundError, que se lanza cuando un archivo no existe en el sistema

try:
    f = open('readme.txt') #el archivo readme.txt no existe en el sistema, lanzará una excepción de tipo FileNotFoundError
    texto = f.readlines()
    f.close()
except FileNotFoundError as e:
    print("Error de E/S", type(e).__name__ ) #mostrará Error de E/S FileNotFoundError, cuando se produzca la excepción FileNotFoundError
except EOFError as e:
    print("Error de final de fichero", type(e).__name__ ) #mostrará Error de final de fichero EOFError, cuando se produzca la excepción EOFError

En el ejemplo se ha usado un bloque try con varios bloques except para gestionar varias excepciones

Un bloque try puede tener varios except asociados

Le hemos añadimos la sentencia as al bloque except despues de nombrarlo para convertirlo en el objeto de excepción que hemos llamado e

Como puede verse, después de convertirlo en objeto, podemos utilizarlo como si fuera una clase

Cuando una excepción no se corresponde con ningún catch se propaga hacia atrás en la secuencia de invocaciones hasta encontrar un catch adecuado

def f1(accion):
    try:
        if accion == 1:
            raise FileNotFoundError
        elif accion == 2:
            raise EOFError
    except FileNotFoundError as e:
        print("Error de E/S", type(e).__name__ ) #mostrará Error de E/S FileNotFoundError, cuando se produzca la excepción FileNotFoundError
    except EOFError as e:
        print("Error de final de fichero", type(e).__name__ ) #mostrará Error de final de fichero EOFError, cuando se produzca la excepción EOFError
    
def f2(valor):
    try:
        f1(valor)
    except EOFError as e:
        print("Error corregido f2") #mostrará Error corregido f2, cuando se produzca la excepción EOFError
    else:
        print("Finalización normal de f2") #mostrará Finalización normal de f2, cuando no haya habido errores

#simulación de los errores
f2(1)
#muestra
#Error de E/S FileNotFoundError
#Finalización normal de f2
f2(2)
#muestra
#Error de final de fichero EOFError
#Finalización normal de f2

En el ejemplo se gestionan las excepciones de los métodos f1 y f2 y si no encuentran ninguna continua la ejecución del código de forma normal fuera del bloque try

Se ha usado la sentencia raise seguida del nombre del tipo de excepción para propagarla y tratarla en otro lugar

En este caso la hemos tratado dentro de la propia función f1 en sus bloques excepción

Aunque al propagarla podría haberse tratado fuera de la misma en otro lugar del script

También se ha utilizado un bloque else que permite continuar la ejecución del código en caso de que no haya excepciones antes de continuar fuera del bloque try

Bloque else

Permite continuar la ejecución del código en caso de que no haya excepciones antes de continuar fuera del bloque try

El bloque else puede utilizarse para salir de un bucle si al final del mismo se añade la sentencia break

Es opcional y si no se usa, continuará la ejecución del código en el bloque finally y por último fuera del bloque try

while(True):
    try:
        n = float( input("Introduce un número: ") )
        m = 4
        print("{}/{} = {}".format(n, m, n / m) )
    except:
        print("Ha ocurrido un error, introduce bien el número")
    else:
        print("Todo ha funcionado correctamente")
        break  #Importante romper la iteración si todo ha salido bien

Bloque finally

Puede haber ocasiones en que se desea realizar alguna operación tanto si se producen excepciones como si no

Dichas operaciones se pueden situar dentro de un bloque finally

Si no hay ninguna excepción se ejecutará el bloque try, después el bloque else y por último el finally

Al igual que el bloque else, es opcional y si no se usa, continuará la ejecución del código fuera del bloque try

try:
    f = open('readme.txt') #el archivo readme.txt no existe en el sistema, lanzará una excepción de tipo FileNotFoundError
    texto = f.readlines()
except FileNotFoundError as e:
    print("Error de E/S", type(e).__name__ ) #mostrará Error de E/S FileNotFoundError, cuando no encuentre el fichero
except EOFError as e:
    print("Error de final de fichero", type(e).__name__ ) #mostrará Error de final de fichero EOFError, cuando llegue al final del fichero
    finally:
        try:
            f.close() #se cierra el fichero independientemente de si ha habido excepciones o no
        except IOError as e:
            print("Error de E/S", type(e).__name__ ) #mostrará Error de E/S IOError, cuando se produzca no pueda cerrar el fichero

Normas de uso

1. Norma

   • Si una excepción se puede manejar no debe propagarse

   • Es más cómodo usar métodos que no produzcan errores

2. Norma

   • No utilizar las excepciones para evitar una consulta

     • No abusar de ellas

       class Pila:
           def pop():
               raise EmptyStackError

3. Norma

   • Separar el tratamiento de errores de la lógica

     Todo junto
     cad = "ejemplo" for c in cad: try: obj1.mesg1() except NameError as a: Tratamiento de a try: obj2.mesg2() except NameError as b: Tratamiento de b

     Separado
     cad = "ejemplo" try: for c in cad: obj1.mesg1() obj2.mesg2() except NameError as a: Tratamiento de a except NameError as b: Tratamiento de b

4. Norma

   • No ignorar una excepción ya que dejamos el código con errores sin controlar

     try:
        operaciones
     except EmptyStackError:
         pass #Para que calle el interprete