La mayoría de la gente aprende Python, escribe código que funciona, hace sus cosillas y cree que con eso ya está. Y aquí va la verdad un poco incómoda: usar Python y usar Python bien no son lo mismo. Hay un salto muy concreto entre ambas cosas, y casi nadie te lo enseña.

El error no es que no sepas programar. El error es tratar el código como una lista de instrucciones sueltas: copiar y pegar el mismo cálculo en diez sitios, escribir rutas que solo funcionan en tu ordenador y rezar para que nada se rompa. Es el clásico "escribe y reza", pero con Python. A veces funciona. Muchas veces, no.

La diferencia entre un uso novato y un uso realmente profesional no está en escribir más líneas ni en prompts más largos. Está en cómo organizas el código, en cómo lo conectas con el mundo real y en cómo lo preparas para sobrevivir cuando las cosas fallan. Porque van a fallar.

En este artículo te llevo por ese salto paso a paso: funciones que no te obligan a repetirte, parámetros y valores de retorno, las librerías que te conectan con el exterior, APIs reales, una estructura de proyecto que escala y la gestión de errores que evita que tu programa explote. Cuando termines, vas a mirar tu código de otra manera.

Funciones: deja de copiar y pegar de una vez

Una función es simplemente un bloque de código reutilizable que lleva a cabo una tarea concreta. Lo escribes una sola vez y lo llamas tantas veces como quieras. Piensa en ella como una receta de cocina o como una máquina: metes algo, ocurre una tarea, y la puedes ejecutar cuando te dé la gana.

¿Por qué importan tanto? Por tres motivos que cambian tu forma de trabajar:

• No te repites. Escribes el código una vez en lugar de copiarlo y pegarlo por todo el fichero.
• Organizas. Rompes un programa complejo en piezas pequeñas. Dividir y vencerás.
• Arreglas errores en un solo sitio. Si hay un bug dentro de la función, lo corriges una vez y se arregla en todos los lugares donde se usa.

El patrón es siempre el mismo: la palabra reservada def, un nombre, paréntesis, dos puntos y el cuerpo indentado. Y ojo con el nombre, porque dice más de lo que crees. calcular_total o enviar_email te explican qué hacen de un vistazo. funcion_1 o Calculate no le dicen nada a nadie, ni siquiera a tu yo del futuro. Minúsculas, palabras separadas por guiones bajos y nombres descriptivos: parecen detalles, pero son la diferencia entre un código que se entiende y uno que da pereza tocar.

Variables locales y globales: el ámbito de visibilidad

Cuando defines una variable dentro de una función, esa variable es local: solo existe ahí dentro. Si intentas usarla fuera, Python te da un error porque, para el resto del programa, no existe. Una variable global, en cambio, se define fuera de cualquier función y se puede consultar desde dentro.

Modificar variables globales dentro de funciones se puede (con la palabra global), pero mi recomendación es que lo evites siempre que puedas. El código se vuelve difícil de seguir y de depurar: una variable que cambia "misteriosamente" dentro de una función es una fuente de dolores de cabeza. Es mucho más limpio pasar el valor como parámetro de entrada y devolverlo modificado. La función transforma, como esa máquina, en lugar de tocar cosas a escondidas.

Si quieres dominar esta base de forma ordenada y con proyectos reales, el curso completo de Python de la A a la Z recorre exactamente este camino desde cero.

Parámetros y valores de retorno: convierte tu función en una máquina flexible

Una función sin parámetros que solo sabe saludar a Juan es inútil: en cuanto quieras saludar a otra persona, estás vendido. En cambio, si le pasas el nombre como parámetro de entrada, la misma función sirve para saludar a cualquiera. Esa es la diferencia entre código rígido y código versátil.

Y hay un par de trucos que dan mucho juego:

• Valores por defecto: puedes asignar un valor por defecto a un parámetro (por ejemplo, que el saludo por defecto sea "Hola"). Eso sí, los parámetros con valor por defecto van siempre al final.
• Argumentos con nombre: si los nombras al llamar a la función, ya no importa el orden. Puedes pasar primero la ciudad, luego la edad y luego el nombre, y Python sabrá colocar cada cosa en su sitio.

