DEV Community: Tu codigo cotidiano

How to Organize Python Code with Modules and Packages — A Practical Beginner Guide

Tu codigo cotidiano — Thu, 03 Sep 2026 15:54:20 +0000

A Python program can work perfectly and still become difficult to maintain.

That usually happens when one file slowly starts doing everything:

program.py

├── register expenses
├── save CSV files
├── calculate totals
├── generate reports
└── run the program

Nothing is necessarily broken.

The problem is that finding and changing one responsibility starts requiring you to understand several unrelated parts of the file.

The first useful question

When a Python project grows, don't start by asking:

How many lines should a file have?

A better question is:

Which responsibilities belong together, and which ones should be able to change separately?

For example, an expense tracker could evolve from one large file into:

expense_tracker/
├── main.py
└── finance/
├── init.py
├── expenses.py
├── files.py
└── reports.py

Now the structure itself tells us something:

expenses.py handles expense logic.

files.py handles persistence.

reports.py handles calculations and summaries.

main.py coordinates the program.

That is the real value of modules and packages: they help the code communicate its structure.

A tiny example

Instead of keeping every function in main.py, we can create a module:

file: finance/expenses.py

def add_expense(expenses, date, category, amount):
expenses.append({
"date": date,
"category": category,
"amount": amount
})

Then use it from another file:

file: main.py

from finance.expenses import add_expense

expenses = []

add_expense(
expenses,
"2026-09-02",
"Food",
18000
)

The behavior is simple, but the important change is architectural:

the responsibility now has a clear home.

The mistake to avoid

Learning modules doesn't mean creating one file for every function.

This:

calculator/
├── add.py
├── subtract.py
├── multiply.py
└── divide.py

is not automatically better than:

calculator.py

More files do not always mean better organization.

The goal is not fragmentation.

The goal is clarity.

Want the full visual walkthrough?

I wrote a complete step-by-step guide in Spanish on TuCódigoCotidiano.

It covers:

modules and packages;

import;

init.py;

if name == "main";

absolute and relative imports;

circular imports;

pycache;

when to split code — and when not to.

👉 Read the complete guide:

https://tucodigocotidiano.yarumaltech.com/leer_guias/modulos-y-paquetes-organiza-tu-codigo-sin-perderte/

If you're moving from small Python scripts to projects with multiple files, this is exactly the transition the guide is designed to explain.

¿Qué ocurre realmente cuando ejecutas un contenedor Docker?

Tu codigo cotidiano — Mon, 31 Aug 2026 15:10:41 +0000

¿Qué ocurre realmente cuando ejecutas un contenedor Docker?

Escribes:

docker run nginx

Unos segundos después nginx está funcionando.

Puede parecer que Docker acaba de crear una pequeña computadora dentro de tu computador.

Pero eso no es realmente lo que ocurre.

Todo comienza con una imagen

Docker necesita una imagen que contenga los elementos necesarios para ejecutar la aplicación.

Las imágenes normalmente están construidas mediante capas.

Eso permite reutilizar partes que ya existen en el sistema y evita descargar o almacenar todo nuevamente.

Después aparece el contenedor

Docker utiliza la imagen como base y crea un entorno donde ejecutará la aplicación.

Aquí aparece una diferencia fundamental:

una imagen y un contenedor no son lo mismo.

La imagen es reutilizable.

El contenedor es una instancia creada a partir de ella.

En el fondo hay procesos

En Linux, un contenedor no necesita ejecutar un sistema operativo completo independiente.

La aplicación se ejecuta como uno o varios procesos que comparten el kernel del host.

Entonces, ¿cómo consigue Docker que parezca un entorno independiente?

Namespaces: aislamiento

Linux dispone de mecanismos llamados namespaces.

Gracias a ellos, un proceso puede tener una visión aislada de elementos como:

procesos
interfaces de red
puntos de montaje
usuarios
hostname

Para la aplicación, parece que existe dentro de su propio entorno.

Cgroups: controlar recursos

También necesitamos evitar que un contenedor consuma todos los recursos de la máquina.

Para eso Linux dispone de los cgroups.

Permiten gestionar y contabilizar recursos como:

CPU
memoria
entrada y salida

Docker utiliza estos mecanismos para aplicar límites a los contenedores.

¿Qué ocurre con la red?

Docker también puede crear redes virtuales.

