Saltar a contenido

Python

Python es un lenguaje de programación de alto nivel, interpretado, de propósito general y con una filosofía de diseño que enfatiza la legibilidad del código. Creado por Guido van Rossum y lanzado por primera vez en 1991, Python se ha convertido en uno de los lenguajes más populares del mundo debido a su simplicidad, versatilidad y amplia gama de aplicaciones.

Características Principales

1. Sintaxis Clara y Legible

Python utiliza la indentación para definir bloques de código, lo que fuerza un estilo de codificación consistente y mejora la legibilidad.

def calcular_media(numeros):
    if not numeros:
        return 0
    return sum(numeros) / len(numeros)

# Ejemplo de uso de condicionales
idade = 18
if idade >= 18:
    print("Mayor de edad")
else:
    print("Menor de edad")

2. Tipado Dinámico y Fuerte

Python es un lenguaje de tipado dinámico, lo que significa que el tipo de una variable se determina en tiempo de ejecución. Al mismo tiempo, es de tipado fuerte, lo que significa que los tipos de los objetos no cambian implícitamente.

x = 10          # x es un entero
x = "Python"    # ahora x es un string
# x + 5         # Esto generaría un error: no se puede concatenar 'str' e 'int'

3. Interpretado

Python es un lenguaje interpretado, lo que significa que el código es ejecutado línea por línea por un intérprete, sin necesidad de una compilación previa a código de máquina.

4. Multiparadigma

Python soporta múltiples paradigmas de programación:

  • Programación Imperativa: Basada en comandos que alteran el estado del programa.
  • Programación Orientada a Objetos: Basada en clases y objetos.
  • Programación Funcional: Tratando las funciones como ciudadanos de primera clase.
  • Programación Procedural: Basada en procedimientos o rutinas.

5. Biblioteca Estándar Extensa

Python viene con una extensa biblioteca estándar que ofrece módulos y paquetes para diversas tareas, desde la manipulación de archivos hasta el desarrollo web.

Sintaxis Básica

Variables y Tipos de Datos

# Números
entero = 10
flotante = 3.14
complejo = 1 + 2j

# Strings
texto = "Python"
texto_multilinea = """Este es un
texto con múltiples
líneas"""

# Booleanos
verdadero = True
falso = False

# Listas (mutables)
lista = [1, 2, 3, 4, 5]
lista_mixta = [1, "dos", 3.0, [4, 5]]

# Tuplas (inmutables)
tupla = (1, 2, 3)

# Diccionarios
diccionario = {"llave": "valor", "nombre": "Python"}

# Conjuntos
conjunto = {1, 2, 3, 4, 5}

Estructuras de Control

Condicionales

# If-elif-else
edad = 20
if edad < 18:
    print("Menor de edad")
elif edad == 18:
    print("Acaba de cumplir la mayoría de edad")
else:
    print("Mayor de edad")

# Operador ternario
status = "Mayor de edad" if edad >= 18 else "Menor de edad"

Bucles

# Bucle for
for i in range(5):
    print(i)  # Imprime 0, 1, 2, 3, 4

# Iterando sobre una lista
frutas = ["manzana", "banana", "naranja"]
for fruta in frutas:
    print(fruta)

# Bucle while
contador = 0
while contador < 5:
    print(contador)
    contador += 1

# Break y continue
for i in range(10):
    if i == 3:
        continue  # Salta a la siguiente iteración
    if i == 7:
        break     # Sale del bucle
    print(i)

Funciones

# Definición de función
def saudacao(nombre):
    return f"¡Hola, {nombre}!"

# Llamada de función
mensagem = saudacao("Python")
print(mensagem)  # Salida: ¡Hola, Python!

# Parámetros por defecto
def saudacao_personalizada(nombre, saudacao="Hola"):
    return f"{saudacao}, ¡{nombre}!"

