La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Python ======

Lenguaje interpretado, multiparadigma y multiplataforma.

  * [[https://www.python.org/|Web oficial]]

Al ser un lenguaje interpretado, el elemento que se encarga de ejecutar un programa Python (el intérprete) ejecuta cada sentencia una a una, empezando desde el comienzo del fichero que contiene el código Python.

Páginas relacionadas:

  * [[informatica:programacion:python:poo|Python: Programación Orientada a Objetos]]
  * [[informatica:programacion:python:web_scraping|Python: Web Scraping]]
  * [[informatica:programacion:python:fechas|Python: Fechas]]
  * [[informatica:programacion:python:ficheros|Python: Ficheros]]
  * [[informatica:programacion:python:mail|Python: Mail]]
  * [[informatica:programacion:python:automatizacion_gui|Python: Automatización GUI]]
  * [[informatica:programacion:python:ftp|Python: FTP]]
  * [[informatica:programacion:python:graficas|Python: Gráficas]]
  * [[informatica:programacion:python:matematicas|Python: Matemáticas]]
  * [[informatica:programacion:python:bases_de_datos|Python: Bases de Datos]]
  * [[informatica:programacion:python:sistema_ficheros|Python: Sistema de ficheros]]
  * [[informatica:programacion:python:depuracion|Python: Depuración]]

===== Características =====

  * **Interpretado**: El código Python se ejecuta directamente por el intérprete, sin necesidad de compilarlo previamente. Esto lo hace más rápido de desarrollar y depurar.
  * **Multiparadigma**: Python admite diferentes paradigmas de programación, como la programación imperativa, la programación orientada a objetos y la programación funcional. Esto lo hace versátil y adaptable a diferentes necesidades.
  * **Multiplataforma**: Python se puede ejecutar en una amplia gama de plataformas, incluyendo Windows, macOS, Linux y Android.
  * **Propósito general**: Python se puede utilizar para una amplia gama de aplicaciones, incluyendo desarrollo web, ciencia de datos, inteligencia artificial y machine learning.
  * **Tipado dinámico**: Python es un lenguaje de tipado dinámico, lo que significa que los tipos de datos no se declaran explícitamente.

Python tiene una comunidad activa de desarrolladores que proporcionan soporte y recursos.

===== Instalación =====

==== Linux ====

Debian 10 viene con Python 2 y Python 3.

En Arch Linux:

<code>
pacman -S python
</code>

<WRAP center round info 60%>
El intérprete oficial de Python es **cpython**
</WRAP>

También se puede optar por soluciones como [[https://www.anaconda.com/|Anaconda]] que viene con bibliotecas y editores. Para Windows, existe [[https://winpython.github.io/|WinPytyon]] que también incluye paquetes y editores, pero es portable.

Para saber la versión que tenemos instalada de Python:
<code python>
python -V
</code>

Ejemplo de salida:

<code>
Python 3.8.6
</code>

===== Ejecución =====

Como Python es un lenguaje interpretado, para poder ejecutar los programas que escribamos en este lenguaje, debemos hacerlo a través del intérprete:

<code>
python script.py
</code>

<WRAP center round info 60%>
Los scripts de Python tienen la extensión ''.py''
</WRAP>

==== Linux ====

Si queremos ejecutarlo como un script, tenemos que añadir como primera línea en los scripts:

<code bash>
#! /usr/bin/env python
</code>

Esto indicará al intérprete de comandos dónde debe buscar el intérprete de Python para ejecutar ese script.

Finalmente, le daremos permisos de ejecución:

<code bash>
chmod +x script.py
</code>

Y podremos lanzarlo de la siguiente manera:

<code bash>
./script.py
</code>
===== Gestión de paquetes =====

**pip** es el instalador oficial de paquetes Python.

En Arch Linux se instala a través del paquete ''python-pip''. En Debian con ''python3-pip''.

===== Todo es un objeto =====

En Python todo es un objeto:

  * ''1234''
  * ''3.14159''
  * ''%%"%%Hola%%"%%''
  * ''[1, 2, 3, 4, 5]''
  * ''{%%"%%CA%%"%%: %%"%%California%%"%%, %%"%%MA%%"%%: %%"%%Massachusetts%%"%%}}''

Todos ellos son objetos y cada objeto tiene:

  * Un tipo
  * Una representación de la información (primitiva o compuesta)
  * Un conjunto de funciones (métodos) para interactuar con el objeto.

Un objeto es la "instancia" de un tipo:

  * ''1234'' es una instancia de un ''int''
  * ''%%"%%hola%%"%%'' es una instancia de un ''string''

Incluso las funciones son también objetos en Python.

  * Podemos crear nuevos objetos 
  * Podemos manipular objetos
  * Podemos destruir objetos (podemos hacerlo explícitamente o Python también dispone de un recolector de basura)

Un objeto es una abstracción de la información que captura:

  * La representación interna (a través de los atributos)
  * Una interfaz para interactuar con el objeto (a través de métodos). Define comportamientos, pero oculta la implementación.
===== Hola, mundo =====

Si creamos un fichero con el contenido:
<code python>
print("Hola, mundo!")
</code>

Y lo guardamos como ''hola-mundo.py'', podemos ejecutarlo con 

<code>
python hola-mundo.py
</code>

Python es un lenguaje interpretado así que para ejecutar los programas hechos en este lenguaje es necesario lanzarlos con un intérprete que es el que se encargará de generar un bytecode que finalmente ejecutará la máquina virtual para hacer la traducción final a código máquina.

===== Imprimir por pantalla =====

==== Método format ====

El objeto String contiene el método ''format()'' que es una de las mejores maneras de formatear cadenas de caracteres en Python:

<code python>
nombre = "Pepito"
apellido = "Grillo"

print("Me llamo {a}, {n} {a}".format(a=apellido, n=nombre))

# "Me llamo Grillo, Pepito Grillo"
</code>
===== Saludar =====

Otro ejemplo típico es pedir el nombre y responder con un saludo

<code python>
nombre = input("Cómo te llamas? ")

print("Hola, " + nombre)
</code>

Podemos utilizar //placeholders// o marcadores de posición:

<code python>
nombre = input("Cómo te llamas? ")

print("Hola, %s" % nombre)
</code>

Con ''%s'' indicamos que en ese lugar va a ir el contenido de una variable tipo string. Después le decimos qué variable ocupará ese lugar.

Si queremos imprimir más de una variable:

<code python>
num1 = 10
num2 = 30
sum = num1 + num2
print("La suma de %s + %s es %s", % (num1, num2, sum))
</code>
===== Comentarios =====

Texto que el intérprete de Python ignorará. En Python los comentarios comienzan con ''#''

<code python>
# Esto es un comentario

# Este comentario tiene
# varias
# líneas

print(1 + 1) # Esto también es un comentario
</code>

<WRAP center round important 60%>
Python no tiene una forma de delimitar comentarios multilínea, pero se puede utilizar una cadena de caracteres (string) multilínea:
<code>
"""
Este texto puede ser considerado
un comentario mientras no esté 
asignado a una variable
"""
</code>
</WRAP>

===== Tipos de datos =====

Los tipos de datos son una categoría de valores. Cada valor pertenece a un único tipo de dato.

<WRAP center round info 60%>
En Python todo es un objeto.
</WRAP>


==== Números enteros ====

  * 5
  * 10
  * -23
  * 0

==== Números decimales ====

  * 3.14
  * 9.99
  * -113.1268

==== Cadenas de caracteres ====

Son trozos de texto, una secuencia de caracteres. También conocido como //strings//. Se indican entre comillas simples (''%%'%%''), dobles (''%%"%%'') o triple comillas dobles (''%%"""%%'').

  * ''%%"%%hola%%"%%''
  * ''%%'%%hola%%'%%''
  * '3'
  * ''%%"%%%%"%%'' (string vacío)

'3' (string) es distinto de 3 (número entero)

<WRAP center round important 60%>
Los strings en Python son tipos de datos **inmutables**, no pueden cambiar.
</WRAP>

==== Boolean ====

Valores lógicos, indican si algo es verdadero o falso.

  * ''False''
  * ''True''

<WRAP center round important 60%>
Los tipos de datos boolean deben comenzar con mayúsculas
</WRAP>

==== None ====

Es un tipo de dato especial que se usa para representar nada o la ausencia de un valor. Sería algo parecido a //null// en otros lenguajes.

  * ''None''

===== Casting (conversiones) =====

//Cast//, en el mundo de la programación, se podría traducir como convertir o modelar, es decir, partir de una cosa y obtener otra diferente. En Python contamos con varias funciones para convertir ciertos tipos de datos en otros:

  * ''int()'': crea un número entero a partir de un literal entero, decimal o un string que representa un número.
  * ''float()'': crea un número decimal (en coma flotante) a partir de un literal entero, decimal o string que representa un número
  * ''str()'': crea un string desde una variedad de tipos de datos (cadenas, enteros, decimales...)
===== Operadores =====

Símbolos que realizan ciertas operaciones sobre los objetos.

==== Ariméticos ====

  * ''+'': suma
  * ''-'': resta
  * ''*'': multiplicación
  * ''/'': división
  * ''%%**%%'': potencia
  * ''%%//%%'': división entera. Descarta la parte decimal.
  * ''%'': módulo. Resto de la división.

<WRAP center round info 60%>
Siempre que hagamos una división, obtendremos un número decimal, aunque la división sea exacta. Tendríamos que hacer una conversión del tipo de dato para que fuese entero.
</WRAP>


Precedencia, orden en que los operadores son evaluados (prioridad de las operaciones).

PEMDAS es un mnemotécnico para recordar el orden de las operaciones:

  * **P**aréntesis
  * **E**xponentes
  * **M**ultiplicación
  * **D**ivisión
  * **A**dición (suma)
  * **S**ustracción (resta)
==== Concatenación ====

Unión de cadenas de caracteres. Se utiliza el signo más (''+''):

<code python>
"hola" + " mundo"

# Resultado:
# "hola mundo"
</code>

Si queremos repetir una cadena cierto número de veces, utilizamos el asterisco (''*'') para indicar las veces que queremos repetir la cadena:

<code python>
"hola" * 5

# Resultado:
# "holaholaholaholahola"
</code>

==== Lógicos y comparación ====

  * ''=='': igualdad
  * ''>'': mayor que
  * ''<'': menor que
  * ''>='': mayor o igual que
  * ''%%<=%%'': menor o igual que
  * ''!='': distinto
  * ''and''
  * ''or''
  * ''not''

Tabla de verdad del operador ''and'':

^    Expresión    ^ Se evalúa a ^
| True and True   |   True      |
| True and False  |   False     |
| False and True  |   False     |
| False and False |   False     |

Tabla de verdad del operador ''or'':

^    Expresión    ^ Se evalúa a ^
| True and True   |   True      |
| True and False  |   True      |
| False and True  |   True      |
| False and False |   False     |


Tabla de verdad del operador ''not'':

^    Expresión  ^ Se evalúa a ^
| not True      |   False     |
| not False     |   True      |

===== Variables =====

Nombre que le damos a un objeto en Python.

==== Asignación ====

Para crear una variable utilizamos el símbol ''='' como operador de asignación:

<code python>
nombre = "Pepito"
</code>

<WRAP center round info 60%>
Como en Python todo es un objeto, al crear una variable, estamos haciendo una referencia a un objeto y al asignarle un valor, indicamos el valor que contiene dicho objeto. ''a = %%"%%hola%%"%%'' y ''b = %%"%%hola%%"%%'' son dos referencias al mismo objeto.
</WRAP>

Reglas de nomenclatura:

  * Deben empezar con una letra o guión bajo (''_'')
  * Pueden contener letras, números y guiones bajos
  * No se pueden utilizar caracteres especiales o palabras reservadas.

<WRAP center round tip 60%>
Para ver un listado de las palabras reservadas, podemos utilizar ''kwlist'' del módulo ''keyword'': 
''print(keyword.kwlist)''
</WRAP>

Python también permite hacer asignaciones múltiples a la vez:

<code python>
a, b, c = 10, 20, 30
</code>
===== Control de flujo =====

Modifican el flujo de ejecución del programa, deciden qué instrucciones se ejecutarán bajo ciertas circunstancias.
==== Condicionales ====

<code python>
if (condicion):
    codigo
else:
    codigo
</code>

<WRAP center round important 60%>
Es muy importante respetar la sangría para indicar que estamos dentro de una estructura de control o función y saber a qué corresponde cada bloque de código.
</WRAP>

<code python>
if (condicion):
    codigo
elif (condicion):
    codigo
elif (condicion):
    codigo
</code>

==== Bucles ====

Repiten un mismo código mientras se cumple una condición.

=== While ===

<code python>
while (condicion):
    codigo
</code>

Si queremos forzar la salida de un bucle, incluimos la palabra reservada ''break'':

<code python>
while (condicion):
    codigo
    break
</code>

<WRAP center round tip 60%>
Si provocamos un bucle infinito (nunca termina su ejecución), podemos forzar la parada con la combinación de teclas ''Ctrl'' + ''c''
</WRAP>


Si queremos forzar a que salte a la siguiente repetición del código, usaremos la palabra reservada ''continue'':

<code python>
while (condicion):
    codigo
    continue
</code>

=== For ===

La diferencia con las sentencias while es que en los bucles for especificamos el número de veces que se repetirá el código.

<code python>
for i in range(5):
    print("Hola")
</code>

<WRAP center round info 60%>
La función ''range'' genera números. Para el ejemplo, genera 5 números, números del 0 al 4
</WRAP>

===== Funciones del sistema =====

Las funciones son bloques de código, una secuencia de instrucciones que permiten obtener un resultado consistente.

Python incluye ciertas funciones para facilitar ciertas operaciones o cálculos.

==== len ====

Cuenta los caracteres que tiene una cadena, lista, mapa o tupla.

<code python>
len("Hola, caracola")

# Resultado:
# 14
</code>

==== str ====

Convierte un número en un string:

<code python>
str(3.14)

# Resultado:
# '3.14'
</code>

==== int ====

Convierte un valor a número entero.

==== float ====

Convierte un valor a número decimal.

==== type ====

Indica el tipo de dato de cierto valor o variable

<code python>
type(5)

# Resultado:
# int
</code>

==== dir ====

Devuelve todos los atributos y métodos disponibles en un objeto.

<code python>
saludo = "hola"

dir(saludo)

# Resultado:

# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
</code>

==== help ====

Devuelve una descripción de lo que realiza una función de Python.

<code python>
help(max)

# Help on built-in function max in module builtins:

# max(...)
#     max(iterable, *[, default=obj, key=func]) -> value
#     max(arg1, arg2, *args, *[, key=func]) -> value  

#     With a single iterable argument, return its biggest item. The
#     default keyword-only argument specifies an object to return if
#     the provided iterable is empty.
#     With two or more arguments, return the largest argument.
</code>

==== eval ====

Evalúa 

<code python>
eval ("print('hola')")

# hola
</code>

Es útil cuando queramos que se ejecute algún comando introducido directamente por el usuario y ver su resultado.
==== sorted ====

Devuelve resultados ordenados

<code python>
sorted(["Pepito", "Manolito", "Alejandro"])

# Resultado
# ['Alejandro', 'Manolito', 'Pepito']
</code>

==== max ====

Devuelve el valor máximo

==== min ====

Devuelve el valor mínimo

==== sum ====

Devuelve la suma de unos valores.
==== list ====

Convierte en una lista.

==== dict ====

Convierte en un diccionario.
===== Funciones personalizadas =====

Funciones que crea el usuario.

<code python>
def nombre_funcion(arg1, arg2):
    codigo
    codigo
    codigo
    return valor
</code>

Los argumentos son los valores de entrada que espera la función.

<WRAP center round important 60%>
En Python, al no usar llaves para indicar bloques de código, es importante respetar la sangría del texto para indicar qué está contenido dentro de qué
</WRAP>

Ejemplo de función:

<code python>
def convertir_a_fahrenheit(celsius):
    producto = celsius * 1.8
    return producto + 32
</code>

Y la usaríamos:

<code python>
convertir_a_fahrenheit(0)

# Resultado:
# 32.0
</code>

===== Módulos =====

Si tenemos un script de Python con funciones que nos interesen usar desde otros scripts, podemos importarlo como un módulo de Python:

<code python>
import os

os.chdir("/directorio/scripts")

# Importamos el script por el nombre del fichero (sin la extensión)
import nombre-script

# Usamos las funciones del script
nombre-script.funcion()
</code>

Importante, para que no se ejecuten las funciones del script que vamos a importar, en el script a importar todo lo que no queremos que se ejecute debe ir dentro de: 

<code python>
if __main__ == "__main__":
</code>

Si solo queremos importar un método de un módulo:

<code python>
from math import sqrt

print(sqrt(9))
</code>

Si hubiésemos importado todo el módulo:

<code python>
import math

print(math.sqrt(9))
</code>
===== Métodos de cadenas =====

Los métodos son funciones sobre los objetos. En Python vienen definidos varios para las cadenas de caracteres:

<code python>
trabajo = "Desarrollador"

trabajo.upper()

# Resultado:
# "DESARROLLADOR"

trabajo.lower()

# Resultado:
# "desarrollador"

trabajo.swapcase()

# Resultado:
# "dESARROLLADOR"

# Recordamos que los strings en Python son inmutables
# así que si vemos qué contiene 'trabajo':

# "Desarrollador"

titulo = "los goonies"

titulo.title()

# Resultado
# 'Los Goonies'

texto = "         Esto tiene espacios        "
texto.strip

# Resultado
# 'Esto tiene espacios'

trabajo.replace("e", 3)

# Resultado
# 'D3sarrollador'
</code>

Más métodos de strings:

  * ''startswith'': indica si una cadena empieza por cierto(s) caracter(es).
  * ''endswith'': indica si una cadena termina por cierto(s) caracter(es).

Otra forma de comprobar si algo está contenido en una cadena, podemos usar el operador ''in'':

<code python>
"cara" in "hola, caracola"

# Resultado:
# True
</code>

===== Métodos numéricos =====

Número entero aleatorio entre un rango (incluye los límites):

<code python>
import random

print(random.randint(1, 100))
</code>
===== Estructuras de datos =====

==== Listas ====

Estructura que contiene una colección ordenada de elementos de cualquier tipo. Es mutable, puede modificarse.

<code python>
[1, 2, 3, 4, 5]

# Asignación

amigos = ['Fulanito', 'Menganito']
</code>

Podemos usar la función ''len'' para saber cuántos elementos tiene la lista.

Añadir elementos:

<code python>
amigos.append("Zutanito")
</code>

Eliminar el último elemento:

<code python>
amigos.pop()

# Resultado
# 'Zutanito'
</code>

Si queremos elegir cierto elemento a eliminar:

<code python>
amigos.remove("Fulanito")
</code>

Para buscar elementos en una lista, se puede utilizar el operador ''in'':

<code python>
amigos = ['Fulanito', 'Menganito', 'Zutanito']

"Pepito" in amigos

# Resultado:
# False
</code>
==== Diccionarios ====

Colección **desordenada** de pares clave-valor. Como una carta de un restaurante donde hay una asociación entre el plato y el valor del mismo.

<code python>
menu = {
    "Filet Mignon": 29.99,
    "Pizza": 7.99,
    "Hamburguesa": 3.99
}
</code>

Para acceder a cierto elemento, usamos su índice que en este caso será la **clave**:

<code python>
menu['Pizza']

# Resultado:
# 7.99
</code>

Podemos añadir más pares a un diccionario ya existente:

<code python>
menu["Burrito"] = 5.99
</code>

O modificar un par existente:

<code python>
menu["Pizza"] = 10.99
</code>

Si queremos eliminar:

<code python>
menu.pop("Filet Mignon")
</code>

Para saber si existe un elemento, utilizamos el operador ''in'':

<code python>
"Burrito" in menu

# Resultado: 
# True
</code>

Si queremos hacer la búsqueda por los valores y no por las claves:

<code python>
5.99 in menu.values()

# Resultado: 
# True
</code>

==== Tuplas ====

==== Conjuntos ====
===== Índices y cortes (slicing) =====

<WRAP center round important 60%>
En Python el conteo empieza en 0. Es decir, que el primer caracter de una cadena de caracteres ocupa la posición 0
</WRAP>


<code python>
heroe = "Spiderman"

heroe[1]

# Resultado
# 'p'

# Último caracter:
heroe[-1]

# Resultado
# 'n'
</code>

También funciona con las listas:

<code python>
heroes = ["Batman", "Spiderman", "Superman", "Daredevil", "Ironman"]

heroes[1]

# Resultado:
# 'Spiderman'
</code>

Para poder extraer más elementos de una cadena o una lista:

El primer número indica el índice desde donde queremos hacer la extracción y el segundo representa el índice donde terminaremos la extracción:

<code python>
heroes[1:3]

# Resultado
# ['Spiderman', 'Superman']
</code>

<WRAP center round important 60%>
El elemento con el índice de fin no se incluye en la extracción
</WRAP>

Cuando la extracción la queremos hacer desde el primer elemento, no tenemos por qué poner ''[0:10]''. El índice de inicio se puede omitir: ''[:10]''

Lo mismo sucede con el índice final cuando queremos llegar hasta el final: ''[2:]''
===== Entrada por teclado =====

Si queremos que el programa obtenga algo del usuario mediante el teclado, usaremos la función ''input()'':

<code python>
print("Cómo te llamas?")

# El programa se quedará a la espera de que el usuario introduzca
# algún valor por teclado y pulse Enter
nombre = input()

print("Encantado de conocerte, " + nombre)
</code>

===== Iterables =====

Los iterables son objetos sobre los que podemos iterar, es decir, recorrer.

==== Secuencias ====

Son iterables con acceso aleatorio, como las tuplas y las listas.

<code python>
colores = ['rojo', 'verde', 'azul']

for item in colores:
    print(item)
</code>

==== Asociaciones (mappings) ====

Diccionarios

==== Generadores ====

Los generadores son una forma útil de construir iteradores. A tener en cuenta:

  * Los valores se generan a demanda
  * Los valores no están en memoria
  * Solo se puede iterar una vez
  * No hay acceso aleatorio

<code python>
def mi_range(n):
    num = 0
    while num < n:
        yield num
        num += 1
        
x = mi_range(5)
</code>

En este punto ''x'' es ''<generator object mi_range at 0x11196a780>''

Para recorrerlo:

<code python>
for item in x:
    print(item)

</code>

Una vez recorrido, el iterable no puede ser recorrido de nuevo
===== List comprehensions =====

Una //comprehension// es un tipo de construcción que permite crear secuencias a partir de otras secuencias. Normalmente nos referiremos a las listas.

<code python>
cuadrados = [] 

for x in range(100):
    cuadrados.append(x*x)
</code>

Utilizando la comprensión de listas, podríamos hacerlo de la siguiente manera:

<code python>
cuadrados = [x*x for x in range(100)]
</code>

<WRAP center round info 60%>
También se puede usar la //comprensión// con diccionarios y objetos iterables.
</WRAP>

==== map, reduce y filter ====

Es una forma de lidiar con secuencias utilizando la programación funcional.

Ejemplo con ''map'':

<code python>
def f(x):
    return x*x

numeros = range(10)

# cuadrados = (f(x) for x in numbers)    
cuadrados = map(f, numeros)
</code>

Ejemplo con ''reduce'':

<code python>
add_them(a, b):
    return a + b
    
from functools import reduce

seq = [1, 2, 3, 4]

results = reduce(add_them, seq)

# 10
</code>

Función ''filter'':

<code python>
def es_par(x):
    return x % 2 == 0
    
seq = range(10)

numeros_pares = filter(es_par, seq)

# resultado: [0, 2, 4, 6, 8]
</code>
===== Manejo de errores =====


==== Excepciones ====

Las excepciones son errores.

  * [[https://docs.python.org/3/library/exceptions.html|Built-in Exceptions]]

Sentencias ''try'' y ''except''.

Cualquier error que suceda dentro de un bloque ''try'', hará que se ejecute el código que se indique en el bloque ''except''. Este código manejará el error o mostrará un mensaje al usuario y el programa podrá seguir en ejecución o finalizar correctamente.

<code python>
print("Vamos a dividir")
print("Dame un dividendo:")
dividendo = int(input())
print("Dame un divisor:")
divisor = int(input())

try:
    resultado = dividendo / divisor
    print("Resultado: " + resultado)
except ZeroDivisionError:
    print("Error: no se puede dividir entre 0")
</code>

En la línea del ''except'' indicamos el error que debe capturar el programa para indicar qué hacer. Si no ponemos nada, solo ''except'', se ejecutará esa línea con cualquier error que produzca el programa.

<WRAP center round tip 60%>
Se pueden añadir tantos bloques ''except'' como excepciones se quieran controlar
</WRAP>


También podemos utilizarlo para la validación de datos:

<code python>
print("Cuántos años tienes?")

edad = input()

try:
    if int(edad) >= 18:
        print("Eres mayor de edad")
    else:
        print("Eres menor")
except ValueError:
    print("No has introducido un número")
</code>

Para generar excepciones utilizamos la palabra reservada ''raise'':

<code python>
raise Exception("Este es un mensaje de error")
</code>

Existe también la estructura con ''else'' y/o ''finally'':

<code python>
def manejoExcepciones():
    try:
        a = 10
        b = 20
        c = 0
        
        d = (a + b) / c
        
        print(d)
    except:
        print("Estoy en el bloque de las excepciones")
    else:
        print("Como no ha habido excepciones, me imprimo yo")
    finally:
        print("Yo me imprimo siempre")
</code>
==== Registro (logging) ====

<code python>
import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

logging.debug("Inicio")

def factorial(n):
    logging.debug("Calculando factorial(%s)" % (n))
    
    total = 1
    for i in range(1, n + 1):
        total *= i
        
        logging.debug("Valor devuelto: %s" % (total))
    return total

print(factorial(5))

logging.debug("Fin")
</code>

Ejemplo de salida:

<code>
2020-11-05 13:18:59,752 - DEBUG - Inicio
2020-11-05 13:18:59,755 - DEBUG - Calculando factorial(5)
2020-11-05 13:18:59,757 - DEBUG - Valor devuelto: 1
2020-11-05 13:18:59,759 - DEBUG - Valor devuelto: 2
2020-11-05 13:18:59,761 - DEBUG - Valor devuelto: 6
2020-11-05 13:18:59,762 - DEBUG - Valor devuelto: 24
2020-11-05 13:18:59,764 - DEBUG - Valor devuelto: 120
2020-11-05 13:18:59,765 - DEBUG - Fin

120
</code>

<WRAP center round tip 60%>
Es recomendable no usar ''print()'' para la depuración de un programa ya que cuando hayamos terminado, es mucho más tedioso eliminar esos mensajes.
</WRAP>


Si queremos eliminar los mensajes de log, añadimos la siguiente línea al principio:

<code python>
import logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

logging.disable(logging.CRITICAL)
</code>

Los niveles de log:

  * debug (el más bajo)
  * info
  * warning
  * error
  * critical (el más alto)

Se usarían en Python de la siguiente manera:

  * ''logging.DEBUG''
  * ''logging.INFO''
  * ''logging.WARNING''
  * ''logging.ERROR''
  * ''logging.CRITICAL''

Si queremos que los logs vayan a un fichero, añadimos el argumento ''filename'':

<code python>
import logging

logging.basicConfig(filename="programa-log", level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

</code>


===== Ejecución en línea de comandos =====

Hay dos maneras de ejecutar los scripts de Python desde la línea de comandos:

Ejecutando el intérprete de Python sobre el script en cuestión:
<code bash>
python programa.py
</code>

Ejecutando el script de Python directamente:

<code bash>
./programa.py
</code>

Para este último método, el programa Python debe tener una primera línea que indique la ruta del intérprete. Por ejemplo, en Linux:

<code pytho>
#! /usr/bin/env python 
</code>

<WRAP center round info 60%>
A la combinación de los caracteres ''#!'' se le conoce como //shebang//
</WRAP>


Además, el script debe ser marcado como ejecutable:

<code bash>
chmod +x programa.py
</code>

==== Argumentos ====

Para capturar las opciones/argumentos que le pasamos al script que lanzamos desde línea de comandos:

<code python>
import sys

# Lista de opciones que pasamos por pantalla
# El primer elemento es el nombre del script
sys.argv 

</code>

===== Ficheros =====

==== Rutas ====

Las rutas en Windows tienen una barra invertida (''\''). Esto confunde al intérprete porque es el caracter que se usa en Python para las secuencias de escape. Si vamos a usar rutas de Windows, tenemos dos opciones:

  * Escapar la barra invertida: ''%%'%%C:\Windows\%%'%%'' sería ''%%'%%C:\\Windows\\%%'%%''
  * Indicar que la cadena debe ser tratada tal cual: ''%%'%%C:\Windows\%%'%%'' sería ''r'C:\windows\%%'%%''

Podemos utilizar el módulo ''os'' para lidiar con las rutas:

<code python>
import os

os.path.join('ruta', 'al', 'fichero.ext')

# Resultado en Windows:
# 'ruta\\al\\fichero.ext'

# Resultado en Linux:
# 'ruta/al/fichero.ext'
</code>

Para ver el separador que se está usando:

<code python>
os.sep

# Resultado en Windows:
# '\\'

# Resultado en Linux:
# '/'
</code>

Para obtener la ruta absoluta al directorio actual (en el que se ejecuta el script):

<code python>
os.getcwd()
</code>

Para cambiar de ruta:

<code python>
os.chdir("/")

os.getcwd()
# Resultado:
# '/'
</code>

Para obtener la ruta absoluta a cierto fichero:

<code python>
fichero = "foto.jpg"

os.path.abspath("foto.jpg")

# Resultado
# '/home/usuario/foto.jpg'
</code>

Obtener el directorio de un fichero:

<code python>
os.path.dirname("/home/usuario/foto.jpg")

# Resultado:
# '/home/usuario'
</code>

Obtener el nombre del fichero a partir de su ruta absoluta:

<code python>
os.path.basename("/home/usuario/foto.jpg")

# Resultado
# 'foto.jpg'
</code>

Comprobar si una ruta existe:

<code python>
os.path.exists("/home/usuario/foto.jpg")

# Resultado
# True si existe
# False si no existe
</code>

Si queremos comprobar si una ruta es un fichero o un directorio:

<code python>
os.path.isfile("/home/usuario/foto.jpg")

# Resultado
# True

os.path.isdir("/home/usuario/foto.jpg")
# Resultado
# False
</code>

==== Tamaño ====

Si queremos saber el tamaño de un fichero:

<code python>
os.path.getsize("/home/usuario/foto.jpg")

# Resultado (en bytes)
918522
</code>

==== Listar ====

Para conocer los ficheros que hay en cierta ruta:

<code python>
os.listdir("/ruta/")

# Resultado
# Lista con el nombre de los ficheros y directorios que contiene '/ruta'
</code>

==== Creación directorios ====

<code python>
os.makedirs("/ruta/dir1")
</code>

<WRAP center round tip 60%>
Si no existe la ruta al directorio que queremos crear, ''os.makedirs()'' los creará
</WRAP>

==== Lectura ====

Para leer el contenido de un fichero de texto:

<code python>
f = open("/ruta/al/fichero.txt")

# Para mostrar su contenido:
f.read()

# Cerramos:
f.close()
</code>

Si queremos leer un fichero línea a línea:

<code python>
f = open("/ruta/al/fichero.txt")

# Lee el fichero y crea una lista con sus líneas
f.read()

# Cerramos:
f.close()
</code>

==== Escritura ====

Para poder escribir en un fichero, tenemos que abrir indicando la manera en que vamos a escribir en él:

<code python>
f = open("/ruta/al/fichero.txt", "w")
f.write("Hola")
f.close()

f2 = open("/ruta/al/fichero2.txt", "a")
f2.write("Hola")
f2.close()
</code>

  * ''w'': abre el fichero para ser sobrescrito (se perderá el contenido que hubiese)
  * ''a'': abre el fichero para añadir contenido a continuación de lo que ya hubiese

==== Copiar ====

<code python>
import shutil 

shutil.copy("/ruta/fichero.txt", "/ruta/destino/fichero.txt")
</code>

Si queremos copiar directorios:

<code python>
shutil.copytree("/ruta/directorio/", "/ruta/directorio_copia")
</code>

==== Mover ====

Para mover o renombrar ficheros:

<code python>
import shutil 

shutil.move("/ruta/fichero.txt", "/ruta/destino/fichero.txt")
</code>

==== Eliminar ====

Para borrar un fichero:

<code python>
os.unlink("/ruta/fichero.txt")
</code>

Si queremos borrar un directorio (si está vacío):

<code python>
os.rmdir("/ruta/directorio")
</code>

Si queremos eliminar el directorio y todo lo que contiene:

<code python>
import shutil

shutil.rmtree("/ruta/directorio/")
</code>

<WRAP center round important 60%>
Ninguna de estas funciones envía los ficheros eliminados a la papelera. Hay un módulo llamado ''send2trash'' que contiene funciones para enviar a la papelera lo que se borre.
</WRAP>

===== Editores =====

  * IDLE
  * [[https://www.spyder-ide.org/|Spyder]]
  * [[https://jupyter.org/|Jupyter Notebook]], Jupyter Lab.
  * [[https://www.jetbrains.com/es-es/pycharm/|PyCharm]]

===== Curiosidades =====

El nombre de Python viene del gusto del autor por la serie británica Flying Circus, de los Monty Python.

Si ejecutamos ''import this'' en el intérprete de Python veremos el poema //The Zen of Python//:

<code>
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
</code>

Python se lanzó en 1991. Es más viejo que Java (1995).

No usa corchetes para delimitar bloques de código. Si hacemos ''from %%__%%future%%__%% import braces'' veremos un curioso "error":

<code>
 File "<stdin>", line 1
SyntaxError: not a chance
</code>

Usa el [[https://docs.python.org/3.8/faq/design.html#why-does-python-use-indentation-for-grouping-of-statements|sangrado]] (//identation//, en inglés) para delimitar bloques de código.

Las funciones pueden devolver más de un valor.

Los bucles ''for'' y ''while'' pueden contener cláusulas ''else''

No existe la construcción ''switch'' o ''case''. Hay que encadenar ''if'', ''elif'', ''else''.

Permite encadenar comparaciones: ''1 < 2 < 3''

Permite añadir comas finales en listas y tuplas:

<code python>
a = [0, 1, 2, 3,]

b = ("hola", "adios",]
</code>

Permite asignación múltiple:

<code python>
a, b, c = 10, 1, "hola"
</code>

Es muy fácil dar la vuelta a las lista: 

<code python>
reves = nums[::-1]
</code>
===== Utilidades =====

==== Servidor web ====

<code python>
python -m http.server
</code>

Se lanzará un servidor web sencillo en el puerto 8000. Podemos modificar el puerto pasándolo como argumento:

<code python>
python -m http.server 8080
</code>

El servidor web servirá los ficheros que estén en el directorio donde se haya lanzado el servidor. Si queremos indicar otro directorio, podemos hacerlo con la opción ''-d'' (o ''%%--%%directory''):

<code python>
python -m http.server -d /home/tempwin/videos
</code>


<WRAP center round info 60%>
[[https://docs.python.org/3/library/http.server.html|http.server]] es un módulo disponible por defecto en la versión 3 de Python. Para versiones antiguas, existe el módulo ''SimpleHTTPServer''
</WRAP>

===== Entornos virtuales =====

El entorno virtual es un sandbox, una caja que queda aislada del resto del sistema. Sirve para pruebas y luego poder destruir todo sin dejar rastro ni afectar al sistema.

<WRAP center round important 60%>
Las explicaciones aquí recogidas están centradas en la instalación de Python para Linux. En Windows los comandos para activar y desactivar el entorno virtual son diferentes.
</WRAP>

==== Instalación ====

Para comenzar con los entornos virtuales hay que instalar el módulo ''virtualenv'':

<code>
pip install virtualenv
</code>

==== Creación ====

Creamos el entorno virtual:

<code>
python -m venv /code/python/venv
</code>

==== Activación ====

En el directorio ''/code/python/venv'', activamos el entorno:

<code>
source /code/python/venv/bin/activate
</code>

Veremos el prompt que se añade ''(venv)''.

Para ver los módulos instalados:

<code>
pip list
</code>

Si ejecutamos esa misma instrucción dentro del entorno virtual recién creado, la lista será mucho menor.

<WRAP center round info 60%>
En sistemas Windows, para activar el entorno virtual hay que ejecutar ''venv\Scripts\activate''. Se trata de un script en PowerShell y es posible que debamos cambiar la política de ejecución si nos da error. 
</WRAP>

==== Desactivación ====

Para desactivar el entorno, desde dentro del proyecto:

<code>
deactivate
</code>

  * [[https://towardsdatascience.com/virtual-environments-104c62d48c54|A Guide to Python’s Virtual Environments]]

<WRAP center round info 60%>
En sistemas Windows, para activar el entorno virtual hay que ejecutar venv\Scripts\activate. Se trata de un script en PowerShell y es posible que debamos cambiar la política de ejecución si nos da error. 
</WRAP>

===== Fichero de requisitos =====

==== Creación ====

Aunque no es más que un fichero de texto que podríamos rellenar manualmente, podemos hacerlo de forma automáticamente mediante:

<code>
pip freeze > requirements.txt
</code>

Dicho comando muestra una lista de todos los módulos Python instalados con sus versiones.

==== Instalar requisitos ====

<code>
pip install -r requirements.txt
</code>

===== Recursos =====

  * [[https://pypi.org/|The Python Package Index (PyPI)]]: repositorio de software para Python
  * [[https://repl.it/|repl.it]]: escribir código online y ejecutarlo.
  * [[https://glot.io/|glot.io]]: escribir código online y ejecutarlo.
  * [[http://automatetheboringstuff.com/|Automate the Boring Stuff with Python]]: curso gratuito.
  * [[http://pythontutor.com/|Python Tutor: Visualize code execution]]: visualiza la ejecución paso a paso de código Python.
  * [[https://www.kaggle.com/datasets|Kaggle]]: conjunto de datos (datasets) abiertos.
  * [[https://developers.google.com/edu/python|Google for Education: Python]]
  * [[https://python101.pythonlibrary.org/|Python 101]]: curso gratuito de Python 3
  * [[https://pythonprinciples.com/|Python Principles]]: curso online de programación en Python
  * [[https://hackr.io/blog/python-projects|Cool, Fun & Easy Python Projects for Beginners (with Code)]]
  * [[https://www.youtube.com/watch?v=OSGv2VnC0go|Transforming Code into Beautiful, Idiomatic Python]] (YouTube)
  * [[https://www.youtube.com/watch?v=PtBHnMMRI0E|Python en 8 Minutos]] (YouTube)