Por ejemplo:

docker run -p 8080:80 nginx

Aquí estamos indicando que el tráfico recibido en el puerto 8080 del host pueda llegar al puerto 80 utilizado por nginx dentro del contenedor.

¿Y los datos?

Un contenedor puede eliminarse.

Pero nuestros datos muchas veces deben sobrevivir.

Para eso existen los volúmenes.

Los volúmenes permiten almacenar información fuera de la capa efímera del contenedor.

Son especialmente importantes cuando trabajamos con bases de datos.

Entonces, ¿qué hay detrás de `docker run`?

Podemos visualizarlo así:

IMAGEN
   ↓
PROCESO
   ↓
AISLAMIENTO
   ↓
CONTROL DE RECURSOS
   ↓
RED
   ↓
ALMACENAMIENTO
   ↓
CONTENEDOR

Docker hace que toda esta coordinación parezca sencilla.

Y esa es precisamente una de sus mayores virtudes.

🎧 En Tu Código Cotidiano preparé un episodio corto explicando todo este recorrido:

¿Qué ocurre dentro de Docker cuando ejecutas un contenedor?

https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/que-ocurre-dentro-de-docker-cuando-ejecutas-un-contenedor/

Tu programa funciona… pero olvida todo: persistencia de datos con Python

Tu codigo cotidiano — Thu, 27 Aug 2026 20:16:50 +0000

Tu programa funciona… pero olvida todo

Imagina que estás creando un pequeño programa en Python para registrar gastos:

gastos = []

gastos.append({
    "categoria": "Comida",
    "valor": 18000
})

print(gastos)

Todo funciona.

Pero cierras el programa, lo ejecutas nuevamente y gastos vuelve a estar vacío.

¿Por qué?

Porque tener información dentro de una variable no significa haberla guardado permanentemente.

Memoria no es persistencia

Mientras nuestro programa está ejecutándose puede trabajar con listas, diccionarios, números y otros objetos.

Pero si queremos encontrar esa información después de cerrar el programa necesitamos representarla fuera de ese ciclo de ejecución.

Una de las formas más sencillas de hacerlo es utilizando archivos.

with open("nota.txt", "w", encoding="utf-8") as archivo:
    archivo.write("Mi primer dato persistente")

Ahora la información puede continuar existiendo incluso después de que Python termine.

Tres letras importantes: r, w y a

Cuando empezamos a trabajar con archivos hay tres modos especialmente útiles:

r → leer
w → escribir desde cero
a → añadir

Hay que tener especial cuidado con w: si el archivo ya contenía información, podemos reemplazarla.

Si queremos añadir algo sin borrar lo anterior:

with open("nota.txt", "a", encoding="utf-8") as archivo:
    archivo.write("\nOtra línea")

¿TXT, CSV o JSON?

Una forma sencilla de pensarlo es observar la estructura de nuestros datos.

TXT

Útil cuando queremos guardar texto sencillo.

CSV

Tiene sentido cuando nuestros datos se parecen a una tabla:

fecha,categoria,valor
2026-08-27,Comida,18000
2026-08-27,Transporte,6500

Python incluye el módulo csv, por lo que no necesitamos construir el archivo concatenando comas manualmente.

JSON

Empieza a resultar interesante cuando nuestros datos contienen claves, listas, números, booleanos o estructuras anidadas.

La decisión no consiste simplemente en memorizar tres extensiones.

Consiste en preguntarnos:

¿qué forma tienen mis datos?

Ese cambio de perspectiva hace mucho más sencillo entender la persistencia.

Preparé una guía completa en español donde desarrollamos el recorrido desde memoria y archivos TXT hasta CSV y JSON, con ejemplos paso a paso:

👉 https://tucodigocotidiano.yarumaltech.com/leer_guias/archivos-de-texto-csv-y-json-datos-que-sobreviven-al-programa/

Una frase resume bastante bien todo el concepto:

El programa puede terminar. Los datos no tienen por qué desaparecer.

Python Didn't Crash. The Result Was Still Wrong.

Tu codigo cotidiano — Wed, 26 Aug 2026 20:50:27 +0000

One of the most dangerous bugs isn't a SyntaxError.

It isn't an exception.

It doesn't even produce a traceback.

Sometimes Python executes your entire program successfully...

…and gives you the wrong answer.

Consider this:

