Python: guía completa para principiantes y nivel intermedio

Python es uno de los lenguajes de programación más populares y accesibles del mundo. Su sintaxis clara y su gran versatilidad lo convierten en una excelente elección tanto para principiantes como para desarrolladores con experiencia. Esta guía le presenta los conceptos fundamentales de Python y cómo utilizarlos eficazmente en sus proyectos.

¿Por qué elegir Python?

Python destaca por varias características que explican su creciente popularidad:

• Sintaxis clara y legible: Diseñado para ser fácil de leer y de escribir
• Versátil: Se utiliza en desarrollo web, análisis de datos, IA, automatización, etc.
• Gran comunidad: Una amplia comunidad de desarrolladores y abundantes recursos
• Rico en bibliotecas: Miles de paquetes para ampliar sus funcionalidades
• Interpretado: No es necesario compilar el código, lo que acelera el desarrollo
• Multiplataforma: Funciona en Windows, macOS, Linux y muchos otros sistemas

Instalación de Python

Para empezar con Python, primero debe instalarlo en su sistema:

Windows

# Descargar desde https://www.python.org/downloads/
# O instalar con winget
winget install Python.Python.3.11

macOS

# Con Homebrew
brew install python

# O descargar desde https://www.python.org/downloads/

Linux (Ubuntu/Debian)

# Instalar Python 3
sudo apt update
sudo apt install python3 python3-pip python3-venv

Entornos virtuales

Utilizar entornos virtuales es una buena práctica para aislar las dependencias de sus proyectos:

# Creación de un entorno virtual
python -m venv mon_env

# Activación del entorno virtual
# En Windows
mon_env\Scripts\activate

# En macOS/Linux
source mon_env/bin/activate

# Instalación de paquetes
pip install numpy pandas matplotlib

Sintaxis básica y tipos de datos

Variables y asignación

# Variables
nom = "Alice"
age = 30
taille = 1.75
est_developpeur = True

# Visualización de variables
print(f"Je m'appelle {nom}, j'ai {age} ans.")

Tipos de datos fundamentales

# Cadenas de caracteres (str)
texte = "Bonjour, monde !"
multiple_lignes = """Ceci est un texte
sur plusieurs lignes."""

# Números (int, float)
entier = 42
decimal = 3.14159

# Booleanos (bool)
vrai = True
faux = False

# Comprobación de tipo
print(type(entier))  # <class 'int'>

Colecciones

# Listas (mutables, ordenadas)
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = [1, "deux", 3.0, True]

# Acceso a los elementos (indexación desde 0)
premier_fruit = fruits[0]  # pomme
dernier_fruit = fruits[-1]  # orange

# Modificación
fruits[1] = "fraise"
fruits.append("kiwi")
fruits.extend(["mangue", "ananas"])
fruits.remove("pomme")

# Tuplas (inmutables, ordenadas)
coordonnees = (10, 20)
rgb = (255, 0, 128)

# Diccionarios (pares clave-valor)
personne = {
    "nom": "Dupont",
    "prenom": "Jean",
    "age": 30,
    "competences": ["Python", "JavaScript", "SQL"]
}

# Acceso a los valores
print(personne["nom"])
print(personne.get("adresse", "Non spécifiée"))

# Conjuntos (elementos únicos, no ordenados)
couleurs = {"rouge", "vert", "bleu"}
couleurs.add("jaune")

Estructuras de control

Condicionales

# If, elif, else
age = 20
if age < 18:
    print("Mineur")
elif age < 21:
    print("Majeur, mais pas aux USA")
else:
    print("Majeur partout")

# Operadores de comparación
# ==, !=, <, >, <=, >=

# Operadores lógicos
# and, or, not
if age >= 18 and age <= 65:
    print("En âge de travailler")

Bucles

# Bucle for
for fruit in fruits:
    print(fruit)

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

for i in range(2, 8, 2):  # 2, 4, 6
    print(i)

# Enumeración
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

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

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

Funciones

# Definición de función
def saluer(nom):
    """Cette fonction salue la personne passée en paramètre."""
    return f"Bonjour, {nom} !"

# Llamada a la función
message = saluer("Bob")
print(message)

# Parámetros por defecto
def saluer_formellement(nom, titre="M./Mme"):
    return f"Bonjour, {titre} {nom} !"

print(saluer_formellement("Dupont"))
print(saluer_formellement("Dupont", "Dr."))

# Argumentos con nombre
def calculer_prix(montant, taxe=0.2, reduction=0):
    return montant * (1 + taxe) - reduction

