Programación en Python para Principiantes: Una Guía Integral

Introducción a Python

Python, creado por Guido van Rossum y lanzado en 1991, es un lenguaje de programación destacado por su sintaxis clara y legible. Su diseño promueve un código fácil de leer y escribir, lo que lo ha llevado a ser uno de los lenguajes más populares y versátiles en el mundo del desarrollo de software.

Ventajas de Usar Python

• Sintaxis Simple: Hace que el aprendizaje y la lectura del código sean más accesibles.
• Multiparadigma: Soporta programación orientada a objetos, imperativa y funcional.
• Biblioteca Estándar Amplia: Ofrece herramientas útiles para diversas tareas.
• Interpretado: Facilita la depuración al ejecutar código línea por línea.
• Portabilidad: Funciona en diversas plataformas sin modificaciones.

Aplicaciones Comunes

• Desarrollo Web: Utilizando frameworks como Django y Flask.
• Ciencia de Datos: A través de bibliotecas como Pandas y NumPy.
• Machine Learning: Con herramientas como TensorFlow y Scikit-learn.

Instalación y Configuración de Python

La instalación varía según el sistema operativo, pero es crucial asegurarse de que Python esté en el PATH para facilitar la ejecución de scripts. El uso de entornos virtuales se recomienda para gestionar dependencias.

Paso 1: Descarga e instalación de Python

• En Windows:
  1. Abre tu terminal (puedes buscar “cmd” en el menú Inicio).
  2. Ejecuta el siguiente comando para instalar Python usando `winget`:

winget install -e --id Python.Python.3.9

3. Sigue las instrucciones del instalador. Asegura que puedes lanzar el comando `python` desde tu cmd.

• En GNU/Linux:
  1. Abre tu terminal.
  2. Ejecuta el siguiente comando para instalar Python usando `apt-get`:

sudo apt-get update -y
sudo apt-get install -y python3

Paso 2: Asegurar si Python está en el PATH

Desde nuestro terminal lanzamos el siguiente comando para comprobar si tenemos python.

— En Windows:

python --version

— En GNU/Linux:

python3 --version

Paso 2.5: Agregar Python al PATH

> [!NOTE]
> Si olvidaste marcar la opción “Agregar Python 3.x al PATH” durante la instalación en Windows, puedes hacerlo manualmente siguiendo estos pasos:

> 1. Encuentra la ubicación de instalación de Python, generalmente en `C:\Users\TuUsuario\AppData\Local\Programs\Python\Python3x`.
> 2. Copia esta dirección.
> 3. Haz clic derecho en “Este PC” o “Mi PC” en el escritorio o en el explorador de archivos y selecciona “Propiedades”.
> 4. Haz clic en “Configuración avanzada del sistema”.
> 5. En la pestaña “Opciones avanzadas”, haz clic en “Variables de entorno”.
> 6. En la sección “Variables del sistema”, selecciona la variable `Path` y haz clic en “Editar”.
> 7. Haz clic en “Nuevo” y pega la dirección de la instalación de Python.

> Luego de estos pasos, deberías poder ejecutar scripts de Python desde cualquier ubicación en tu terminal.

Primeros pasos con Python

Tu Primer Programa ‘Hola, Mundo!’

1. Abre tu editor de texto preferido.
2. Crea un nuevo archivo hola_mundo.py.
3. Escribe el siguiente código:

print("Hola, Mundo!")

Ejecutar el Script

Abre tu terminal, navega al directorio donde guardaste tu archivo y ejecuta el script con:

• En Windows: python hola_mundo.py
• En GNU/Linux: python3 hola_mundo.py

¡Felicidades! Acabas de ejecutar tu primer programa en Python.

Fundamentos de Programación en Python

Sintaxis básica y Tipos de datos

Python simplifica la declaración y manipulación de variables. El tipado estático opcional mejora la claridad del código.

from typing import List, Set, Dict, Tuple, Optional

x: int = 5
nombre: str = "Juan"

radio = 5
area = 3.14159 * radio ** 2
print("El área del círculo es:", area)

Operadores

Python soporta operadores aritméticos, de comparación y lógicos, con la posibilidad de aplicar tipado estático para asegurar operaciones correctas entre tipos de datos específicos.

Operadores Aritméticos

a: int = 5
b: int = 2


# Suma
suma: int = a + b
# Resta
resta: int = a - b
# Multiplicación
multiplicacion: int = a * b
# División
division: float = a / b
# Módulo
modulo: int = a % b
# Exponente
exponente: int = a ** b
# División entera
division_entera: int = a // b

Operadores de Comparación

# Igualdad
igual: bool = a == b
# Desigualdad
diferente: bool = a != b
# Mayor que
mayor_que: bool = a > b
# Menor que
menor_que: bool = a < b
# Mayor o igual que
mayor_igual_que: bool = a >= b
# Menor o igual que
menor_igual_que: bool = a <= b

Operadores Lógicos