def calcular_total(precios, descuento):
subtotal = sum(precios)
total = subtotal - descuento
return total

precios = [120000, 80000]
descuento = 0.10

print(calcular_total(precios, descuento))

Expected:

180000

Actual:

199999.9

Python isn't broken.

Our assumption is.

And that's where debugging becomes much more interesting.

A mistake I made when learning to debug was asking:

“What should I print?”

A better question is:

“What do I need to observe to prove or reject my hypothesis?”

That changes debugging from guessing into an experiment:

Reproduce → Hypothesis → Measure → Evidence → Conclusion

For example:

Are the inputs correct?
Is subtotal correct?
Is descuento what we expect?
At which exact operation does the state become wrong?

Once you know that:

subtotal = 200000 ✓
descuento = 0.10 ✓

the search space becomes tiny.

The suspicious operation is now:

subtotal - descuento

That's the real goal of debugging:

Turn “something is wrong” into one small, testable question.

I wrote a practical guide showing this process with print(), type(), repr(), breakpoint() and step-by-step state inspection.

Full guide:
https://tucodigocotidiano.yarumaltech.com/leer_guias/depuracion-aprende-a-encontrar-el-error-antes-de-culpar-a-python/

Python Exceptions: From a Crashing Program to Controlled Error Handling

Tu codigo cotidiano — Mon, 24 Aug 2026 23:50:50 +0000

What should your Python program do when reality doesn’t follow the happy path?

I published a new practical guide on errors and exceptions in Python.

Instead of starting by memorizing try, except, else, and finally, the guide begins with a program that crashes because of unexpected input and builds the solution step by step.

It covers traceback reading, ValueError, ZeroDivisionError, specific exception handling, else, finally, raise, common mistakes, and a final program that survives invalid input.

The main idea:

Exception handling is not about hiding errors. It is about designing what your program should do when something goes wrong.

Full guide in Spanish:
https://tucodigocotidiano.yarumaltech.com/leer_guias/errores-y-excepciones-en-python-evita-que-tu-programa-muera-en-el-intento/

De Ionic a PostgreSQL: qué ocurre realmente cuando creamos una tarea

Tu codigo cotidiano — Tue, 18 Aug 2026 20:41:48 +0000

De Ionic a Posts una tarea

Aprender Django, Angular o PostgreSQL por separado es relativamente sencillo.

El verdadero salto ocurre cuando intentamos entender cómo todas esas tecnologías colaboran dentro de una aplicación real.

Supongamos que tenemos una aplicación móvil para administrar tareas y el usuario pulsa:

Crear tarea

¿Qué ocurre después?

La respuesta completa se parece a esto:

Ionic / Angular
      ↓
   HTTP + JSON
      ↓
Django REST Framework
      ↓
   Django ORM
      ↓
PostgreSQL

1. Angular recoge la información

El formulario mantiene temporalmente valores como:

título;
descripción;
estado;
fecha límite.

Pero esos datos todavía no forman parte del estado permanente del sistema.

2. El cliente construye una petición HTTP

Angular utiliza un servicio para enviar los datos hacia nuestra API.

El frontend no debería conectarse directamente a PostgreSQL.

Su trabajo es solicitar una operación al backend.

3. Django REST Framework recibe el JSON

Aquí comienza una de las partes más importantes.

El servidor no debería confiar ciegamente en lo enviado desde la interfaz.

Django REST Framework valida el contrato de la petición y permite que las reglas del dominio permanezcan centralizadas en el servidor.

4. El backend aplica las reglas

Una tarea puede tener, por ejemplo, solamente tres estados válidos:

pendiente;
pospuesta;
completada.

También podemos implementar reglas como:

identificar tareas próximas a vencer;
conservar información de auditoría;
asignar usuarios;
realizar eliminación lógica en lugar de destruir registros.

Estas decisiones pertenecen al dominio de la aplicación, no simplemente a la interfaz.

5. El ORM persiste la información

Una vez validada la operación, Django utiliza su ORM para escribir los cambios en PostgreSQL.

Ahora sí existe una representación persistente de la tarea.

6. La API responde

Django REST Framework serializa nuevamente la entidad y devuelve JSON al cliente.

7. Ionic actualiza la interfaz

Angular recibe la respuesta y actualiza el estado visible de la aplicación.

Tenemos entonces un ciclo completo:

interfaz → API → reglas → persistencia → API → interfaz

Y esa misma arquitectura puede reutilizarse cuando llevamos la aplicación a Android utilizando Ionic y Capacitor.

Construí un tutorial completo donde implementamos este proyecto paso a paso utilizando:

Django REST Framework
PostgreSQL
Docker
Angular
Ionic
CaD, filtros, soft delete, auditoría, cambios de estado y tareas próximas a vencer.

👉 Tutorial completo en español:

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/construye-una-app-fullstack-con-django-rest-postgresql-angular-ionic-y-android/

Si estás aprendiendo arquitectura fullstack, mi recomendación es que no te concentres únicamente en hacer funcionar cada tecnología.

Intenta seguir el recorrido completo de una sola operación desde la pantalla hasta la base de datos y de vuelta.

Ahí es donde muchas piezas empiezan a tener sentido.

What Physically Happens When You Ask an AI a Question?

Tu codigo cotidiano — Tue, 11 Aug 2026 22:18:14 +0000

We often think about artificial intelligence as something purely digital.

You type a question.

Press Enter.

A few seconds later, an answer appears.

But physically, a surprising amount of infrastructure has been involved during those few seconds.

Your question first travels through networking infrastructure toward a data center. There, the text is transformed into tokens that can be processed by an AI model.

Specialized hardware—often GPUs or other accelerators—performs billions of mathematical operations to calculate what should come next.

That computation requires electricity.

Electricity produces heat.

Heat requires cooling.

And all of this happens while networking systems move information between your device, servers, memory, storage and computing accelerators.

In other words, an AI response is not simply “generated by software.”

It is the result of a physical chain involving:

Networks
Data centers
GPUs and accelerators
Memory
Electricity
Cooling systems
Large-scale distributed computing

I recently explored this idea in a new episode of TuCodigoCotidiano:

🎧 ¿Qué ocurre físicamente cuando le preguntas algo a una IA?

https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/que-ocurre-fisicamente-cuando-le-preguntas-algo-a-una-ia/

The episode is in Spanish and focuses on understanding the physical infrastructure behind something we now do every day: asking an AI a question.

ai #machinelearning #computerscience #technology

Build a Personal Expense Tracker in Python: From Fundamentals to a Real Terminal App

Tu codigo cotidiano — Tue, 28 Jul 2026 12:06:08 +0000

Learning Python syntax is one thing.

Using variables, conditionals, loops, lists, dictionaries, and functions together to build an actual program is where things start to become much more interesting.

I published a new step-by-step project in TuCodigoCotidiano where we build a personal expense tracker that runs entirely in the terminal.

The guide is written in Spanish and is designed for people who already know the basic Python concepts but want to understand how those pieces fit together inside a real application.

What we build

The project starts small.

A single expense becomes a dictionary.

Multiple expenses become a list of dictionaries.

Then we gradually add functions until the program can:

Register income
Register expenses
Display transactions
Calculate total income
Calculate total expenses
Calculate the current balance
Group expenses by category
Validate user input
Run through an interactive terminal menu
Save data to JSON
Load previous data when the program starts again

The final structure is intentionally simple:

problem → data → functions → interaction → validation → persistence → application

No classes.

No database.

No external libraries.

Just Python and the standard library.

Why I built the tutorial this way

A common beginner experience is learning concepts independently:

if

for

lists

dictionaries

functions

But knowing those concepts does not automatically explain how to design a program.

So instead of starting with a large finished script, the project begins with a practical question:

What would a program need to do to help you understand where your money is going?

From there, every new piece of code solves one specific part of the problem.

The goal is not only to finish an expense tracker.

The goal is to understand how a real program grows from a simple idea.

Read the complete project

🐍 Construye un gestor de gastos personales en la terminal

https://tucodigocotidiano.yarumaltech.com/leer_guias/construye-un-gestor-de-gastos-personales-en-la-terminal/#del-problema-cotidiano-al-programa

The complete tutorial is in Spanish and includes the code, explanations, visual diagrams, validation, JSON persistence, testing ideas, common mistakes, and challenges to extend the project.

If you were extending this project, what would you build next: budgets, dates, search, editing transactions, or something else?

The Electromagnetic Spectrum: The Invisible Infrastructure Behind Our Connected World

Tu codigo cotidiano — Mon, 27 Jul 2026 14:13:34 +0000