# Args y kwargs
def exemplo_args_kwargs(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

exemplo_args_kwargs(1, 2, 3, nome="Python", versao=3.9)

Funciones Lambda

# Función lambda (anónima)
dobro = lambda x: x * 2
print(dobro(5))  # Salida: 10

# Uso con funciones de orden superior
numeros = [1, 2, 3, 4, 5]
pares = list(filter(lambda x: x % 2 == 0, numeros))
dobrados = list(map(lambda x: x * 2, numeros))

Programación Orientada a Objetos

Clases y Objetos

class Pessoa:
    # Atributo de clase
    especie = "Homo sapiens"

    # Método constructor
    def __init__(self, nombre, edad):
        # Atributos de instancia
        self.nombre = nombre
        self.edad = edad

    # Método de instancia
    def presentar(self):
        return f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años."

    # Método de clase
    @classmethod
    def criar_de_ano_nascimento(cls, nombre, ano_nacimiento):
        from datetime import date
        edad = date.today().year - ano_nacimiento
        return cls(nombre, edad)

    # Método estático
    @staticmethod
    def e_adulto(edad):
        return edad >= 18

# Creando instancias
pessoa1 = Pessoa("Ana", 30)
pessoa2 = Pessoa.criar_de_ano_nascimento("Carlos", 1995)

print(pessoa1.presentar())  # Salida: Hola, mi nombre es Ana y tengo 30 años.
print(Pessoa.e_adulto(17))   # Salida: False

Herencia

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def emitir_sonido(self):
        pass

class Cachorro(Animal):
    def emitir_sonido(self):
        return "¡Guau guau!"

class Gato(Animal):
    def emitir_sonido(self):
        return "¡Miau!"

# Creando instancias
rex = Cachorro("Rex")
felix = Gato("Felix")

print(rex.nombre)           # Salida: Rex
print(rex.emitir_sonido())  # Salida: ¡Guau guau!
print(felix.emitir_sonido())  # Salida: ¡Miau!

Encapsulamiento

class ContaBancaria:
    def __init__(self, titular, saldo_inicial=0):
        self.titular = titular
        self.__saldo = saldo_inicial  # Atributo privado

    def depositar(self, valor):
        if valor > 0:
            self.__saldo += valor
            return True
        return False

    def retirar(self, valor):
        if 0 < valor <= self.__saldo:
            self.__saldo -= valor
            return True
        return False

    def consultar_saldo(self):
        return self.__saldo

# Creando una cuenta
conta = ContaBancaria("João", 1000)

# Accediendo a métodos públicos
conta.depositar(500)
conta.retirar(200)
print(conta.consultar_saldo())  # Salida: 1300

# Intentando acceder al atributo privado
# print(conta.__saldo)  # Esto generaría un AttributeError

Características Avanzadas

Generadores

# Función generadora
def contador(maximo):
    contador = 0
    while contador < maximo:
        yield contador
        contador += 1

# Usando el generador
for numero in contador(5):
    print(numero)  # Salida: 0, 1, 2, 3, 4

# Expresión generadora
quadrados = (x**2 for x in range(5))
print(list(quadrados))  # Salida: [0, 1, 4, 9, 16]

Decoradores

# Definiendo un decorador
def meu_decorador(funcao):
    def wrapper(*args, **kwargs):
        print("Antes de la función")
        resultado = funcao(*args, **kwargs)
        print("Después de la función")
        return resultado
    return wrapper

# Aplicando el decorador
@meu_decorador
def saudacao(nombre):
    print(f"¡Hola, {nombre}!")

saudacao("Python")
# Salida:
# Antes de la función
# ¡Hola, Python!
# Después de la función

Administradores de Contexto

# Usando with para archivos
with open("archivo.txt", "w") as archivo:
    archivo.write("¡Hola, Python!")

# Creando un administrador de contexto personalizado
class MinhaConexao:
    def __init__(self, host, porta):
        self.host = host
        self.porta = porta

    def __enter__(self):
        print(f"Conectando a {self.host}:{self.porta}")
        # Código para establecer la conexión
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Desconectando de {self.host}:{self.porta}")
        # Código para cerrar la conexión
        return False  # Propaga las excepciones

# Usando el administrador de contexto
with MinhaConexao("localhost", 8080) as conn:
    print("Conexión establecida")

Type Hints (Python 3.5+)

from typing import List, Dict, Optional, Union

def somar_lista(numeros: List[int]) -> int:
    return sum(numeros)

def processar_usuario(usuario: Dict[str, Union[str, int]]) -> str:
    return f"Usuario: {usuario['nome']}, Edad: {usuario['idade']}"

def buscar_usuario(id: int) -> Optional[Dict[str, Union[str, int]]]:
    # Simulación de búsqueda
    if id == 1:
        return {"nome": "Alice", "idade": 30}
    return None

Bibliotecas y Frameworks Populares

Ciencia de Datos y Machine Learning

  • NumPy: Computación numérica
  • Pandas: Análisis y manipulación de datos
  • Matplotlib y Seaborn: Visualización de datos
  • Scikit-learn: Machine learning
  • TensorFlow y PyTorch: Deep learning

Desarrollo Web

  • Django: Framework web full-stack
  • Flask: Microframework web
  • FastAPI: Framework moderno para APIs

Automatización y Scripting

  • Requests: HTTP para humanos
  • Beautiful Soup: Web scraping
  • Selenium: Automatización de navegadores
  • Paramiko: Cliente SSH

Python en el Proyecto

En el contexto de nuestro proyecto de sistema de feedback, Python se utiliza para implementar el microservicio de visualización de feedback con FastAPI y Peewee ORM.

Conclusión

Python es un lenguaje versátil y potente que se destaca por su simplicidad y legibilidad. Su amplia gama de bibliotecas y frameworks lo hace adecuado para diversas aplicaciones, desde el desarrollo web hasta la ciencia de datos y el machine learning.

En el contexto de nuestro proyecto, Python con FastAPI y Peewee ofrece una solución eficiente y moderna para implementar el microservicio de visualización de feedback, demostrando la versatilidad del lenguaje en un entorno de microservicios.

La combinación de una sintaxis clara, tipado dinámico y fuerte, y un rico ecosistema de bibliotecas hace de Python una excelente elección para los desarrolladores que buscan productividad y expresividad en sus proyectos.