La otra cara de la máquina es lo que devuelve. La palabra return saca un valor de la función para que lo uses en cualquier otra parte del código. Es clave entender la diferencia con print:

• ❌ print muestra algo por pantalla, pero ese valor se pierde: no lo puedes reutilizar.
• ✅ return devuelve el resultado para guardarlo en una variable y seguir trabajando con él.

Un detalle importante: en cuanto Python llega a un return, sale de la función. Todo lo que escribas después no se ejecuta. Y si necesitas devolver varios valores a la vez, puedes hacerlo con una tupla. Usa return cuando necesites el resultado para algo; usa print cuando solo quieras mostrar información.

Módulos, paquetes y pip: el superpoder de no reinventar la rueda

Aquí es donde Python despega de verdad. Por sí solo no llega muy lejos, pero su poder real es que puedes importar cualquier capacidad que necesites: hacer peticiones a internet, analizar datos como un profesional, leer ficheros de Excel... y muchas veces con apenas dos líneas de código.

Conviene tener claro el vocabulario, porque se mezcla mucho:

• Módulo: un fichero .py. La caja de herramientas.
• Paquete: una carpeta con varios módulos. El garaje lleno de cajas.
• Función: una herramienta concreta dentro de la caja.
• Clase: una plantilla para construir tus propias herramientas (eso ya es otro nivel).

Importar tiene varias formas: traerte la caja entera (import math), coger solo lo que necesitas (from math import sqrt, pi) o ponerle un alias para nombres largos (import numpy as np). Python trae muchos módulos de serie —random, datetime, os, json—, pero los grandes como Pandas, NumPy o requests hay que instalarlos.

Para eso está pip install (desde una terminal de verdad, no desde la consola de Python). Y cuando tu proyecto crece, el fichero requirements.txt guarda exactamente qué paquetes y versiones usas, para que cualquiera pueda recrear tu entorno con un solo comando. Hoy ya existen alternativas más modernas y rápidas como uv, pero el concepto es el mismo: tu entorno, controlado y reproducible.

APIs: cuando tu código empieza a hablar con el mundo real

Una API es como el camarero de un restaurante: tú pides algo, y te lo trae. En código, es el puente que conecta tu programa con otros sistemas: datos de un CRM, mensajes por Slack o Telegram, o modelos de inteligencia artificial como los de OpenAI o Anthropic. En el contexto de la IA, esto es esencial, porque es lo que conecta los modelos con tus datos y tus sistemas reales.

El ejemplo clásico para entenderlo es consultar el tiempo. Con la librería requests construyes una URL con tus coordenadas, haces la petición y recibes la respuesta, casi siempre en formato JSON. El reto está en que la información viene anidada: para llegar al dato que te interesa —la temperatura— tienes que navegar el diccionario clave a clave. Pero una vez lo tienes, puedes sacar la temperatura de París, Londres o Tokio con una sola función.

Y aquí ocurre la magia de verdad: combinas piezas. Pides los datos de los últimos 7 días con requests, los estructuras en un DataFrame de Pandas (esas tablas rectangulares de filas y columnas que tanto nos gustan en análisis de datos) y los visualizas con matplotlib. En un puñado de líneas pasas de una petición web a un gráfico guardado en disco y un CSV listo para reutilizar. Eso ya no es un script de juguete.

Si esto es lo que te llama, en las rutas de inteligencia artificial y en la formación de Python de Frogames trabajamos exactamente este flujo: de los datos en bruto a modelos y agentes que funcionan.

De script de escritorio a proyecto que escala

Hay una diferencia brutal entre un script suelto en el escritorio y un proyecto que puede crecer. Y la diferencia no está en el código, sino en cómo lo organizas.

El error clásico son las rutas hardcodeadas del tipo /Users/juan/escritorio/datos.csv: funcionan en tu máquina y petan en cualquier otra. La solución es trabajar con rutas relativas y una estructura de carpetas clara: una para el código, otra data para los datos y otra output para los resultados. Mantén separados los datos, el código y la salida, y tu proyecto se entenderá solo.

Las dos preguntas que resuelven los paths