Before getting out of bed, you have probably already used one of the most important infrastructures in the modern world.

You checked your phone, received a message, or connected to Wi-Fi.

None of those actions would be possible without the electromagnetic spectrum.

An invisible network around us

Radio, Wi-Fi, Bluetooth, mobile networks, television, satellite communications, and many navigation systems use specific regions of the electromagnetic spectrum.

Although these technologies may appear unrelated, they all transmit information using electromagnetic waves.

What changes between them is mainly their frequency, wavelength, transmission power, and method of encoding information.

Even visible light belongs to this same family. Our eyes simply detect a very small portion of a much larger spectrum.

Frequencies as invisible lanes

Imagine hundreds of people speaking inside the same room at the same time.

Without separate conversations, turns, or channels, understanding anyone would become extremely difficult.

Something similar happens with wireless communications.

Different services use different frequency bands to reduce interference. Mobile networks, aviation, emergency services, weather systems, radio stations, and satellites must operate under carefully coordinated rules.

These frequencies work like invisible lanes through which information travels.

Some frequencies can cover long distances and pass through obstacles more effectively. Others can carry larger amounts of information but require more antennas or clearer paths between transmitter and receiver.

Internet is not a magical cloud

Wireless signals are only one part of the journey.

After reaching an antenna, information may continue through base stations, fiber-optic cables, data centers, and satellite links.

Fiber optics also use electromagnetic radiation, transmitting information through pulses of light.

The connected world therefore combines two major routes:

Electromagnetic waves travelling through the air.
Light pulses travelling through fiber-optic cables.

Together, they support everything from everyday messages to aircraft navigation, weather alerts, emergency communications, and space exploration.

Listen to the episode

In this Spanish-language episode of TuCódigoCotidiano, Javier and Laura explore the electromagnetic spectrum and explain why it can be understood as the invisible infrastructure of modern society.

🎧 Listen here:

https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/el-espectro-electromagnetico-la-infraestructura-invisible/

Cities have visible roads for vehicles and electromagnetic roads for information.

Although we cannot see them, their design determines how connected, secure, and resilient our society can become.

Python Functions for Beginners: Stop Repeating Code and Start Reusing Solutions

Tu codigo cotidiano — Fri, 24 Jul 2026 14:10:27 +0000

Copying a few lines of code may seem harmless.

But what happens when the same instructions appear three, five, or ten times throughout your program?

A small change suddenly requires editing several places. One forgotten copy may behave differently from the others, and the program becomes harder to understand and maintain.

This is one of the problems that functions help us solve.

If a task appears several times, it probably needs a name.

A function turns a group of related instructions into a reusable solution that we can execute whenever we need it.

The problem with repeated code

Imagine that we need to calculate the total price of several purchases:

product_1 = "notebook"
price_1 = 8500
quantity_1 = 3
total_1 = price_1 * quantity_1

print(f"{quantity_1} units of {product_1} cost ${total_1}")

product_2 = "pencil"
price_2 = 2000
quantity_2 = 5
total_2 = price_2 * quantity_2

print(f"{quantity_2} units of {product_2} cost ${total_2}")

The program works, but the same procedure is repeated:

Receive a product.
Receive its price.
Receive a quantity.
Calculate the total.
Display the result.

Instead of copying that procedure every time, we can create a function and give the task a descriptive name.

Creating a function with `def`

In Python, a function definition begins with the def keyword:

def greet():
    print("Hello! Welcome to Python.")

This definition contains several important parts:

def tells Python that we are defining a function.
greet is the function name.
() contains the function parameters.
: marks the beginning of the function body.
The indented instructions belong to the function.

Defining a function does not execute it automatically.

To run its instructions, we must call it:

def greet():
    print("Hello! Welcome to Python.")

greet()
greet()

Each call executes the function body again.

This distinction is essential:

A function definition describes a task. A function call asks Python to perform it.

Parameters and arguments

Our first function always displays the same message.

To make it work with different values, we can add a parameter:

def greet(name):
    print(f"Hello, {name}. Welcome to Python.")

greet("Laura")
greet("Carlos")
greet("Sofia")

In this example:

name is a parameter.
"Laura", "Carlos", and "Sofia" are arguments.

A parameter represents the information that a function expects to receive.

An argument is the actual value provided when the function is called.

The same function can therefore process different data without changing its internal instructions.