prix = calculer_prix(100, reduction=20, taxe=0.1)

# *args y **kwargs
def info_personne(nom, *hobbies, **caracteristiques):
    print(f"Nom: {nom}")
    print("Hobbies:")
    for hobby in hobbies:
        print(f"- {hobby}")
    print("Autres caractéristiques:")
    for cle, valeur in caracteristiques.items():
        print(f"- {cle}: {valeur}")

info_personne("Alice", "lecture", "natation", "vélo", 
              age=28, profession="Ingénieure", ville="Paris")

# Funciones lambda
carre = lambda x: x * x
print(carre(5))  # 25

Programación orientada a objetos

# Definición de clase
class Personne:
    """Classe représentant une personne."""
    
    # Variable de clase
    espece = "Humain"
    
    # Constructor
    def __init__(self, nom, age):
        # Atributos de instancia
        self.nom = nom
        self.age = age
        self._adresse = None  # Atributo semiprivado
    
    # Método de instancia
    def se_presenter(self):
        return f"Je m'appelle {self.nom} et j'ai {self.age} ans."
    
    # Property
    @property
    def adresse(self):
        return self._adresse
    
    @adresse.setter
    def adresse(self, nouvelle_adresse):
        if isinstance(nouvelle_adresse, str):
            self._adresse = nouvelle_adresse
        else:
            raise TypeError("L'adresse doit être une chaîne de caractères")
    
    # Método estático
    @staticmethod
    def est_majeur(age):
        return age >= 18
    
    # Método de clase
    @classmethod
    def creer_depuis_annee_naissance(cls, nom, annee_naissance):
        from datetime import date
        age = date.today().year - annee_naissance
        return cls(nom, age)

# Creación de instancias
alice = Personne("Alice", 30)
print(alice.se_presenter())

bob = Personne.creer_depuis_annee_naissance("Bob", 1990)

# Herencia
class Employe(Personne):
    def __init__(self, nom, age, poste, salaire):
        super().__init__(nom, age)
        self.poste = poste
        self.salaire = salaire
    
    def se_presenter(self):
        presentation = super().se_presenter()
        return f"{presentation} Je travaille comme {self.poste}."

# Polimorfismo
personnes = [alice, Employe("Charlie", 35, "Développeur", 50000)]
for personne in personnes:
    print(personne.se_presenter())

Gestión de archivos

# Lectura de un archivo
with open("exemple.txt", "r", encoding="utf-8") as fichier:
    contenu = fichier.read()
    print(contenu)

# Lectura línea a línea
with open("exemple.txt", "r", encoding="utf-8") as fichier:
    for ligne in fichier:
        print(ligne.strip())

# Escritura de un archivo
with open("sortie.txt", "w", encoding="utf-8") as fichier:
    fichier.write("Bonjour, monde !\n")
    fichier.write("Ceci est un exemple d'écriture de fichier en Python.")

# Añadir contenido a un archivo
with open("sortie.txt", "a", encoding="utf-8") as fichier:
    fichier.write("\nCette ligne est ajoutée à la fin.")

Gestión de excepciones

# Try-except básico
try:
    nombre = int(input("Entrez un nombre: "))
    resultat = 10 / nombre
    print(f"10 / {nombre} = {resultat}")
except ValueError:
    print("Erreur: Veuillez entrer un nombre valide.")
except ZeroDivisionError:
    print("Erreur: Division par zéro impossible.")
except Exception as e:
    print(f"Une erreur inattendue s'est produite: {e}")
else:
    print("Aucune exception levée.")
finally:
    print("Ce bloc s'exécute toujours, qu'il y ait eu une exception ou non.")

# Lanzar excepciones
def verifier_age(age):
    if not isinstance(age, int):
        raise TypeError("L'âge doit être un nombre entier")
    if age < 0:
        raise ValueError("L'âge ne peut pas être négatif")
    return True

# Crear excepciones propias
class MajesteException(Exception):
    """Exception levée quand on manque de respect à Sa Majesté."""
    pass

def adresser_roi(message):
    if "votre majesté" not in message.lower():
        raise MajesteException("Il faut s'adresser au roi avec respect !")
    return "Le roi vous écoute."

Módulos y paquetes

# Importación de un módulo
import math
racine = math.sqrt(16)

# Importación específica
from datetime import datetime, timedelta
maintenant = datetime.now()
demain = maintenant + timedelta(days=1)

# Importación con alias
import numpy as np
tableau = np.array([1, 2, 3, 4, 5])

