Lenguaje interpretado, multiparadigma y multiplataforma.

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

• Python: Programación Orientada a Objetos
• Python: Web Scraping
• Python: Fechas
• Python: Ficheros
• Python: Mail
• Python: Automatización GUI
• Python: FTP
• Python: Gráficas
• Python: Matemáticas
• Python: Bases de Datos
• Python: Sistema de ficheros
• Python: Depuración

Debian 10 viene con Python 2 y Python 3.

En Arch Linux:

pacman -S python

También se puede optar por soluciones como Anaconda que viene con bibliotecas y editores. Para Windows, existe WinPytyon que también incluye paquetes y editores, pero es portable.

Para saber la versión que tenemos instalada de Python:

python -V

Ejemplo de salida:

Python 3.8.6

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

python script.py

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

#! /usr/bin/env python

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:

chmod +x script.py

Y podremos lanzarlo de la siguiente manera:

./script.py

pip es el instalador oficial de paquetes Python.

En Arch Linux se instala a través del paquete python-pip

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.

Si creamos un fichero con el contenido:

print("Hola, mundo!")

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

python hola-mundo.py

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.

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

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

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

nombre = input("Cómo te llamas? ")
 
print("Hola, " + nombre)

Podemos utilizar placeholders o marcadores de posición:

nombre = input("Cómo te llamas? ")
 
print("Hola, %s" % nombre)

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:

num1 = 10
num2 = 30
sum = num1 + num2
print("La suma de %s + %s es %s", % (num1, num2, sum))

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

# Esto es un comentario
 
# Este comentario tiene
# varias
# líneas
 
print(1 + 1) # Esto también es un comentario

"""
Este texto puede ser considerado
un comentario mientras no esté 
asignado a una variable
"""

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

• 5
• 10
• -23
• 0

• 3.14
• 9.99
• -113.1268

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)

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

• False
• True

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

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

Símbolos que realizan ciertas operaciones sobre los objetos.

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

  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.

  Precedencia, orden en que los operadores son evaluados (prioridad de las operaciones). PEMDAS es un mnemotécnico para recordar el orden de las operaciones: * Paréntesis * Exponentes * Multiplicación * División * Adición (suma) * Sustracció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>

  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.

  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.

  Para ver un listado de las palabras reservadas, podemos utilizar kwlist del módulo keyword: print(keyword.kwlist)

  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>

  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.

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

  Si provocamos un bucle infinito (nunca termina su ejecución), podemos forzar la parada con la combinación de teclas Ctrl + c

  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>

  La función range genera números. Para el ejemplo, genera 5 números, números del 0 al 4

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

  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é

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

  En Python el conteo empieza en 0. Es decir, que el primer caracter de una cadena de caracteres ocupa la posición 0

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

  El elemento con el índice de fin no se incluye en la extracción

  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>

  También se puede usar la comprensión con diccionarios y objetos iterables.

  ==== 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. * 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.

  Se pueden añadir tantos bloques except como excepciones se quieran controlar

  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>

  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.

  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>

  A la combinación de los caracteres #! se le conoce como shebang

  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>

  Si no existe la ruta al directorio que queremos crear, os.makedirs() los creará

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

  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.

  ===== Editores ===== * IDLE * Spyder * Jupyter Notebook, Jupyter Lab. * 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 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>

  http.server es un módulo disponible por defecto en la versión 3 de Python. Para versiones antiguas, existe el módulo SimpleHTTPServer

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

  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.

  ==== 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. ==== Desactivación ==== Para desactivar el entorno, desde dentro del proyecto: <code> deactivate </code> * A Guide to Python’s Virtual Environments ===== Recursos ===== * The Python Package Index (PyPI): repositorio de software para Python * repl.it: escribir código online y ejecutarlo. * glot.io: escribir código online y ejecutarlo. * Automate the Boring Stuff with Python: curso gratuito. * Python Tutor: Visualize code execution: visualiza la ejecución paso a paso de código Python. * Kaggle: conjunto de datos (datasets) abiertos. * Google for Education: Python * Python 101: curso gratuito de Python 3 * Python Principles: curso online de programación en Python * Cool, Fun & Easy Python Projects for Beginners (with Code) * Transforming Code into Beautiful, Idiomatic Python (YouTube)