Using multiple parameters

A function can receive more than one value:

def show_total(product, price, quantity):
    total = price * quantity
    print(f"{quantity} units of {product} cost ${total}")

show_total("notebook", 8500, 3)
show_total("pencil", 2000, 5)

Python matches positional arguments with parameters according to their order:

"notebook" → product
8500       → price
3          → quantity

For this reason, both the number and order of the arguments matter.

The calculation logic now exists in only one place. We can reuse it with as many products as necessary.

Returning results with `return`

The previous function displays the calculated total.

But what happens when another part of the program needs to use that value?

This is where return becomes important:

def calculate_total(price, quantity):
    total = price * quantity
    return total

The returned value can be stored in a variable:

notebook_total = calculate_total(8500, 3)
pencil_total = calculate_total(2000, 5)

print(notebook_total)
print(pencil_total)

It can also participate in another operation:

grand_total = notebook_total + pencil_total
print(grand_total)

A returned value is not limited to being displayed.

The program can store it, compare it, transform it, send it to another function, or use it in a larger calculation.

`print()` and `return` are not the same

This is one of the most important distinctions when learning Python functions.

Consider these two examples:

def show_double(number):
    print(number * 2)


def calculate_double(number):
    return number * 2

Both functions calculate the same value, but they do different things.

show_double() displays the value:

show_double(5)

Its output is:

calculate_double() returns the value:

result = calculate_double(5)
print(result + 4)

Its output is:

A useful way to remember the difference is:

print() communicates a value to the user.
return gives the value back to the program.

Use print() when the main purpose is to display information.

Use return when the result must continue participating in the program.

Why does a function return `None`?

Every Python function call produces a result.

When a function finishes without an explicit return, Python automatically returns None.

Consider this example:

def show_total(price, quantity):
    print(price * quantity)

result = show_total(8500, 3)

print(result)

The output will be:

25500
None

The function displayed 25500, but it did not return that number.

Therefore, the value stored in result is None.

None does not mean zero, an empty string, or an error.

It represents the absence of a useful returned value.

Common beginner mistakes

1. Forgetting the parentheses

Writing the function name by itself refers to the function:

greet

Adding parentheses calls it:

greet()

The first expression identifies the function object. The second expression executes the function.

2. Sending the wrong number of arguments

A function with three required parameters expects three corresponding arguments:

def show_total(product, price, quantity):
    return price * quantity

This call is incomplete:

show_total("notebook", 8500)

Python will report an error because the quantity argument is missing.

The correct call is:

show_total("notebook", 8500, 3)

3. Sending arguments in the wrong order

Consider this function:

def show_total(product, price, quantity):
    return price * quantity

This call uses the correct number of arguments but places them incorrectly:

show_total(8500, "notebook", 3)

Python will assign:

8500       → product
"notebook" → price
3          → quantity

The names of positional parameters do not automatically identify the arguments. Their position determines how Python assigns them.

4. Trying to calculate with a function that only prints

This function displays a value but returns None:

def show_double(number):
    print(number * 2)

Therefore, this operation will fail:

result = show_double(5)
print(result + 4)

The function prints 10, but result contains None.

To reuse the calculated value, return it instead:

def calculate_double(number):
    return number * 2

result = calculate_double(5)
print(result + 4)

A practical example

Let us create a function that calculates the price of a purchase after applying a discount:

def calculate_discounted_price(price, discount_percentage):
    discount = price * discount_percentage / 100
    final_price = price - discount
    return final_price

We can now use the same solution with different values:

first_product = calculate_discounted_price(100000, 10)
second_product = calculate_discounted_price(80000, 15)

print(first_product)
print(second_product)

The output is:

90000.0
68000.0

We can also combine the returned values:

purchase_total = first_product + second_product
print(purchase_total)

This demonstrates the main advantage of return: the results can continue moving through the program.

A better way to think about functions

Functions are more than a Python syntax feature.

They help us:

Divide large problems into smaller tasks.
Give meaningful names to those tasks.
Avoid repeating instructions.
Make changes in one place.
Test individual pieces of logic.
Reuse solutions with different data.
Combine small solutions into larger programs.

When deciding whether to create a function, ask:

Does this task appear more than once?
Can I describe the task with a clear name?
Which information does the task need?
Should the function display something or return a result?
Will another part of the program need the result?