# Creación de un módulo
# archivo: mon_module.py
def saluer(nom):
    return f"Bonjour, {nom} !"

class MaClasse:
    pass

# En otro archivo
from mon_module import saluer, MaClasse

Bibliotecas populares

Análisis de datos

# Pandas para la manipulación de datos
import pandas as pd

# Creación de un DataFrame
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Ville': ['Paris', 'Lyon', 'Marseille']
})

# Selección de datos
personnes_paris = df[df['Ville'] == 'Paris']

# Operaciones estadísticas
age_moyen = df['Age'].mean()

# NumPy para el cálculo científico
import numpy as np

# Creación de un array
tableau = np.array([[1, 2, 3], [4, 5, 6]])

# Operaciones matemáticas
somme = np.sum(tableau)
moyenne = np.mean(tableau)

Visualización de datos

# Matplotlib
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [10, 15, 7, 12, 9]

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-o', linewidth=2, markersize=8)
plt.title('Mon Graphique')
plt.xlabel('Axe X')
plt.ylabel('Axe Y')
plt.grid(True)
plt.savefig('graphique.png')
plt.show()

# Seaborn
import seaborn as sns

# Definir un estilo
sns.set_theme(style="whitegrid")

# Crear un gráfico
tips = sns.load_dataset("tips")
sns.boxplot(x="day", y="total_bill", data=tips)
plt.title('Distribution des factures par jour')
plt.show()

Desarrollo web

# Flask
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def accueil():
    return render_template('index.html', titre='Mon Application Web')

@app.route('/utilisateur/<nom>')
def utilisateur(nom):
    return f'Bonjour, {nom} !'

if __name__ == '__main__':
    app.run(debug=True)

# Django (estructura de proyecto)
# mysite/
# ├── manage.py
# └── mysite/
#     ├── __init__.py
#     ├── settings.py
#     ├── urls.py
#     └── wsgi.py

Buenas prácticas en Python

Convenciones de nomenclatura

• Variables y funciones: snake_case (ejemplo: ma_variable, calculer_moyenne)
• Clases: PascalCase (ejemplo: MaClasse, GestionnaireDeConnexion)
• Constantes: UPPER_CASE (ejemplo: PI, MAX_TAILLE)
• Módulos: snake_case (ejemplo: mon_module.py)
• Variables “privadas”: prefijo _ (ejemplo: _variable_interne)

Estilo de código (PEP 8)

• Utilizar 4 espacios para la indentación (sin tabuladores)
• Limitar las líneas a 79 caracteres
• Dejar 2 líneas entre las definiciones de clases y de funciones de nivel superior
• Rodear los operadores con espacios: x = 1 + 2
• No dejar espacios antes de los paréntesis de las funciones: print(x)
• Añadir docstrings a sus funciones y clases

Documentación

def calculer_moyenne(nombres):
    """
    Calcule la moyenne d'une liste de nombres.
    
    Args:
        nombres (list): Une liste de nombres (int ou float)
        
    Returns:
        float: La moyenne des nombres
        
    Raises:
        TypeError: Si l'argument n'est pas une liste
        ValueError: Si la liste est vide
    """
    if not isinstance(nombres, list):
        raise TypeError("L'argument doit être une liste")
    if not nombres:
        raise ValueError("La liste ne peut pas être vide")
    return sum(nombres) / len(nombres)

Pruebas

# test_calculs.py
import unittest
from calculs import calculer_moyenne

class TestCalculs(unittest.TestCase):
    def test_calculer_moyenne(self):
        self.assertEqual(calculer_moyenne([1, 2, 3, 4, 5]), 3.0)
        self.assertEqual(calculer_moyenne([0, 0, 0]), 0.0)
        
    def test_calculer_moyenne_erreurs(self):
        with self.assertRaises(TypeError):
            calculer_moyenne("pas une liste")
        with self.assertRaises(ValueError):
            calculer_moyenne([])

if __name__ == '__main__':
    unittest.main()

Conclusión

Python es un lenguaje potente y flexible que puede utilizarse en numerosos ámbitos. Si dominas sus fundamentos, podrás:

• Automatizar tareas repetitivas
• Analizar y visualizar datos
• Crear aplicaciones web
• Desarrollar modelos de inteligencia artificial
• Construir herramientas y utilidades

Para ir más allá, explora las numerosas bibliotecas especializadas de Python e involúcrate en la activa comunidad que sigue haciendo evolucionar este lenguaje versátil y accesible.