x: bool = True
y: bool = False


# AND lógico
and_logico: bool = x and y
# OR lógico
or_logico: bool = x or y
# NOT lógico
not_logico: bool = not x

Ejemplo de operadores:

# Ejemplo de operadores aritméticos con tipado estático
a: int = 5
b: int = 2
suma: int = a + b

Estructuras de Control en Python

Python utiliza estructuras condicionales y de repetición, como if, elif, else, for y while, para controlar el flujo de ejecución de los programas.

Condicionales

Python utiliza las declaraciones if, elif, y else para ejecutar condicionalmente un bloque de código.

edad: int = 20


if edad >= 18:
    estado: str = "Mayor de edad."
else:
    estado: str = "Menor de edad."
print(estado)

Bucles

Los bucles permiten ejecutar un bloque de código repetidamente bajo ciertas condiciones.

Bucle For

El bucle for se utiliza para iterar sobre una secuencia (como una lista, un diccionario, un conjunto o una cadena de texto).

from typing import List


nombres: List[str] = ["Ana", "Bruno", "Carlos"]
for nombre in nombres:
    print(f"Hola, {nombre}!")

Bucle While

El bucle while se repite mientras una condición sea verdadera.

contador: int = 0


while contador < 3:
    print(f"Contador es {contador}")
    contador += 1

Ejemplo de programa que encuentra números primos dentro de un rango:

for num in range(2, 10):
    for i in range(2, num):
        if num % i == 0:
            print(num, "es igual a", i, "*", num//i)
            break
    else:
        print(num, "es un número primo")

Funciones y Módulos

Definir funciones en Python permite reutilizar código, y la importación de módulos extiende las capacidades de los programas. La importación de módulos externos o de la biblioteca estándar extiende las capacidades del programa.

def saludo(nombre: str) -> str:
    return f"Hola, {nombre}"

Crear un ejemplo de un módulo simple matematicas.py que contenga una función para sumar dos números.

# matematicas.py
def sumar(a, b):
    return a + b

Importamos nuestra propia función desde matematicas.py si están en el mismo directorio.

# programa_principal.py
from matematicas import sumar

resultado = sumar(1, 2)
print("El resultado es:", resultado)

Definición y Uso de Funciones

Las funciones se definen con la palabra clave def seguida de un nombre de función, paréntesis y dos puntos. Dentro de los paréntesis, se pueden definir los argumentos de la función con tipado fuerte.

from typing import List


def sumar_numeros(numeros: List[int]) -> int:
    return sum(numeros)
resultado: int = sumar_numeros([1, 2, 3, 4])
print(f"El resultado es {resultado}")

Importación de Módulos

Python cuenta con una vasta biblioteca estándar y permite la importación de módulos para extender las funcionalidades de tus programas.

import math


resultado: float = math.sqrt(16)
print(f"La raíz cuadrada de 16 es {resultado}")

Palabras Clave Importantes

Python tiene palabras clave reservadas importantes para su sintaxis, como class, def, break, continue, try, except, with, y return.

Ejemplos de Palabras Clave y Uso

• False, True: Valores booleanos.
• None: Representa la ausencia de valor.
• and, or, not: Operadores lógicos.
• as: Se usa con with para renombrar un recurso importado o en manejo de excepciones.
• assert: Para hacer afirmaciones utilizadas en pruebas.
• break: Sale de un bucle.
• continue: Salta al próximo ciclo del bucle más cercano.
• class: Define una clase.
• def: Define una función.
• del: Elimina un objeto.
• elif, else, if: Estructuras de control de flujo condicionales.
• except, finally, raise, try: Manejo de excepciones.
• for, while: Bucles.
• from, import: Importación de módulos.
• global: Declara una variable global.
• in: Chequea si un valor está en una secuencia.
• is: Chequea si dos referencias apuntan al mismo objeto.
• lambda: Define una función anónima.
• nonlocal: Declara una variable no local.
• pass: Una declaración nula, no hace nada.
• return: Devuelve un valor de una función.
• with: Utilizado para envolver la ejecución de un bloque con métodos definidos por un contexto.
• yield: Se utiliza en una función como un generador.

Ejemplo

Vamos a usar algunas de las palabras clave mencionadas en el ejemplo:

from typing import List, Optional


# Uso de `class`
class Persona:
    def __init__(self, nombre: str, edad: Optional[int] = None) -> None:
        self.nombre: str = nombre
        self.edad: Optional[int] = edad
# Uso de `def`, `return` y `if`
def saluda(persona: Persona) -> str:
    if persona.edad is not None:
        return f"Hola, {persona.nombre}. Tienes {persona.edad} años."
    else:
        return f"Hola, {persona.nombre}. Tu edad es desconocida."
# Uso de `try`, `except`, `finally`
def divide(a: int, b: int) -> float:
    try:
        resultado: float = a / b
    except ZeroDivisionError:
        print("Error: No se puede dividir por cero.")
        resultado = None
    finally:
        print("Operación de división finalizada.")
    return resultado
# Uso de `for`, `in`, `break` y `continue`
def encuentra_primer_positivo(numeros: List[int]) -> Optional[int]:
    for num in numeros:
        if num > 0:
            return num
        elif num == 0:
            continue
        else:
            break
    return None

Trabajando con Colecciones

Python ofrece listas, diccionarios, conjuntos y tuplas, permitiendo operaciones como añadir, eliminar, iterar y verificar la pertenencia de elementos.

Listas

Las listas son colecciones ordenadas y modificables que pueden contener elementos de diferentes tipos. Con tipado fuerte, puedes especificar el tipo de elementos que una lista debe contener.

from typing import List


nombres: List[str] = ["Ana", "Luis", "Pedro"]

Diccionarios

Los diccionarios en Python son colecciones no ordenadas de pares clave-valor. Utilizando el tipado fuerte, es posible definir el tipo tanto de las claves como de los valores.

from typing import Dict


usuario: Dict[str, str] = {"nombre": "Carlos", "apellido": "Vega"}

Conjuntos

Los conjuntos son colecciones no ordenadas sin elementos duplicados. El tipado fuerte también se puede aplicar a los conjuntos para especificar el tipo de sus elementos.

from typing import Set


numeros_unicos: Set[int] = {1, 2, 3, 4, 5}

Tuplas

Las tuplas son colecciones ordenadas e inmutables. Puedes utilizar el tipado fuerte para definir el tipo de cada elemento dentro de una tupla.

from typing import Tuple


coordenadas: Tuple[int, int] = (10, 20)

Operaciones Comunes con Colecciones

Las colecciones en Python soportan una variedad de operaciones, como la adición y eliminación de elementos, la iteración sobre los elementos, y la verificación de la pertenencia de un elemento.

Python ofrece una serie de estructuras de datos integradas que facilitan el almacenamiento y la manipulación de datos.

Listas

Las listas en Python son colecciones ordenadas y modificables. A continuación, se presentan operaciones comunes:

• Añadir elementos: append() para añadir un elemento al final, insert() para añadir un elemento en una posición específica.
• Eliminar elementos: remove() para eliminar el primer elemento con un valor específico, pop() para eliminar el elemento en una posición dada o al final por defecto.
• Ordenar: sort() para ordenar los elementos.
• Revertir: reverse() para invertir el orden de los elementos.

from typing import List

numeros: List[int] = [1, 2, 3]
numeros.append(4)  # Añade al final
numeros.insert(1, 5)  # Inserta 5 en la posición 1
numeros.sort()  # Ordena la lista
numeros.reverse()  # Invierte la lista

Diccionarios

Los diccionarios son colecciones no ordenadas de pares clave-valor.

• Añadir o actualizar: Directamente con diccionario[clave] = valor.
• Eliminar: pop(clave) para eliminar el par clave-valor.
• Obtener: get(clave) para obtener el valor de una clave.
• Claves y Valores: keys() para obtener las claves, values() para los valores.

from typing import Dict

usuario: Dict[str, str] = {"nombre": "Carlos", "apellido": "Vega"}
usuario["edad"] = "30"  # Añade o actualiza
usuario.pop("edad")  # Elimina la clave "edad"

Conjuntos

Los conjuntos son colecciones no ordenadas y sin elementos duplicados.

• Añadir: add(elemento) para añadir un elemento al conjunto.
• Eliminar: remove(elemento) para eliminar un elemento específico.

from typing import Set

numeros_unicos: Set[int] = {1, 2, 3}
numeros_unicos.add(4)  # Añade 4 al conjunto
numeros_unicos.remove(2)  # Elimina el 2 del conjunto

Tuplas

Las tuplas son colecciones ordenadas e inmutables.

• Acceso: Mediante el índice, por ejemplo, tupla[0].

from typing import Tuple


coordenadas: Tuple[int, int] = (10, 20)

Manejo de Archivos en Python

Python proporciona herramientas para leer y escribir archivos de forma segura y eficiente, facilitando la gestión de archivos de texto y binarios.

Lectura y Escritura de Archivos en Python

La manipulación de archivos es una parte esencial de la programación en Python, permitiendo a los desarrolladores leer y escribir en archivos, así como interactuar con el sistema de archivos. Python facilita estas tareas con funciones integradas y módulos, ofreciendo una interfaz sencilla para manejar archivos de texto y binarios. En este contexto, el tipado fuerte puede ser utilizado para mejorar la claridad del código y asegurar que las operaciones de archivo se realicen con los tipos de datos esperados.

Lectura de Archivos

Para leer contenido de un archivo, Python utiliza la función open() que soporta el tipado fuerte mediante la anotación de tipos para las variables que manejan el archivo y su contenido.

from typing import TextIO

def leer_archivo(ruta: str) -> str:
    with open(ruta, 'r', encoding='utf-8') as archivo:  # Tipo específico para el manejo de archivos de texto
        contenido: str = archivo.read()  # Lectura completa del archivo
    return contenido

# Uso de la función
ruta_archivo: str = 'documento.txt'
contenido_archivo: str = leer_archivo(ruta_archivo)
print(contenido_archivo)

En el ejemplo anterior, archivo es una variable del tipo IO (entrada/salida) que representa el archivo abierto. El contenido leído del archivo se almacena en la variable contenido, que está tipada como str, indicando que esperamos que el contenido del archivo sea un texto.

Escritura de Archivos

La escritura en un archivo sigue un proceso similar, usando también la función open() pero con un modo diferente. Aquí, especificamos el tipo de datos que esperamos escribir en el archivo.

from typing import TextIO

def escribir_archivo(ruta: str, contenido: str) -> None:
    with open(ruta, 'w', encoding='utf-8') as archivo:  # Uso de 'w' para escritura
        archivo.write(contenido)  # Escribiendo el contenido en el archivo

# Uso de la función
nuevo_contenido: str = 'Este es un nuevo contenido.'
ruta_archivo: str = 'documento_nuevo.txt'
escribir_archivo(ruta_archivo, nuevo_contenido)

El modo 'w' en la función open() indica que el archivo está abierto para escritura. Cualquier contenido previo del archivo será borrado. Si se desea agregar contenido al final del archivo sin borrar lo existente, se puede usar el modo 'a'.

Uso de with para la Gestión de Archivos

Python proporciona una forma más segura y concisa de manejar archivos utilizando el administrador de contexto with. Esto asegura que el archivo se cierre automáticamente después de salir del bloque with, incluso si ocurren excepciones.

from typing import IO


with open('ejemplo.txt', 'r') as archivo: 
    contenido: str = archivo.read()
    print(contenido)
with open('salida.txt', 'w') as archivo:
    texto_a_escribir: str = "Otro texto de ejemplo."
    archivo.write(texto_a_escribir)

Trabajar con Archivos de Forma Segura

El uso del administrador de contexto with asegura que el archivo se cierre automáticamente después de su uso, incluso si ocurre una excepción, lo cual es una práctica recomendada para el manejo seguro de archivos.

Uso de Archivos con Bases de Datos en Python

La integración de archivos con bases de datos es común en desarrollo de software, permitiendo operaciones como exportar e importar datos.

Exportar Datos a un Archivo

Supongamos que queremos exportar los datos de una tabla de nuestra base de datos a un archivo CSV. Usaremos el módulo csv de Python y sqlite3 para interactuar con una base de datos SQLite como ejemplo.

import csv
import sqlite3
from typing import List, Tuple


def exportar_datos_a_csv(ruta_db: str, consulta_sql: str, ruta_csv: str) -> None:
    conexion: sqlite3.Connection = sqlite3.connect(ruta_db)
    cursor: sqlite3.Cursor = conexion.cursor()
    
    cursor.execute(consulta_sql)
    filas: List[Tuple] = cursor.fetchall()  # Recuperar todas las filas del resultado
    
    with open(ruta_csv, 'w', newline='', encoding='utf-8') as archivo_csv:
        escritor_csv: csv.writer = csv.writer(archivo_csv)
        escritor_csv.writerows(filas)  # Escribir las filas en el archivo CSV
    
    cursor.close()
    conexion.close()
# Uso de la función
ruta_db: str = 'mi_base_de_datos.db'
consulta_sql: str = 'SELECT * FROM mi_tabla'
ruta_csv: str = 'datos_exportados.csv'
exportar_datos_a_csv(ruta_db, consulta_sql, ruta_csv)

Importar Datos desde un Archivo

Para importar datos desde un archivo CSV a una base de datos, el procedimiento es similar pero en reversa. Leeremos los datos del archivo CSV y los insertaremos en la tabla correspondiente de nuestra base de datos.

import csv
import sqlite3
from typing import List, Tuple


def importar_datos_desde_csv(ruta_csv: str, ruta_db: str, nombre_tabla: str) -> None:
    conexion: sqlite3.Connection = sqlite3.connect(ruta_db)
    cursor: sqlite3.Cursor = conexion.cursor()
    
    with open(ruta_csv, 'r', encoding='utf-8') as archivo_csv:
        lector_csv: csv.reader = csv.reader(archivo_csv)
        filas: List[Tuple] = [tuple(fila) for fila in lector_csv]  # Convertir cada fila a una tupla
        
        cursor.executemany(f'INSERT INTO {nombre_tabla} VALUES (?,?,?)', filas)
    
    conexion.commit()
    cursor.close()
    conexion.close()
# Uso de la función
ruta_csv: str = 'datos_a_importar.csv'
ruta_db: str = 'mi_base_de_datos.db'
nombre_tabla: str = 'mi_tabla_nueva'
importar_datos_desde_csv(ruta_csv, ruta_db, nombre_tabla)

Consideraciones

Al trabajar con archivos y bases de datos, es crucial gestionar correctamente los recursos para evitar bloqueos o pérdidas de datos. El uso del administrador de contexto with asegura que los recursos se manejen adecuadamente.

Programación Orientada a Objetos (POO)

Python soporta POO, permitiendo modelar objetos del mundo real. Conceptos como herencia, polimorfismo y encapsulamiento son fundamentales.

Definición de Clases

Una clase es una plantilla para la creación de objetos que encapsula datos y funcionalidades relacionadas. Python permite definir el tipo de los atributos y el retorno de los métodos dentro de las clases.

class Vehiculo:
    def __init__(self, marca: str, modelo: str) -> None:
        self.marca: str = marca
        self.modelo: str = modelo

    def mostrar_informacion(self) -> str:
        return f"Marca: {self.marca}, Modelo: {self.modelo}"

# Creación de un objeto de la clase Vehiculo
mi_vehiculo: Vehiculo = Vehiculo("Toyota", "Corolla")
print(mi_vehiculo.mostrar_informacion())

Herencia y el Uso de super() en Python

La herencia es uno de los pilares de la Programación Orientada a Objetos (POO), permitiendo a las clases hijas heredar atributos y métodos de las clases padres, evitando así la duplicidad de código y fomentando la reutilización.

Cuando una clase hija necesita acceder o modificar métodos ya definidos en su clase padre, Python ofrece la función super(), la cual permite llamar a métodos del padre sin necesidad de nombrarlo explícitamente. Esto no solo mejora la mantenibilidad del código, sino que también lo hace más adaptable a cambios futuros.

La herencia permite definir una clase que hereda todos los métodos y propiedades de otra clase. La clase de la que se hereda se llama clase base o superclase, y la clase que hereda se llama clase derivada o subclase.

Ejemplo de Uso de super()

Consideremos un ejemplo en el que extendemos la funcionalidad del método __init__ de una clase padre en una clase hija:

class Vehiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo

class VehiculoElectrico(Vehiculo):
    def __init__(self, marca, modelo, autonomia):
        super().__init__(marca, modelo)  # Llama al constructor de Vehiculo
        self.autonomia = autonomia  # Añade un nuevo atributo a VehiculoElectrico

    def mostrar_informacion(self):
        return f"{super().mostrar_informacion()}, Autonomía: {self.autonomia} km"

En este ejemplo, VehiculoElectrico hereda de Vehiculo. Utilizamos super() para llamar al método __init__ de la clase Vehiculo desde VehiculoElectrico, permitiéndonos añadir funcionalidad adicional (en este caso, el atributo autonomia) sin tener que reescribir el código de inicialización de la clase padre.

El uso de super() es especialmente poderoso en estructuras de herencia complejas, ya que mantiene el código limpio y bien organizado, facilitando su comprensión y mantenimiento.

Encapsulamiento

El encapsulamiento es un concepto de la POO que restringe el acceso directo a los componentes del objeto y puede prevenir la modificación accidental de datos. Python no tiene modificadores de acceso (como private o protected en otros lenguajes), pero se puede lograr un efecto similar usando guiones bajos (_) o dobles guiones bajos (__) como prefijos de nombres de atributos o métodos.

class Cuenta:
    def __init__(self, titular: str, saldo_inicial: float = 0.0) -> None:
        self.titular: str = titular
        self.__saldo: float = saldo_inicial  # Atributo privado

    def depositar(self, cantidad: float) -> None:
        if cantidad > 0:
            self.__saldo += cantidad
            print("Depósito realizado.")
        else:
            print("La cantidad debe ser mayor a cero.")

    def mostrar_saldo(self) -> str:
        return f"Saldo de la cuenta: {self.__saldo}"

cuenta_de_ana: Cuenta = Cuenta("Ana", 1000.0)
cuenta_de_ana.depositar(500.0)
print(cuenta_de_ana.mostrar_saldo())

Polimorfismo

El polimorfismo es la capacidad de utilizar un interfaz para múltiples formas de datos. Python permite polimorfismo, permitiendo que el mismo método realice diferentes acciones basadas en el objeto que lo invoca.

def mostrar_detalles_del_vehiculo(vehiculo: Vehiculo) -> None:
    print(vehiculo.mostrar_informacion())

mostrar_detalles_del_vehiculo(mi_vehiculo)
mostrar_detalles_del_vehiculo(mi_vehiculo_electrico)

Creación de Clases y Objetos en Python

Definir clases y crear objetos son pilares de la POO, con Python facilitando estas tareas mediante una sintaxis clara.

Definición de una Clase

Para definir una clase en Python, se utiliza la palabra clave class, seguida del nombre de la clase y dos puntos. Dentro de la clase, se pueden definir atributos y métodos para describir el comportamiento y las características de los objetos de esa clase.

from typing import List

class Libro:
    def __init__(self, titulo: str, autor: str, paginas: int) -> None:
        self.titulo: str = titulo
        self.autor: str = autor
        self.paginas: int = paginas
    def descripcion(self) -> str:
        return f"'{self.titulo}' por {self.autor}, {self.paginas} páginas"

Instanciación de Objetos

La instanciación de objetos se realiza llamando al nombre de la clase como si fuera una función, pasando los argumentos necesarios que el método __init__ de la clase define.

mi_libro: Libro = Libro("El Quijote", "Miguel de Cervantes", 1345)
print(mi_libro.descripcion())

Clase con Métodos Especiales

Python permite definir métodos especiales (también conocidos como métodos mágicos), como __str__, que permiten a las clases interactuar con funciones integradas de Python y proporcionar una representación más amigable de los objetos.

class Persona:
    def __init__(self, nombre: str, edad: int) -> None:
        self.nombre: str = nombre
        self.edad: int = edad

    def __str__(self) -> str:
        return f"Persona({self.nombre}, {self.edad})"

Clase con Métodos de Clase y Estáticos

Python también soporta métodos de clase y métodos estáticos. Los métodos de clase toman cls como su primer argumento y pueden modificar el estado de la clase. Los métodos estáticos, por otro lado, no toman un argumento self o cls y se comportan como funciones normales, pero pertenecen al namespace de la clase.

class Calculadora:
    @staticmethod
    def sumar(a: int, b: int) -> int:
        return a + b

    @classmethod
      def crear_desde_string(cls, datos: str) -> "Calculadora":
          a, b = map(int, datos.split('+'))
          return cls()  # Suponiendo que Calculadora puede ser instanciada sin argumentos


print(Calculadora.sumar(5, 3))
calculadora = Calculadora.crear_desde_string("10+20")
print(calculadora.sumar(10, 20))

Clases Abstractas

Las clases abstractas en Python sirven como plantillas para otras clases, definiendo métodos que deben ser implementados por las clases derivadas. Utilizando el módulo abc (Abstract Base Classes), podemos declarar clases y métodos como abstractos.

from abc import ABC, abstractmethod

class Forma(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

class Circulo(Forma):
    def __init__(self, radio: float) -> None:
        self.radio: float = radio
    
    def area(self) -> float:
        return 3.14159 * self.radio ** 2

class Cuadrado(Forma):
    def __init__(self, lado: float) -> None:
        self.lado: float = lado
    
    def area(self) -> float:
        return self.lado ** 2

Desarrollo Web y Ciencia de Datos

Python es ideal tanto para desarrollo web, con frameworks como Flask y Django, como para ciencia de datos, utilizando librerías especializadas.

En el ámbito de la ciencia de datos, librerías como Pandas y NumPy permiten el manejo eficiente de datos, mientras que TensorFlow posibilita la implementación de complejos modelos de machine learning. Estas herramientas convierten a Python en una elección preferente para analistas y científicos de datos que buscan procesar, analizar y visualizar grandes volúmenes de información de manera intuitiva.

En el lado del desarrollo web, Python proporciona frameworks robustos como Flask y Django. Flask ofrece una plataforma ligera y flexible para el desarrollo web, ideal para proyectos de todos los tamaños, desde pequeñas aplicaciones web hasta grandes plataformas. Django, por otro lado, es conocido por su “baterías incluidas” enfoque, ofreciendo una solución más completa que incluye todo lo necesario para construir aplicaciones web robustas y escalables de manera rápida y eficiente. Ambos frameworks simplifican el desarrollo web con Python, desde la creación de rutas hasta la gestión de bases de datos, haciendo de Python una opción versátil para desarrolladores web.

La combinación de estas herramientas y librerías en Python no solo facilita el desarrollo de aplicaciones web y el análisis de datos sino que también promueve una integración fluida entre ambas disciplinas, permitiendo el desarrollo de soluciones web que se benefician directamente de análisis de datos avanzados y capacidades de machine learning. Esto convierte a Python en una herramienta indispensable en el arsenal de cualquier desarrollador o científico de datos moderno, capaz de abordar una amplia gama de desafíos, desde el desarrollo web hasta la innovación en la ciencia de datos.

Buenas Prácticas de Ejecución y Gestión de Dependencias

Uso de Shebangs

En scripts de Python, es común empezar el archivo con una línea shebang. Esto permite ejecutar el script directamente desde la terminal sin tener que especificar explícitamente el intérprete de Python. Los shebangs más comunes en entornos Unix son:

• Para Python 2: #!/usr/bin/env python2
• Para Python 3: #!/usr/bin/env python3

Esto busca el intérprete en el entorno del usuario, lo que permite la compatibilidad entre diferentes sistemas donde el intérprete de Python podría estar en diferentes ubicaciones.

Para hacer un script ejecutable con un shebang, sigue estos pasos:

1. Añade la línea shebang al inicio de tu script de Python.
2. Cambia los permisos del archivo para hacerlo ejecutable: chmod +x mi_script.py.
3. Ejecuta el script directamente desde la terminal: ./mi_script.py.

Creación y Uso de Entornos Virtuales con venv

Los entornos virtuales permiten aislar las dependencias de un proyecto de las dependencias globales del sistema y de otros proyectos, facilitando la gestión de versiones y la replicabilidad de entornos. Para crear un entorno virtual en tu proyecto:

1. Navega a la carpeta de tu proyecto: cd mi_proyecto.
2. Crea el entorno virtual: python3 -m venv venv.
3. Activa el entorno virtual:

• En Windows: .\venv\Scripts\activate.
• En Unix o MacOS: source venv/bin/activate.

Con el entorno virtual activo, cualquier paquete que instales usando pip se instalará en este entorno aislado.

Gestión de Dependencias con requirements.txt

Para gestionar las dependencias de tu proyecto, puedes listarlas en un archivo requirements.txt. Esto facilita la instalación de todas las dependencias con un solo comando y asegura que otros desarrolladores o sistemas puedan replicar el entorno de tu proyecto.

Para generar un requirements.txt con todas las dependencias instaladas en tu entorno virtual:

pip freeze > requirements.txt

Para instalar las dependencias desde un requirements.txt:

pip install -r requirements.txt

Asegúrate de incluir tu archivo requirements.txt en el control de versiones para compartirlo con otros desarrolladores.

Uso de Entornos Virtuales (venv)

Los entornos virtuales en Python son una herramienta esencial para gestionar las dependencias de los proyectos y asegurar que estos se ejecuten en un entorno aislado, sin interferir con otros proyectos o con el sistema operativo en general. Esto es particularmente útil cuando trabajas en múltiples proyectos en tu máquina, cada uno con sus propias dependencias.

Creación de un Entorno Virtual:

Para crear un entorno virtual en tu proyecto, sigue estos pasos:

1. Navega hasta el directorio de tu proyecto:

cd ruta/a/tu/proyecto

1. Crea el entorno virtual:

• En Windows:

python -m venv venv

• En GNU/Linux y macOS

python3 -m venv venv

Esto creará una carpeta venv en el directorio de tu proyecto, conteniendo el entorno virtual.

Activación del Entorno Virtual:

• En Windows:

.\venv\Scripts\activate

• En GNU/Linux y macOS:

source venv/bin/activate

Una vez activado el entorno virtual, puedes instalar las dependencias necesarias utilizando pip sin afectar al entorno global de Python en tu sistema.

Notarás que el prompt de tu terminal cambia para reflejar que el entorno virtual está activo, usualmente precediendo el nombre del entorno (venv) en tu prompt.

Uso de pip en un Entorno Virtual

Una vez activado el entorno virtual, cualquier comando pip que ejecutes afectará únicamente a ese entorno aislado, sin interferir con el sistema global o con otros entornos virtuales.

• Instalar paquetes: Para instalar un nuevo paquete, utiliza el comando pip install seguido del nombre del paquete:

pip install nombre_del_paquete

• Listar paquetes instalados: Puedes ver los paquetes instalados en tu entorno virtual con:

pip list

• Desinstalar paquetes: Para remover un paquete instalado:

pip uninstall nombre_del_paquete

• Actualizar pip: Es buena práctica mantener pip, el gestor de paquetes, actualizado:

pip install --upgrade pip

Desactivación del Entorno Virtual

Cuando termines de trabajar en tu proyecto, puedes desactivar el entorno virtual para volver al entorno global o sistema. Esto se hace con el comando:

deactivate

Después de desactivar el entorno virtual, cualquier comando pip o ejecución de Python que realices utilizará nuevamente las versiones globales instaladas en tu sistema.

Ejecución Directa del Intérprete y pip del Entorno Virtual

Cada entorno virtual en Python incluye su propio intérprete y su propia instancia de pip. Cuando activas el entorno virtual, básicamente ajustas tu entorno de shell para que estos ejecutables se busquen primero dentro del entorno virtual, antes de buscar en el resto del sistema. Sin embargo, puedes ejecutar estos ejecutables directamente sin activar el entorno.

Ejemplo de Uso del Intérprete de Python del venv:

Supongamos que tu entorno virtual se llama venv y está ubicado en tu directorio de proyecto. Puedes ejecutar un script de Python utilizando el intérprete del entorno virtual con el siguiente comando:

• En Windows:

.\venv\Scripts\python.exe tu_script.py

• En GNU/Linux y macOS:

./venv/bin/python tu_script.py

Este comando ejecuta tu_script.py utilizando el intérprete de Python aislado del entorno virtual, sin necesidad de activar previamente el venv.

Ejemplo de Uso de pip del venv:

De manera similar, puedes instalar paquetes utilizando pip del entorno virtual sin activarlo, simplemente especificando la ruta completa a pip dentro del entorno virtual:

• En Windows:

.\venv\Scripts\pip.exe install nombre_del_paquete

• En GNU/Linux y macOS:

./venv/bin/pip install nombre_del_paquete

Este comando instala nombre_del_paquete en el entorno virtual venv, sin interferir con el sistema global de Python ni con otros entornos virtuales.

Ventajas de la Ejecución Directa

• Automatización: Facilita la ejecución de scripts y herramientas en entornos aislados mediante scripts de shell o tareas programadas sin la necesidad de activar manualmente el entorno virtual.
• Simplicidad: Simplifica los flujos de trabajo en herramientas de desarrollo integrado (IDEs) y entornos de integración continua/despliegue continuo (CI/CD) que requieren el uso de entornos virtuales.

Uso de virtualenv para la Creación de Entornos Virtuales con Diferentes Versiones de Python:

Además de utilizar venv, otra opción popular para la gestión de entornos virtuales en Python es virtualenv. virtualenv permite crear entornos virtuales con diferentes versiones de Python, lo cual puede ser útil cuando necesitas trabajar en proyectos que requieren versiones específicas de Python.

Para instalar virtualenv, puedes utilizar pip, asegurándote de que la instalación cumpla con ciertos requisitos para no interferir con la instalación de Python que está ligada en el PATH (la versión de Python del sistema). A continuación se muestra cómo instalar `virtualenv` de forma segura:

1. Instalación de virtualenv:

pip install virtualenv

Es importante tener en cuenta que este comando utiliza el pip asociado con la instalación de Python del sistema. Si tienes múltiples versiones de Python instaladas, asegúrate de utilizar el pip correcto.

2. Creación de un Entorno Virtual con virtualenv:

Una vez instalado virtualenv, puedes crear un entorno virtual especificando la versión de Python que deseas utilizar. Por ejemplo, para crear un entorno virtual con Python 3, puedes usar el siguiente comando:

virtualenv -p python3 venv

Esto creará un nuevo directorio llamado venv que contiene el entorno virtual con la versión específica de Python.

En Windows, la ruta puede variar dependiendo de dónde esté instalada tu versión de Python. Por ejemplo:

virtualenv -p "C:\Users\User\AppData\Local\Programs\Python\Python38\python.exe" venv

Esto creará un nuevo directorio llamado venv que contiene el entorno virtual con la versión específica de Python.

3. Activación y Uso del Entorno Virtual:

La activación de un entorno virtual creado con virtualenv es similar a la activación de un entorno creado con venv. Puedes activarlo utilizando el script de activación adecuado según tu sistema operativo:

• En Windows:

.\env\Scripts\activate

• En GNU/Linux y macOS:

source env/bin/activate

Una vez activado, puedes utilizar este entorno virtual de la misma manera que cualquier otro, instalando paquetes con pip y ejecutando scripts de Python.

Usar virtualenv te brinda la flexibilidad de crear entornos virtuales con diferentes versiones de Python, lo que puede ser útil para proyectos que requieren versiones específicas de Python o para probar la compatibilidad con diferentes versiones del lenguaje. Asegúrate siempre de instalar virtualenv de forma segura y de activar los entornos virtuales de manera adecuada para evitar conflictos con otras instalaciones de Python en tu sistema.

Automatización de la Ejecución con Shebangs

El shebang es una secuencia de caracteres (#!), seguida de la ruta al intérprete que se utiliza para ejecutar el script. Esto permite ejecutar un script de Python directamente como un archivo ejecutable, sin necesidad de preceder la llamada con python o python3.

Uso de Shebangs

Para utilizar shebangs en tus scripts de Python, simplemente añade una de las siguientes líneas al principio de tu archivo .py:

• En entornos donde python apunta a Python 3:

#!/usr/bin/env python

• Específicamente para Python 3, que es más común en sistemas recientes:

#!/usr/bin/env python3

Ejemplo de Script con Shebang

#!/usr/bin/env python3
print("Hola, Mundo!")

Después de añadir el shebang, asegúrate de hacer el script ejecutable:

• En GNU/Linux y macOS:

chmod +x tu_script.py

Ahora puedes ejecutar tu script directamente desde la terminal:

./tu_script.py

Resumen

La adopción de entornos virtuales y el uso correcto de shebangs son prácticas recomendadas que mejoran la portabilidad y la eficiencia de tus proyectos en Python. Aseguran un manejo adecuado de las dependencias y facilitan la ejecución de scripts en diferentes entornos. Incorpora estas prácticas en tu flujo de trabajo para un desarrollo más estructurado y profesional en Python.

Más de Axlfc en Medium

Si te ha interesado esta guía sobre los primeros pasos en Python y buscas profundizar aún más en tus habilidades de programación en Python creando tu primer programa, te recomiendo explorar más recursos que he preparado especialmente para ti. Espero poder ayudarte en tu viaje de aprendizaje:

• Iniciando con Python: Tu Primer Programa ‘Hola, Mundo!’
  Explora los fundamentos de Python y aprende cómo escribir y ejecutar tu primer programa. Un punto de partida ideal para principiantes en la programación.
  Leer más