These questions transform functions from a syntax exercise into a tool for designing better programs.

Final challenge

Create a function called calculate_average that receives three grades and returns their average.

Start with this structure:

def calculate_average(grade_1, grade_2, grade_3):
    # Write your solution here
    pass

Then store the result and display it:

student_average = calculate_average(4.5, 3.8, 4.2)
print(student_average)

As an additional challenge, create another function that receives the average and returns either "Passed" or "Failed".

Continue learning

I published a complete illustrated Spanish guide that explains these concepts with additional examples, practical exercises, and common mistakes:

👉 https://tucodigocotidiano.yarumaltech.com/leer_guias/funciones-divide-los-problemas-y-reutiliza-soluciones/

What confused you the most when you first learned functions: parameters, arguments, return, or None?

Python Dictionaries and Sets: Organize Named Data and Remove Duplicates

Tu codigo cotidiano — Tue, 21 Jul 2026 16:44:17 +0000

When we start learning Python, lists are often one of the first data structures we use:

student = ["Laura", 24, "Medellín"]

This works, but what does each position represent?

We need to remember that:

Position 0 contains the name.
Position 1 contains the age.
Position 2 contains the city.

A dictionary provides a clearer alternative because every value is identified by a descriptive key.

Creating a dictionary

A dictionary stores information as key-value pairs:

student = {
    "name": "Laura",
    "age": 24,
    "city": "Medellín"
}

Instead of asking for the value at position 0, we can ask directly for the value associated with "name":

print(student["name"])

Output:

Laura

A useful way to remember the difference is:

A list position tells you where a value is. A dictionary key tells you what the value means.

Updating and adding information

Python dictionaries are mutable, so their content can change after creation.

To update an existing value:

product = {
    "name": "Keyboard",
    "price": 120000
}

product["price"] = 110000

To add a new key-value pair, use the same syntax with a key that does not exist yet:

product["available"] = True

The resulting dictionary is:

{
    "name": "Keyboard",
    "price": 110000,
    "available": True
}

Safely reading values with `get()`

Using square brackets requires the key to exist:

print(student["email"])

If "email" is missing, Python raises a KeyError.

The get() method provides a safer alternative:

print(student.get("email"))

It returns None when the key is missing.

You can also define a default value:

print(student.get("email", "Not registered"))

Output:

Not registered

To check whether a key exists, use the in operator:

if "city" in student:
    print(student["city"])

Keys, values, and pairs

Python provides three useful dictionary methods:

course = {
    "name": "Python Basics",
    "duration": "4 weeks",
    "format": "Online"
}

print(course.keys())
print(course.values())
print(course.items())

They provide different views of the same information:

keys() returns the keys.
values() returns the stored values.
items() returns complete key-value pairs.

Looping through a dictionary

The items() method is especially useful when working with a for loop:

capitals = {
    "Colombia": "Bogotá",
    "Peru": "Lima",
    "Argentina": "Buenos Aires"
}

for country, capital in capitals.items():
    print(f"{country}: {capital}")

Output:

Colombia: Bogotá
Peru: Lima
Argentina: Buenos Aires

During every iteration, Python assigns the current key to country and its associated value to capital.

What is a set?

A set is a collection that stores unique values.

Consider this list:

languages = ["Python", "Rust", "Python", "JavaScript", "Rust"]

We can remove repeated values by converting it into a set:

unique_languages = set(languages)

print(unique_languages)

The set keeps only one occurrence of each language.

Sets are useful when you need to:

Remove duplicate values.
Check whether a value is present.
Compare groups of elements.
Work with unique categories or identifiers.

Unlike lists, sets do not support indexes or slicing.

An important detail

Empty braces create an empty dictionary:

empty_dictionary = {}

To create an empty set, use set():

empty_set = set()

This is a common source of confusion for Python beginners.

Which structure should you choose?

Use a list when position and order are important.

Use a dictionary when every value should have a descriptive name.

Use a set when you need unique values and repetitions do not matter.

Understanding this distinction makes programs easier to read, maintain, and extend.

The original Spanish guide includes a step-by-step explanation with additional examples:

https://tucodigocotidiano.yarumaltech.com/leer_guias/diccionarios-y-conjuntos-datos-con-nombre-y-sin-duplicados/

What was more confusing when you first learned Python: dictionaries or sets?