Los paths son, probablemente, la parte más confusa cuando empiezas. A todos nos ha pasado. Y se simplifican muchísimo si te haces solo dos preguntas: ¿dónde estoy? (en qué carpeta se ejecuta tu código) y ¿dónde quiero ir? (dónde está el fichero o módulo que necesito). La instrucción os.getcwd() te dice siempre dónde estás antes de seguir adelante. Con eso, y sabiendo que .. sube un nivel, dejas de pelearte con los ficheros.

A medida que el proyecto crece, encapsular las funciones que repites en un módulo helper.py e importarlas donde haga falta mantiene tu código reutilizable, legible y fácil de probar. Escribes una vez, usas mil.

Leer y escribir datos: el pan de cada día en IA

Cuando trabajas con Python para inteligencia artificial, vas a tocar ficheros constantemente: CSV, Excel, JSON, texto plano... La buena noticia es que cada formato tiene su herramienta especializada y casi todo se reduce a un par de líneas:

• CSV: Pandas es tu mejor amigo con read_csv y to_csv.
• JSON: el módulo json o el propio Pandas, ideal porque es lo que devuelven las APIs.
• Excel: con openpyxl por debajo, perfecto cuando el destinatario es marketing o tu jefe.
• Texto: el caso más simple, con with open(...).

Ese with open no es un capricho: abre el fichero solo si existe y lo cierra solo cuando terminas, evitando que se quede abierto y se corrompa. Es el primer control de calidad de tu código, y te ahorra errores que de principiante cuesta semanas descubrir.

Gestión de errores: ¿tu código falla con elegancia o explota sin avisar?

El código organizado es maravilloso... hasta que falla. Y la pregunta no es si va a fallar, sino si lo hará con gracia o con un crash total. Todo lo que escribes asume que el mundo se va a portar bien: que el fichero existe, que la API responde, que el usuario mete un número y no un emoji. El mundo real no funciona así.

Hay errores que cometes tú (un typo, dividir por cero, usar una variable antes de definirla) y errores que se escapan a tu control (un usuario escribe "Antonio Banderas" donde esperabas una edad, internet se cae, un fichero desaparece). No puedes escribir "código perfecto" que los evite: el mundo es impredecible. Lo que sí puedes es gestionarlos.

La herramienta es el bloque try / except:

• try: dentro va la operación con riesgo de fallar (abrir un fichero, leer una entrada, dividir).
• except: aquí va el plan B que se ejecuta cuando salta ese error concreto.
• else: código que solo corre si todo ha ido bien.
• finally: código que se ejecuta siempre, haya error o no (ideal para cerrar ficheros y limpiar).

Conviene capturar errores concretos y no de cualquier manera: FileNotFoundError cuando el fichero no existe, ValueError cuando el dato no es lo que esperabas, ZeroDivisionError al dividir por cero, KeyError al pedir una clave que no está, IndexError al acceder a una posición inexistente o TypeError al mezclar tipos incompatibles. Y un consejo: nunca dejes un except vacío. Pon al menos un print que te diga qué ha fallado y dónde. Un error silencioso es peor que un error ruidoso.

Con esto, tu código deja de explotar: te dice qué ha ido mal, dónde, y sigue funcionando. Eso ya es Python de verdad.

La idea clave: de escribir instrucciones a construir sistemas

El verdadero cambio no va de memorizar más sintaxis. Va de pasar de escribir una lista de instrucciones a construir sistemas que se sostienen solos. Funciones que reutilizas, librerías que te dan superpoderes, proyectos bien estructurados y errores controlados antes de que se vuelvan inmanejables.

Quien siga copiando y pegando código suelto seguirá obteniendo resultados sueltos y frágiles. Quien aprenda a pensar en piezas reutilizables, conexiones con el mundo real y código que sobrevive a los fallos, tendrá una ventaja enorme, sobre todo ahora que la siguiente frontera son la programación orientada a objetos y los agentes de inteligencia artificial.

Si quieres recorrer este camino de forma estructurada —y de paso obtener diplomas blockchain que hagan crecer tu perfil—, échale un vistazo a las rutas de aprendizaje de Frogames, con decenas de cursos en Python, análisis de datos e inteligencia artificial, o sigue leyendo más recursos en el blog de Frogames.

Deja de escribir código y rezar. Organiza, conecta y construye. Ahí empieza el uso serio de Python.