Python Lists and Tuples for Beginners: Organize Data Step by Step

Tu codigo cotidiano — Thu, 16 Jul 2026 11:46:35 +0000

When you start learning Python, storing information in individual variables feels natural:

student_1 = "Ana"
student_2 = "Luis"
student_3 = "Marta"

However, this approach becomes difficult to maintain as the amount of information grows.

Python lists allow us to group related values inside a single ordered collection:

students = ["Ana", "Luis", "Marta"]

Now we can access each element using its index:

print(students[0]) # Ana
print(students[-1]) # Marta

Because lists are mutable, their elements can be updated after creation:

students[1] = "Carlos"

We can also add new information using append() or insert():

students.append("Laura")
students.insert(1, "Daniel")

To remove elements, Python provides methods such as remove() and pop():

students.remove("Ana")
removed_student = students.pop(1)

Lists can also be inspected without modifying them:

print(len(students))
print("Laura" in students)
print("Pedro" not in students)

Another useful operation is slicing, which lets us obtain part of a list:

numbers = [10, 20, 30, 40, 50]

print(numbers[1:4])
print(numbers[:3])
print(numbers[3:])

Lists are ideal when the information may change. Tuples, on the other hand, are useful when the values should remain stable.

Understanding both structures is an essential step toward building cleaner programs, processing collections of data, and working with loops, functions, APIs, and databases.

I created a practical, beginner-friendly guide explaining these concepts step by step, with examples in Spanish.

📖 Read the complete guide:

https://tucodigocotidiano.yarumaltech.com/leer_guias/listas-y-tuplas-organiza-informacion-en-orden/

What was the first real project where you needed to use a Python list?

DEV Community: Tu codigo cotidiano

How to Organize Python Code with Modules and Packages — A Practical Beginner Guide

file: finance/expenses.py

file: main.py

¿Qué ocurre realmente cuando ejecutas un contenedor Docker?

¿Qué ocurre realmente cuando ejecutas un contenedor Docker?

Todo comienza con una imagen

Después aparece el contenedor

En el fondo hay procesos

Namespaces: aislamiento

Cgroups: controlar recursos

¿Qué ocurre con la red?

¿Y los datos?

Entonces, ¿qué hay detrás de docker run?

Tu programa funciona… pero olvida todo: persistencia de datos con Python

Tu programa funciona… pero olvida todo

Memoria no es persistencia

Tres letras importantes: r, w y a

¿TXT, CSV o JSON?

Python Didn't Crash. The Result Was Still Wrong.

Python Exceptions: From a Crashing Program to Controlled Error Handling

De Ionic a PostgreSQL: qué ocurre realmente cuando creamos una tarea

De Ionic a Posts una tarea

1. Angular recoge la información

2. El cliente construye una petición HTTP

3. Django REST Framework recibe el JSON

4. El backend aplica las reglas

5. El ORM persiste la información

6. La API responde

7. Ionic actualiza la interfaz

What Physically Happens When You Ask an AI a Question?

ai #machinelearning #computerscience #technology

Build a Personal Expense Tracker in Python: From Fundamentals to a Real Terminal App

What we build

Why I built the tutorial this way

Read the complete project

The Electromagnetic Spectrum: The Invisible Infrastructure Behind Our Connected World

An invisible network around us

Frequencies as invisible lanes

Internet is not a magical cloud

Listen to the episode

Python Functions for Beginners: Stop Repeating Code and Start Reusing Solutions

The problem with repeated code

Creating a function with def

Parameters and arguments

Using multiple parameters

Returning results with return

print() and return are not the same

Why does a function return None?

Common beginner mistakes

1. Forgetting the parentheses

2. Sending the wrong number of arguments

3. Sending arguments in the wrong order

4. Trying to calculate with a function that only prints

A practical example

A better way to think about functions

Final challenge

Continue learning

Python Dictionaries and Sets: Organize Named Data and Remove Duplicates

Creating a dictionary

Updating and adding information

Safely reading values with get()

Keys, values, and pairs

Looping through a dictionary

What is a set?

An important detail

Which structure should you choose?

Python Lists and Tuples for Beginners: Organize Data Step by Step

Entonces, ¿qué hay detrás de `docker run`?

Creating a function with `def`

Returning results with `return`

`print()` and `return` are not the same

Why does a function return `None`?

Safely reading values with `get()`