Python Scouts

Estructuras de datos en Python: Colas (queues)

2026-04-11T12:55:00+02:00

En este artículo, aprenderás cómo implementar una cola en Python, incluyendo sus operaciones y características principales.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué es una cola o queue?
Operaciones comunes en una cola
Implementación de una cola en Python
Ejemplo de uso de la cola
Conclusión

¿Qué es una cola o queue?

Una cola es una colección de elementos que permite añadir elementos por un extremo y retirarlos por el extremo opuesto.

Esta estructura de datos es ampliamente utilizada en la gestión de tareas, la programación de procesos, la simulación de eventos y los algoritmos.

Las características fundamentales de una cola incluyen las siguientes:

FIFO (First In, First Out): El primer elemento que entró es el primero que sale.
Dos extremos: Los elementos se añaden por la parte trasera (enqueue) y se retiran por la parte delantera (dequeue).
Tamaño dinámico: La cola crece o decrece conforme añades o eliminas elementos.

En Python, las colas no están disponibles como una estructura de datos integrada. La librería estándar incluye el módulo queue que está orientado sobre todo a la comunicación entre hilos (threads). Para implementar tu propia cola, también puedes usar collections.deque, que suele ser una opción práctica porque ofrece inserciones y eliminaciones eficientes en ambos extremos.

Operaciones comunes en una cola

A continuación, un resumen de las operaciones que soportará tu cola:

Operación	Descripción
`queue = Queue()`	Construye una cola vacía.
`queue = Queue(iterable)`	Construye una cola con elementos de `iterable`.
`queue.enqueue(item)`	Añade `item` al final de la cola.
`queue.dequeue()`	Extrae y elimina el elemento del frente de la cola.
`queue.front()`	Devuelve el elemento del frente sin eliminarlo.
`queue.remove(item)`	Elimina la primera aparición de `item` en la cola.
`queue.is_empty()`	Devuelve `True` si la cola está vacía, `False` en caso contrario.
`len(queue)`	Devuelve la cantidad de elementos en la cola.
`item in queue`	Devuelve `True` si `item` existe en la cola, `False` en caso contrario.
`for item in queue: ...`	Itera sobre los elementos de la cola.
`for item in reversed(queue): ...`	Itera sobre los elementos en orden inverso.

Implementación de una cola en Python

Para implementar tu propia cola en Python, utilizarás la clase Queue que encapsula la funcionalidad descrita anteriormente con el soporte de collections.deque para almacenar los elementos de la cola.

A continuación, la implementación completa de la clase Queue:

Python - queue.py

from collections import deque
from typing import Any, Iterable, Iterator, Optional

class Queue:
    """Implement a Queue (FIFO) abstract data type."""

    def __init__(
        self,
        data: Optional[Iterable[Any]] = None,
        /
        ) -> None:
        self._data: deque = deque()
        if data is not None:
            self._data.extend(data)

    def enqueue(self, item: Any) -> None:
        """Add items to the right end of the queue."""
        self._data.append(item)

    def dequeue(self) -> Any:
        """Remove and return an item from the front of the queue."""
        try:
            return self._data.popleft()
        except IndexError:
            raise IndexError("dequeue from an empty queue") from None

    def front(self) -> Any:
        """Return the item at the beginning of the queue."""
        try:
            return self._data[0]
        except IndexError:
            raise IndexError("front from an empty queue") from None

    def remove(self, item: Any) -> None:
        """Remove the first occurrence of item."""
        try:
            self._data.remove(item)
        except ValueError:
            raise ValueError(
                f"{self.__class__.__name__}.remove(x): x not found"
            ) from None

    def is_empty(self) -> bool:
        """Return True if the queue is empty, False otherwise."""
        return len(self._data) == 0

    def __len__(self) -> int:
        return len(self._data)

    def __contains__(self, item: Any) -> bool:
        return item in self._data

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}({list(self._data)})"

    __str__ = __repr__

    def __iter__(self) -> Iterator:
        yield from self._data

    def __reversed__(self) -> Iterator:
        yield from reversed(self._data)

El atributo ._data es un objeto deque que almacena los elementos de la cola. La clase deque proporciona operaciones de inserción y eliminación en tiempo constante O(1) en ambos extremos, lo que la hace apropiada para implementar colas.

Los métodos principales te permiten ofrecer las siguientes funcionalidades:

.enqueue(): añade un elemento al final de la cola usando .append().
.dequeue(): devuelve y elimina el elemento del frente de la cola usando .popleft() y lanza IndexError si la cola está vacía.
.front(): devuelve el elemento del frente sin eliminarlo y lanza IndexError si la cola está vacía.
.remove(): elimina la primera aparición de un elemento. Lanza ValueError si el elemento no existe.
.is_empty(): comprueba si la cola está vacía.

Los métodos especiales te permiten ofrecer las siguientes funcionalidades:

.__len__(): devuelve el número de elementos en la cola.
.__contains__(): comprueba si un elemento está en la cola y devuelve True o False según corresponda.
.__iter__() y .__reversed__(): permiten iterar sobre los elementos de la cola en orden normal o inverso.
.__repr__() y .__str__(): devuelven representaciones de cadena de la cola.

Ejemplo de uso de la cola

En esta sección verás ejemplos prácticos de cómo crear y manipular instancias de tu clase Queue.

Inicialización

Para crear una Queue, puedes hacerlo sin argumentos o pasando un iterable como una lista:

Python REPL

>>> queue = Queue()
>>> queue
Queue([])

>>> queue = Queue([1, 2, 3])
>>> queue
Queue([1, 2, 3])

Encolar y desencolar elementos

Puedes añadir elementos al final de la cola y extraerlos del frente, siguiendo el orden FIFO:

Python REPL

>>> queue = Queue()
>>> queue.enqueue(1)
>>> queue.enqueue(2)
>>> queue.enqueue(3)
>>> queue
Queue([1, 2, 3])

>>> queue.dequeue()
1
>>> queue.dequeue()
2
>>> queue
Queue([3])

Si intentas extraer un elemento de una cola vacía, obtendrás un error:

Python REPL

>>> queue = Queue()
>>> queue.dequeue()
Traceback (most recent call last):
    ...
IndexError: dequeue from an empty queue

Consultar el frente

El método .front() te permite ver el elemento del frente sin eliminarlo:

Python REPL

>>> queue = Queue([1, 2, 3])
>>> queue.front()
1
>>> queue
Queue([1, 2, 3])

Eliminar un elemento específico

El método .remove() elimina la primera aparición de un elemento de la cola y lanza un ValueError si el elemento no se encuentra:

Python REPL

>>> queue = Queue([1, 2, 3])
>>> queue.remove(2)
>>> queue
Queue([1, 3])

>>> queue.remove(10)
Traceback (most recent call last):
    ...
ValueError: Queue.remove(x): x not found

Longitud y pertenencia

Puedes consultar la longitud de la cola con len() y verificar si un elemento está contenido en ella con el operador in:

Python REPL

>>> queue = Queue([10, 20, 30])

>>> len(queue)
3
>>> queue.is_empty()
False

>>> 20 in queue
True
>>> 99 in queue
False

Iteración

Los métodos .__iter__() y .__reversed__() permiten iterar sobre la cola tanto hacia adelante como hacia atrás:

Python REPL

>>> queue = Queue([1, 2, 3])

>>> for item in queue:
...     print(item)
...
1
2
3

>>> for item in reversed(queue):
...     print(item)
...
3
2
1

Conclusión

Has aprendido cómo implementar una cola (queue) que proporciona operaciones esenciales como añadir y eliminar elementos siguiendo el principio FIFO, consultar el primer elemento, eliminar elementos específicos y verificar si un elemento pertenece a la cola.

Este conocimiento te sirve de base para entender algoritmos que dependen de colas, como la búsqueda en anchura, la gestión de tareas en sistemas operativos y los buffers de datos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Estructuras de datos en Python: Pilas (stacks)

2026-04-07T22:20:00+02:00

En este artículo, aprenderás cómo implementar una pila en Python, incluyendo sus operaciones y características principales.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué es una pila o stack?
Operaciones comunes en una pila
Implementación de una pila en Python
Ejemplo de uso de la pila
Conclusión

¿Qué es una pila o stack?

Una pila es una estructura de datos donde el acceso está restringido a un solo extremo de la secuencia. Los elementos se empujan (push) hacia la pila para añadirlos y se extraen (pop) de la pila para retirarlos. Las pilas son muy utilizadas en algoritmos de informática y resultan especialmente útiles para tareas de análisis sintáctico (parsing).

Las características fundamentales de una pila incluyen las siguientes:

LIFO (Last In, First Out): El último elemento que entró es el primero que sale.
Acceso restringido: Solo puedes acceder al elemento de la cima (top) de la pila.
Tamaño dinámico: La pila crece o decrece conforme añades o eliminas elementos.

En Python, las pilas no están integradas como una estructura de datos primitiva, pero puedes implementarla fácilmente usando el tipo collections.deque, que proporciona operaciones eficientes de inserción y eliminación en ambos extremos.

Operaciones comunes en una pila

En la tabla siguiente tienes un resumen de las operaciones que soportará tu pila:

Operación	Descripción
`stack = Stack()`	Construye una pila vacía.
`stack = Stack(iterable)`	Construye una pila con elementos de `iterable`.
`stack.push(item)`	Empuja `item` a la cima de la pila.
`stack.pop()`	Extrae y elimina el elemento de la cima de la pila.
`stack.top()`	Devuelve el elemento de la cima sin eliminarlo.
`stack.is_empty()`	Devuelve `True` si la pila está vacía, `False` en caso contrario.
`len(stack)`	Devuelve la cantidad de elementos en la pila.
`item in stack`	Devuelve `True` si `item` existe en la pila, `False` en caso contrario.
`for item in stack: ...`	Itera sobre los elementos de la pila.
`for item in reversed(stack): ...`	Itera sobre los elementos en orden inverso.

Implementación de una pila en Python

A continuación encontrarás un ejemplo de implementación de una pila en Python:

Python - stack.py

from collections import deque
from typing import Any, Iterable, Iterator, Optional

class Stack:
    """Implement a Stack (LIFO) abstract data type."""

    def __init__(
        self,
        iterable: Optional[Iterable[Any]] = None,
        /,
    ) -> None:
        self._data: deque = deque()
        if iterable is not None:
            self._data.extend(iterable)

    def push(self, item: Any) -> None:
        """Push an item onto the stack."""
        self._data.append(item)

    def pop(self) -> Any:
        """Remove and return an item from the top of the stack."""
        try:
            return self._data.pop()
        except IndexError:
            raise IndexError("pop from an empty stack") from None

    def top(self) -> Any:
        """Return the item at the top of the stack."""
        try:
            return self._data[-1]
        except IndexError:
            raise IndexError("top from an empty stack") from None

    def is_empty(self) -> bool:
        """Return True if the stack is empty, False otherwise."""
        return len(self._data) == 0

    def __len__(self) -> int:
        return len(self._data)

    def __contains__(self, item: Any) -> bool:
        return item in self._data

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}({list(self._data)})"

    __str__ = __repr__

    def __iter__(self) -> Iterator:
        yield from self._data

    def __reversed__(self) -> Iterator:
        yield from reversed(self._data)

El atributo ._data es un objeto deque del módulo collections que almacena los elementos de la pila. La clase deque proporciona operaciones de inserción y eliminación en tiempo constante O(1) en ambos extremos.

Los métodos principales te permiten ofrecer las siguientes funcionalidades:

.push(): añade un elemento a la cima de la pila usando .append().
.pop(): elimina y devuelve el elemento de la cima de la pila. Lanza IndexError si la pila está vacía.
.top(): devuelve el elemento de la cima sin eliminarlo. Lanza IndexError si la pila está vacía.
.is_empty(): comprueba si la pila está vacía.

Los métodos especiales te permiten ofrecer las siguientes funcionalidades:

.__len__(): devuelve el número de elementos en la pila.
.__contains__(): comprueba si un elemento está en la pila y devuelve True o False.
.__iter__() y .__reversed__(): permiten iterar sobre los elementos de la pila en orden normal o inverso.
.__repr__() y .__str__(): devuelven representaciones de cadena legibles.

Ejemplo de uso de la pila

En esta sección verás ejemplos prácticos de cómo crear y manipular instancias de tu clase Stack.

Inicialización

Para crear una Stack, puedes hacerlo sin argumentos o pasando un iterable:

Python REPL

>>> stack = Stack()
>>> stack
Stack([])

>>> stack = Stack([1, 2, 3])
>>> stack
Stack([1, 2, 3])

Empujar y extraer elementos

Puedes empujar elementos a la cima y extraerlos en orden LIFO:

Python REPL

>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)
>>> stack
Stack([1, 2, 3])

>>> stack.pop()
3
>>> stack.pop()
2
>>> stack
Stack([1])

Si intentas extraer un elemento de una pila vacía, obtendrás un error:

Python REPL

>>> stack = Stack()
>>> stack.pop()
Traceback (most recent call last):
    ...
IndexError: pop from an empty stack

Consultar la cima

El método .top() te permite ver el elemento en la cima sin eliminarlo:

Python REPL

>>> stack = Stack([1, 2, 3])
>>> stack.top()
3
>>> stack
Stack([1, 2, 3])

Longitud y pertenencia

Puedes consultar la longitud de la pila y verificar si un elemento está contenido en ella:

Python REPL

>>> stack = Stack([10, 20, 30])

>>> len(stack)
3
>>> stack.is_empty()
False

>>> 20 in stack
True
>>> 99 in stack
False

Iteración

Los métodos .__iter__() y .__reversed__() permiten iterar sobre la pila tanto hacia adelante como hacia atrás:

Python REPL

>>> stack = Stack([1, 2, 3])

>>> for item in stack:
...     print(item)
...
1
2
3

>>> for item in reversed(stack):
...     print(item)
...
3
2
1

Conclusión

Has aprendido cómo implementar una pila que proporciona operaciones esenciales como empujar y extraer elementos siguiendo el principio LIFO, consultar la cima, verificar pertenencia e iterar sobre sus elementos. Este conocimiento te sirve de base para entender algoritmos que dependen de pilas, como la evaluación de expresiones, el recorrido de grafos en profundidad y la gestión de historial de acciones.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: case

2026-04-05T22:05:00+02:00

Esta estructura de control de flujo te permite comparar una expresión con múltiples patrones de datos de manera explícita, facilitando la escritura de programas más legibles y menos propensos a errores en comparación con otros métodos de control de flujo.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de case
Resumiendo

Sintaxis

Para utilizar case, necesitas una sentencia match que proporcione el valor a evaluar. Cada bloque case define un patrón con el que se comparará dicho valor.

La sintaxis básica es la siguiente:

Sintaxis de Python

match expression:
    case pattern1:
        # Código si expression coincide con pattern1
    case pattern2:
        # Código si expression coincide con pattern2
    ...
    case _:
        # Patrón comodín para manejar cualquier otro caso

En este flujo de ejecución, el intérprete evalúa cada case de arriba abajo. Cuando encuentra la primera coincidencia, ejecuta su bloque de código y sale de la estructura.

El uso de un guion bajo (_) al final actúa como un comodín (catch-all) para capturar cualquier valor que no haya coincidido con los patrones anteriores.

Las palabras clave suaves (soft keywords) como case se diferencian de las palabras clave normales en que pueden ser usadas como identificadores, lo que incluye nombres de variables, funciones o clases.

Ejemplos prácticos

Observa el siguiente ejemplo de una función que clasifica edades:

Python REPL

>>> def classify_age(age):
...     match age:
...         case n if n < 13:
...             return "Eres un niño"
...         case n if n < 20:
...             return "Eres un adolescente"
...         case _:
...             return "Eres un adulto"
...

>>> classify_age(10)
'Eres un niño'
>>> classify_age(15)
'Eres un adolescente'
>>> classify_age(30)
'Eres un adulto'

Como puedes ver, match ... case te ofrece una vía directa para tomar decisiones basadas en valores específicos de tus objetos de forma más declarativa que las sentencias condicionales tradicionales.

Uso de `case`

Los casos de uso más comunes de la palabra clave case incluyen los siguientes:

Ramificar la lógica de tus aplicaciones según el contenido específico o la estructura de tus datos
Simplificar la lectura y mantenimiento de programas que dependen de múltiples condiciones de decisión
Evaluar y desestructurar de forma segura estructuras de datos complejas mediante la coincidencia de patrones
Sustituir cadenas extensas de sentencias if - elif - else cuando comparas una sola variable contra múltiples opciones posibles
Manejar respuestas de APIs o eventos de manera más clara y declarativa

Resumiendo

La palabra clave case constituye una adición esencial a Python para realizar coincidencias de patrones eficaces.

Conocer y emplear esta herramienta te permitirá desarrollar aplicaciones más claras, fáciles de mantener y con un control de flujo mucho más potente.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: match

2026-03-29T21:50:00+02:00

Esta característica de control de flujo te ofrece una forma elegante y declarativa de evaluar tus objetos y realizar ramificaciones de decisión que anteriormente habrían requerido múltiples sentencias condicionales encadenadas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de match
Resumiendo

Sintaxis

La sintaxis básica para usar la palabra clave match consiste en una expresión seguida de bloques case que definen los patrones:

Sintaxis de Python

match expression:
    case pattern1:
        # Código si pattern1 coincide con expression
    case pattern2:
        # Código si pattern2 coincide con expression
    ...
    case _:
        # Patrón comodín (opcional)

En esta estructura, la expresión se evalúa y su resultado se compara con cada patrón en orden. El primer patrón que coincida ejecutará su bloque de código asociado. Si ningún patrón coincide, se ejecuta el bloque del patrón comodín (_), si este existe.

Las palabras clave suaves (soft keywords) se diferencian de las palabras clave normales en que pueden ser usadas como identificadores, lo que incluye nombres de variables, funciones o clases.

Ejemplos prácticos

Aquí tienes algunos ejemplos básicos de cómo puedes usar match en Python:

Python REPL

>>> def process_command(command):
...     match command:
...         case "start":
...             return "Iniciando..."
...         case "stop":
...             return "Deteniendo..."
...         case _:
...             return "Comando desconocido"
...

>>> process_command("start")
'Iniciando...'
>>> process_command("stop")
'Deteniendo...'

También es ideal para realizar comparaciones múltiples de forma concisa usando el operador | (OR). El siguiente ejemplo muestra cómo obtener información sobre un código de estado HTTP:

Python REPL

>>> def process_http_status(status):
...     match status:
...         case 200 | 201 | 204:
...             return "Éxito"
...         case 400 | 401 | 404:
...             return "Error del cliente"
...         case 500 | 503:
...             return "Error del servidor"
...         case _:
...             return "Otro código"
...

>>> process_http_status(200)
'Éxito'
>>> process_http_status(404)
'Error del cliente'

Como puedes ver, el uso de match hace que estas comparaciones múltiples sean mucho más legibles.

Uso de `match`

Los casos de uso más comunes de la palabra clave match incluyen los siguientes:

Comparar el contenido y la forma de tus datos de manera clara y concisa para tomar decisiones de control de flujo
Extraer información específica de estructuras de datos complejas
Reemplazar múltiples bloques de if-elif-else encadenados
Procesar eventos o estados según la forma que tengan tus datos

Resumiendo

En definitiva, la palabra clave match en Python te ofrece una vía moderna y potente para evaluar una expresión contra varios patrones, lo que se traduce en un código mucho más limpio y fácil de seguir.

Al dominar match, contarás con una herramienta fundamental para mejorar la legibilidad y mantenibilidad de tus programas, especialmente cuando trabajes con estructuras de datos complejas y múltiples condiciones lógicas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: type

2026-03-27T18:15:00+01:00

Al emplear esta palabra clave, verás cómo tus anotaciones de tipos (type hints) se vuelven más expresivas y fáciles de mantener.

Las palabras clave suaves (soft keywords) se diferencian de las palabras clave normales en que pueden ser usadas como identificadores, lo que incluye nombres de variables, funciones o clases.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de type
Resumiendo

Sintaxis

La sintaxis básica para declarar un alias de tipo con type es la siguiente:

Sintaxis de Python

type AliasName = Type

Además, puedes usar type para crear alias que se adapten a diferentes tipos de datos, también conocidos como tipos genéricos:

Sintaxis de Python

type AliasName[T] = BaseType[T]

En esta sintaxis, la letra T representa un parámetro de tipo que actúa como un marcador de posición para el tipo concreto que se usará al emplear el alias. Aunque por convención se suele usar T (de Type), puedes emplear cualquier otro nombre válido en Python.

Ejemplos prácticos

Aquí tienes algunos ejemplos de cómo puedes usar la palabra clave type en tus programas:

Python REPL

>>> # Un alias de tipo
>>> type Point = tuple[float, float]

>>> def move_to(target: Point):
...     print(f"Moviendo a: {target}")
...

>>> # Un alias de tipo genérico
>>> type ListOrSet[T] = list[T] | set[T]

>>> def process_data(items: ListOrSet[int]):
...     for item in items:
...         print(item)
...

En estos ejemplos, usas type para crear nombres más legibles para tipos complejos. Nota que Point es ahora un alias para una tupla de dos números float, y ListOrSet es un alias genérico que puede representar tanto una lista como un conjunto (set) de elementos de un tipo T.

Al usar estos alias, los analizadores estáticos de tipos (static type checkers) como mypy o pyright no reportarán errores y te ayudarán a validar que tus datos coincidan con los tipos definidos.

Uso de `type`

Los casos de uso más comunes de la palabra clave type incluyen los siguientes:

Crear alias descriptivos para tipos complejos o anidados.
Facilitar la lectura de las anotaciones de tipos.
Implementar clases y funciones genéricas de forma más limpia.
Centralizar la definición de estructuras de datos que se usan en múltiples partes de tu aplicación.

Resumiendo

En resumen, la palabra clave suave type es una adición moderna al lenguaje que te ayuda a escribir código más expresivo y fácil de mantener mediante la declaración de alias de tipos.

Conocer y emplear esta palabra clave te proporciona una herramienta esencial para manejar la complejidad de los tipos en tus programas, permitiéndote aprovechar al máximo el sistema de tipos de Python a la vez que mejoras la legibilidad.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Ciclos o bucles while

2026-03-18T21:35:00+01:00

Estos ciclos son especialmente útiles cuando no conoces de antemano cuántas repeticiones necesitas. En este tutorial, aprenderás lo esencial sobre el funcionamiento de los ciclos while y cómo utilizarlos de forma efectiva en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Conociendo los ciclos while
Iterando con ciclos while en Python
Controlando la iteración con break y continue
Implementando ciclos infinitos con while True
Usando la cláusula else en ciclos while
Usando ciclos while anidados
Conclusiones

Conociendo los ciclos `while`

Un ciclo o bucle while te permite ejecutar repetidamente un bloque de código mientras una condición sea verdadera. A diferencia de los ciclos for, que iteran sobre una secuencia de elementos como una lista, los ciclos while dependen de una condición que se evalúa antes de cada iteración.

La sintaxis básica de un ciclo while en Python es la siguiente:

Sintaxis de Python

while condition:
    <block>

condition: expresión que se evalúa antes de cada iteración. Si es True, el ciclo continúa. Si es False, se detiene y la ejecución pasa al siguiente bloque de código.
<block>: bloque de código con las instrucciones que se ejecutan o repiten en cada iteración.

Aquí tienes un ejemplo básico:

Python REPL

>>> counter = 0

>>> while counter < 5:
...     print(f"Contador: {counter}")
...     counter += 1
...
Contador: 0
Contador: 1
Contador: 2
Contador: 3
Contador: 4

En este ejemplo, se inicia con counter = 0. Mientras la condición counter < 5 devuelva True, el ciclo imprime el valor actual y le suma 1 a la variable counter. El ciclo se detiene cuando counter alcanza 5, pues la condición se evalúa como False.

Iterando con ciclos `while` en Python

Los ciclos while son versátiles y puedes emplearlos en diversas situaciones. En las secciones siguientes, explorarás algunos patrones de uso comunes.

Acumulando con un ciclo `while`

Uno de los usos más básicos de un ciclo while es acumular valores en una variable. Aunque en muchos casos puedes usar un ciclo for con range() para esto, el ciclo while te ofrece más control sobre la condición de parada:

Python REPL

>>> total = 0
>>> number = 1

>>> while number <= 10:
...     total += number
...     number += 1
...

>>> total
55

En este ejemplo, el ciclo suma los números del 1 al 10. La variable total acumula la suma, y number se incrementa en cada iteración hasta que supera 10.

Procesando datos de entrada del usuario

Los ciclos while son ideales para solicitar datos al usuario de forma repetida hasta que este proporcione una entrada válida:

Python - user_input.py

user_input = ""
while user_input.lower() != "salir":
    user_input = input("Escribe algo (o 'salir' para terminar): ")
    if user_input.lower() != "salir":
        print(f"Escribiste: {user_input}")

print("¡Hasta luego!")

Puedes usar el operador walrus (:=) para simplificar este tipo de ciclos, permitiéndote asignar la entrada del usuario a una variable y evaluarla en la misma línea:

Python

msg = "Escribe algo (o 'salir' para terminar): "

while (user_input := input(msg)).lower() != "salir":
    print(f"Escribiste: {user_input}")

Esta versión es más eficiente y compacta, pues elimina la necesidad de inicializar user_input fuera del ciclo y de repetir la lógica de validación.

Si ejecutas este programa, podrás interactuar con él de la siguiente manera:

Terminal

$ python user_input.py
Escribe algo (o 'salir' para terminar): hola
Escribiste: hola
Escribe algo (o 'salir' para terminar): Python
Escribiste: Python
Escribe algo (o 'salir' para terminar): salir
¡Hasta luego!

Este patrón es frecuente en programas interactivos que necesitan mantener un ciclo de ejecución hasta que el usuario decida salir.

Recorriendo colecciones con un ciclo `while`

Otro uso común de while es consumir los elementos de una lista con el método .pop(). En este ejemplo, el siguiente ciclo se ejecuta hasta que la lista tasks esté vacía:

Python REPL

>>> tasks = ["Comprar pan", "Estudiar Python", "Hacer ejercicios"]

>>> while tasks:
...     task = tasks.pop()
...     print(f"Completada: {task}")
...
Completada: Hacer ejercicios
Completada: Estudiar Python
Completada: Comprar pan

Aquí, el ciclo while utiliza la lista tasks directamente como condición. Cuando la lista queda vacía, se evalúa como False y el ciclo termina. El método .pop() elimina y devuelve el último elemento de la lista en cada iteración.

Controlando la iteración con `break` y `continue`

En Python, las sentencias break y continue te permiten controlar el flujo de ejecución en los ciclos while. La función de estas sentencias es la siguiente:

break: termina el ciclo anticipadamente y salta a la sentencia inmediatamente después del ciclo.
continue: salta a la siguiente iteración, sin ejecutar el código que le sigue en el bloque del ciclo.

A continuación, un ejemplo de cómo usar break:

Python REPL

>>> counter = 0

>>> while counter < 10:
...     if counter == 3:
...         break
...     print(counter)
...     counter += 1
...
0
1
2

El ciclo se detiene cuando counter llega a 3, aunque la condición original counter < 10 siga siendo True.

Considera el siguiente ejemplo de cómo funciona continue:

Python REPL

>>> counter = 0

>>> while counter < 5:
...     counter += 1
...     if counter == 3:
...         continue
...     print(counter)
...
1
2
4
5

Cuando counter es 3, la sentencia continue evita la ejecución de print(), saltando directamente a la siguiente iteración del ciclo.

Implementando ciclos infinitos con `while True`

Si la condición de un ciclo while nunca se vuelve False, el ciclo se repite indefinidamente. Esto se conoce como un ciclo infinito:

Python REPL

>>> while True:
...     print("Esto se repite para siempre")
...

Este puede ser un error de lógica importante en tu código. Asegúrate siempre de que la condición se vuelva falsa en algún momento para evitar ciclos infinitos involuntarios.

Si en algún momento te encuentras en un ciclo infinito, puedes detenerlo presionando Ctrl+C en tu terminal. Esta combinación genera una excepción de tipo KeyboardInterrupt y detiene la ejecución del programa.

A pesar de que los ciclos infinitos pueden ser el resultado de un error, en muchas ocasiones son una herramienta poderosa y necesaria cuando los diseñas intencionalmente.

Estos ciclos intencionados son la base de los ciclos de eventos (event loops) en aplicaciones con interfaz gráfica de usuario (GUI por sus siglas en inglés) y juegos, donde el programa debe esperar acciones del usuario o eventos externos en todo momento. También los encontrarás en servidores de red que escuchan peticiones de forma permanente.

Para implementar este tipo de lógica de manera efectiva, puedes usar el patrón while True combinado con una sentencia break. De esta forma, podrás controlar con total precisión cuándo debe terminar el ciclo según los eventos que ocurran.

Aquí tienes un ejemplo de un juego de adivinanza:

Python - guessing_game.py

import random

target = random.randint(1, 10)

while True:  # Ciclo infinito intencional
    guess = int(input("Adivina el número (1-10): "))
    if guess == target:
        print("¡Correcto!")
        break  # Termina el ciclo cuando adivinas el número
    elif guess < target:
        print("Muy bajo, intenta de nuevo.")
    else:
        print("Muy alto, intenta de nuevo.")

Si ejecutas este programa, podrás jugar a adivinar un número:

Terminal

$ python guessing_game.py
Adivina el número (1-10): 5
Muy bajo, intenta de nuevo.
Adivina el número (1-10): 8
Muy alto, intenta de nuevo.
Adivina el número (1-10): 7
¡Correcto!

En este ejemplo, el patrón while True crea un ciclo que se ejecuta indefinidamente. La sentencia break termina el ciclo cuando el usuario adivina el número correcto.

Usando la cláusula `else` en ciclos `while`

Como las sentencias condicionales, los ciclos while pueden tener una cláusula else. Esta cláusula se ejecuta únicamente cuando la condición se evalúa como False sin que se haya ejecutado una sentencia break:

Python REPL

>>> counter = 0

>>> while counter < 3:
...     print(counter)
...     counter += 1
... else:
...     print("Ciclo terminado")
...
0
1
2
Ciclo terminado

Este ciclo termina naturalmente luego de que counter alcanza el valor de 3. Entonces, el else se ejecuta y ves el mensaje Ciclo terminado en la pantalla. Este tipo de else sin un break no es muy útil, pues es equivalente a poner el mensaje fuera del ciclo.

En contraste, si usas una instrucción break, el bloque else no se ejecuta:

Python REPL

>>> counter = 0

>>> while counter < 3:
...     if counter == 1:
...         break
...     print(counter)
...     counter += 1
... else:
...     print("Ciclo terminado")
...
0

En este caso, el ciclo termina prematuramente cuando counter es 1, y la cláusula else se omite por completo.

La cláusula else te permite manejar de forma elegante situaciones donde la condición del ciclo se vuelve falsa después de varios intentos. Es particularmente útil en escenarios como los siguientes:

Implementar mecanismos de reintento en operaciones de red o archivos.
Esperar a que un recurso externo alcance un estado específico o se agote el tiempo de espera.
Procesar flujos de datos continuos hasta que aparezca una señal de parada.

Al emplear else, evitas el uso de variables de control adicionales para saber si la operación tuvo éxito o no después de agotar los intentos. A continuación, verás un ejemplo más realista que simula una conexión:

Python - retry_connection.py

import random

def connect():
    # Simula un intento de conexión aleatorio
    return random.choice([True, False])

attempts = 0
max_attempts = 3

while attempts < max_attempts:
    attempts += 1
    print(f"Intento {attempts}: Conectando...")
    if connect():
        print("¡Conexión establecida con éxito!")
        break
else:
    print("No se pudo establecer la conexión.")

En este ejemplo, la función connect() simula el resultado de una operación que puede fallar. Si el intento tiene éxito, el break detiene el ciclo y el programa continúa normalmente. Si el ciclo se completa porque se alcanzaron los tres intentos sin éxito, el bloque else se activa para manejar el fallo definitivo.

Dependiendo de la aleatoriedad, al ejecutar este programa podrías ver una salida exitosa:

Terminal

$ python retry_connection.py
Intento 1: Conectando...
Intento 2: Conectando...
¡Conexión establecida con éxito!

$ python retry_connection.py
Intento 1: Conectando...
Intento 2: Conectando...
Intento 3: Conectando...
No se pudo establecer la conexión.

Si el ciclo se interrumpe mediante una sentencia break, el bloque else no se ejecutará y verás el mensaje de ¡Conexión establecida con éxito!. En caso contrario, verás el mensaje de No se pudo establecer la conexión. que indica que el else se ejecutó.

Usando ciclos `while` anidados

Puedes anidar un ciclo while dentro de otro. Al anidar ciclos, el ciclo interno se ejecuta por completo en cada iteración del ciclo externo.

Este patrón es común en aplicaciones que gestionan menús jerárquicos:

Python - menu.py

while True:
    print("\n--- Menú Principal ---")
    print("1. Entrar a Configuración")
    print("2. Salir")
    menu_choice = input("Selecciona una opción: ")

    if menu_choice == "1":
        while True:
            print("\n--- Configuración ---")
            print("1. Cambiar Idioma")
            print("2. Volver")
            config_choice = input("Selecciona una opción: ")

            if config_choice == "1":
                print("Idioma cambiado con éxito.")
            elif config_choice == "2":
                break  # Sale del ciclo interno hacia el menú principal
    elif menu_choice == "2":
        print("Saliendo del sistema...")
        break  # Sale del ciclo externo y termina el programa

En este esquema, el primer ciclo mantiene la aplicación en ejecución de forma indefinida. Cuando el usuario elige la opción 1, se ejecuta el ciclo interno, presentando un nuevo menú.

Esta estructura te permite crear interfaces interactivas que se adaptan al ritmo del usuario. Sin embargo, debes tener en cuenta que anidar demasiados niveles puede hacer que el código sea difícil de entender, en cuyo caso, considera extraer las subtareas en funciones independientes.

Conclusiones

Los ciclos o bucles while son esenciales en Python cuando necesitas ejecutar un bloque de código un número indeterminado de veces, basándote en una condición dinámica.

Estos ciclos son ideales para procesar datos de entrada del usuario, implementar menús interactivos y manejar situaciones donde no conoces de antemano el número de iteraciones.

También puedes combinar while con break, continue y else para controlar el flujo de ejecución de tu código de una manera mucho más precisa. El patrón while True (ciclo infinito) con break es especialmente útil para ciclos que dependen de eventos externos.

Dominar los ciclos while es fundamental para escribir código más limpio e idiomático en Python. ¡Practica con tus propios ejemplos y experimenta con diferentes patrones para afianzar tu comprensión!

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: await

2026-03-05T19:15:00+01:00

Esta palabra clave es una parte fundamental del manejo de la programación asíncrona en Python, permitiendo que tu código espere de manera eficiente a que se resuelvan las operaciones sin bloquear el hilo de ejecución.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de await
Resumiendo

Sintaxis

La sintaxis básica para usar await es la siguiente:

Sintaxis de Python

result = await some_awaitable()

Aquí, some_awaitable() es la llamada a una función async que produce un objeto awaitable (una corrutina), y await se utiliza para esperar a que se complete antes de continuar con el código.

Ejemplos prácticos

A continuación tienes algunos ejemplos de cómo se usa await en Python:

Python - await_python.py

import asyncio

async def main():
    print("Inicio")
    await asyncio.sleep(1) # Simula una operación asíncrona
    print("Fin")

# Ejecutar la función asíncrona
asyncio.run(main())

En este ejemplo, await asyncio.sleep(1) pausa la ejecución de la función main durante un segundo sin bloquear el hilo de ejecución principal. Después de un segundo, el programa continúa y ejecuta print("Fin").

El siguiente ejemplo muestra cómo usar await para esperar los resultados de múltiples solicitudes de red concurrentes. Para ello, usarás la biblioteca aiohttp junto con la API pública JSONPlaceholder.

Antes de ejecutar el ejemplo, instala aiohttp en tu entorno virtual con el siguiente comando:

Terminal

$ pip install aiohttp

Una vez instalada la biblioteca, crea un archivo con el siguiente código:

Python - fetch_todos.py

import asyncio
import aiohttp

async def fetch_data(session, url):
    async with session.get(url) as response:
        return await response.json()

async def main():
    base = "https://jsonplaceholder.typicode.com"

    async with aiohttp.ClientSession() as session:
        user_ids = [1, 2, 3]

        users = await asyncio.gather(
            *(
                fetch_data(session, f"{base}/users/{uid}")
                for uid in user_ids
            )
        )
        todos = await asyncio.gather(
            *(
                fetch_data(session, f"{base}/todos?userId={uid}")
                for uid in user_ids
            )
        )
        for user, user_todos in zip(users, todos):
            pending = [t for t in user_todos if not t["completed"]]
            print(f"{user['name']}: {len(pending)} tareas pendientes")

asyncio.run(main())

Si ejecutas este script, obtendrás una salida similar a la siguiente:

Terminal

$ python fetch_todos.py
Leanne Graham: 9 tareas pendientes
Ervin Howell: 12 tareas pendientes
Clementine Bauch: 10 tareas pendientes

En este ejemplo, la función fetch_data() usa await para esperar la respuesta de la API en formato JSON. En main(), las llamadas a await asyncio.gather() permiten lanzar todas las solicitudes de forma concurrente, de modo que mientras una espera su respuesta, las demás pueden avanzar sin bloquear el hilo de ejecución.

Uso de `await`

Los casos de uso más comunes de la palabra clave await incluyen los siguientes:

Esperar a que se completen las operaciones de entrada/salida (I/O) asíncronas, como solicitudes de red o acceso a bases de datos.
Coordinar tareas asíncronas que dependen del resultado de otras tareas.
Mejorar la eficiencia de las aplicaciones al permitir que se realicen otras operaciones mientras se espera la finalización de tareas asíncronas.

Resumiendo

La palabra clave await es esencial en Python para trabajar con programación asíncrona, permitiendo que las funciones esperen de manera eficiente a que se completen las tareas.

Conocer y utilizar await te permite escribir código que es más eficiente en el manejo de operaciones de entrada/salida y en la gestión de tareas que pueden ejecutarse de forma concurrente.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: async

2026-03-03T21:30:00+01:00

Esta palabra clave resulta especialmente útil para operaciones que pueden llevar tiempo, como la lectura de archivos o las solicitudes de red, debido a que permite que el programa continúe ejecutándose mientras espera que estas operaciones se completen.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de async
Resumiendo

Sintaxis

La sintaxis básica para definir una función asíncrona con def es la siguiente:

Sintaxis de Python

async def function_name():
    <block>  # Async code here

También puedes usar async con la sentencia with para crear gestores de contexto asíncronos:

Sintaxis de Python

async with resource as alias:
    <block>  # Async code here

Y con ciclos for para iterar de forma asíncrona:

Sintaxis de Python

async for item in async_iterable:
    <block>  # Async code here

Ejemplos prácticos

Aquí tienes algunos ejemplos que ilustran cómo se usa async en Python:

Python REPL

>>> import asyncio

>>> async def greeting():
...     print("Hola")
...     await asyncio.sleep(1)
...     print("Mundo")
...

>>> asyncio.run(greeting())
Hola
Mundo

En este ejemplo, la función greeting() utiliza async y await para pausar la ejecución durante un segundo entre las dos impresiones. La función asyncio.run() se utiliza para ejecutar la función asíncrona.

El siguiente ejemplo muestra cómo async te permite ejecutar varias solicitudes de red de forma concurrente. Para ello, usarás la biblioteca aiohttp junto con la API pública JSONPlaceholder para obtener la información de varios usuarios al mismo tiempo.

Antes de ejecutar el ejemplo, instala aiohttp en tu entorno virtual con el siguiente comando:

Terminal

$ pip install aiohttp

Una vez instalada la biblioteca, crea un archivo con el siguiente código:

Python - fetch_users.py

import asyncio
import aiohttp

async def fetch_user(session, user_id):
    url = f"https://jsonplaceholder.typicode.com/users/{user_id}"
    async with session.get(url) as response:
        data = await response.json()
        print(f"Usuario {user_id} recibido")
        return data

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [
            fetch_user(session, 1),
            fetch_user(session, 2),
            fetch_user(session, 3),
        ]
        results = await asyncio.gather(*tasks)
        for user in results:
            print(f"Usuario {user['id']}:")
            print(f"  Nombre: {user['name']}")
            print(f"  Email: {user['email']}")
            print(f"  Empresa: {user['company']['name']}")
            print()

asyncio.run(main())

Si ejecutas este script, obtendrás la siguiente salida:

Terminal

$ python fetch_users.py
Usuario 2 recibido
Usuario 3 recibido
Usuario 1 recibido

Usuario 1:
  Nombre: Leanne Graham
  Email: Sincere@april.biz
  Empresa: Romaguera-Crona

Usuario 2:
  Nombre: Ervin Howell
  Email: Shanna@melissa.tv
  Empresa: Deckow-Crist

Usuario 3:
  Nombre: Clementine Bauch
  Email: Nathan@yesenia.net
  Empresa: Romaguera-Jacobson

En este ejemplo, las tres llamadas a fetch_user() se lanzan de forma concurrente con asyncio.gather(). Las solicitudes se realizan al mismo tiempo en lugar de esperar a que cada una termine antes de iniciar la siguiente. Esto ilustra la ventaja principal de la programación asíncrona: aprovechar los tiempos de espera en operaciones de red para realizar otras solicitudes de forma simultánea.

Uso de `async`

Los casos de uso más comunes de la palabra clave async incluyen los siguientes:

Definir funciones asíncronas que realizan operaciones de entrada/salida de larga duración sin bloquear el hilo principal del programa
Mejorar el rendimiento de las aplicaciones al permitir que múltiples operaciones se ejecuten simultáneamente
Usar en combinación con await para esperar el resultado de una operación asíncrona sin bloquear la ejecución del código

Resumiendo

La palabra clave async en Python es fundamental para escribir código asíncrono, lo que permite realizar operaciones concurrentes de manera eficiente.

Conocer y utilizar async te ayuda a mejorar el rendimiento de tus aplicaciones, especialmente cuando se trata de operaciones de E/S que resultan lentas o bloquean el flujo del programa.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: nonlocal

2026-03-02T19:10:00+01:00

Esto resulta especialmente útil cuando trabajas con clausuras (closures) y necesitas que la función anidada recuerde y modifique el estado de la función que la contiene, sin recurrir a variables global.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de nonlocal
Resumiendo

Sintaxis

La sintaxis básica para usar la palabra clave nonlocal es la siguiente:

Sintaxis de Python

nonlocal variable_name

Donde variable_name es el nombre de la variable que deseas marcar como no local.

La palabra clave nonlocal solo es válida dentro de funciones anidadas. Usarla a nivel de módulo o dentro de una función que no está anidada en otra provoca un SyntaxError.

Ejemplos prácticos

Veamos un ejemplo para ilustrar cómo funciona nonlocal:

Python REPL

>>> def outer_function():
...     value = 10
...     def inner_function():
...         nonlocal value
...         value = 20
...         print("Dentro de inner_function:", value)
...     inner_function()
...     print("Dentro de outer_function:", value)
...

>>> outer_function()
Dentro de inner_function: 20
Dentro de outer_function: 20

En este ejemplo, inner_function() modifica el valor de value declarado en outer_function() gracias a la palabra clave nonlocal. Sin nonlocal, inner_function() trataría value como una nueva variable local.

Un ejemplo más práctico es un contador que mantiene su estado entre llamadas gracias a una clausura:

Python REPL

>>> def make_counter(start=0):
...     count = start
...     def increment():
...         nonlocal count
...         count += 1
...         return count
...     return increment
...

>>> counter = make_counter()
>>> counter()
1
>>> counter()
2
>>> counter()
3

Aquí, make_counter() devuelve la función increment(), que recuerda y modifica count gracias a nonlocal. Cada llamada a counter() incrementa el valor sin necesidad de variables globales ni clases.

A diferencia de global, que permite acceder a variables del ámbito global del módulo, nonlocal solo actúa sobre variables definidas en la función externa. Esto la convierte en una herramienta clave para trabajar con clausuras (closures) y funciones anidadas.

Uso de `nonlocal`

Los casos de uso más comunes de la palabra clave nonlocal incluyen los siguientes:

Modificar variables de la función externa sin afectar el ámbito global
Mantener el estado entre llamadas sucesivas a una función anidada
Crear clausuras (closures) que recuerdan el estado de la función que las contiene

Resumiendo

La palabra clave nonlocal en Python te permite modificar variables de la función externa desde dentro de funciones anidadas.

Conocer y emplear esta palabra clave te permite controlar mejor el alcance de las variables y crear clausuras y funciones anidadas más flexibles y poderosas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: global

2026-02-25T21:30:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de global
Resumiendo

Sintaxis

La sintaxis básica para usar la palabra clave global es la siguiente:

Sintaxis de Python

global var_name

Donde var_name es el nombre de la variable global que deseas modificar dentro de una función.

Ejemplos prácticos

El ejemplo clásico es un contador global:

Python REPL

>>> counter = 0  # Variable global

>>> def increment():
...     global counter  # Declaración global
...     counter += 1
...

>>> increment()
>>> increment()

>>> # Contador incrementado
>>> counter
2

En este ejemplo, la función increment() utiliza global para modificar la variable counter que se encuentra fuera de la función. Sin la declaración global, intentar ejecutar counter += 1 dentro de la función provocaría un error (UnboundLocalError), pues Python interpretaría que intentas modificar una variable local antes de haberle asignado un valor.

Aunque la palabra clave global puede ser útil en ciertos casos, gestionar el estado de un programa mediante variables globales no es una buena práctica de programación. El uso excesivo de variables globales puede dificultar el mantenimiento, la depuración y la reutilización del código. Siempre que sea posible, emplea alternativas como el paso de argumentos, el retorno de valores o el uso de clases y objetos para gestionar el estado.

Uso de `global`

Los casos de uso más comunes de la palabra clave global incluyen los siguientes:

Modificar una variable definida fuera del ámbito de la función actual.
Compartir una variable entre múltiples funciones dentro del mismo módulo.
Inicializar o reiniciar variables globales desde funciones cuando el estado global debe ser controlado explícitamente.

Resumiendo

La palabra clave global en Python te permite modificar variables globales desde dentro de una función.

Conocer y emplear esta palabra clave puede facilitar la gestión del estado global del programa de manera controlada, aunque debe usarse con precaución para mantener un código limpio y fácil de mantener.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: finally

2026-02-21T19:30:00+01:00

Esto la convierte en una palabra clave especialmente útil para la limpieza de recursos, como cerrar archivos o conexiones de red, asegurando que estas operaciones se completen sin importar el resultado de los bloques try y except.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de finally
Resumiendo

Sintaxis

La sintaxis básica para usar finally es la siguiente:

Sintaxis de Python

try:
    <block>
except ExceptionType:
    <handler>
finally:
    <cleanup_block>

También puedes usar finally directamente con try, sin incluir except:

Sintaxis de Python

try:
    <block>
finally:
    <cleanup_block>

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo se utiliza la palabra clave finally:

Python REPL

>>> file = open("data.txt", mode="w")

>>> try:
...     file.write("Hola, Python Scouts")
... except IOError as error:
...     print(f"Error de escritura: {error}")
... finally:
...     file.close()
...     print(f"Archivo cerrado: {file.closed}")
...
Archivo cerrado: True

En este ejemplo, abres un archivo (data.txt) para escritura y usas finally para garantizar que el archivo se cierre sin importar si la operación de escritura produce un error o no.

También puedes usar finally sin except cuando solo necesitas asegurar la limpieza de recursos:

Python REPL

>>> file = open("data.txt")

>>> try:
...     content = file.read()
...     print(content)
... finally:
...     file.close()
...     print(f"Archivo cerrado: {file.closed}")
...
Hola, Python Scouts!
Archivo cerrado: True

Aquí, el bloque finally se ejecuta independientemente de si la lectura del archivo fue exitosa o no, asegurando que el recurso se libere correctamente.

Aunque puedes usar try y finally para gestionar recursos como archivos, la forma recomendada en Python es emplear la sentencia with, que se encarga automáticamente de cerrar el archivo y manejar posibles excepciones de manera más segura y concisa. El ejemplo anterior quedaría de la siguiente manera:

Python

with open("data.txt") as file:
    content = file.read()
    print(content)

El archivo se cierra automáticamente al salir del bloque with.

Uso de `finally`

Los casos de uso más comunes de la palabra clave finally incluyen los siguientes:

Liberación de recursos como cerrar archivos o conexiones de base de datos.
Ejecución de tareas de limpieza sin importar si se produjo una excepción.
Asegurar que ciertas operaciones críticas se realicen incluso en presencia de errores.

Resumiendo

La palabra clave finally en Python te permite garantizar la ejecución de un bloque de código independientemente de si ocurre una excepción o no.

Conocer y emplear finally es beneficioso para asegurar que los recursos se gestionen de manera adecuada y que se realicen las tareas necesarias de limpieza en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: except

2026-02-20T19:30:00+01:00

Con esta palabra clave defines bloques de respuesta ante errores específicos dentro de una sentencia try, indicando qué tipo de excepción capturar y cómo reaccionar en cada caso.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de except
Resumiendo

Sintaxis

La sintaxis básica para usar except es la siguiente:

Sintaxis de Python

try:
    <block>
except ExceptionType [as variable]:
    <handler>

Puedes capturar múltiples excepciones con cláusulas except separadas:

Sintaxis de Python

try:
    <block>
except ExceptionType1:
    <handler_1>
except ExceptionType2:
    <handler_2>

También puedes agrupar varias excepciones en una sola cláusula usando una tupla:

Sintaxis de Python

try:
    <block>
except (ExceptionType1, ExceptionType2):
    <handler>

Los corchetes indican elementos opcionales.

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo se utiliza la palabra clave except:

Python REPL

>>> try:
...     result = 10 / 0
... except ZeroDivisionError:
...     print("Error: división por cero")
...
Error: división por cero

En este ejemplo, intentas dividir 10 entre 0, lo cual genera una excepción ZeroDivisionError. La cláusula except captura esa excepción y muestra un mensaje en lugar de detener el programa.

Puedes acceder a los detalles de la excepción usando la palabra clave as:

Python REPL

>>> try:
...     number = int("Python")
... except ValueError as error:
...     print(f"No se pudo convertir: {error}")
...
No se pudo convertir: invalid literal for int() with base 10: 'Python'

Aquí, intentas convertir una cadena que no representa un número a un entero, lo que provoca una excepción ValueError. Con as, capturas el objeto de excepción para mostrar un mensaje más detallado.

También puedes capturar múltiples excepciones en diferentes cláusulas except:

Python REPL

>>> def process_input(value):
...     try:
...         number = int(value)
...         result = 100 / number
...     except ValueError:
...         print("Error: valor no numérico")
...     except ZeroDivisionError:
...         print("Error: división por cero")
...     else:
...         print(f"Resultado: {result}")
...

>>> process_input("abc")
Error: valor no numérico

>>> process_input("0")
Error: división por cero

>>> process_input("4")
Resultado: 25.0

En la práctica, es recomendable capturar excepciones específicas en lugar de usar un except genérico sin tipo de excepción o usando Exception. Esto te permite manejar cada error de forma adecuada y evitar ocultar errores inesperados en tu código.

Uso de `except`

Los casos de uso más comunes de la palabra clave except incluyen los siguientes:

Capturar excepciones específicas, como ZeroDivisionError, ValueError, entre otras, para proporcionar mensajes de error claros y personalizados.
Acceder a los detalles de una excepción usando as para registrar o presentar información útil.
Manejar múltiples tipos de excepciones con distintas cláusulas except, ofreciendo respuestas diferenciadas ante cada error.
Proveer un mecanismo para continuar la ejecución del programa incluso cuando ocurre un error.
Implementar lógica de recuperación o limpieza cuando se produce un error inesperado.

Resumiendo

La palabra clave except en Python es fundamental para el manejo de excepciones, permitiéndote capturar y gestionar errores de manera controlada.

Conocer y emplear except junto con try, else y finally te permite crear programas más robustos que manejan situaciones inesperadas sin interrupciones abruptas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: is

2026-02-17T19:25:00+01:00

A diferencia del operador ==, que compara si los valores de dos objetos son iguales, es decir, si tienen el mismo contenido, is te ayuda a verificar la identidad del objeto.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de is
Resumiendo

Sintaxis

La sintaxis para usar la palabra clave is es bastante sencilla:

Sintaxis de Python

x is y

Aquí, x y y son las dos referencias que deseas comparar para ver si apuntan al mismo objeto.

Ejemplos prácticos

Veamos algunos ejemplos prácticos para entender mejor cómo funciona el operador is:

Python REPL

>>> a = [1, 2, 3]
>>> b = a
>>> c = a[:]

>>> a is b
True

>>> a is c
False

>>> a == c
True

En el primer ejemplo, a is b devuelve True porque b es una referencia al mismo objeto que a en la memoria.

En el segundo ejemplo, a is c devuelve False porque c es una copia superficial de a, lo que significa que tienen el mismo contenido, pero son objetos diferentes en la memoria. Sin embargo, a == c devuelve True porque los valores son iguales.

Uso de `is`

Los casos de uso más comunes de la palabra clave is incluyen los siguientes:

Comprobar si una variable es None, es decir, variable is None.
Verificar la identidad de objetos inmutables como cadenas y números en ciertas situaciones.
Controlar el flujo para tomar decisiones basadas en la identidad de los objetos.

Resumiendo

La palabra clave is en Python te permite verificar la identidad de los objetos, asegurándote de que dos referencias apuntan al mismo objeto en la memoria.

Conocer cómo y cuándo usar is te permite escribir código más preciso y eficiente, especialmente cuando trabajas con comparaciones de objetos y estructuras de datos complejas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Iniciando con FastAPI para desarrollo de APIs

2026-02-09T22:20:00+01:00

Para desarrollar APIs modernas y robustas con Python, puedes emplear una variedad de frameworks, incluyendo Django REST Framework, Flask, Falcon, entre otros. Sin embargo, FastAPI se ha convertido en una de las opciones más populares y sólidas disponibles gracias a su alto rendimiento y su enfoque en la productividad del desarrollador.

En este tutorial, aprenderás cómo:

Instalar FastAPI y configurarlo en tu computadora
Crear tu primera API con un endpoint básico
Usar parámetros de ruta y parámetros de query para recibir datos
Validar datos de entrada con modelos Pydantic
Aprovechar la documentación interactiva automática

Para obtener el máximo de este tutorial, debes conocer lo básico de programación con Python, especialmente temas relacionados con funciones, decoradores y type hints.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Conociendo FastAPI
Instalando FastAPI
Creando una aplicación FastAPI
- Ejecutando el servidor
- Documentación interactiva
Explorando las operaciones HTTP
Usando parámetros de ruta
Usando parámetros de query
Validando datos con modelos Pydantic
Demo API con FastAPI: Autos
Conclusión

Conociendo FastAPI

FastAPI es un web framework moderno y de alto rendimiento para construir APIs con Python 3.9+ basado en los indicadores de tipo estándar (type hints). Sus características principales incluyen:

Rapidez: Muy alto rendimiento, a la par con NodeJS y Go, gracias a Starlette y Pydantic
Rápido de programar: Incrementa la velocidad de desarrollo entre 200% y 300%
Menos errores: Reduce alrededor del 40% de errores inducidos por desarrolladores
Intuitivo: Gran soporte en editores con autocompletado en todas partes, lo que reduce el tiempo de depuración
Fácil: Diseñado para ser fácil de usar y aprender, lo que reduce el tiempo leyendo documentación
Corto: Minimiza la duplicación de código con múltiples funcionalidades para cada declaración de parámetros
Robusto: Código listo para producción con documentación interactiva automática
Basado en estándares: Totalmente compatible con los estándares abiertos para APIs, como OpenAPI y JSON Schema

FastAPI se apoya internamente en dos bibliotecas clave: Starlette para la parte web y Pydantic para la validación de datos. Esta combinación le permite alcanzar un rendimiento comparable al de frameworks escritos en Go o NodeJS.

Instalando FastAPI

Para comenzar a trabajar con FastAPI, necesitas instalarlo junto con un servidor ASGI (Asynchronous Server Gateway Interface), como uvicorn, que será el encargado de ejecutar tu aplicación.

Si estás utilizando uv para gestionar tu proyecto, lo cual es recomendado, puedes añadir las dependencias con el siguiente comando:

Terminal

$ uv add fastapi uvicorn

Alternativamente, puedes usar pip directamente en tu entorno virtual Python:

Terminal

(.venv) $ pip install fastapi uvicorn

Creando una aplicación FastAPI

Con FastAPI instalado, estás listo para crear tu primera API. Para comenzar, crearás una aplicación de Hola, Mundo! Crea un archivo llamado main.py con el siguiente contenido:

Python - main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hola, Mundo!"}

Veamos qué está pasando en este código:

from fastapi import FastAPI: Importas la clase principal FastAPI
app = FastAPI(): Creas una instancia de la aplicación. Esta instancia app será el punto de interacción principal para crear tu API
@app.get("/"): Este decorador le dice a FastAPI que la función que está justo debajo se encarga de manejar las peticiones que van al path /, es decir, la raíz, usando la operación HTTP GET
def read_root(): Esta es la función que define la lógica del endpoint
return {"message": "Hola, Mundo!"}: Retornas un diccionario que FastAPI convierte a JSON y envía la respuesta en el formato esperado

Ejecutando el servidor

Para ver tu aplicación en acción, ejecuta el siguiente comando en tu terminal. Asegúrate de estar en el mismo directorio que main.py:

Terminal

$ uvicorn main:app --reload

La opción --reload hace que el servidor se reinicie automáticamente cada vez que guardas cambios en tu código, lo cual es ideal durante el proceso de desarrollo.

Al ejecutarse el comando, verás una salida similar a esta:

Texto

INFO:     Will watch for changes in these directories: ['/home/user/app']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [28720] using WatchFiles
INFO:     Started server process [28722]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Abre tu navegador y ve a http://127.0.0.1:8000. Verás la respuesta en JSON:

Json

{"message":"Hola, Mundo!"}

Documentación interactiva

Una de las características más deseables de FastAPI es que genera documentación interactiva automáticamente, sin escribir una sola línea extra de código. Puedes consultarla yendo a http://127.0.0.1:8000/docs:

Documentación interactiva automática (Swagger UI)

Desde aquí puedes ver tus endpoints, probarlos directamente desde el navegador y examinar las respuestas en formato JSON. Esta funcionalidad es especialmente útil durante el desarrollo, puesto que te permite depurar y verificar tu API sin necesidad de herramientas externas como Postman o cURL.

También tienes disponible una documentación alternativa basada en ReDoc en http://127.0.0.1:8000/redoc.

Explorando las operaciones HTTP

Para construir APIs efectivas, es importante entender cómo funcionan las peticiones HTTP. Cuando un cliente, como un navegador o una app móvil, quiere interactuar con tu API, envía una petición o request, y tu servidor devuelve una respuesta o response.

En FastAPI, cada operación de ruta corresponde a un método HTTP específico:

GET: Leer datos
POST: Crear datos
PUT: Actualizar datos
DELETE: Borrar datos

Por eso usas @app.get("/") para leer la raíz. Si quisieras crear un elemento, usarías @app.post("/").

Usando parámetros de ruta

A menudo necesitarás obtener un elemento específico de tu API, por ejemplo, un usuario por su ID. FastAPI te permite hacer esto definiendo parámetros en la ruta.

Añade la siguiente función a tu archivo main.py:

Python - main.py

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

El valor del argumento de ruta item_id se pasará a tu función como el argumento item_id. Observa el identificador de tipo: item_id: int. Esto le dice a FastAPI que valide que el valor sea un entero. La validación es automática gracias a los type hints de Python.

Si vas a http://127.0.0.1:8000/items/5, verás:

Json

{"item_id":5}

Pero si intentas ir a http://127.0.0.1:8000/items/foo, verás un error HTTP indicando que el valor no es un entero válido. FastAPI se encarga de esta validación automáticamente.

Usando parámetros de query

Cuando declaras otros parámetros en la función que no son parte de la ruta, FastAPI los interpreta automáticamente como parámetros de query, es decir, los que van después del signo de interrogación, ?, en la URL:

Python - main.py

@app.get("/items/")
def read_items(skip: int = 0, limit: int = 10):
    return {"fake_items_db": [{"item_name": "Foo"}, {"item_name": "Bar"}]}

Aquí, skip tiene un valor por defecto de 0 y limit de 10. Como son int, FastAPI también los validará. Prueba ir a: http://127.0.0.1:8000/items/?skip=0&limit=1.

Los parámetros de query son opcionales cuando tienen valores por defecto. Si no proporcionas un valor, FastAPI usará el valor por defecto que definiste en la firma de la función.

Validando datos con modelos Pydantic

Para enviar datos a tu API, por ejemplo para crear un item, necesitas usar el cuerpo de la petición. FastAPI usa Pydantic para esto, lo cual es una de sus mayores fortalezas.

Primero, importa BaseModel de pydantic y define tu modelo de datos con los campos necesarios:

Python - main.py

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = False

En este modelo, name y price son campos obligatorios pues no tienen valor por defecto. En contraste, is_offer es opcional y su valor por defecto es False.

Ahora, usa una Item como un parámetro en tu operación POST para crear un nuevo item:

Python - main.py

@app.post("/items/")
def create_item(item: Item):
    return {
        "item_name": item.name,
        "item_price": item.price,
        "is_offer": item.is_offer
    }

FastAPI hará lo siguiente automáticamente:

Leer el cuerpo de la petición como JSON
Convertir los tipos correspondientes si es necesario
Validar los datos y devolver un error si, por ejemplo, envías un string en price
Entregarte el objeto item en tu función, con autocompletado en tu editor

Esta validación automática es una de las grandes ventajas de FastAPI frente a otros frameworks. No necesitas escribir código de validación manual, lo que reduce la cantidad de errores y simplifica tu código considerablemente.

Puedes probar este endpoint con curl desde tu terminal:

Terminal

$ curl -X POST http://127.0.0.1:8000/items/ \
    -H "Content-Type: application/json" \
    -d '{"name": "Laptop", "price": 999.99, "is_offer": true}'

La respuesta será:

Json

{"item_name":"Laptop","item_price":999.99,"is_offer":true}

Si omites un campo obligatorio o envías un tipo incorrecto, FastAPI responderá con un error 422 detallando exactamente qué falló en la validación.

Demo API con FastAPI: Autos

Ahora que conoces las bases de FastAPI, es momento de reunir todo en un ejemplo más completo. Crearás una pequeña API para gestionar un catálogo de autos que incluye operaciones GET y POST.

Crea un archivo llamado cars.py con el siguiente contenido:

Python - cars.py

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Base de datos simulada
cars_db = [
    {"id": 1, "brand": "Toyota", "model": "Corolla", "year": 2022},
    {"id": 2, "brand": "Honda", "model": "Civic", "year": 2023},
]

class Car(BaseModel):
    brand: str
    model: str
    year: int

@app.get("/cars/")
def get_cars():
    return cars_db

@app.get("/cars/{car_id}")
def get_car(car_id: int):
    for car in cars_db:
        if car["id"] == car_id:
            return car
    return {"error": "Auto no encontrado"}

@app.post("/cars/")
def create_car(car: Car):
    new_id = max(c["id"] for c in cars_db) + 1
    new_car = {"id": new_id, **car.model_dump()}
    cars_db.append(new_car)
    return new_car

En este ejemplo, usas una lista de diccionarios como base de datos simulada. La API expone tres endpoints:

GET /cars/: Devuelve todos los autos del catálogo
GET /cars/{car_id}: Devuelve un auto específico por su ID usando un parámetro de ruta
POST /cars/: Crea un nuevo auto validando los datos con el modelo Car

Ejecuta el servidor con:

Terminal

$ uvicorn cars:app --reload

Ahora puedes consultar todos los autos:

Terminal

$ curl http://127.0.0.1:8000/cars/

La salida de este comando será la siguiente:

Json

[
    {"id": 1, "brand": "Toyota", "model": "Corolla", "year": 2022},
    {"id": 2, "brand": "Honda", "model": "Civic", "year": 2023}
]

Para obtener un auto específico, puedes usar su id:

Terminal

$ curl http://127.0.0.1:8000/cars/1

En este caso, obtendrás el JSON siguiente:

Json

{"id": 1, "brand": "Toyota", "model": "Corolla", "year": 2022}

Finalmente, para crear un nuevo auto, puedes hacerlo así:

Terminal

$ curl -X POST http://127.0.0.1:8000/cars/ \
    -H "Content-Type: application/json" \
    -d '{"brand": "Ford", "model": "Mustang", "year": 2024}'

Y obtendrás lo siguiente:

Json

{"id": 3, "brand": "Ford", "model": "Mustang", "year": 2024}

Con este ejemplo puedes ver cómo FastAPI te permite construir una API funcional con muy pocas líneas de código, combinando parámetros de ruta, modelos Pydantic y múltiples operaciones HTTP.

Conclusión

Las APIs representan una parte esencial del desarrollo de software moderno. Python ofrece varios frameworks que pueden ayudarte a desarrollar APIs robustas y de alto rendimiento.

En este tutorial, aprendiste cómo usar FastAPI, que es uno de los frameworks más populares y eficientes para el desarrollo de APIs en Python.

En este tutorial, has aprendido a:

Instalar FastAPI y configurarlo en tu computadora
Crear tu primera API con un endpoint básico
Usar parámetros de ruta y parámetros de query para recibir datos
Validar datos de entrada con modelos Pydantic
Aprovechar la documentación interactiva automática

Ahora puedes usar tus conocimientos de Python y FastAPI para dar vida a tus propias APIs. Para seguir profundizando, puedes explorar la documentación oficial, aprender sobre inyección de dependencias, conectar tu API a una base de datos o implementar autenticación con tokens JWT.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: try

2026-02-08T19:35:00+01:00

Junto con las cláusulas except, else y finally, esta palabra clave te ofrece un control preciso sobre el flujo de ejecución cuando surgen condiciones inesperadas en tu código.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de try
Resumiendo

Sintaxis

La sintaxis básica para usar try es la siguiente:

Sintaxis de Python

try:
    <block>
except ExceptionType [as variable]:
    <handler>
[else:
    <no_error_block>]
[finally:
    <cleanup_block>]

Los corchetes indican elementos opcionales. Para que un bloque try sea válido, debes incluir al menos una cláusula except o una cláusula finally.

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo se utiliza la palabra clave try:

Python REPL

>>> try:
...     result = 10 / 0
... except ZeroDivisionError:
...     print("Error: división por cero")
...
Error: división por cero

En este ejemplo, intentas dividir 10 entre 0, lo cual genera una excepción ZeroDivisionError. Con try y except, capturas esta excepción e imprimes un mensaje de error en lugar de que el programa falle.

Puedes acceder a los detalles de la excepción usando la palabra clave as:

Python REPL

>>> try:
...     number = int("abc")
... except ValueError as error:
...     print(f"No se pudo convertir: {error}")
...
No se pudo convertir: invalid literal for int() with base 10: 'abc'

La cláusula else se ejecuta únicamente cuando no ocurre ninguna excepción:

Python REPL

>>> try:
...     result = 10 / 2
... except ZeroDivisionError:
...     print("Error: división por cero")
... else:
...     print(f"Resultado: {result}")
...
Resultado: 5.0

La cláusula finally se ejecuta siempre, haya o no una excepción. Esto la hace ideal para liberar recursos:

Python REPL

>>> try:
...     result = 10 / 0
... except ZeroDivisionError:
...     print("Error: división por cero")
... finally:
...     print("Bloque finally ejecutado")
...
Error: división por cero
Bloque finally ejecutado

También puedes capturar múltiples excepciones en un solo bloque try:

Python REPL

>>> def divide(a, b):
...     try:
...         result = a / b
...     except ZeroDivisionError:
...         print("Error: división por cero")
...     except TypeError:
...         print("Error: tipo de dato no válido")
...     else:
...         print(f"Resultado: {result}")
...

>>> divide(10, 0)
Error: división por cero

>>> divide(10, "2")
Error: tipo de dato no válido

>>> divide(10, 2)
Resultado: 5.0

Uso de `try`

Los casos de uso más comunes de la palabra clave try incluyen los siguientes:

Manejar excepciones específicas y prevenir que el programa se detenga abruptamente.
Proporcionar mensajes de error personalizados o realizar acciones específicas cuando ocurren errores.
Acceder a los detalles de una excepción usando as para registrar o presentar información útil.
Ejecutar lógica alternativa con else cuando el código del bloque try se ejecuta sin errores.
Limpiar recursos con la cláusula finally, asegurando que ciertas acciones se realicen sin importar si ocurrió una excepción o no.
Combinar try con la palabra clave with para gestionar recursos externos de forma segura.

Resumiendo

La palabra clave try en Python es esencial para el manejo de excepciones, permitiéndote escribir código más robusto y fácil de mantener.

Conocer y emplear try junto con except, else y finally te permite gestionar errores de manera clara y controlada, manteniendo tu programa funcionando sin interrupciones inesperadas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: in

2026-02-05T21:00:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de in
Resumiendo

Sintaxis

La sintaxis de la palabra clave in como operador de pertenencia es la siguiente:

Sintaxis de Python

element in sequence

Para los bucles for, la sintaxis es:

Sintaxis de Python

for element in sequence:
    <block>

Ejemplos prácticos

Aquí tienes algunos ejemplos de cómo puedes usar la palabra clave in:

Python REPL

>>> "a" in "manzana"
True

>>> 3 in [1, 2, 3, 4, 5]
True

>>> 7 in {1, 2, 3, 4, 5}
False

El operador in devuelve True cuando el elemento existe en la colección y False en caso contrario.

Cuando usas in en un bucle for, puedes iterar a través de cada elemento de un iterable:

Python REPL

>>> for letter in "hola":
...     print(letter)
...
h
o
l
a

En este caso, se itera a través de cada carácter de la cadena "hola", imprimiéndolos uno por uno.

Uso de `in`

Los casos de uso más comunes de la palabra clave in incluyen los siguientes:

Comprobar si un elemento está presente en una colección como listas, tuplas, cadenas, conjuntos o diccionarios.
Verificar si una clave existe en un diccionario.
Iterar sobre elementos de un iterable utilizando bucles for.
Comprobar si un elemento no pertenece a una colección combinando not con in.

Resumiendo

La palabra clave in te permite verificar la pertenencia de elementos en secuencias. También es clave en ciclos for.

Conocer y emplear in de forma eficiente te ayudará a escribir código más claro y conciso al trabajar con colecciones de datos. Consulta también los artículos sobre not, for y colecciones para ampliar tus conocimientos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: not

2026-01-31T12:00:00+01:00

Cuando usas not, estás diciendo esencialmente "no" al valor de verdad que se evalúa, convirtiendo True en False y viceversa.

Sintaxis

La sintaxis para utilizar not es bastante sencilla:

Sintaxis de Python

not expression
not obj

Aquí, expression es cualquier expresión que retorne un valor booleano o no. Mientras que obj es cualquier objeto Python.

Ejemplos prácticos

Veamos algunos ejemplos de cómo puedes usar not en Python:

Python REPL

>>> not True
False

>>> not False
True

>>> not 5 > 3
False

>>> not 3 > 5
True

En estos ejemplos, puedes ver la lógica de funcionamiento del operador. Cuando ejecutas not True, el resultado es False y not False se convierte en True. También puedes ver cómo se puede aplicar not a expresiones más complejas como comparaciones.

A diferencia de otros operadores lógicos como and y or, not siempre devuelve un valor booleano:

Python REPL

>>> not 5
False

>>> not []
True

Cuando empleas not con objetos o valores, en lugar de con expresiones booleanas, Python determina el valor de verdad del objeto y lo convierte en el valor opuesto.

También puedes combinar not con and y or. Estos operadores son fundamentales para construir condiciones y controlar el flujo de tus programas.

Uso de `not`

Los casos de uso más comunes de la palabra clave not incluyen los siguientes:

Invertir el valor de una expresión booleana en sentencias de control de flujo, como if y while.
Simplificar las condiciones lógicas en el código para hacerlo más legible.
Negar condiciones en expresiones condicionales para ejecutar bloques de código específicos.

Resumiendo

La palabra clave not en Python invierte el valor de verdad de un objeto, lo que te permite tener un mayor control sobre las condiciones lógicas en tu código.

Conocer y usar not de forma eficiente puede simplificar tus sentencias de control de flujo y mejorar la claridad del código al manejar condiciones negativas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: yield

2026-01-22T16:00:00+01:00

Sintaxis

La sintaxis para utilizar yield en una función es la siguiente:

Sintaxis de Python

def generator():
    yield value

Solo necesitas incluir la palabra clave yield seguida del valor que deseas devolver.

Los generadores también pueden incluir varios yield:

Sintaxis de Python

def gen_numbers():
    yield 0
    yield 1
    yield 2

Finalmente, es común usar yield en un ciclo for:

Sintaxis de Python

def gen_numbers():
    for number in range(3):
        yield number

Ejemplos prácticos

Veamos un ejemplo de cómo se usa la palabra clave yield en Python:

Python REPL

>>> def counter():
...     n = 0
...     while n < 3:
...         yield n
...         n += 1
...

>>> gen = counter()
>>> next(gen)
0
>>> next(gen)
1
>>> next(gen)
2

>>> next(gen)
Traceback (most recent call last):
    ...
StopIteration

En este ejemplo, la función counter() es un generador que utiliza yield para devolver los valores 0, 1 y 2, uno a la vez, cada vez que se llama a next() en el generador.

Si intentas llamar a next(gen) una vez que el generador ha producido todos sus valores, Python lanzará una excepción StopIteration. Esta excepción indica que no quedan más elementos por generar y es el comportamiento esperado para finalizar la iteración.

En la mayoría de los casos, usarás un ciclo for para iterar sobre el generador:

Python REPL

>>> for count in counter():
...     print(count)
...
0
1
2

En este ejemplo, el ciclo for gestiona automáticamente el fin de la iteración cuando ocurre la excepción StopIteration.

Uso de `yield`

Los casos de uso más comunes de la palabra clave yield incluyen los siguientes:

Crear generadores que producen una secuencia de valores donde cada valor se genera bajo demanda, lo cual es útil para manejar grandes cantidades de datos haciendo un uso eficiente de la memoria.
Implementar algoritmos que requieren una pausa y reanudación de su estado, como iteradores personalizados.
Mejorar la eficiencia de memoria al no requerir que se almacenen todos los valores en la memoria al mismo tiempo.

Resumiendo

La palabra clave yield en Python te permite crear generadores para gestionar y procesar grandes cantidades de datos de manera eficiente y con un uso mínimo de memoria.

Conocer y emplear yield te permite escribir código más eficiente y legible, especialmente cuando trabajas con flujos de datos continuos o grandes.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: from

2026-01-21T13:05:00+01:00

Esta palabra clave se emplea generalmente en combinación con import y permite acceder solo a objetos específicos de un módulo sin cargar todo el contenido del módulo.

Además, from tiene otros usos en Python:

Con raise: Encadena excepciones y preserva el contexto del error original.
Con yield: Delega la iteración a otro generador o iterable.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de from
Resumiendo

Sintaxis

La sintaxis básica para utilizar from junto con import es la siguiente:

Sintaxis de Python

from module_name import specific_component

Si necesitas crear un alias para evitar conflictos de nombres o simplificar el uso, puedes usar as:

Sintaxis de Python

from module_name import specific_component as alias

También puedes importar múltiples componentes separados por comas:

Sintaxis de Python

from module_name import component1, component2

Además, puedes usar * para importar todos los componentes del módulo:

Sintaxis de Python

from module_name import *

Esta sintaxis se conoce como wildcard import y es común en secciones de trabajo interactivas. Sin embargo, no se recomienda usarla en código en producción pues puede causar conflictos de nombres y dificultar la depuración.

Sintaxis para el uso con raise:

Sintaxis de Python

raise NewException("mensaje") from original_exception

Si deseas suprimir el contexto de la excepción original, puedes usar None:

Sintaxis de Python

raise NewException("mensaje") from None

Sintaxis para el uso con yield:

Sintaxis de Python

yield from iterable

Esta sintaxis equivale a iterar sobre el iterable y producir cada elemento uno por uno.

Ejemplos prácticos

Aquí hay algunos ejemplos que ilustran cómo se usa la palabra clave from:

Python REPL

>>> from math import pi
>>> pi
3.141592653589793

En este ejemplo, solo se importa pi del módulo math, permitiéndote usarlo directamente sin tener que prefijarlo con math.

Python REPL

>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> future = now + timedelta(days=5)
>>> future
datetime.datetime(2023, 10, 27, 15, 34, 50, 401213)

En este ejemplo, se importan datetime y timedelta del módulo datetime. Esto permite trabajar con fechas y tiempos de manera más directa.

A continuación, un ejemplo de encadenamiento de excepciones con raise from:

Python REPL

>>> def connect_to_database(connection_string):
...     try:
...         # Código de conexión
...         raise ConnectionError("no se pudo conectar al servidor")
...     except ConnectionError as error:
...         raise RuntimeError("error en la base de datos") from error
...

>>> connect_to_database("localhost:5432")
Traceback (most recent call last):
    ...
ConnectionError: no se pudo conectar al servidor

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
    ...
RuntimeError: error en la base de datos

En este ejemplo, se preserva la excepción original (ConnectionError) como causa directa del nuevo error (RuntimeError).

Finalmente, un ejemplo de delegación de iteración con yield from:

Python REPL

>>> def combine(first, second):
...     yield from first
...     yield from second
...

>>> list(combine([1, 2], [3, 4]))
[1, 2, 3, 4]

En este ejemplo, yield from delega la iteración a cada lista, produciendo sus elementos sin necesidad de un bucle explícito.

Uso de `from`

Los casos de uso más comunes de la palabra clave from incluyen los siguientes:

Importar componentes específicos de un módulo para mantener el namespace limpio y mejorar la legibilidad.
Evitar conflictos de nombres al importar solo lo necesario.
Hacer el código más limpio y fácil de entender al eliminar la necesidad de prefijos de módulo para componentes importados.
Permitir la importación de múltiples componentes de un módulo en una sola línea.
Encadenar excepciones con raise ... from ... para preservar el contexto del error original.
Delegar la iteración a otro generador o iterable con yield from.

Resumiendo

La palabra clave from en Python es una herramienta versátil con múltiples usos: importar componentes específicos de módulos, encadenar excepciones con raise y delegar iteraciones con yield.

Dominar estos usos te permite escribir código más claro, modular y expresivo en diferentes contextos de programación.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: or

2026-01-09T18:35:00+01:00

Este operador se emplea para combinar condiciones lógicas y es fundamental para la toma de decisiones en el flujo de un programa.

Sintaxis

La sintaxis para utilizar or es la siguiente:

Sintaxis de Python

expr1 or expr2

Donde expr1 y expr2 son las expresiones lógicas que deseas evaluar. Si alguna de ellas es verdadera, el resultado será True. Si ambas son falsas, el resultado es False.

El operador or aplica lo que se conoce como evaluación diferida (short-circuiting): si expr1 es verdadera, entonces Python no evalúa expr2.

Además, or devuelve el primer operando con valor de verdad verdadero (truthy). Si ninguno es verdadero, devuelve el último operando. Por lo tanto, no siempre devuelve True o False.

La tabla de verdad del operador cuando lo usamos con expresiones lógicas se resume a continuación:

`expression_1` (bool)	`expression_2` (bool)	`expression_1 or expression_2`
`True`	`True`	`True`
`True`	`False`	`True`
`False`	`False`	`False`
`False`	`True`	`True`

Ejemplos prácticos

Aquí tienes algunos ejemplos prácticos que muestran cómo se usa el operador or:

Python REPL

>>> 5 > 3 or 2 < 1
True

>>> 5 == 6 or 4 != 4
False

En estos ejemplos, el operador or evalúa las expresiones a la izquierda y a la derecha. Si alguna de las expresiones es verdadera, el resultado de toda la expresión es True. En el caso de que ambas expresiones sean falsas, el resultado es False.

Si usamos or con objetos concretos o con expresiones que retornan objetos distintos de True o False, tenemos el comportamiento siguiente:

Python REPL

>>> "" or "default"
'default'

>>> 0 or 5
5

>>> 5 or 0
5

>>> None or []
[]

En estos ejemplos, el operador devuelve objetos concretos en lugar de los valores True o False. Esto se debe a que todo objeto en Python tiene un valor de verdad intrínseco. Estos son los objetos considerados falsos:

constantes definidas para tener valor falso: None y False.

cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0) (Fuente)

El resto de los objetos son considerados verdaderos a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva zero.

Uso de `or`

Los casos de uso más comunes de la palabra clave or incluyen los siguientes:

Evaluar múltiples condiciones en declaraciones de control de flujo como if, while, o assert.
Simplificar la lógica condicional al permitir que al menos una condición sea verdadera para que la expresión completa sea verdadera.
Utilizar en expresiones booleanas para determinar el flujo de un programa.

Resumiendo

La palabra clave or es un operador lógico esencial en Python y permite evaluar múltiples condiciones y devolver True si al menos una es verdadera o False si ambas son falsas.

Conocer y utilizar or te ayuda a escribir código más eficiente y legible al simplificar la lógica condicional en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: raise

2026-01-06T10:00:00+01:00

Te permite señalar la ocurrencia de un error que debe manejarse, interrumpiendo el flujo normal de ejecución y activando el mecanismo de manejo de excepciones.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de raise
Resumiendo

Sintaxis

La sintaxis básica para usar raise es la siguiente:

Sintaxis de Python

raise ExceptionType("mensaje opcional")

Aquí, ExceptionType es el tipo de excepción que deseas generar o lanzar, y el "mensaje opcional" proporciona más detalles sobre la excepción.

Para encadenar excepciones y conservar el contexto del error original, puedes usar la palabra clave from:

Sintaxis de Python

raise NewException("mensaje") from original_exception

Esto permite que la nueva excepción conserve la traza (traceback) de la excepción original, facilitando la depuración.

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo usar raise:

Python REPL

>>> raise ValueError("este es un error de valor")
Traceback (most recent call last):
    ...
ValueError: este es un error de valor

En este ejemplo, raise genera un ValueError con un mensaje personalizado.

También puedes definir tus propias excepciones personalizadas y generarlas con raise:

Python REPL

>>> class CustomException(Exception):
...     pass
...

>>> raise CustomException("esto es un error personalizado")
Traceback (most recent call last):
    ...
CustomException: esto es un error personalizado

Aquí, defines una nueva clase de excepción llamada CustomException que hereda de Exception, y luego la lanzas usando raise.

Python REPL

>>> try:
...     int("abc")
... except ValueError as original_error:
...     raise RuntimeError("error al convertir a entero") from original_error
...
Traceback (most recent call last):
    ...
ValueError: invalid literal for int() with base 10: 'abc'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
    ...
RuntimeError: error al convertir a entero

Aquí, raise ... from ... permite que la excepción RuntimeError conserve la traza de la excepción original, facilitando la depuración.

En la práctica, debes generar excepciones en código de bajo nivel (backend) y capturarlas en código de alto nivel (frontend).

Uso de `raise`

Los casos de uso más comunes de la palabra clave raise incluyen los siguientes:

Generar excepciones personalizadas para indicar condiciones de error específicas.
Interrumpir el flujo de ejecución normal cuando se detecta un error que no puede manejarse en el contexto actual.
Proporcionar mensajes de error contextualizados que ayuden a depurar problemas en el código.

Resumiendo

La palabra clave raise es una herramienta para el manejo de excepciones que te permite generar errores de manera explícita cuando las condiciones del programa lo requieran.

El uso correcto de raise contribuye a la robustez y mantenibilidad de tu código.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: elif

2026-01-03T20:45:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de elif
Resumiendo

Sintaxis

La sintaxis básica para emplear la palabra clave elif es la siguiente:

Sintaxis de Python

if condition1:
    # Código si condition1 es verdadera
elif condition2:
    # Código si condition2 es verdadera
...
elif conditionN:
    # Código si conditionN es verdadera
else:
    # Código si ninguna de las condiciones anteriores es verdadera

Ejemplos prácticos

Veamos un ejemplo de cómo puedes usar la palabra clave elif en Python:

Python REPL

>>> x = 10

>>> if x < 0:
...     print("x es negativo")
... elif x == 0:
...     print("x es cero")
... elif x == 10:
...     print("x es diez")
... else:
...     print("x es positivo")
...
x es diez

En este ejemplo, x es 10. La primera condición if es falsa; el primer elif también es falso, pero el segundo elif es verdadero, por lo que se ejecuta ese bloque y se imprime "x es diez".

Debes tener en cuenta que elif se adecúa mejor a situaciones donde tus condiciones son mutuamente excluyentes y evalúan el estado de una misma variable. Python evalúa las ramas en orden y ejecuta solo la primera condición verdadera, por lo que usar elif deja claro que solo una rama debe ejecutarse.

Un ejemplo típico de condiciones mutuamente excluyentes es cuando necesitas clasificar códigos de estado HTTP según su rango de valores:

Python REPL

>>> status_code = 404

>>> if 100 <= status_code < 200:
...     print("Respuesta informativa")
... elif 200 <= status_code < 300:
...     print("Respuesta exitosa")
... elif 300 <= status_code < 400:
...     print("Redirección")
... elif 400 <= status_code < 500:
...     print("Error del cliente")
... elif 500 <= status_code < 600:
...     print("Error del servidor")
... else:
...     print("Código desconocido")
...
Error del cliente

Aquí, todas las condiciones evalúan el estado de una misma variable, status_code, y solo una rama debe ejecutarse. Por eso, elif es la opción natural.

Si necesitas comprobar condiciones independientes donde podrían cumplirse varias, utiliza un bloque if separado para cada una.

Uso de `elif`

Los casos de uso más comunes de la palabra clave elif incluyen los siguientes:

Verificar múltiples condiciones para tomar decisiones en el flujo de control.
Mejorar la legibilidad al organizar claramente condiciones mutuamente excluyentes.

Resumiendo

La palabra clave elif en Python te permite manejar múltiples condiciones dentro de una sentencia if. Al usar elif, puedes mejorar la legibilidad de tu código cuando necesitas evaluar más de dos condiciones.

Conocer y emplear elif te permitirá escribir código más claro y eficiente en tus programas de Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Iniciando con Kivy para desarrollo GUI

2026-01-02T16:45:00+01:00

Si quieres crear interfaces gráficas en Python con un enfoque moderno y con soporte para gestos y multitouch en dispositivos móviles y táctiles, Kivy es una buena opción.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Conociendo Kivy

Kivy es un framework para crear aplicaciones con interfaces gráficas en Python. Está pensado para UI con soporte multitouch y puede ejecutarse en varios sistemas operativos.

Kivy funciona muy bien cuando:

Quieres una GUI en Python con componentes y layouts listos para usar
Te interesa reutilizar la misma base de código en escritorio y, más adelante, empaquetar para móviles
Prefieres un enfoque declarativo para la interfaz y dejar la lógica de negocio en Python

Instalando Kivy

La forma recomendada de instalar Kivy es usar un entorno virtual y luego instalar el framework desde PyPI. Los comandos necesarios pueden variar un poco según tu sistema operativo.

En Windows

En Windows, puedes crear el entorno virtual e instalar Kivy ejecutando los comandos siguientes:

Powershell

PS> python -m venv venv
PS> venv\Scripts\Activate.ps1
(venv) PS> python -m pip install "kivy[base]"

Con estos comandos, primero creas y activas un entorno virtual de Python y luego instalas Kivy desde PyPI. Opcionalmente, puedes instalar los ejemplos de Kivy con el paquete kivy_examples.

En Linux y macOS

En Linux y macOS el proceso es similar y puedes realizarlo con los siguientes comandos:

Terminal

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install "kivy[base]"

Kivy también ofrece las variantes kivy[base,media] o kivy[full] para incluir más opciones y funcionalidades, como, por ejemplo, el manejo de audio y video. Si estás comenzando, kivy[base] suele ser suficiente.

Creando una aplicación Kivy

Una aplicación mínima en Kivy generalmente requiere que sigas los pasos siguientes:

Crear una subclase de App.
Implementar el método .build() para devolver el widget raíz de la UI.
Crear una instancia de la clase y llamar su método .run().

Para traducir estos pasos a código Python, guarda el código siguiente como hello.py:

Python - hello.py

from kivy.app import App
from kivy.uix.label import Label

class HelloApp(App):
    def build(self):
        return Label(text="Hola, Mundo!")

HelloApp().run()

En este ejemplo, importas App como la clase base de tu aplicación. También importas Label para mostrar texto en pantalla. Luego defines HelloApp heredando de App e implementas .build() para construir la interfaz. El widget que devuelves en este método será la raíz del árbol de widgets de Kivy. En este ejemplo, usas el Label con el texto Hola, Mundo!.

Por último, creas la instancia de HelloApp y llamas al método .run(). Con esto, Kivy inicia la aplicación y su bucle principal de eventos, abre la ventana y renderiza el Label que devolviste en .build().

Puedes ejecutar la aplicación con el comando siguiente:

Terminal

$ python hello.py

Una vez que ejecutas este comando, verás en pantalla una ventana que luce como la siguiente:

Aplicación "Hola, Mundo!" con Kivy y Python

Explorando widgets comunes en Kivy

En Kivy, una interfaz (UI) es un árbol de widgets. Muchos widgets exponen eventos, como on_press en un Button. También tienen propiedades como .text, .active o .value, que puedes vincular con .bind() para reaccionar a eventos de usuario.

En las siguientes secciones, encontrarás una selección de widgets básicos que te ayudarán a comprender conceptos fundamentales para empezar a crear tus GUIs con Kivy.

Botones clicables

La clase Button ofrece un widget clicable en forma rectangular. Algunos botones típicos incluyen Ok, Cancelar, Aplicar, Sí, No, Cerrar, entre otros. He aquí un ejemplo que crea estos botones:

Python - buttons.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button

class ButtonsApp(App):

    def build(self):
        self.title = "Botones Kivy"
        Window.size = (200, 200)
        layout = BoxLayout(orientation="vertical", padding=20, spacing=10)

        for text in ["Ok", "Cancelar", "Aplicar", "Sí", "No", "Cerrar"]:
            button = Button(text=text)
            layout.add_widget(button)

        return layout
    
ButtonsApp().run()

En este ejemplo, la clase ButtonsApp crea una ventana que muestra varios botones en una columna. En .build(), primero configuras la ventana con un título y un tamaño apropiado. Luego, creas un BoxLayout vertical con padding y spacing para garantizar margen interno y separación entre los botones.

El ciclo for recorre la lista de botones y los crea para luego añadirlos al layout con .add_widget(). Al final, .build() devuelve el layout como widget raíz.

Cuando corres la aplicación, obtienes una ventana como la siguiente:

Botones en Kivy

Estos botones todavía no ejecutan ninguna acción al hacer clic en ellos, pues aún no están vinculados o enlazados a una función o método. Aprenderás sobre esto en la sección "Conectando eventos con callbacks en Kivy".

Campos de entrada de texto

TextInput permite que el usuario escriba texto. Considera el siguiente ejemplo que crea un formulario para entrada de credenciales de usuario:

Python - text_inputs.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.textinput import TextInput

class TextInputApp(App):
    def build(self):
        self.title = "Campos de texto Kivy"
        Window.size = (250, 180)
        layout = BoxLayout(orientation="vertical", padding=20, spacing=10)
        for text in ["Nombre", "Usuario", "Contraseña"]:
            entry = TextInput(
                hint_text=text,
                multiline=False,
            )
            layout.add_widget(entry)
        return layout

TextInputApp().run()

Este ejemplo muestra cómo usar TextInput para crear campos de texto. En el ciclo for, creas tres instancias de TextInput y las agregas al BoxLayout, de modo que cada campo aparezca apilado en la ventana. La propiedad hint_text actúa como texto de ayuda (placeholder) y le indica al usuario qué debe escribir en cada campo.

Además, al establecer multiline=False, le dices a TextInput que actúe como un campo de una sola línea.

A continuación se muestra cómo luce tu aplicación:

Campos de texto en Kivy

Prueba a introducir texto en cada campo. También podrás copiar y pegar texto con las combinaciones de teclas Ctrl+C y Ctrl+V, respectivamente.

Botones de opción

La clase CheckBox representa una opción booleana que te permite activar o desactivar características, funcionalidades, configuraciones y similares:

Python - checkboxes.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.checkbox import CheckBox
from kivy.uix.label import Label

class CheckBoxApp(App):
    def build(self):
        self.title = "Botones de opción Kivy"
        Window.size = (250, 150)
        Window.clearcolor = (1, 1, 1, 1)

        options = [
            "Recibir notificaciones",
            "Aceptar términos y condiciones",
            "Suscribirse al boletín",
        ]

        layout = BoxLayout(orientation="vertical", padding=10, spacing=10)

        for option in options:
            row = BoxLayout(orientation="horizontal", spacing=8)
            row.add_widget(CheckBox(size_hint_x=None, width=30))

            label = Label(
                text=option,
                color=(0, 0, 0, 1),
                size_hint_x=None,
            )
            label.texture_update()
            label.width = label.texture_size[0]

            row.add_widget(label)
            layout.add_widget(row)

        return layout

CheckBoxApp().run()

En este ejemplo, creas una lista de opciones con casillas de verificación usando objetos CheckBox. Creas un BoxLayout vertical para la aplicación y, para cada opción, construyes una fila horizontal (row) en la que insertas un checkbox. Al fijar size_hint_x=None y un width concreto, aseguras que todas las casillas tengan el mismo ancho y queden alineadas de forma consistente, una por fila, justo a la izquierda del texto.

Luego añades un Label con el texto de la opción y lo ajustas al tamaño real del contenido para que el texto quede pegado al checkbox sin ocupar el resto de la fila.

Finalmente, agregas cada fila al layout principal, lo que produce una columna de filas, cada una con su checkbox y su descripción al lado.

Al ejecutar esta aplicación, obtendrás una ventana similar a la siguiente:

Botones de opción en Kivy

Cuando haces clic en las casillas, las activas o desactivas alternativamente. Puedes usar la propiedad .active para comprobar el estado actual de cada casilla y tomar acciones en consecuencia.

Selectores deslizantes

La clase Slider proporciona un selector deslizante que es útil para seleccionar un valor dentro de un rango predeterminado:

Python - sliders.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.slider import Slider

class SliderApp(App):
    def build(self):
        self.title = "Selector deslizante Kivy"
        Window.size = (300, 150)

        root = BoxLayout(orientation="vertical", padding=20, spacing=10)

        label = Label(text="Valor: 0")
        slider = Slider(min=0, max=100, value=0)

        def on_value(instance, value):
            label.text = f"Valor: {int(value)}"

        slider.bind(value=on_value)

        root.add_widget(label)
        root.add_widget(slider)
        return root

SliderApp().run()

En este ejemplo, organizas la UI en un BoxLayout vertical, con un Label arriba y un Slider abajo. Creas el Slider con min=0, max=100 y value=0, que son los parámetros típicos para definir el rango y el valor inicial de este widget.

Luego, conectas el Slider con el Label mediante la función on_value(), que recibe el nuevo valor del control y actualiza el texto del label según los cambios. Al hacer slider.bind(value=on_value), le dices a Kivy que ejecute esa función cada vez que cambie la propiedad .value del Slider.

Ejecuta la app y obtendrás una ventana como la siguiente:

Selector deslizante en Kivy

Prueba a mover el selector del slider y verás cómo el Label se actualiza, lo que logra una interfaz reactiva que refleja el valor seleccionado en tiempo real.

Listas desplegables

La clase Spinner ofrece un selector compacto que muestra el valor actual y, al presionarlo, despliega una lista de opciones:

Python - spinners.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.spinner import Spinner

class SpinnerApp(App):
    def build(self):
        self.title = "Lista desplegable Kivy"
        Window.size = (250, 350)

        root = BoxLayout(orientation="vertical", padding=20, spacing=10)

        options = ("Kivy", "PyQt6", "PySide6", "Tkinter")
        base_text = "Framework GUI favorito"

        spinner = Spinner(
            text=base_text,
            values=options,
            size_hint_y=None,
            height=100,
        )
        root.add_widget(spinner)

        return root

SpinnerApp().run()

En este ejemplo, creas una lista desplegable usando Spinner. La lista muestra un texto inicial: Framework GUI favorito. Luego, añades una colección (tupla) de opciones entre las cuales el usuario podrá seleccionar una a la vez.

Si ejecutas esta aplicación, obtendrás una ventana como la siguiente:

Lista desplegable en Kivy

Aquí se muestra la lista desplegada. Puedes experimentar y seleccionar opciones de la lista. La opción seleccionada se mostrará en el selector compacto al cerrar la lista.

Usando gestores de disposición

Los layouts o gestores de disposición son contenedores que controlan la distribución de los widgets en la ventana de la aplicación. En Kivy, es habitual empezar con un layout mínimo y luego refinar la interfaz a medida que avanzas en el desarrollo de tu aplicación.

Disponer widgets en vertical u horizontal

La clase BoxLayout te permite organizar los widgets de forma secuencial, ya sea en orientación vertical (uno encima de otro) u horizontal (uno al lado del otro). El ejemplo siguiente demuestra la forma básica de usar este tipo de layout para disponer los widgets horizontalmente:

Python - box_layout_horizontal.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button

class BoxLayoutApp(App):
    def build(self):
        self.title = "Disposición horizontal Kivy"
        Window.size = (300, 100)

        root = BoxLayout(orientation="horizontal", padding=20, spacing=10)
        root.add_widget(Button(text="Izquierda"))
        root.add_widget(Button(text="Centro"))
        root.add_widget(Button(text="Derecha"))

        return root

BoxLayoutApp().run()

La orientación horizontal es la orientación por defecto del BoxLayout, así que puedes obtener el mismo resultado si omites el argumento orientation al crear la instancia de BoxLayout.

En un BoxLayout, el padding controla el margen interno del layout, es decir, el espacio entre el borde del contenedor y sus widgets hijos. En cambio, el spacing controla el espacio entre los widgets hijos. En este ejemplo, sería el espacio (en píxeles) que dejas entre un botón y el siguiente, ya sea en una columna (vertical) o en una fila (horizontal).

Así es como luce esta aplicación:

Disposición horizontal de widgets en Kivy

Para ordenar los widgets de manera vertical, solo tienes que hacer orientation="vertical":

Python - box_layout_vertical.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button

class BoxLayoutApp(App):
    def build(self):
        self.title = "Disposición vertical Kivy"
        Window.size = (300, 300)

        root = BoxLayout(orientation="vertical", padding=20, spacing=10)
        root.add_widget(Button(text="Arriba"))
        root.add_widget(Button(text="Centro"))
        root.add_widget(Button(text="Abajo"))

        return root

BoxLayoutApp().run()

Al ejecutar esta app, obtienes una ventana como la siguiente:

Disposición vertical de widgets en Kivy

Como puedes apreciar, ahora los botones se muestran en una sola columna, manteniendo el orden en que los añadiste en el código.

Organizar widgets en cuadrículas

La clase GridLayout te permite distribuir los widgets en una cuadrícula de filas y columnas. Para usarlo, debes especificar al menos una dimensión, por ejemplo, cols o rows para columnas o filas respectivamente:

Python - grid_layout.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.button import Button
from kivy.uix.gridlayout import GridLayout

class GridLayoutApp(App):
    def build(self):
        self.title = "Disposición en cuadrícula Kivy"
        Window.size = (300, 300)

        root = GridLayout(cols=2, padding=20, spacing=10)

        for index in range(6):
            root.add_widget(Button(text=f"index={index}"))

        return root

GridLayoutApp().run()

En este ejemplo, creas una app que organiza botones en una cuadrícula de dos columnas usando un GridLayout. Con cols=2 estableces cuántas columnas tendrá la cuadrícula.

Luego, en el ciclo for, creas seis botones y los vas añadiendo con .add_widget(). Kivy no coloca widgets en una fila o columna especificada, sino que asigna la posición automáticamente según el orden (index) en que agregas los widgets.

Si ejecutas la aplicación, obtendrás una ventana como la siguiente:

Disposición de widgets en cuadrícula en Kivy

Cada botón muestra el índice con el que fue creado, y GridLayout lo coloca en la cuadrícula según el orden en que lo agregas con .add_widget().

Colocar widgets en posiciones específicas

FloatLayout te da más libertad para posicionar los widgets. Este layout respeta las propiedades pos_hint y size_hint de sus widgets hijos. Considera el siguiente ejemplo:

Python - float_layout.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.button import Button
from kivy.uix.floatlayout import FloatLayout

class FloatLayoutApp(App):
    def build(self):
        self.title = "Disposición flotante Kivy"
        Window.size = (600, 300)

        root = FloatLayout()

        button1 = Button(
            text="Centrado",
            size_hint=(0.5, 0.2),
            pos_hint={"center_x": 0.5, "center_y": 0.5},
        )

        button2 = Button(
            text="Esquina inferior derecha",
            size_hint=(0.3, 0.1),
            pos_hint={"right": 1, "y": 0},
        )
        root.add_widget(button1)
        root.add_widget(button2)
        return root

FloatLayoutApp().run()

Aquí, creas una app con un FloatLayout que te permite posicionar y dimensionar sus widgets hijos a partir de sus propiedades size_hint y pos_hint. El button1 ocupará el 50% del ancho y el 20% del alto del contenedor, lo cual logras con size_hint. Con pos_hint, lo anclas al centro del layout.

El button2 muestra otra forma común de ubicar elementos en FloatLayout. En este caso, usas pos_hint={"right": 1, "y": 0} para indicar que el borde derecho del botón debe coincidir con el borde derecho del contenedor (right=1) y que su posición vertical esté pegada al borde inferior (y=0). Además, size_hint lo hace ocupar el 30% de ancho y el 10% de alto del layout.

Tu aplicación debe lucir como la siguiente:

Disposición en posiciones específicas en Kivy

Como puedes ver, el layout renderiza los botones en las posiciones correspondientes sin necesidad de calcular las coordenadas manualmente. Al redimensionar la ventana, notarás que los botones se mantienen en sus posiciones.

Conectando eventos con callbacks en Kivy

En Kivy, la mayoría de los widgets te permiten vincular eventos y propiedades con funciones de callback mediante el método .bind(). Esta es la base para reaccionar a eventos del usuario, como clics, selecciones y entradas de texto.

Es importante que sepas que no es lo mismo enlazar un evento que enlazar una propiedad. Por ejemplo, on_press (evento) suele llamar un callback con un solo argumento: la instancia del widget. En contraste, .text, .active o .value (propiedades) invocan un callback con dos argumentos: la instancia y el nuevo valor.

Enlazar eventos

Cuando quieres ejecutar una acción al pulsar un botón, puedes enlazar el evento on_press (al presionar) u on_release (al soltar) a una función o método. En la función (callback), el parámetro instance te permite identificar qué botón disparó o generó el evento.

Considera el siguiente ejemplo:

Python - button_callbacks.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label

class ButtonsCallbacksApp(App):
    def build(self):
        self.title = "Enlazar eventos Kivy"
        Window.size = (220, 220)

        root = BoxLayout(orientation="vertical", padding=20, spacing=10)

        self.label = Label(
            text="Presionaste: ...",
        )
        root.add_widget(self.label)

        def on_press(instance):  # Callback
            self.label.text = f"Presionaste: {instance.text}"

        for text in ["Ok", "Cancelar", "Aplicar"]:
            button = Button(text=text)
            button.bind(on_press=on_press)  # Enlace
            root.add_widget(button)

        return root

ButtonsCallbacksApp().run()

En este ejemplo, creas una app que muestra un Label con el texto "Presionaste: ...". Este label mostrará el resultado de la interacción con los botones.

Luego, creas una función llamada on_press() que actualizará el texto del label según el botón que presiones. En el bucle, creas tres botones y los enlazas con on_press() mediante .bind().

Al ejecutar la app, obtendrás lo siguiente:

Enlace de eventos en Kivy

De este modo, cuando pulsas un botón en la ventana, Kivy llama al callback, pasándole la instancia del botón que disparó el evento, y el label se actualiza.

Enlazar propiedades

Además de eventos, puedes enlazar propiedades. Por ejemplo, en un TextInput puedes reaccionar a los cambios en la propiedad .text.

Considera el siguiente ejemplo:

Python - bind_properties.py

from kivy.app import App
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput

class BindPropertiesApp(App):
    def build(self):
        self.title = "Enlazar propiedades Kivy"
        Window.size = (320, 220)

        root = BoxLayout(orientation="vertical", padding=20, spacing=10)

        entry = TextInput(hint_text="Escribe algo aquí...", multiline=False)
        display = Label(text="")

        def on_text(instance, value):
            display.text = f"Escribiste: '{value}'"

        entry.bind(text=on_text)

        root.add_widget(entry)
        root.add_widget(display)

        return root

BindPropertiesApp().run()

En este ejemplo, creas una app con un TextInput y un Label. El TextInput funciona como campo de entrada, mientras que el Label sirve como salida para mostrar lo que el usuario va escribiendo.

La clave está en la función on_text(). Como aquí enlazas una propiedad (.text), Kivy llama al callback con dos argumentos: la instancia del widget que cambió (instance) y el nuevo valor de la propiedad (value). En consecuencia, cada vez que el usuario modifica el contenido del TextInput, el callback actualiza el texto del Label con display.text = ....

Al ejecutar la app, obtendrás lo siguiente:

Enlace de propiedades en Kivy

Como ves, .text es una propiedad que cambia mientras escribes. Enlazar propiedades con .bind() es una forma directa de construir interfaces reactivas, en las que la UI se actualiza automáticamente en respuesta a cambios de estado.

Separando la interfaz de la lógica con KV language

Una de las características más poderosas de Kivy es el KV language. Se trata de un lenguaje dedicado que te permite definir la interfaz de forma declarativa en un archivo .kv y dejar la lógica en Python.

Kivy puede cargar automáticamente un archivo .kv por convención de nombres, usando el nombre de la subclase de App. Por ejemplo, si tu clase de app se llama CounterApp, Kivy buscará y cargará un archivo llamado counter.kv.

Supón que tu app tiene la estructura siguiente:

Texto

counter/
├── main.py
└── counter.kv

El archivo main.py define la aplicación y el widget raíz con la lógica de la aplicación:

Python - main.py

from kivy.app import App
from kivy.core.window import Window
from kivy.properties import NumericProperty
from kivy.uix.boxlayout import BoxLayout

class CounterApp(App):
    def build(self):
        self.title = "KV language Kivy"
        Window.size = (300, 200)

        return RootWidget()

class RootWidget(BoxLayout):
    count = NumericProperty(0)

    def increment(self):
        self.count += 1

CounterApp().run()

Este código no define elementos gráficos para la UI de tu aplicación. Puedes hacer este trabajo en counter.kv. Para este ejemplo, añadirás un label y un botón:

Kv - counter.kv

<RootWidget>:
    orientation: "vertical"
    padding: 20
    spacing: 10

    Label:
        text: "Clics: " + str(root.count)
        font_size: "24sp"

    Button:
        text: "Incrementar"
        size_hint: (1, None)
        height: 48
        on_press: root.increment()

RootWidget:

Con este código en su lugar, la aplicación lucirá como se muestra a continuación:

KV language en Kivy

Fíjate en dos ventajas importantes de esa manera de construir tus aplicaciones Kivy:

La UI queda definida en counter.kv, lo que facilita iterar sobre el diseño.
La lógica de la app (incrementar el contador) se encuentra en tus archivos de Python, lo que desacopla el frontend del backend.

Conclusión

Con Kivy, puedes construir aplicaciones de interfaz gráfica con un conjunto sólido de widgets y layouts. También puedes separar la lógica y el diseño de la interfaz en archivos .kv a medida que tu aplicación crece.

A partir de aquí, prueba a combinar widgets y layouts para crear aplicaciones multiplataforma, crear tus interfaces con KV language para mantener tu proyecto organizado.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: continue

2025-12-31T06:00:00+01:00

Puedes usar continue para saltar casos que no quieres procesar sin salir del bucle.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de continue
Resumiendo

Sintaxis

La sintaxis básica de continue en un bucle for o while es la siguiente:

Sintaxis de Python

for item in iterable:
    <block>
    if condition:
        continue
    <block>

while condition:
    <block>
    if condition:
        continue
    <block>

Si continue queda como última sentencia del cuerpo del bucle, es innecesaria porque no hay código que omitir y el bucle pasa igual a la siguiente iteración.

Ejemplos prácticos

A continuación, algunos ejemplos prácticos de cómo emplear continue. Comenzamos con un ejemplo de cómo saltar números pares en un bucle for:

Python REPL

>>> for n in range(6):
...     if n % 2 == 0:
...         continue
...     print(n)
...
1
3
5

Un caso de uso típico de while es validar la entrada del usuario. En el ejemplo siguiente, continue evita ejecutar el resto del cuerpo del bucle cuando la entrada es inválida:

Python - continue_python.py

while True:
    raw = input("Edad (Enter para salir): ").strip()

    if raw == "":
        break

    try:
        age = int(raw)
    except ValueError:
        print("Entrada inválida. Escribe un número entero.")
        continue

    if age <= 0:
        print("La edad debe ser mayor que cero.")
        continue

    print(f"Edad registrada: {age}")

En bucles anidados, continue afecta solo al bucle más interno:

Python REPL

>>> pairs = []

>>> for i in range(3):
...     for j in range(3):
...         if i == j:
...             continue    # Salta pares donde i == j
...         pairs.append((i, j))
...

>>> pairs
[(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

El bloque else de un bucle aún se ejecuta si usas continue. Solo break lo evita:

Python REPL

>>> for n in [1, 2, 3]:
...     if n == 2:
...         continue
...     print(n)
... else:
...     print("Terminó sin usar break")
...
1
3
Terminó sin usar break

Errores comunes:

Python REPL

>>> def function():
...     continue
...
SyntaxError: 'continue' not properly in loop

Como ves, continue solo puede emplearse dentro de un ciclo.

Uso de `continue`

Los casos de uso más comunes de la palabra clave continue incluyen los siguientes:

Saltar entradas inválidas o casos especiales sin duplicar lógica de salida del bucle.
Simplificar condiciones anidadas (“guard clauses”) para aplanar el cuerpo del bucle.
Omitir iteraciones que no cumplen un filtro dentro de bucles for/while.
Mantener disponible el bloque else del bucle (a diferencia de break, que lo inhibe).

Resumiendo

La palabra clave continue te permite omitir de forma limpia el resto de la iteración actual y pasar a la siguiente, manteniendo el bucle en ejecución.

Conocer y emplear continue mejora la claridad del flujo en tus bucles al evitar anidaciones profundas y manejar casos especiales de manera directa.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: else

2025-12-30T15:25:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de else
Resumiendo

Sintaxis

La sintaxis básica de else en una condicional if es la siguiente:

Sintaxis de Python

if condition:
    # Bloque que se ejecuta si la condición es verdadera
else:
    # Bloque que se ejecuta si la condición es falsa

Y en un bucle for, se usa así:

Sintaxis de Python

for item in iterable:
    # Código para cada item
else:
    # Código si el bucle completa sin interrupciones

En la práctica, no deberías emplear else en ciclos que no contienen una sentencia break.

También puedes usar else junto con bloques try para ejecutar código solo si no ocurre ninguna excepción:

Sintaxis de Python

try:
    # Código que puede lanzar una excepción
except Exception:
    # Código que se ejecuta si ocurre una excepción
else:
    # Código que se ejecuta si no ocurre ninguna excepción

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo se usa else:

Python REPL

>>> x = 1

>>> if x > 5:
...     print("x es mayor que 5")
... else:
...     print("x no es mayor que 5")
...
x no es mayor que 5

En este ejemplo, como x es menor que 5, el bloque de código dentro del if no se ejecuta. En su lugar, se ejecuta el código dentro de else.

Python REPL

>>> for i in range(3):
...     print(i)
... else:
...     print("Bucle completado sin interrupciones")
0
1
2
Bucle completado sin interrupciones

En el ejemplo anterior, el ciclo se completa sin interrupciones, por lo que el bloque else se ejecuta.

Ahora considera lo que ocurre si usas break:

Python REPL

>>> for i in range(5):
...     if i == 2:
...         print("¡Se encontró el 2!")
...         break
...     print(i)
... else:
...     print("Bucle completado sin interrupciones")
0
1
¡Se encontró el 2!

En este caso, el bucle se interrumpe con break y el bloque else no se ejecuta.

Uso de `else`

Los casos de uso más comunes de la palabra clave else incluyen los siguientes:

Proporcionar un camino de ejecución por defecto en las condicionales if.
Ejecutar un bloque de código al finalizar un bucle for o while sin interrupciones.
Junto con try para especificar un bloque de código que se ejecuta si no se produce ninguna excepción.

Resumiendo

La palabra clave else en Python es fundamental para manejar flujos alternativos de ejecución en tus programas.

Conocer y emplear else correctamente te permite gestionar y organizar mejor la lógica de tu código, haciendo que tus programas sean más robustos y fáciles de seguir.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: break

2025-12-29T12:00:00+01:00

Es una herramienta útil para controlar el flujo de ejecución y evitar iteraciones innecesarias.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de break
Resumiendo

Sintaxis

La sintaxis básica de break es la siguiente, dependiendo del tipo de bucle que uses:

Sintaxis de Python

for item in iterable:
    <block>
    if condition:
        break
    <block>

while True:
    <block>
    if condition:
        break
    <block>

Coloca break dentro del cuerpo de un bucle para interrumpir su ejecución cuando se cumpla una determinada condición.

En general, no debes usar break directamente en el cuerpo del ciclo, pues eso provocaría que solo se realice una iteración. En su lugar, debes colocar esta palabra clave dentro de una sentencia condicional.

Ejemplos prácticos

A continuación, algunos ejemplos prácticos de cómo usar break:

Python REPL

>>> for n in range(10):
...     if n == 5:
...         break
...     print(n)
...
0
1
2
3
4

En este ejemplo, el bucle for se detiene cuando n es igual a 5, por lo que solo se imprimen los números del 0 al 4.

Python REPL

>>> i = 0

>>> while True:
...     if i >= 3:
...         break
...     print(i)
...     i += 1
...
0
1
2

Aquí, el bucle while se ejecuta indefinidamente hasta que i alcanza 3, momento en el que break interrumpe el ciclo.

Uso de `break`

Los casos de uso más comunes de la palabra clave break incluyen los siguientes:

Salir anticipadamente de bucles for o while cuando se cumple una condición.
Evitar iteraciones o repeticiones innecesarias una vez que se ha encontrado el resultado deseado.
Mejorar la eficiencia y legibilidad del código al controlar el flujo de ejecución en bucles.

Resumiendo

La palabra clave break en Python te permite controlar cuándo finalizar un bucle, haciendo tu código más eficiente y fácil de leer.

Conocer y emplear break te ayuda a escribir programas más claros y optimizados, evitando iteraciones y repeticiones innecesarias en tus ciclos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: assert

2025-12-28T12:00:00+01:00

Si la condición evaluada es falsa, assert genera una excepción de tipo AssertionError, lo que te ayuda a identificar y corregir problemas en tu código.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de assert
Resumiendo

Sintaxis

Sintaxis de Python

assert condition[, message]

condition: Una expresión que se evalúa como verdadera o falsa.
message: Un mensaje opcional de error que se mostrará si la condición es falsa.

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo se utiliza la palabra clave assert:

Python REPL

>>> x = 10
>>> assert x > 5
>>> # No se genera ningún error porque la condición es verdadera.

>>> y = 3
>>> assert y > 5, "'y' debería ser mayor que 5"
Traceback (most recent call last):
    ...
AssertionError: 'y' debería ser mayor que 5

En el primer ejemplo, la condición x > 5 es verdadera, por lo que no ocurre nada ni se imprime ningún mensaje en pantalla.

En el segundo ejemplo, la condición y > 5 es falsa, por lo que se lanza un AssertionError con el mensaje especificado.

Uso de `assert`

Los casos de uso más comunes de la palabra clave assert incluyen los siguientes:

Verificar condiciones en el código durante la fase de desarrollo y depuración.
Asegurarse de que los valores de las variables cumplen con los requisitos esperados antes de continuar con la ejecución.
Documentar supuestos en el código que deberían mantenerse verdaderos.

En la práctica, no debes emplear la palabra clave assert para verificar condiciones en producción, como puede ser la validación de datos de entrada. Esto se debe a que Python permite deshabilitar assert con el fin de optimizar el funcionamiento del código en producción y, por tanto, tu validación quedaría sin efecto.

Resumiendo

La palabra clave assert en Python garantiza que ciertas precondiciones se mantengan durante la ejecución de un programa. Es especialmente valiosa durante la fase de desarrollo y depuración, pues permite identificar rápidamente errores lógicos y corregirlos.

Conocer y emplear assert te ayuda a escribir código más robusto y confiable.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: del

2025-12-27T12:00:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de del
Resumiendo

Sintaxis

La sintaxis básica para usar del es la siguiente:

Sintaxis de Python

del name

También puedes usarla para eliminar elementos de una lista, pares de un diccionario o atributos de un objeto:

Sintaxis de Python

del a_list[index]
del a_dict[key]
del obj.attribute

Ejemplos prácticos

Veamos algunos ejemplos de cómo se usa del en diferentes contextos:

Python REPL

>>> x = 10

>>> del x
>>> x
Traceback (most recent call last):
    ...
NameError: name 'x' is not defined

En este ejemplo, la variable x se elimina con del. Cualquier intento de acceder a ella después de eliminada genera un error.

Python REPL

>>> numbers = [1, 2, 3, 4]
>>> del numbers[2]
>>> numbers
[1, 2, 4]

Aquí, usas del para eliminar el elemento en el índice 2 de la lista, modificando la lista original.

Python REPL

>>> letters = {"a": 1, "b": 2, "c": 3}
>>> del letters["b"]
>>> letters
{'a': 1, 'c': 3}

En diccionarios, del dic["key"] elimina el par clave-valor correspondiente. Si la clave no existe, se lanza una excepción KeyError.

Python REPL

>>> class DemoClase:
...     def __init__(self):
...         self.attribute = 42
...

>>> obj = DemoClase()
>>> del obj.attribute
>>> obj.attribute
Traceback (most recent call last):
    ...
AttributeError: 'DemoClase' object has no attribute 'attribute'

En este ejemplo, empleas del para eliminar un atributo de un objeto, lo que resulta en un error si intentas acceder a él después de haberlo eliminado.

Uso de `del`

Los casos de uso más comunes de la palabra clave del incluyen los siguientes:

Eliminar variables para liberar memoria.
Remover elementos de listas, diccionarios y otros tipos mutables.
Eliminar atributos de objetos en clases.

Resumiendo

La palabra clave del en Python es una herramienta poderosa para gestionar la memoria y mantener tu código limpio y eficiente al eliminar variables, elementos de listas, diccionarios y atributos de objetos.

Conocer y emplear esta palabra clave te permite escribir programas más eficientes y evitar errores relacionados con referencias innecesarias.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: with

2025-12-25T13:10:00+01:00

Esta palabra clave es especialmente útil cuando necesita gestionar situaciones que requieren lógica de configuración y desmontaje (setup and teardown).

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de with
Resumiendo

Sintaxis

La sintaxis básica para usar with es la siguiente:

Sintaxis de Python

with expression [as variable]:
    <block>

La porción [as variable] es opcional y solo la necesitas cuando quieres una referencia al valor generado por la expresión.

Ejemplos prácticos

A continuación algunos ejemplos que muestran cómo se usa la palabra clave with:

Python - with_python.py

with open("archivo.txt", mode="r", encoding="utf-8") as file:
    content = file.read()

print(content)

En este ejemplo, with se utiliza para abrir un archivo llamado archivo.txt en modo de lectura. El archivo se asigna a la variable file, y luego se lee su contenido. Una vez que el bloque with se completa, el archivo se cierra automáticamente, liberando el recurso incluso si ocurre una excepción.

Otro ejemplo podría ser:

Python - with_python.py

from threading import Lock

with Lock():
    # Código que requiere acceso exclusivo
    print("Bloque protegido por un lock")

Aquí, utilizas with para adquirir un lock antes de ejecutar un bloque de código que requiere acceso exclusivo a un recurso compartido. El lock se libera automáticamente al salir del bloque with de modo que otros hilos o procesos puedan usar el recurso compartido.

Uso de `with`

Los casos de uso más comunes de la palabra clave with incluyen los siguientes:

Gestión automática de archivos, asegurando que se cierren correctamente después de su uso.
Manejo de conexiones de red, bases de datos o sockets, liberando los recursos al finalizar.
Adquisición y liberación de locks en programación concurrente para prevenir condiciones de carrera (race condition) y corrupción de datos.

Resumiendo

La palabra clave with en Python es una herramienta fundamental para la gestión de recursos externos, garantizando que se liberen de manera adecuada y simplificando el manejo de excepciones.

Conocer y emplear with puede ayudarte a escribir código más limpio, seguro y menos propenso a errores relacionados con la gestión de recursos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: pass

2025-12-22T22:40:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de pass
Resumiendo

Sintaxis

La sintaxis de la palabra clave pass es extremadamente sencilla, ya que solo consiste en la palabra en sí:

Sintaxis de Python

pass

Ejemplos prácticos

Aquí tienes algunos ejemplos rápidos que muestran cómo se usa la palabra clave pass:

Python REPL

>>> class CustomException(Exception):
...     pass
...

>>> def load_data():
...     pass  # TODO: Implementar luego
...

>>> import os
>>> def remove_file(filename):
...     try:
...         os.remove(filename)
...     except FileNotFoundError:
...         pass

En el primer ejemplo, pass se utiliza para crear una excepción personalizada sin añadir comportamiento adicional.

En el segundo ejemplo, la función load_data() aún no hace nada. En este caso, pass sirve como un recordatorio para implementar la lógica más tarde sin que el código genere un error de sintaxis.

En el tercer ejemplo, usas pass en un bloque except para ignorar explícitamente el error que ocurre si el archivo que intentas borrar no existe.

Uso de `pass`

Los casos de uso más comunes de la palabra clave pass incluyen los siguientes:

Como marcador de posición en una sentencia compuesta como if, for o while donde el código aún no está implementado.
Para crear funciones y evitar errores de sintaxis mientras se desarrolla el esqueleto del programa.
En clases como un marcador de posición para métodos o bloques de código que se implementarán más tarde.

Resumiendo

La palabra clave pass en Python es una herramienta esencial para situaciones en las que no deseas realizar ninguna acción específica, pero necesitas cumplir con la sintaxis del lenguaje.

Conocer y utilizar pass te permite estructurar tu código de manera más limpia y evita errores mientras desarrollas o refactorizas tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: lambda

2025-12-18T09:45:00+01:00

Estas funciones son ideales cuando requieres encapsular una lógica breve y desecharla inmediatamente después, como sucede al ordenar colecciones, transformar datos o definir callbacks.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis básica
Ejemplos prácticos
Usos de lambda
Resumiendo

Sintaxis básica

Una función lambda se compone de tres partes:

La palabra clave lambda
Una lista opcional de argumentos separados por comas
Una única expresión cuyo resultado se devuelve de forma implícita

Esta es la sintaxis:

Sintaxis de Python

lambda arguments: expression

Al igual que las funciones creadas con def, las lambdas aceptan valores por defecto, argumentos posicionales y hasta *args o **kwargs. Lo que no puedes hacer es escribir varias sentencias dentro del cuerpo de una lambda porque únicamente admiten una expresión.

Ejemplos prácticos

A continuación algunos ejemplos:

Python REPL

>>> multipliers = []

>>> for n in range(3):
...     multipliers.append(lambda x, factor=n: x * factor)
...

>>> multipliers[2](4)
8

En este ejemplo, cada lambda captura el valor de n mediante un parámetro con valor por defecto. Al final del ciclo for obtienes una lista de funciones a las que puedes pasar un valor para multiplicarlo por la n correspondiente.

Las lambdas brillan cuando las combinas con funciones que aceptan otras funciones como argumento:

Python REPL

>>> words = ["SALUDO", "mañana", "funciones"]

>>> sorted(words, key=lambda word: word.lower())
['funciones', 'mañana', 'SALUDO']

>>> numbers = [3, -2, 0, 11, -7]
>>> list(filter(lambda n: n >= 0, numbers))
[3, 0, 11]

>>> from functools import reduce
>>> reduce(lambda acc, n: acc + n, numbers, 0)
5

sorted() usa la lambda para normalizar cada elemento antes de comparar.
filter() filtra la lista para mantener solo los números positivos.
reduce() acumula los valores sin necesidad de definir una función separada.

Usos de `lambda`

Los casos de uso más comunes de la palabra clave lambda incluyen los siguientes:

Crear transformaciones breves dentro de funciones de orden superior como map(), filter(), sorted() y similares.
Definir claves o métricas inline para ordenar, agrupar o seleccionar datos.
Escribir callbacks o manejadores temporales en APIs que esperan funciones, como eventos en interfaces gráficas o hooks de librerías.

Resumiendo

La palabra clave lambda te ayuda a empaquetar lógica limitada de forma concisa sin necesidad de un identificador o nombre de función. Cuando la legibilidad, las pruebas o la trazabilidad sean prioritarias, prefiere def y reserva las lambdas para los casos puntuales donde brilla su brevedad.

Conocer y emplear esta palabra clave te ayuda a crear funciones rápidas y breves que operan con un tiempo de vida limitado.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: import

2025-12-14T09:00:00+01:00

Los imports actúan como conexión entre tu código y el ecosistema Python. Con ella puedes acceder a funciones, clases y constantes definidas en otros módulos, ya sea de la biblioteca estándar, de terceros o propios.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis básica
Ejemplos prácticos
Cuándo usar import
Buenas prácticas
Resumiendo

Sintaxis básica

La forma más directa de cargar un módulo consiste en escribir su nombre después de la palabra clave:

Sintaxis de Python

import module_name

También puedes asignar un alias que resulte más corto o significativo, aprovechando la palabra clave as:

Sintaxis de Python

import module_name as alias

Otra opción consiste en traer símbolos concretos desde el módulo para usarlos directamente:

Sintaxis de Python

from module_name import name

Si lo necesitas, también puedes renombrar el símbolo importado:

Sintaxis de Python

from module_name import name as alias

Los imports selectivos te permiten traer únicamente los nombres que necesitas:

Sintaxis de Python

from math import pi, sqrt

Finalmente, los imports relativos privilegian módulos dentro de tu propio paquete:

Sintaxis de Python

from .helpers import parse_config

Este estilo solo funciona dentro de paquetes y ayuda a mantener rutas cortas y claras.

Ejemplos prácticos

A continuación algunos ejemplos prácticos de cómo usar la palabra clave import:

Python REPL

>>> import random
>>> random.choice(["🐍", "🧠", "⚙️"])
'🐍'

>>> import statistics as sts
>>> sts.mean([10, 15, 20])
15

>>> from statistics import median
>>> median([1, 9, 3, 5])
4.0

Estos ejemplos muestran cómo import activa capacidades adicionales sin necesidad de duplicar código ni copiar archivos.

Cuándo usar `import`

Los usos más frecuentes de la palabra clave import incluyen los siguientes:

Acceder a paquetes y módulos de la biblioteca estándar, tales como math, datetime, pathlib o itertools.
Usar paquetes de terceros, tales como requests, numpy, pandas o cualquier otro que instales con herramientas como pip o uv.
Modularizar proyectos propios y dividir tu aplicación en múltiples archivos con responsabilidades específicas.
Configurar extensiones opcionales y cargar dinámicamente módulos solo cuando se requieren, reduciendo tiempos de arranque.

Buenas prácticas

Agrupa las importaciones al inicio de cada archivo siguiendo el orden:
1. Librería estándar
2. Paquetes de terceros
3. Paquetes locales.
Sitúa estas importaciones antes de tus definiciones de funciones y clases, manteniendo cada archivo coherente y fácil de recorrer.
Usa alias descriptivos solo cuando aporten claridad.
Evita from module import * (wildcard imports), pues comprometen la legibilidad del código, contaminan tu espacio de nombres y puede sobrescribir nombres sin aviso, causando bugs.

Resumiendo

La palabra clave import es la base de la modularidad en Python. Te permite incorporar funcionalidad existente, mantener el código ordenado y facilitar la colaboración entre diferentes partes de un proyecto.

Dominar sus variantes y buenas prácticas te ayuda a escribir programas limpios, escalables y fáciles de mantener.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: as

2025-12-08T21:00:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de as
Resumiendo

Sintaxis

La sintaxis básica para usar as es:

Importar módulos con alias:

Sintaxis de Python

import module_name as alias_name

Capturar excepciones:

Sintaxis de Python

try:
    # Code that may raise an exception
except ExceptionType as error:
    # Handle the exception

Gestionar contextos con with:

Sintaxis de Python

with expression as variable:
    # Code that uses variable

Ejemplos prácticos

Aquí tienes algunos ejemplos de cómo se usa as:

Python REPL

>>> import numpy as np
>>> np.array([1, 2, 3])
array([1, 2, 3])

>>> try:
...     1 / 0
... except ZeroDivisionError as error:
...     print(f"Error: {error}")
...
Error: division by zero

En el primer ejemplo, se importa el módulo numpy y se le asigna el alias np, lo que permite referirse a él de forma más concisa.

En el segundo ejemplo, as se utiliza para capturar una excepción y asignarla a la variable error, permitiendo manejarla e imprimir un mensaje de error.

Uso de `as`

Los casos de uso más comunes de la palabra clave as incluyen los siguientes:

Crear alias para módulos importados, lo que ayuda a reducir la longitud del código y mejora la legibilidad, especialmente con nombres de módulos largos.
Capturar excepciones para acceder a los detalles de la excepción en bloques try-except, permitiendo un manejo más preciso de errores.
Gestionar contextos con with, asignando el resultado de un gestor de contexto a una variable para facilitar el manejo de recursos como archivos, conexiones de red o bloqueos.

Resumiendo

La palabra clave as en Python es una herramienta versátil que te permite asignar alias a módulos, capturar excepciones y gestionar contextos, facilitando un código más limpio y manejable.

Conocer y emplear as puede mejorar significativamente la legibilidad y organización de tu código Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: ¿Cuáles son?

2025-12-06T21:00:00+01:00

Por esta razón, es importante que las conozcas y sepas su rol en el lenguaje. Con ellas, podrás escribir diferentes tipos de sentencias que, en su conjunto, conformarán tus programas y aplicaciones Python.

En este tutorial, aprenderás:

Qué son las palabras clave o reservadas
Cuáles son las palabras clave de Python
Cómo obtener ayuda sobre las palabras clave de Python

Con estos conocimientos, mejorarás tu comprensión del lenguaje y estarás mejor preparado para enfrentar el aprendizaje del mismo.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué son las palabras clave o reservadas en Python?
¿Cuáles son las palabras clave de Python?
- Palabras clave suaves
¿Cómo obtengo ayuda sobre palabras clave específicas?
¿Puedo emplear palabras clave como nombres?
Resumiendo

¿Qué son las palabras clave o reservadas en Python?

Python cuenta con lo que se conoce como palabras clave o palabras reservadas (keywords). Se trata de un conjunto reducido de palabras, en idioma inglés, que tienen un significado especial en el lenguaje y que forman parte de su sintaxis.

Tal y como refiere la documentación oficial de Python en español:

[Las palabras clave] Deben escribirse exactamente como están escritas aquí: (Fuente)

Cuando la documentación dice que deben escribirse de esta forma, esto incluye el detalle de las mayúsculas, como en los casos de None, False y True. Sí, Python discrimina entre mayúsculas y minúsculas, de modo que las variantes True y true no son equivalentes.

Cualquier error de escritura en una palabra clave provoca una excepción del tipo NameError. Este comportamiento se debe a que como la palabra está mal escrita, Python asume que se trata de un identificador o nombre y al no encontrar el nombre, levanta la excepción.

Con esta breve introducción al concepto de palabras clave, estás listo para conocer cuáles son las palabras clave de Python.

¿Cuáles son las palabras clave de Python?

Dependiendo de la versión, Python tiene un conjunto de palabras clave o reservadas que ronda las 30 palabras. Estas palabras constituyen el núcleo de la sintaxis del lenguaje. Para conocer o consultar cuáles son estas palabras, puedes abrir una sesión interactiva de Python y ejecutar el siguiente código:

Python REPL

>>> # Python 3.13
>>> from keyword import kwlist, softkwlist

>>> kwlist
[
    'False',
    'None',
    'True',
    'and',
    'as',
    'assert',
    'async',
    'await',
    'break',
    'class',
    'continue',
    'def',
    'del',
    'elif',
    'else',
    'except',
    'finally',
    'for',
    'from',
    'global',
    'if',
    'import',
    'in',
    'is',
    'lambda',
    'nonlocal',
    'not',
    'or',
    'pass',
    'raise',
    'return',
    'try',
    'while',
    'with',
    'yield'
]

>>> softkwlist
['_', 'case', 'match', 'type']

>>> len(kwlist + softkwlist)
39

El módulo keyword de la biblioteca estándar exporta las listas kwlist y softkwlist que contienen todas las palabras clave de Python.

En el código anterior, primeramente importas kwlist y softkwlist desde keyword y luego muestras su contenido. Python 3.13 tiene 39 palabras clave, incluidas las suaves, tal y como resulta de ejecutar len(kwlist + softkwlist) en la última línea de código del ejemplo.

Debes tener en cuenta que el número de palabras clave varía en dependencia de la versión de Python que estés usando actualmente.

Otra manera de consultar las palabras clave de Python es mediante la función help(). Se trata de una función incluida (built-in) que te permite consultar la documentación y obtener ayuda rápida sobre cualquier objeto en Python.

Para consultar las palabras clave de Python por esta vía, primeramente ejecuta help() para entrar al sistema de ayuda integrado de Python. Luego consulta el contenido de la página de palabras clave usando el comando keywords como en el ejemplo siguiente:

Python REPL

>>> help()

Welcome to Python 3.13's help utility!

...

help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not

En este caso, cuando ejecutas help() en una sesión interactiva de Python, entras inmediatamente al sistema de ayuda integrado del lenguaje. El indicador (prompt) help> te hace saber que estás dentro. Una vez allí, tecleas el comando keywords y presionas Enter. Esta acción te devuelve el listado de palabras clave de tu versión específica del lenguaje.

Es importante que domines las palabras clave o reservadas de Python, y sobre todo que conozcas su significado en español. A continuación, un resumen que incluye la traducción al español y una breve descripción de cada palabra clave:

Palabra clave	Traducción	Descripción
`False`	Falso	Representa el valor booleano falso
`None`	Ninguno	Representa un objeto nulo
`True`	Verdadero	Representa el valor booleano verdadero
`and`	y	Operador lógico `AND`
`as`	como	Permite crear alias de módulos, clases o funciones
`assert`	afirmar	Verifica si una expresión es verdadera y lanza un error si es falsa
`async`	Asíncrono	Define una función o estructura asíncrona
`await`	esperar	Espera a que se complete una función o estructura asíncrona
`break`	romper	Sale de un bucle `for` o `while`
`class`	clase	Define una clase
`continue`	continuar	Salta a la siguiente iteración en un bucle
`def`	definir	Define una función
`del`	borrar	Elimina nombres, elementos de listas, claves de diccionarios
`elif`	entonces si	Cláusula `else if` para una sentencia `if`
`else`	entonces	Cláusula `else` para una sentencia `if`
`except`	excepto	Captura y maneja excepciones en un bloque `try`
`finally`	finalmente	Se ejecuta siempre en un bloque `try`, independientemente de si se produjo una excepción o no
`for`	para	Inicia un bucle `for`
`from`	desde	Importa objetos específicos desde un módulo
`global`	global	Indica que una variable se define en el ámbito global
`if`	si	Inicia una sentencia condicional
`import`	importar	Importa un módulo o elementos específicos de un módulo
`in`	en	Verifica si un valor se encuentra en una lista, diccionario o cualquier objeto iterable
`is`	es	Compara si dos objetos son el mismo objeto
`lambda`	lambda	Crea una función anónima
`nonlocal`	no local	Indica que una variable se encuentra en el ámbito externo a una función
`not`	no	Operador lógico `NOT`
`or`	o	Operador lógico `OR`
`pass`	pasar	Es una sentencia que no hace nada
`raise`	lanzar	Lanza una excepción
`return`	retornar	Sale de una función y devuelve un valor
`try`	intentar	Inicia un bloque de manejo de excepciones
`while`	mientras	Inicia un bucle `while`
`with`	con	Simplifica el manejo de recursos mediante un gestor de contexto
`yield`	producir	Devuelve un valor de un generador sin finalizar la función

Palabras clave suaves

Python también cuenta con palabras clave suaves (soft keywords). A diferencia de las palabras clave normales, las palabras clave suaves pueden emplearse en identificadores, tales como nombres de variables o funciones, siempre que no se usen en el contexto sintáctico específico que las define como palabras reservadas.

Palabra clave	Traducción	Descripción
`_`	guión bajo	Funciona como un patrón comodín que coincide con cualquier valor u objeto sin vincularlo a un nombre en una sentencia `match`
`case`	caso	Define un patrón de coincidencia en una sentencia `match`
`match`	coincidencia	Define una sentencia usada para coincidencia de patrones
`type`	tipo	Declara un alias de tipo

Conocer las palabras reservadas de Python te facilitará la comprensión y la escritura de código. Recuerda que este conjunto de palabras es el núcleo de toda la sintaxis del lenguaje.

¿Cómo obtengo ayuda sobre palabras clave específicas?

En determinadas situaciones, sobre todo cuando estás comenzando con Python, necesitarás consultar rápidamente el objetivo de determinada palabra clave. En esos casos, puedes auxiliarte de help() nuevamente.

Una vez que entras al sistema de ayuda integrado usando help(), puedes introducir la palabra clave que deseas consultar y presionar Enter. De inmediato te aparecerá en pantalla la documentación de la palabra en cuestión.

Por ejemplo, si introduces if y presionas Enter, entonces el sistema de ayuda entrará directamente a la página que documenta esta sentencia y mostrará la salida siguiente:

Texto

The "if" statement
******************

The "if" statement is used for conditional execution:

   if_stmt ::= "if" assignment_expression ":" suite
               ("elif" assignment_expression ":" suite)*
               ["else" ":" suite]

It selects exactly one of the suites by evaluating the expressions one
by one until one is found to be true (see section Boolean operations
for the definition of true and false); then that suite is executed
(and no other part of the "if" statement is executed or evaluated).
If all expressions are false, the suite of the "else" clause, if
present, is executed.

Related help topics: TRUTHVALUE

Si introduces una palabra clave o palabra reservada cualquiera (if en el ejemplo anterior) en el indicador (prompt) del sistema de ayuda de Python, obtienes acceso directo a la documentación de la misma. Esta documentación solo aparece en idioma inglés. Si deseas obtener ayuda en idioma español, entonces puedes usar la documentación oficial en español.

Es importante que sepas que cuando consultas una página de documentación específica en el sistema de ayuda integrado, tendrás que presionar la tecla Q en tu teclado para poder salir de la página y regresar a la ayuda.

El sistema de ayuda integrado te ofrece además una guía de temas relacionados con la palabra clave que estés consultando. En la última línea del ejemplo anterior puedes leer Related help topics: TRUTHVALUE. Si introduces TRUTHVALUE y presionas Enter, obtendrás la página de ayuda correspondiente. Adelántate y experiméntalo tú mismo.

¿Puedo emplear palabras clave como nombres?

En la mayoría de los casos, si tratas de emplear una palabra clave o reservada para definir una variable o nombre, recibirás un error de sintaxis:

Python REPL

>>> class = "Economy"
  File "<input>", line 1
    class = "Economy"
          ^
SyntaxError: invalid syntax

En este ejemplo, cuando tratas de usar class como un nombre de variable, recibes una excepción de tipo SyntaxError. Sin embargo, este no es siempre el caso. Python también tiene palabras clave suaves que en determinado contexto, puedes emplear como nombres. Las más comunes son match y case, que solo están restringidas en el contexto de sentencias match:

Python REPL

>>> match = True
>>> match
True

Este ejemplo demuestra que puedes emplear la palabra reservada match como un nombre de variable. En este caso, Python no levanta una excepción como lo hace con otras palabras reservadas.

En cualquier caso, debes evitar emplear palabras clave como nombres o identificadores de variables, funciones, clases, módulos, paquetes o de cualquier otra estructura u objeto Python. Emplearlas de esta forma podría generar problemas difíciles de identificar y resolver en tu código.

Resumiendo

Ya has adquirido conocimientos elementales sobre las palabras clave o palabras reservadas de Python. Sabes cómo obtener la lista de palabras reservadas disponibles en tu entorno Python y cómo obtener ayuda sobre estas palabras y su papel en la sintaxis del lenguaje.

Ahora conoces:

La definición de palabra clave o reservada
Las palabras clave de Python y su significado
Cómo usar la función help() para obtener ayuda sobre las palabras clave

Con estos conocimientos tienes las bases y las herramientas necesarias para profundizar en los conceptos y definiciones que encierra cada una de las palabras clave de Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: return

2025-12-06T20:30:00+01:00

Esta palabra clave es una parte esencial de las funciones porque permite que estas devuelvan resultados útiles que puedes utilizar posteriormente en tu código.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de return
Resumiendo

Sintaxis

La sintaxis básica de la palabra clave return es la siguiente:

Sintaxis de Python

def func():
    <block>
    return expression

Donde expression es opcional y representa el valor que deseas devolver. Si no proporcionas ninguna expresión, la función devolverá None de manera predeterminada.

Si omites la sentencia return, Python automáticamente devuelve None al concluir la ejecución de tu función.

También debes tener en cuenta que solo puedes usar return dentro de funciones.

Ejemplos prácticos

Veamos algunos ejemplos prácticos del uso de return:

Python REPL

>>> def add(a, b):
...     return a + b
...

>>> result = add(3, 5)
>>> result
8

En este ejemplo, la función add() toma dos argumentos numéricos a y b, y utiliza return para devolver la suma de estos. El valor devuelto se almacena en la variable result.

Python REPL

>>> def no_return():
...     print("Hola!")
...     return
...

>>> value = no_return()
Hola!
>>> print(value)
None

Aquí, la función no_return() imprime un mensaje y luego usa return sin una expresión o valor de retorno, lo que significa que devuelve None implícitamente.

Obtendrás el mismo resultado o comportamiento si obvias por completo la sentencia return.

Uso de `return`

Los casos de uso más comunes de la palabra clave return incluyen los siguientes:

Finalizar la ejecución de una función y devolver un valor de retorno al código que la llamas.
Facilitar la reutilización de código al permitir encapsular porciones específicas de código que realizan una tarea o calculan un valor.
Controlar el flujo de ejecución dentro de funciones, ya que puedes utilizar return para salir de la función en cualquier momento.

Resumiendo

En Python, la palabra clave return es fundamental para la creación de funciones, pues te permite obtener y devolver valores al código que las llama.

Conocer y emplear return te permite escribir funciones que no solo realicen tareas, sino que también devuelvan resultados útiles.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: class

2025-12-01T08:50:00+01:00

Las clases encapsulan datos y funcionalidades en una sola entidad, lo que te permite modelar objetos del mundo real y sus interacciones de manera eficiente.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de class
Resumiendo

Sintaxis

La sintaxis básica para definir una clase en Python es la siguiente:

Sintaxis de Python

class ClassName:
    cls_attribute = 42  # Atributo de clase

    def __init__(self, arg):
        self.attribute = arg  # Atributo de instancia

    def method(self):
        <block>

Ejemplos prácticos

Aquí tienes un ejemplo rápido que ilustra cómo se usa la palabra clave class:

Python REPL

>>> class Dog:
...     def __init__(self, name):
...         self.name = name
...
...     def bark(self):
...         return f"{self.name} dice ¡Guau!"
...

>>> fido = Dog("Fido")
>>> fido.bark()
'Fido dice ¡Guau!'
>>> fido.name
'Fido'

En este ejemplo, definimos una clase Dog que tiene un método .bark(). Cuando creamos un objeto fido de la clase Dog, podemos llamar a sus métodos para que realice acciones, como ladrar con .bark(). También podemos acceder a sus atributos o datos con la notación de punto.

Uso de `class`

Los casos de uso más comunes de la palabra clave class incluyen los siguientes:

Crear objetos con atributos y métodos que modelan entidades del mundo real.
Facilitar la reutilización de código mediante herencia.
Encapsular y ocultar detalles internos de implementación para mejorar la modularidad.
Definir estructuras de datos complejas y personalizadas.

Resumiendo

La palabra clave class en Python es fundamental para la programación orientada a objetos, permitiéndote definir nuevas estructuras de datos y modelar comportamientos complejos.

Conocer y emplear esta palabra clave te ayuda a crear aplicaciones más organizadas, modulares y escalables.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Estructuras de datos en Python: Arreglos (arrays)

2025-11-23T22:50:00+01:00

En este artículo, aprenderás cómo implementar un arreglo en Python, incluyendo sus operaciones y características principales.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué es un arreglo o array?
Operaciones comunes en un arreglo
Implementación de un arreglo en Python
Ejemplo de uso del arreglo
Conclusión

¿Qué es un arreglo o array?

Un arreglo es una colección de elementos, cada uno identificado por un índice entero. Las características fundamentales de un arreglo incluyen las siguientes:

Tamaño fijo: El tamaño o número de elementos del arreglo se determina al crearlo y no se puede cambiar.
Acceso aleatorio: Los elementos se pueden acceder directamente usando índices que comienzan en 0.
Homogéneo o heterogéneo: Los arreglos pueden almacenar elementos del mismo tipo de dato o de tipos mixtos, dependiendo de la implementación.

En Python, los arreglos no están integrados como una estructura de datos primitiva. La biblioteca estándar incluye el tipo array.array para trabajar con datos numéricos homogéneos, pero en este artículo implementarás tu propio arreglo usando el módulo ctypes para tener un mayor control de bajo nivel.

A través de este ejercicio, podrás obtener una serie de habilidades fundamentales en Python, como puede ser el uso de clases y de métodos especiales, también conocidos como métodos mágicos o dunder.

Operaciones comunes en un arreglo

A continuación, un resumen de las operaciones que soportará tu arreglo:

Operación	Descripción
`array = Array(size)`	Construye un arreglo que puede contener `size` elementos.
`array[index]`	Accede al elemento en `index`.
`array[index] = value`	Asigna `value` al elemento en `index`.
`array.clear([value])`	Restablece todos los elementos del arreglo, asignándoles el valor `value` o `None`.
`len(array)`	Devuelve la longitud del arreglo.
`item in array`	Devuelve `True` si `item` está contenido en el arreglo y `False` si no lo está.
`for item in array: ...`	Itera sobre los elementos del arreglo.
`for item in reversed(array): ...`	Itera sobre los elementos en orden inverso.

Implementación de un arreglo en Python

A continuación encontrarás la implementación del arreglo en Python:

Python - array_python.py

import ctypes
from typing import Any, Generator, Optional

class Array:
    def __init__(self, size: int) -> None:
        if size <= 0:
            raise ValueError("Array size must be a positive integer")
        self._size = size
        self._data = (ctypes.py_object * self._size)()
        self._type: Optional[type] = None
        self.clear()

    def clear(self, value: Optional[Any] = None) -> None:
        if (
            self._type is not None
            and value is not None
            and not isinstance(value, self._type)
        ):
            raise TypeError(f"Expected type {self._type}, got {type(value)}")
        for i in range(self._size):
            self._data[i] = value

    def __len__(self) -> int:
        return self._size

    def __contains__(self, value: Any) -> bool:
        for item in self._data:
            if item == value:
                return True
        return False

    def _check_index(self, index: int) -> None:
        if not 0 <= index < self._size:
            raise IndexError(
                f"Index out of range: {index}. "
                f"Valid range: 0 to {self._size - 1}"
            )

    def __getitem__(self, index: int) -> Any:
        self._check_index(index)
        return self._data[index]

    def __setitem__(self, index: int, value: Any) -> None:
        if self._type is None and value is not None:
            self._type = type(value)
        elif value is not None and not isinstance(value, self._type):
            raise TypeError(f"Expected type {self._type}, got {type(value)}")
        self._check_index(index)
        self._data[index] = value

    def __iter__(self) -> Generator[Any, None, None]:
        yield from self._data

    def __reversed__(self) -> Generator[Any, None, None]:
        yield from reversed(self._data)

    def __str__(self) -> str:
        return f"{self.__class__.__name__}({', '.join(map(str, self._data))})"

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(size={self._size})"

El atributo ._size almacena el tamaño fijo del arreglo o el número de posiciones disponibles, mientras que ._data proporciona un arreglo de bajo nivel creado con ctypes.py_object * size, donde se guardan las referencias a los objetos de Python.

En ._type, se guarda el tipo de dato de los elementos del arreglo. Una vez que asignas el primer valor no nulo, solo se permiten valores de ese mismo tipo.

El método .clear() recorre todas las posiciones del arreglo y les asigna value o None. Si ._type ya está fijado, comprueba que value coincida con ese tipo.

Los métodos especiales te permiten ofrecer las siguientes funcionalidades:

.__getitem__(): devuelve el valor almacenado en index después de verificar que el índice esté dentro del rango válido.
.__setitem__(): fija el tipo de dato de los elementos del arreglo con el primer value no nulo. A partir de ahí, solo permite valores de ese tipo. También valida que el índice esté en rango antes de asignar.
__len__: devuelve el tamaño del arreglo o el número de elementos.
__contains__(): comprueba si value está contenido en el arreglo y devuelve True o False.
__iter__ y __reversed__: permiten iterar sobre los elementos del arreglo en orden normal o inverso.
__str__ y __repr__: devuelven representaciones de cadena que muestran el contenido actual del arreglo.

Ejemplo de uso del arreglo

En esta sección verás ejemplos prácticos de cómo crear, inicializar y manipular instancias de tu clase Array.

Inicialización

Para crear un Array, solo necesitas indicar su tamaño. Todos los elementos se inicializan con None por defecto:

Python REPL

>>> a = Array(5)  # Crea un arreglo con 5 elementos
>>> print(a)
Array(None, None, None, None, None)

Acceso y modificación de elementos

Puedes leer y escribir elementos con el operador de indexado [index], igual que en una lista:

Python REPL

>>> a[0] = 42  # Establece el primer elemento a 42
>>> a[0]
42

Si intentas asignar un valor de un tipo de dato diferente al que ya tiene el arreglo, o usar un índice fuera del rango válido, obtendrás errores claros:

Python REPL

>>> a = Array(3)

>>> a[0] = 1
>>> a[1] = 2

>>> a[2] = "tres"
Traceback (most recent call last):
    ...
TypeError: Expected type <class 'int'>, got <class 'str'>

>>> a[3] = 10
Traceback (most recent call last):
    ...
IndexError: Index out of range: 3. Valid range: 0 to 2

Limpiar el arreglo

El método .clear() restablece todos los elementos asignándoles el valor especificado. El valor predeterminado es None:

Python REPL

>>> a = Array(5)

>>> a.clear(0)  # Establece todos los elementos a 0
>>> print(a)
Array(0, 0, 0, 0, 0)

Longitud y pertenencia

El método .__len__() devuelve el tamaño del arreglo, mientras que .__contains__() verifica si un elemento existe en el arreglo:

Python REPL

>>> a = Array(5)

>>> len(a)
5
>>> 42 in a
False

>>> a[0] = 42
>>> 42 in a
True

Iteración

Los métodos .__iter__() y .__reversed__() permiten iterar sobre el arreglo tanto hacia adelante como hacia atrás:

Python REPL

>>> a = Array(5)
>>> a[0] = 1
>>> a[1] = 2
>>> a[2] = 3
>>> a[3] = 4
>>> a[4] = 5

>>> for item in a:
...     print(item)
...
1
2
3
4
5

>>> for item in reversed(a):
...     print(item)
...
5
4
3
2
1

Representación en cadena

Los métodos .__str__() y .__repr__() son más bien utilitarios y proporcionan representaciones legibles para humanos y amigables para desarrolladores:

Python REPL

>>> a = Array(5)
>>> a.clear(0)

>>> print(a)
Array(0, 0, 0, 0, 0)

>>> print(repr(a))
Array(size=5)

Conclusión

Has aprendido cómo implementar un arreglo de tamaño fijo que proporciona operaciones esenciales como indexación, iteración y pertenencia, al tiempo que refuerza la consistencia del tipo de dato de sus elementos. Este conocimiento te sirve de base para entender estructuras de datos fundamentales en Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: while

2025-11-22T21:40:00+01:00

La palabra clave while en Python define una estructura de control llamada bucle. Este tipo de bucle te permite ejecutar un bloque de código múltiples veces mientras una condición lógica sea verdadera. Si la condición es falsa desde el principio, el cuerpo del bucle no se ejecuta ni una sola vez.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de while
Resumiendo

Sintaxis

La sintaxis básica para un bucle while es la siguiente:

Sintaxis de Python

while condition:
    <block>

Ejemplos prácticos

Aquí tienes algunos ejemplos que muestran cómo crear bucles while en Python:

Python REPL

>>> counter = 0

>>> while counter < 5:
...     print(counter)
...     counter += 1
0
1
2
3
4

En este ejemplo, el bucle while se ejecuta mientras counter sea menor que 5. En cada repetición, se imprime el valor actual de counter y luego se incrementa en 1.

El siguiente ejemplo muestra cómo usar un bucle while para contar hacia atrás:

Python REPL

>>> number = 5

>>> while number > 0:
...     print(number)
...     number -= 1
...
5
4
3
2
1

Aquí, el bucle while se ejecuta mientras number sea mayor que 0, imprimiendo el valor de number y luego disminuyéndolo en 1 en cada iteración.

Uso de `while`

Los casos de uso más comunes de la palabra clave while incluyen los siguientes:

Repetir un bloque de código hasta que se cumpla una condición específica.
Crear bucles que dependen de condiciones dinámicas que pueden cambiar durante la ejecución del programa.
Implementar bucles infinitos que se detienen mediante condiciones internas y una instrucción break.

Resumiendo

El bucle while es una herramienta muy útil en Python, pues te permite ejecutar código repetidamente mientras se cumpla una condición.

Conocer y utilizar la palabra clave while te proporciona la flexibilidad de controlar el flujo de tu programa y manejar tareas repetitivas de manera eficiente.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo gestionar un proyecto Python con uv?

2025-10-05T22:55:00+02:00

Esta herramienta ofrece una alternativa rápida y completa a otras como pip, pip-tools o poetry.

Con uv puedes instalar diferentes versiones de Python, crear proyectos desde cero, gestionar entornos virtuales, añadir y remover dependencias garantizando reproducibilidad, e incluso construir y publicar tus proyectos en PyPI. Todo desde un único flujo de trabajo.

En esta guía aprenderás lo básico de cómo usar uv para ejecutar las tareas más comunes de gestión de proyectos Python, desde la instalación hasta la distribución.

Contenidos

Instalar uv en tu sistema
Gestionar múltiples versiones de Python
Iniciar un proyecto Python con uv
Gestionar dependencias de proyectos
Distribuir y publicar el proyecto
Conclusión

Instalar `uv` en tu sistema

En macOS y Linux, puedes instalar uv con el comando siguiente:

Terminal

$ curl -LsSf https://astral.sh/uv/install.sh | sh

Si no dispones de curl en tu sistema, entonces puedes usar wget:

Terminal

$ wget -qO- https://astral.sh/uv/install.sh | sh

En Windows, puedes usar el comando:

Powershell

PS> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Una vez concluida la instalación, uv estará disponible en tu sistema. Puedes comprobarla con el comando uv --version.

Gestionar múltiples versiones de Python

Con uv puedes instalar y usar distintas versiones de Python fácilmente. Para instalar una versión de Python, por ejemplo la 3.13, usa el comando siguiente:

Terminal

$ uv python install 3.13

Esto te permite trabajar con varios proyectos que requieran versiones diferentes del lenguaje.

Con el comando uv python list, puedes listar las versiones disponibles y con uv python pin <version>, puedes fijar la versión de Python que quieres emplear en un proyecto específico.

Iniciar un proyecto Python con `uv`

Con uv puedes crear la estructura inicial de tus nuevos proyectos:

Terminal

$ uv init project_name

Este comando crea la estructura de proyecto siguiente:

Texto

project_name/
│
├── .git/
├── .gitignore
├── .python-version
├── README.md
├── main.py
└── pyproject.toml

Aquí tienes un repositorio Git con su correspondiente archivo .gitignore. Luego tienes el archivo .python-version donde uv almacena la versión de Python para el proyecto. El archivo README.md provee el espacio para la documentación básica del proyecto.

Seguidamente tienes el archivo main.py que es el script de entrada del proyecto. Puedes modificarlo según tus necesidades o puedes incluso reemplazarlo por otro. Finalmente, tienes el archivo pyproject.toml que contiene la configuración necesaria para construir y distribuir tu proyecto.

Alternativamente, puedes emplear varias estructuras disponibles en dependencia de tus necesidades:

Terminal

$ uv init --app app_name
$ uv init --lib library_name
$ uv init --pkg package_name
$ uv init --script script_name

Cada tipo genera una estructura inicial de archivos adaptada al caso. Puedes usar esta estructura como punto de partida para programar tu proyecto.

Debes notar que estos comandos crean el directorio raíz del proyecto usando el nombre suministrado. Si ya has creado el directorio, entonces puedes ejecutar uv init . dentro del mismo.

Una vez que has inicializado un proyecto de aplicación, puedes ejecutarlo con el comando uv run main.py.

Gestionar dependencias de proyectos

Uno de los puntos fuertes de uv es la gestión de dependencias. Con uv puedes instalar y desinstalar dependencias de manera rápida y precisa. Además, uv mantiene un estricto registro y control de dependencias que facilita la reproducibilidad de tu entorno de desarrollo en otros sistemas. Esta característica es fundamental cuando trabajas en equipo.

Cuando añades dependencias con uv, se actualizan automáticamente los archivos pyproject.toml y uv.lock. El primero declara las dependencias, mientras que el segundo mantiene un registro estricto de las versiones instaladas.

A continuación aprenderás cómo instalar y desinstalar dependencias externas con uv.

Crear un entorno virtual para tu proyecto

Luego que has inicializado tu proyecto, puedes crear un entorno virtual Python manualmente:

Terminal

$ uv venv

El nombre del directorio del entorno virtual es .venv por defecto, pero puedes usar el nombre que desees con solo añadirlo después del subcomando venv.

El entorno virtual hará referencia al intérprete de Python disponible directamente en tu sistema, entorno de trabajo o shell.

Debes saber que el entorno virtual se crea automáticamente (si es que no existe) cuando ejecutas comandos como uv run, uv add, uv sync, o uv lock.

Instalar dependencias de ejecución

Las dependencias de ejecución son aquellas bibliotecas o paquetes que empleas directamente en el código de tu proyecto.

Por ejemplo, digamos que estás creando un proyecto de Inteligencia Artificial y quieres emplear la API de OpenAI. Puedes instalar la librería openai con el siguiente comando:

Terminal

$ uv add openai

Este comando añade la librería openai al proyecto como dependencia de ejecución.

Instalar dependencias de desarrollo

Las dependencias de desarrollo son aquellas que necesitas durante el ciclo de desarrollo de tu proyecto. Por ejemplo, puedes necesitar pytest para escribir y ejecutar test unitarios para tu proyecto:

Terminal

$ uv add --dev pytest

Este comando instala pytest como dependencia de desarrollo, actualizando los archivos uv.lock y pyproject.toml de manera adecuada.

Desinstalar dependencias

Para eliminar un paquete o biblioteca que ya habías instalado y que no necesitas más, puedes usar el comando siguiente:

Terminal

$ uv remove pytest

Este comando desinstala la biblioteca pytest y todas sus dependencias transitivas, dejando tu entorno virtual de trabajo limpio de paquetes no necesarios. También actualiza el archivo uv.lock de acuerdo con los cambios.

Distribuir y publicar el proyecto

Con uv también puedes empaquetar y publicar tu proyecto:

Terminal

$ uv build
$ uv publish --token tu_token_aquí

El primer comando genera los artefactos de distribución que se guardan en el directorio dist/ por defecto. El segundo comando sube estos artefactos a PyPI.

Debes notar que para que estos comandos funcionen correctamente, es necesario configurar el script de entrada del proyecto y el sistema de construcción (build system). Todo esto en el archivo pyproject.toml de tu proyecto.

Conclusión

Con uv puedes gestionar todo el ciclo de vida de un proyecto Python desde la línea de comandos de manera rápida, precisa y eficiente. Es una alternativa ligera y moderna frente a herramientas como poetry y puede reemplazar la funcionalidad de herramientas como pyenv, pip, venv, pip-tools, twine entre otras.

Palabras clave en Python: for

2025-10-02T20:00:00+02:00

Esta palabra clave define una estructura de control llamada ciclo o bucle que te permite ejecutar acciones sobre o con cada elemento en la secuencia, facilitando la automatización de tareas repetitivas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de for
Resumiendo

Sintaxis

La sintaxis básica de un ciclo for en Python es la siguiente:

Sintaxis de Python

for variable in iterable:
    <block>

Donde variable toma el valor de cada elemento en el iterable, y el bloque de código se ejecuta para cada uno de estos valores.

Ejemplos prácticos

A continuación algunos ejemplos de cómo usar el ciclo for en tu código:

Python REPL

>>> for number in [1, 2, 3, 4]:
...     print(number)
...
1
2
3
4

En este ejemplo, el ciclo for itera sobre una lista de números, y print(number) se ejecuta para cada número en la lista.

Para aprender más sobre los ciclos for revisa el tutorial Python a través de ejemplos: Ciclos o bucles for.

También puedes iterar sobre los caracteres de una cadena:

Python REPL

>>> for letter in "Python":
...     print(letter)
...
P
y
t
h
o
n

Aquí, el ciclo for recorre cada caracter de la cadena "Python" e imprime cada uno de ellos en pantalla.

El ejemplo siguiente muestra cómo iterar sobre un diccionario y acceder a sus claves y valores:

Python REPL

>>> students = {
...     "Ana": 18,
...     "Luis": 20,
...     "María": 19
... }

>>> for name, age in students.items():
...     print(f"{name} tiene {age} años")
...
Ana tiene 18 años
Luis tiene 20 años
María tiene 19 años

En este caso, el método .items() devuelve pares de clave y valor que puedes desempaquetar directamente en el ciclo for.

Uso de `for`

Los casos de uso más comunes de la palabra clave for incluyen los siguientes:

Iterar sobre elementos en una lista, tupla, conjunto o diccionario.
Recorrer cadenas de caracteres.
Ejecutar un bloque de código un número específico de veces utilizando la función range().
Trabajar con estructuras de datos complejas y realizar operaciones en cada elemento.
Iterar sobre un archivo línea por línea.

Resumiendo

La palabra clave for es fundamental en Python para realizar iteraciones sobre secuencias de elementos de manera eficiente y clara.

Conocer y emplear esta palabra clave te permitirá automatizar tareas repetitivas y manejar colecciones de datos de forma efectiva.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: if

2025-09-21T19:30:00+02:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de if
Resumiendo

Sintaxis

La sintaxis básica de una sentencia if es la siguiente:

Sintaxis de Python

if condition:
    <block>

Puedes extender una sentencia if con las palabras clave elif y else para gestionar múltiples condiciones:

Sintaxis de Python

if condition1:
    <block>  # Se ejecuta si condition1 es verdadera
elif condition2:
    <block>  # Se ejecuta si condition2 es verdadera
elif condition3:
    <block>  # Se ejecuta si condition3 es verdadera
...
else:
    <block>  # Se ejecuta si ninguna de las condiciones anteriores es verdadera

Puedes usar tantas cláusulas elif como necesites, pero solo puedes tener una única cláusula else. La cláusula else siempre debe aparecer al final.

Ejemplos prácticos

Estos son algunos ejemplos de cómo usar la palabra clave if:

Python REPL

>>> x = 10

>>> if x > 5:
...     print("x es mayor que 5")
...
x es mayor que 5

En este ejemplo, como x es mayor que 5, el bloque de código de la sentencia if se ejecuta y la función print() muestra el mensaje correspondiente.

La cláusula else funciona como bloque por defecto:

Python REPL

>>> y = 3

>>> if y > 5:
...     print("y es mayor que 5")
... else:
...     print("y no es mayor que 5")
...
y no es mayor que 5

Aquí, como y no es mayor que 5, se ejecuta el bloque de código asociado a else y la función print() muestra el mensaje en pantalla.

Ahora considera el ejemplo siguiente:

Python REPL

>>> z = 7

>>> if z > 10:
...     print("z es mayor que 10")
... elif z > 5:
...     print("z es mayor que 5 pero no mayor que 10")
... else:
...     print("z no es mayor que 5")
...
z es mayor que 5 pero no mayor que 10

En este ejemplo, z es mayor que 5 pero no mayor que 10, por lo que se ejecuta el bloque de código asociado a elif y la función print() muestra el mensaje especificado.

Uso de `if`

Los casos de uso más comunes de la palabra clave if incluyen los siguientes:

Controlar el flujo del programa ejecutando código basado en condiciones específicas.
Implementar lógica de decisiones en funciones y métodos.
Validar y verificar datos antes de proceder con operaciones críticas.
Ejecutar diferentes caminos de ejecución en algoritmos y estructuras de datos.

Resumiendo

La palabra clave if en Python es fundamental para controlar el flujo de ejecución de tus programas basado en condiciones.

Conocer y usar esta palabra clave te permite crear programas que tomen decisiones dinámicas según las condiciones que enfrenten, mejorando la capacidad de respuesta y adaptabilidad de tus aplicaciones.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: def

2025-07-29T23:10:00+02:00

Una vez que escribes una función, puedes llamarla en cualquier parte de tu programa para ejecutar esa tarea.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de def
Resumiendo

Sintaxis

La sintaxis básica para definir una función con def es la siguiente:

Sintaxis de Python

def function_name([parameters]):
    <body>
    [return return_value]

Los corchetes indican elementos opcionales. De modo similar, los corchetes angulares denotan elementos requeridos.

Ejemplos prácticos

Aquí tienes algunos ejemplos de cómo puedes usar def para definir tus funciones:

Python REPL

>>> def greet():
...     print("¡Hola, Mundo!")
...

>>> greet()
¡Hola, Mundo!

En este ejemplo, has definido una función llamada greet() que imprime ¡Hola, Mundo! cuando la llamas.

La función add() permite sumar dos números:

Python REPL

>>> def add(a, b):
...     return a + b
...

>>> add(3, 5)
8

Aquí, la función add() toma dos argumentos a y b que deben ser números, y devuelve su suma. Cuando llamas a add(3, 5), obtienes el resultado 8.

Uso de `def`

Los casos de uso más comunes de la palabra clave def incluyen los siguientes:

Crear funciones que encapsulen lógica reutilizable en tu código.
Dividir el código en unidades modulares y más fáciles de mantener.
Definir funciones con parámetros para recibir argumentos y devolver valores.
Definir funciones anidadas (funciones dentro de otras funciones) para crear lógica interna específica o closures.
Implementar decoradores, que reciben y devuelven funciones para añadir funcionalidad a código existente.

Resumiendo

La palabra clave def en Python es fundamental para definir funciones, lo que te permite estructurar tu código de manera eficiente y reutilizable.

Conocer y utilizar def te ayuda a escribir programas más organizados y modulares, encapsulando lógica para tareas específicas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: and

2025-04-18T13:50:00+02:00

Este operador es comúnmente empleado para combinar múltiples condiciones en una sola expresión lógica o condición compuesta. En este contexto, el operador devuelve un valor verdadero si ambas condiciones son verdaderas y un valor falso si al menos una de las condiciones es falsa.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de and
Resumiendo

Sintaxis

La sintaxis para usar and es como se muestra a continuación:

Sintaxis de Python

expression_1 and expression_2 [and ... and expression_n]

Cada una de las expresiones involucradas puede ser cualquier expresión u objeto Python. La parte de la sintaxis encerrada entre corchetes es opcional y expresa la posibilidad de encadenar múltiples expresiones con varias instancias de and.

Es importante recordar que todos los objetos Python tienen un valor de verdad asociado. Por lo tanto, and puede relacionar cualquier objeto y no está limitado a expresiones booleanas que devuelvan True o False.

La tabla de verdad del operador cuando lo usamos con expresiones lógicas se resume a continuación:

`expression_1` (bool)	`expression_2` (bool)	`expression_1 and expression_2`
`True`	`True`	`True`
`True`	`False`	`False`
`False`	`False`	`False`
`False`	`True`	`False`

Esta tabla aplica cuando usas and con expresiones que retornan un valor booleano concreto, ya sea True o False. Sin embargo, cuando usas and para conectar expresiones u objetos de otro tipo de datos, entonces and funciona como se muestra a continuación:

`expression_1`	`expression_2`	`expression_1 and expression_2`
Verdadero	Verdadero	`expression_2`
Verdadero	Falso	`expression_2`
Falso	Falso	`expression_1`
Falso	Verdadero	`expression_1`

Esta tabla resalta un aspecto importante del comportamiento de and y es que la expresión de la derecha solo se evalúa si la expresión de la izquierda es verdadera. Esto se conoce como evaluación de cortocircuito (short-circuit evaluation).

Ejemplos prácticos

Aquí tienes algunos ejemplos rápidos de cómo se usa and en Python:

Python REPL

>>> True and True
True

>>> True and False
False

>>> 5 > 3 and 3 < 4
True

>>> 5 > 3 and 3 > 4
False

En estos ejemplos, and evalúa dos objetos o expresiones booleanas. Si ambas son verdaderas, el resultado es True. Si alguna de ellas es falsa, el resultado es False.

Experimentar con expresiones que devuelvan otros tipos de datos te permitirá familiarizarte con el comportamiento del operador en estas situaciones:

Python REPL

>>> 5 + 1 and 2 - 3
-1

>>> 5 and 0
0

>>> "" and []
''

>>> "" and 3 + 2
''

>>> {} and 3
{}

En estos ejemplos, se usa and para conectar expresiones y objetos que devuelven tipos no booleanos. En cada caso, se obtiene un objeto en lugar de un valor True o False. Esta característica de and es útil para evaluar expresiones condicionalmente aprovechando la evaluación de cortocircuito.

Python REPL

>>> current_user = "juan"
>>> user_name = current_user and current_user.title()
>>> user_name
'Juan'

>>> current_user = None
>>> user_name = current_user and current_user.title()
>>> print(user_name)
None

En este ejemplo, cuando tienes un usuario activo, puedes usar and para modificar el nombre de usuario para que se muestre con letra inicial mayúscula. Si por el contrario, no tienes ningún usuario activo (current_user = None), la expresión de la derecha no se evalúa.

Cómo puedes confirmar que la expresión de la derecha no se evaluó? Si intentas llamar al método .title() en el objeto None, Python genera una excepción de tipo AttributeError:

Python REPL

>>> current_user.title()
Traceback (most recent call last):
    ...
AttributeError: 'NoneType' object has no attribute 'title'

El hecho de recibir esta excepción confirma que la expresión del lado derecho, current_user.title(), no se ejecutó en tu ejemplo original.

Uso de `and`

Los casos de uso más comunes de la palabra clave and incluyen los siguientes:

Combinar múltiples condiciones en una sentencia if o un ciclo while.
Filtrar elementos en una colección usando múltiples criterios de filtrado.
Evaluar expresiones condicionalmente, usando la evaluación de cortocircuito.

Resumiendo

La palabra clave and en Python es fundamental para crear condiciones compuestas que conecten múltiples condiciones simples entre sí.

Conocer y emplear and te permite construir expresiones lógicas más complejas y precisas, lo cual es esencial para la toma de decisiones en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: True

2025-04-12T11:00:00+02:00

True es comúnmente el resultado de evaluar condiciones y expresa la veracidad de una declaración en el contexto de operaciones lógicas y de control de flujo como condicionales y ciclos while. También puedes emplearla como valor por defecto de argumentos opcionales en funciones y métodos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de True
Resumiendo

Sintaxis

La sintaxis para usar True es bastante sencilla pues se trata de una constante booleana. Solo necesitas usarla directamente en tus declaraciones o expresiones. Por ejemplo, en una asignación como la siguiente:

Sintaxis de Python

variable = True

Ejemplos prácticos

Considera algunos ejemplos rápidos para comprender mejor la manera en que True puede aparecer generalmente en tu código Python:

Python REPL

>>> 5 < 6
True

>>> 4 in [1, 2, 3, 4]
True

>>> isinstance(3.14, float)
True

En estos ejemplos, True es el resultado de evaluar expresiones lógicas que son verdaderas. En el primer ejemplo, 5 es menor que 6. En el segundo ejemplo, 4 está presente en la lista, y en el tercer ejemplo, el número 3.14 es de tipo float. Todas estas expresiones resultan ser verdaderas, por lo tanto devuelven True.

Un uso práctico común donde ves a True empleado de manera explícita es cuando funciona como valor por defecto de argumentos de funciones:

Python REPL

>>> def greet(name, informal=True):
...     if informal:
...         print(f"Hola, {name}!")
...     else:
...         print(f"Buenos días {name}!")
...

>>> greet("Pythonista")
Hola, Pythonista!

>>> greet("Pythonista", informal=False)
Buenos días Pythonista!

En este ejemplo, el argumento informal tiene un valor por defecto igual a True. Esto significa que cuando llamas la función sin pasarle un valor explícito a informal obtienes un saludo informal. Observa que cuando llamas a la función con informal igual a False (el valor de verdad opuesto a True), entonces el saludo se vuelve formal porque se ejecuta la cláusula else de la condicional.

En Python, es una práctica común y más idiomática no comparar explícitamente las condiciones con True o False. En lugar de if informal == True, simplemente puedes usar if informal. Esto hace que tu código sea más limpio y conciso.

Uso de `True`

Los casos de uso más comunes de la palabra clave True incluyen los siguientes:

Representar un valor de verdad verdadero en operaciones lógicas y comparaciones.
Decidir qué acciones ejecutar en declaraciones de control de flujo como sentencias if y ciclos while.
Proporcionar un valor por defecto para argumentos de funciones y métodos.
Indicar éxito o condiciones verdaderas como un valor de retorno en funciones y métodos.
Definir funciones y métodos de valor booleano, es decir, que devuelven True o False.

Resumiendo

La palabra clave True en Python es fundamental para evaluar condiciones y controlar el flujo de tu programa.

Conocer y emplear True te permite trabajar eficazmente con estructuras lógicas y desarrollar programas que tomen decisiones de ejecución basadas en los resultados de las condiciones evaluadas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: None

2025-03-11T11:10:00+01:00

El objeto None es comúnmente usado para indicar que una variable no tiene un valor real o valor con significado. Expresa ideas como inexistente, nulo, ninguno, nada y similares.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de None
Resumiendo

Sintaxis

La sintaxis para None es simplemente usar la palabra tal y como se escribe, incluida la mayúscula inicial, cuando desees establecer un valor nulo:

Sintaxis de Python

variable = None

Ejemplos prácticos

Aquí tienes algunos ejemplos rápidos del uso de la palabra clave None:

Python REPL

>>> username = None

En este ejemplo, None indica que la variable username aún no tiene un valor definido.

Es muy común usar None como valor por defecto de argumentos en funciones:

Python REPL

>>> def greet(name=None):
...     if name is None:
...         name = "mundo"
...     print(f"Hola, {name}!")
...

>>> greet()
Hola, mundo!
>>> greet("Ana")
Hola, Ana!

En este segundo ejemplo, la función greet() acepta el argumento name cuyo valor por defecto es None. Si llamas a la función sin argumentos, entonces obtienes Hola, mundo! como respuesta. Si le pasas un nombre, la función saluda a la persona deseada.

En Python, las funciones sin valor de retorno explícito retornan None. Para visualizar el valor None en una sesión interactiva, puedes emplear la función integrada print().

Uso de `None`

Los casos de uso más comunes de la palabra clave None incluyen los siguientes:

Inicializar variables a un estado nulo antes de asignarles un valor concreto
Indicar que una función no devuelve un valor
Comprobar si una variable o nombre tiene un valor asignado o no

Resumiendo

La palabra clave None es una herramienta esencial en Python para representar la ausencia de un valor.

Conocer y utilizar None te permite manejar situaciones donde necesitas trabajar con variables que aún no tienen un valor definido o funciones que no necesitan devolver datos sino que operan a través de efectos secundarios o colaterales.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Palabras clave en Python: False

2025-03-08T11:00:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Sintaxis
Ejemplos prácticos
Uso de False
Resumiendo

Sintaxis

La sintaxis de False consiste en usar la palabra clave tal cual se escribe (incluyendo la inicial mayúscula) en expresiones o sentencias, como en comparaciones o evaluaciones booleanas:

Python REPL

>>> is_registered = False

Ejemplos prácticos

False puede ser el resultado de evaluar una expresión booleana en Python:

Python REPL

>>> 5 > 6
False

En este ejemplo, 5 es menor que 6, por lo tanto, Python evalúa la expresión y retorna False.

También es común emplear False como valor por defecto de argumentos en funciones y métodos:

Python REPL

>>> def greet(name, verbose=False):
...     if verbose:
...         print(f"Hola, {name}! Cómo estás hoy?")
...     else:
...         print(f"Hola, {name}!")
...

>>> greet("Scout")
Hola, Scout!
>>> greet("Scout", verbose=True)
Hola, Scout! Cómo estás hoy?

En este ejemplo, el argumento verbose es falso por defecto. False se emplea comúnmente para establecer el valor por defecto de argumentos que operan como indicadores (flags) booleanos.

También puedes emplear False como valor inicial de variables booleanas:

Python REPL

>>> is_active = False
>>> has_permission = False

En estos ejemplos, False te permite establecer un valor inicial para variables que pueden ser verdaderas o falsas.

Uso de `False`

Los casos de uso más comunes de la palabra clave False incluyen los siguientes:

Representar un valor de verdad falso en operaciones lógicas y comparaciones
Definir un valor predeterminado o por defecto para argumentos en funciones y métodos.
Determinar qué acción ejecutar en control de flujo como condicionales (if) y ciclos while

Resumiendo

La palabra clave False en Python es fundamental para representar un valor booleano falso en evaluaciones lógicas y control de flujo.

Conocer y emplear esta palabra clave te permitirá escribir código legible y efectivo al manejar condiciones y tomar decisiones en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo obtener ayuda en Python?

2025-03-03T17:30:00+01:00

En esta guía rápida, tienes un resumen de las opciones más utilizadas para obtener ayuda directamente desde una sesión interactiva de Python o desde la terminal de tu sistema operativo.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

1. La documentación oficial de Python
2. El sistema interactivo de ayuda: help()
3. La herramienta pydoc
Resumiendo

1. La documentación oficial de Python

La documentación oficial de Python es la fuente primaria de información actualizada sobre el lenguaje y sus últimas actualizaciones. La estructura de la documentación incluye secciones como las siguientes:

¿Qué hay de nuevo en Python?: Novedades en cada versión
Tutorial: Guía escrita por Guido Van Rossum
Library reference: Referencia de módulos y paquetes
Language reference: Sintaxis del lenguaje
Cómos (HOWTOs) de Python: Preguntas frecuentes

Notarás que la documentación aún tiene fragmentos que no han sido traducidos completamente al Español. ¿Te gustaría contribuir en la traducción? Consulta la guía de contribución.

2. El sistema interactivo de ayuda: `help()`

La función integrada help() proporciona información detallada sobre objetos, funciones y módulos:

Python REPL

>>> help(list)

En este ejemplo, usas la clase list como argumento para help() y obtienes la página de ayuda relacionada.

Para consultar la ayuda de un objeto que no está en tu espacio de nombres actual, puedes emplear una cadena con el nombre del objeto. Por ejemplo, para consultar la ayuda sobre el módulo sys de la librería estándar no tienes que importar el módulo primero, solo usa una cadena con su nombre:

Python REPL

>>> help("sys")

Cuando el objeto que le pasas como argumento a help() tiene una página de ayuda disponible, esa página te aparecerá en pantalla.

Si llamas a la función help() sin argumentos, entonces entrarás al sistema interactivo de ayuda:

Python REPL

>>> help()

Dentro del sistema interactivo de ayuda, puedes explorar temas fundamentales escribiendo algunas palabras clave como por ejemplo:

keywords: Lista de palabras clave de Python
modules: Lista de módulos disponibles
topics: Temas de documentación
symbols: Símbolos disponibles

Para salir de cada página de ayuda, presiona la tecla Q. Para salir del sistema de ayuda y regresar a tu sesión interactiva de Python, escribe q o quit y presiona Enter.

3. La herramienta `pydoc`

La herramienta de línea de comandos pydoc permite obtener información sobre módulos y funciones desde la terminal sin necesidad de estar en una sesión interactiva de Python. Esta herramienta funciona de manera muy parecida a la función help().

Por ejemplo, el siguiente comando muestra información sobre la clase str:

Terminal

$ pydoc str

Puedes generar documentación en HTML con el comando siguiente:

Terminal

$ pydoc -w sys

Guarda la documentación del módulo sys en un archivo HTML llamado sys.html en tu directorio de trabajo.

Para explorar la documentación en un navegador web:

Terminal

$ pydoc -b

Con este comando, puedes iniciar un servidor web con la documentación de Python.

Resumiendo

Contar con buenas fuentes de información es clave para aprender Python eficazmente. La documentación oficial, la función integrada help() y la herramienta pydoc te permitirán encontrar respuestas rápidamente mientras trabajas en tu código.

Explora estas opciones y podrás resolver rápidamente tus dudas sobre Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Ciclos o bucles for

2025-02-24T22:00:00+01:00

Los ciclos for son fundamentales para procesar colecciones de datos, aplicando transformaciones sobre cada valor de la colección o empleando los valores en alguna operación o cálculo intermedio.

En este tutorial, aprenderás lo esencial sobre el funcionamiento de los ciclos for y cómo utilizarlos en tus programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Conociendo los ciclos for
Iterando con ciclos for en Python
Controlando la iteración con break y continue
Usando la cláusula else en ciclos for
Usando ciclos for anidados
Conclusiones

Conociendo los ciclos `for`

Un ciclo o bucle for te permite iterar sobre los elementos de un iterable, colección o contenedor de datos, como pueden ser las listas, tuplas, cadenas de texto y diccionarios. En cada iteración, puedes ejecutar un bloque de código que actúe sobre cada elemento de la colección.

La sintaxis básica de un ciclo for en Python es la siguiente:

Sintaxis de Python

for variable in iterable:
    <block>

variable: variable del ciclo que mantiene una referencia al elemento actual de la secuencia.
iterable: objeto iterable sobre el que se realiza la iteración.
<block>: bloque de código con las instrucciones que se ejecutan en cada iteración.

Iterando con ciclos `for` en Python

En tu trabajo diario con Python, puedes emplear los ciclos for para recorrer los elementos de distintos tipos de datos, siempre y cuando estos soporten la iteración. Esto te permite transformar tus datos y hacer cálculos y operaciones con ellos mientras iteras.

En las secciones siguientes, aprenderás cómo emplear ciclos for para recorrer distintos tipos de datos integrados, como las listas, tuplas, cadenas, diccionarios y conjuntos.

Listas y tuplas

Los ciclos for son comúnmente empleados para iterar sobre listas:

Python REPL

>>> fruits = ["manzana", "banana", "cereza"]
>>> for fruit in fruits:
...     print(fruit)
...
manzana
banana
cereza

En este ejemplo, el ciclo recorre la lista de frutas e imprime cada elemento. La variable fruit es la variable del ciclo, y la lista fruits es el objeto iterable. La llamada a print() representa el bloque de código del bucle. Este bloque generalmente opera sobre o con los elementos del iterable.

También puedes emplear un ciclo for para poblar una lista vacía con valores generados a partir de alguna operación o cálculo:

Python REPL

>>> squares = []
>>> for value in [1, 2, 3]:
...     squares.append(value**2)
...
>>> squares
[1, 4, 9]

En este ejemplo, creas una lista vacía para almacenar los cuadrados de los valores almacenados en una lista de números. El método .append() te permite agregar valores individuales al final de una lista.

El ciclo for funciona de igual manera con tuplas:

Python REPL

>>> person = ("Juan", 35, "Programador", "Cuba")
>>> for value in person:
...     print(value)
...
Juan
35
Programador
Cuba

En este ejemplo, iteras sobre una tupla con un ciclo for. Nuevamente, el ciclo solo imprime cada elemento de la tupla en tu pantalla.

Cadenas de texto

También puedes usar un bucle for para recorrer los caracteres de una cadena de texto:

Python REPL

>>> word = "Python!"
>>> for char in word:
...     print(char)
...
P
y
t
h
o
n
!

Cada iteración de este bucle imprime un carácter de la cadena original.

Rangos de valores

La función incorporada range() genera secuencias de números enteros:

Python REPL

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

Aquí, range(5) genera los números del 0 al 4.

Diccionarios y conjuntos

Los ciclos for también te permiten iterar sobre diccionarios y conjuntos. En el caso de los diccionarios, puedes recorrer un diccionario por sus claves, valores o ítems.

Para recorrer un diccionario por sus claves, puedes emplear el diccionario directamente o el método .keys() como se muestra a continuación:

Python REPL

>>> person = {"nombre": "Juan", "edad": 35, "puesto": "Programador"}

>>> for key in person:
...     print(key, "->", person[key])
...
nombre -> Juan
edad -> 35
puesto -> Programador

>>> for key in person.keys():
...     print(key, "->", person[key])
...
nombre -> Juan
edad -> 35
puesto -> Programador

Ambas maneras de iterar sobre las claves son equivalentes. La primera es más comúnmente usada y ligeramente más eficiente. Sin embargo, la segunda puede ser más explícita en algunas situaciones.

El método .keys() es redundante en este contexto. Iterar directamente sobre el diccionario es la manera preferida en la mayoría de los casos. Este método solo es útil si necesitas específicamente un objeto de vista de claves.

Para iterar sobre los valores, puedes emplear el método .values() como se muestra en el siguiente ejemplo:

Python REPL

>>> for value in person.values():
...     print(value)
...
Juan
35
Programador

Si deseas recorrer los pares clave-valor, puedes usar .items() como se muestra en el siguiente ejemplo:

Python REPL

>>> for key, value in person.items():
...     print(key, "->", value)
...
nombre -> Juan
edad -> 35
puesto -> Programador

Finalmente, los ciclos for también te permiten recorrer conjuntos:

Python REPL

>>> colors = {"rojo", "azul", "verde", "amarillo"}
>>> for color in colors:
...     print(color)
...
amarillo
azul
verde
rojo

Es fundamental que tengas en cuenta que los conjuntos en Python son colecciones no ordenadas de datos. Por esta razón, el ciclo itera sobre los elementos en un orden diferente al orden de inserción.

Controlando la iteración con `break` y `continue`

En Python, las sentencias break y continue te permiten controlar el flujo de ejecución en los ciclos for. La función de estas sentencias es la siguiente:

break: termina el ciclo anticipadamente y salta a la sentencia inmediatamente después del ciclo.
continue: salta a la siguiente iteración, sin ejecutar el código que le sigue en el bloque del ciclo.

A continuación, un ejemplo de cómo usar break:

Python REPL

>>> for letter in "python":
...     if letter == "h":
...         break
...     print(letter)
...
p
y
t

Nota cómo la ejecución termina cuando la letra actual es "h". El resto de las letras no se imprimen.

Considera el siguiente ejemplo de cómo emplear continue:

Python REPL

>>> for letter in "python":
...     if letter == "h":
...         continue
...     print(letter)
...
p
y
t
o
n

En este ejemplo, la letra "h" no se imprime, pues la sentencia continue salta a la próxima iteración sin ejecutar print().

Usando la cláusula `else` en ciclos `for`

Como las sentencias condicionales, los ciclos for pueden tener una cláusula else. En los ciclos, el else se ejecuta únicamente cuando el ciclo finaliza sin ser interrumpido por una sentencia break:

Python REPL

>>> for i in range(4):
...     print(i)
... else:
...     print("Ciclo finalizado")
...
0
1
2
3
Ciclo finalizado

Este ciclo termina naturalmente luego de recorrer el rango de valores completo. Entonces, el else se ejecuta y ves el mensaje Ciclo finalizado en la pantalla.

Si se usa una instrucción break, el bloque else no se ejecuta:

Python REPL

>>> for i in range(4):
...     if i == 2:
...         break
...     print(i)
... else:
...     print("Ciclo finalizado")
...
0
1

Este ciclo termina cuando el valor de i es igual a 2, en cuyo caso la cláusula else no se ejecuta.

Es importante tener en cuenta que, cuando incluyes un bucle for en una función y el bucle contiene una instrucción return, entonces este termina al alcanzar dicha instrucción y la cláusula else no se ejecuta.

Usando ciclos `for` anidados

Puedes anidar un ciclo for dentro de otro para recorrer estructuras más complejas, como por ejemplo listas de listas:

Python REPL

>>> matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

>>> for row in matrix:
...     for value in row:
...         print(value)
...
1
2
3
4
5
6
7
8
9

Puedes anidar ciclos a tantos niveles como necesites. Sin embargo, esta práctica suele causar que tu código sea ineficiente y difícil de entender. Por lo tanto, es recomendable no anidar ciclos a más de dos niveles de profundidad.

Conclusiones

Los ciclos o bucles for son esenciales en Python para realizar tareas repetitivas y manipular datos eficientemente. Con un ciclo for, puedes recorrer diversos tipos de datos como listas, cadenas y diccionarios.

También puedes combinar for con range(), break, continue y else para controlar el flujo de ejecución de tu código de una manera mucho más precisa.

Dominar esta estructura es fundamental para escribir código más limpio y efectivo. Practica con tus propios ejemplos y experimenta con diferentes estructuras para afianzar tu comprensión.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo comprimir archivos con zipfile en Python?

2025-02-11T22:15:00+01:00

El módulo zipfile de la biblioteca estándar de Python permite manipular archivos en formato ZIP que es un formato estándar para comprimir y archivar datos. Con este módulo, puedes crear, leer, escribir, extraer y listar archivos contenidos dentro de archivos ZIP.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Pasos resumidos
Paso 1: Importar el módulo zipfile
Paso 2: Instanciar la clase ZipFile
Paso 3: Elegir el método de compresión
Paso 4: Comprimir los archivos en el archivo ZIP
Resumiendo

Pasos resumidos

Para comprimir archivos usando el módulo zipfile en Python, puedes seguir los siguientes pasos:

Importar el módulo zipfile.
Instanciar la clase ZipFile en modo de escritura ("w") para crear un nuevo archivo ZIP.
Elegir el método de compresión.
Comprimir los archivos en el archivo ZIP usando el método .write().

Estos pasos te permitirán crear y comprimir archivos en un archivo ZIP utilizando Python. El código necesario es el siguiente:

Python - compress_files.py

import zipfile

with zipfile.ZipFile(
    "archivo.zip",
    mode="w",
    compression=zipfile.ZIP_DEFLATED
) as zip_file:
    zip_file.write("archivo_0.txt")
    zip_file.write("archivo_1.txt")

A continuación una discusión más detallada de cada uno de estos pasos y su código Python asociado.

Paso 1: Importar el módulo `zipfile`

Primero, necesitas importar el módulo zipfile en tu script:

Python - compress_files.py

import zipfile

Paso 2: Instanciar la clase `ZipFile`

La clase ZipFile funciona de modo similar a la función incorporada open() de Python, permitiéndote abrir archivos ZIP. Para instanciar la clase, emplearás tres argumentos:

file: El nombre del archivo ZIP resultante.
mode: El modo de apertura que puede ser modo de lectura ("r"), escritura ("w"), anexar ("a") y exclusivo ("x").
compression: El método de compresión deseado.

Esta clase funciona como un gestor de contexto, por lo que puedes utilizarla dentro de una sentencia with. Como nombre de archivo, puedes emplear cualquier identificador de archivo válido en tu sistema operativo seguido de la extensión .zip.

Paso 3: Elegir el método de compresión

Para comprimir archivos mientras los escribes en un archivo ZIP, puedes usar alguno de los modos de compresión siguientes con la constante apropiada:

Método de compresión	Constante	Módulo requerido
Deflate	`zipfile.ZIP_DEFLATED`	`zlib`
Bzip2	`zipfile.ZIP_BZIP2`	`bz2`
LZMA	`zipfile.ZIP_LZMA`	`lzma`

Estos son los métodos de compresión que actualmente puedes usar con ZipFile. Usar un método diferente generará un NotImplementedError. El método más comúnmente usado es ZIP_DEFLATED.

Paso 4: Comprimir los archivos en el archivo ZIP

Ahora, supón que necesitas comprimir los archivos archivo_0.txt y archivo_1.txt que se encuentran en tu directorio de trabajo actual. Puedes lograrlo con el siguiente código:

Python - compress_files.py

with zipfile.ZipFile(
    "archivo.zip",
    mode="w",
    compression=zipfile.ZIP_DEFLATED
) as zip_file:
    zip_file.write("archivo_0.txt")
    zip_file.write("archivo_1.txt")

Este código crea un archivo ZIP llamado archivo.zip y lo abre en modo de escritura. Luego, utiliza el algoritmo Deflate para comprimir los archivos dentro del archivo ZIP. Dentro del bloque de la sentencia with, se agregan los archivos a comprimir utilizando el método .write().

Resumiendo

Para comprimir archivos usando el módulo zipfile en Python, puedes seguir los siguientes pasos:

Importar el módulo zipfile.
Instanciar la clase ZipFile en modo de escritura ("w") para crear un nuevo archivo ZIP.
Elegir el método de compresión.
Comprimir los archivos en el archivo ZIP usando el método .write().

Estos pasos te permiten crear un archivo ZIP y comprimir los archivos deseados utilizando Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo crear un entorno virtual de Python?

2025-02-03T10:20:00+01:00

En esta guía rápida, aprenderás los pasos para crear un entorno virtual en Windows, macOS y Linux (Debian/Ubuntu).

Contenidos

Conociendo los entornos virtuales de Python
Crear un entorno virtual Python en Windows
Crear un entorno virtual Python en macOS
Crear un entorno virtual Python en Linux (Debian/Ubuntu)
Resumiendo

Conociendo los entornos virtuales de Python

Los entornos virtuales de Python te sirven para gestionar dependencias de manera independiente para cada uno de tus proyectos. Esto te evita conflictos entre diferentes versiones de bibliotecas.

En la práctica, un entorno virtual:

Crea una copia aislada de Python y pip dentro de un directorio específico.
Permite instalar paquetes sin interferir con otros proyectos o con el sistema operativo.
Facilita la replicación de entornos en distintos dispositivos o servidores.

Crear un entorno virtual Python en Windows

Los requisitos previos para crear un entorno virtual de Python en Windows son los siguientes:

Tener instalado Python.
Asegurarse de que python y pip funcionan correctamente.

Una vez que tu sistema cumple los requisitos previos, puedes crear un entorno virtual de Python siguiendo los pasos que a continuación se describen.

Abrir símbolo del sistema (cmd.exe) o la aplicación PowerShell.
Navegar a la carpeta donde deseas crear el entorno virtual:
Powershell
```
PS> cd ruta\al\proyecto
```
Crear el entorno virtual:
Powershell
```
PS> py -m venv venv\
```
Activar el entorno virtual:
Powershell
```
PS> venv\Scripts\activate
(venv) PS>
```
Desactivar el entorno y regresar al indicador (prompt) del sistema:
Powershell
```
(venv) PS> deactivate
```

Usar venv como nombre de un entorno virtual de Python es una práctica común. Sin embargo, no es obligatorio hacerlo, puedes emplear el nombre que desees.

Crear un entorno virtual Python en macOS

En macOS, para crear un entorno virtual de Python, solo necesitas tener Python correctamente instalado en tu sistema. Una vez instalado, puedes seguir los siguientes pasos para crear un entorno virtual de Python:

Abrir la Terminal.
Navegar a la carpeta donde deseas crear el entorno virtual:
Terminal
```
$ cd ruta/al/proyecto
```
Crear el entorno virtual:
Terminal
```
$ python3 -m venv venv
```
Activar el entorno virtual:
Terminal
```
$ source venv/bin/activate
(venv) $
```
Desactivar el entorno y regresar al indicador del sistema:
Terminal
```
(venv) $ deactivate
```

Crear un entorno virtual Python en Linux (Debian/Ubuntu)

Si tienes un sistema Linux basado en Debian o Ubuntu, entonces los requisitos son los siguientes:

Tener instalado Python
Tener el módulo venv

En Ubuntu, el módulo venv no viene instalado por defecto. Si ese es tu sistema, entonces puedes instalar venv con el siguiente comando:

Terminal

$ sudo apt update && sudo apt install python3-venv

Luego de cumplir con los requisitos iniciales, puedes crear un entorno virtual Python siguiendo los pasos a continuación:

Abrir la terminal o línea de comandos.
Navegar a la carpeta del proyecto:
Terminal
```
$ cd ruta/al/proyecto
```
Crear el entorno virtual:
Terminal
```
$ python3 -m venv venv
```
Activar el entorno virtual:
Terminal
```
$ source venv/bin/activate
(venv) $
```
Desactivar el entorno y regresar al indicador del sistema:
Terminal
```
(venv) $ deactivate
```

En Ubuntu, pip tampoco viene instalado por defecto. Para poder usar esta herramienta, debes instalarla con el comando sudo apt install python3-pip.

Resumiendo

En Python, las buenas prácticas recomiendan el empleo de entornos virtuales dedicados para cada uno de tus proyectos. Siguiendo los pasos de esta guía, puedes crear y activar entornos virtuales de Python de manera eficiente en el sistema operativo que estés usando en tu computadora.

Iniciando con PySide6 para desarrollo GUI

2025-01-21T21:40:00+01:00

Para desarrollar este tipo de aplicaciones en Python, puedes emplear una amplia variedad de bibliotecas y frameworks, incluyendo Tkinter, wxPython, PyQt, entre otras. Sin embargo, PySide6 es una de las bibliotecas más populares y sólidas disponibles.

En este tutorial, aprenderás los conceptos básicos para construir aplicaciones GUI usando Python y PySide6.

En este tutorial, aprenderás cómo:

Instalar PySide6 y configurarlo en tu computadora
Crear aplicaciones con interfaces gráficas de usuario basadas en PySide6
Organizar una GUI usando gestores de disposición
Crear ventanas principales y diálogos en tus aplicaciones PySide6

Para obtener el máximo de este tutorial, debes conocer lo básico de programación con Python, especialmente temas relacionados con la programación orientada a objetos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Conociendo PySide6

PySide6 es una biblioteca que proporciona el enlace oficial entre Python y Qt, el cual es un framework de desarrollo en C++ para crear interfaces gráficas de usuario (GUIs). Proporciona clases y herramientas para la creación de GUIs, manejo de XML, comunicación de red, expresiones regulares, hilos, bases de datos SQL, navegación web y otras tecnologías disponibles en Qt.

PySide6, también conocida como Qt for Python, es compatible con Windows, Linux y macOS, por lo que puedes emplearla para desarrollar aplicaciones multiplataforma que tengan una apariencia nativa en cada plataforma.

Puedes usar PySide6 con una licencia comercial y en proyectos de código abierto con una licencia compatible con la licencia de Qt que estés empleando ya sea LGPLv3 o GPLv2.

Instalando PySide6

Para instalar PySide6 en tu computadora, la opción recomendada es instalar desde el índice de paquetes de Python, PyPI, usando el comando pip. Para esto, puedes crear un entorno virtual de Python y luego instalar el paquete pyside6, ejecuta lo siguiente en tu línea de comandos, dependiendo de tu sistema operativo.

En Windows

En Windows, puedes instalar PySide6 ejecutando los comandos:

Powershell

PS> python -m venv venv
PS> venv\Scripts\activate.bat
(venv) PS> python -m pip install pyside6

Con estos comandos, primero creas y activas un entorno virtual Python y luego instalas PySide6 desde PyPI.

En Linux y macOS

En Linux y macOS el proceso es el mismo y puedes realizarlo con los siguientes comandos:

Terminal

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install pyside6

Nuevamente, primero creas un entorno virtual usando el módulo venv de la biblioteca estándar de Python. Luego lo activas, y finalmente instalas PySide6.

Creando una aplicación PySide6

Con PySide6 instalado, estás listo para crear tu primera aplicación GUI. Para comenzar, crearás una aplicación de Hola, Mundo!. Aquí están los pasos a seguir:

Importa QApplication y todos los widgets necesarios desde PySide6.QtWidgets.
Crea una instancia de QApplication.
Define la GUI de la aplicación.
Muestra la GUI de la aplicación.
Ejecuta el bucle de eventos de la aplicación.

Crea un nuevo archivo Python llamado app.py en tu directorio de trabajo actual:

Python - app.py

from PySide6.QtWidgets import QApplication, QLabel, QWidget

En esta línea de código, importas QApplication, QLabel, y QWidget desde QtWidgets. Con esto, has cumplido con el primer paso.

Para completar el segundo paso, necesitas crear una instancia de QApplication:

Python - app.py

from PySide6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

En esta línea de código, creas la instancia de QApplication. Es necesario crear esta instancia antes de crear cualquier objeto GUI en PySide6.

El tercer paso consiste en crear la GUI o ventana principal de la aplicación. Para este ejemplo, la GUI se basará en la clase QWidget, que es la clase base de todos los objetos de interfaz de usuario en PySide6.

Así es como puedes crear la GUI de la app:

Python - app.py

from PySide6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

window = QWidget()
window.setWindowTitle("PySide6 Demo")
window.setGeometry(100, 100, 280, 80)
hello = QLabel("<h1>Hola, Mundo!</h1>", parent=window)
hello.move(60, 15)

En este código, window es una instancia de QWidget, la cual proporciona todas las características que necesitarás para crear la ventana de la aplicación.

Como su nombre sugiere, el método .setWindowTitle() te permite establecer el título de la ventana en tu aplicación. En este ejemplo, la ventana de la app mostrará PySide6 Demo en su barra de título.

Puedes usar .setGeometry() para definir el tamaño de la ventana y la posición en la pantalla. Los dos primeros argumentos son las coordenadas de pantalla x y y donde se colocará la ventana. El tercer y cuarto argumentos son el ancho y alto de la ventana.

Cada aplicación GUI necesita widgets. Estos son los componentes gráficos que conforman la GUI de la app. En este ejemplo, usas un widget QLabel llamadohello que te permitirá mostrar el mensaje Hola, Mundo! en la ventana de tu aplicación.

Los objetos QLabel pueden mostrar texto formateado en HTML, por lo que puedes usar el elemento HTML "<h1>Hola, Mundo!</h1>" para proporcionar el texto deseado como un encabezado h1. Finalmente, usas el método .move() para colocar el mensaje en las coordenadas (60, 15) en la ventana de la aplicación.

Has finalizado el tercer paso, así que puedes continuar con los dos últimos pasos y preparar tu aplicación GUI PySide6 para ejecutarse:

Python - app.py

from PySide6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

window = QWidget()
window.setWindowTitle("PySide6 Demo")
window.setGeometry(100, 100, 280, 80)
hello = QLabel("<h1>Hola, Mundo!</h1>", parent=window)
hello.move(60, 15)

window.show()
app.exec()

En las dos últimas líneas, llamas el método .show() en window para mostrar la ventana en la pantalla. Luego, inicias el bucle de eventos de la aplicación ejecutando .exec() y ya está.

Puedes ejecutar tu primera aplicación PySide6 con el siguiente comando:

Terminal

$ python app.py

Al ejecutar este comando, verás una ventana que lucirá como la siguiente:

Aplicación "Hola, Mundo!" con PySide6 y Python

Tu aplicación muestra una ventana basada en QWidget. La ventana muestra el mensaje Hola, Mundo! usando un widget QLabel. ¡Y con eso, has escrito tu primera aplicación de escritorio GUI usando PySide6 y Python!

Explorando widgets comunes de PySide6

Los widgets son componentes gráficos rectangulares que colocas en las ventanas de tu aplicación para construir la GUI. Los widgets tienen atributos y métodos que te permiten ajustar su apariencia y comportamiento.

Los widgets también detectan clics del mouse, pulsaciones de teclas y otros eventos del usuario, el sistema de ventanas y otras fuentes. Cada vez que un widget captura un evento, emite una señal para anunciar su cambio de estado.

PySide6 tiene una colección variada de widgets, cada uno de los cuales tiene un propósito diferente. Algunos de los widgets más comunes incluyen botones, etiquetas o labels, campos de entrada de texto, listas desplegables, y botones radiales.

Botones

Puedes crear un botón con la clase QPushButton, la cual proporciona un botón de comando clásico. Algunos botones típicos son Ok, Cancelar, Aplicar, Sí, No, Cerrar, similares.

Crea un archivo llamado buttons.py y pon el siguiente código en él:

Python - buttons.py

from PySide6.QtWidgets import (
    QApplication,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Botones PySide6")
window.setGeometry(100, 100, 190, 50)
layout = QVBoxLayout()
window.setLayout(layout)

for text in ["Ok", "Cancelar", "Aplicar", "Sí", "No", "Cerrar"]:
    button = QPushButton(text, parent=window)
    layout.addWidget(button)

window.show()
app.exec()

En este ejemplo, primero añades la clase QPushButton a tus objetos importados. El bucle for itera sobre una lista de nombres de botones comunes y crea un botón con cada uno de los nombres definidos. Así es como se verá tu aplicación al ejecutarla desde tu terminal:

Botones en PySide6

Botones como estos son quizás los widgets más utilizados en cualquier GUI. Cuando alguien hace clic en ellos, tu aplicación ordena a la computadora realizar acciones. Así es como puedes ejecutar cálculos cuando un usuario hace clic en un botón.

En este ejemplo, empleas una clase llamada QVBoxLayout que representa un gestor de disposición que permite organizar los widgets con una orientación vertical. Más sobre gestores de disposición en un momento.

Campos de entrada de texto

Los campos de entrada de texto son widgets comunes también. Estos widgets te permite ingresar una sola línea de texto y puedes crearlos con la clase QLineEdit. Los campos de entrada de texto son útiles cuando necesitas obtener información del usuario como texto simple.

Para un ejemplo, crea un archivo line_edits.py y escribe el siguiente código en él:

Python - line_edits.py

from PySide6.QtWidgets import (
    QApplication,
    QLineEdit,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Campos de texto PySide6")
window.setGeometry(100, 100, 250, 50)
layout = QVBoxLayout()
window.setLayout(layout)

for text in ["Nombre", "Usuario", "Contraseña"]:
    edit = QLineEdit(parent=window)
    edit.setPlaceholderText(text)
    layout.addWidget(edit)

window.show()
app.exec()

En el bucle de este ejemplo, creas tres campos de texto para permitir que el usuario introduzca su nombre, usuario y contraseña:

Campos de texto en PySide6

Campos de texto como estos proporcionan funcionalidades estándar como copiar, pegar, deshacer, rehacer, arrastrar, soltar, y similares. En la imagen, puedes notar que los campos muestran texto de marcador de posición para informar al usuario qué tipo de información debe introducir.

Listas desplegables

Las listas desplegables son otro tipo fundamental de widget en aplicaciones GUI. Puedes crearlas usando la clase QComboBox. Una lista desplegable presenta al usuario una serie de opciones de una manera que ocupa un espacio mínimo en la pantalla.

A continuación, un ejemplo de cómo emplear una lista desplegable en PySide6:

Python - combo_boxes.py

from PySide6.QtWidgets import (
    QApplication,
    QComboBox,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Lista desplegable PySide6")
window.setGeometry(100, 100, 250, 50)
layout = QVBoxLayout()
window.setLayout(layout)

combo = QComboBox(parent=window)
combo.addItems(["PySide6", "PyQt", "Kivy", "Tkinter", "wxPython"])
layout.addWidget(combo)

window.show()
app.exec()

En este ejemplo, creas combo como una instancia de QComboBox. Esta instancia contendrá una lista desplegable con una serie de nombres de bibliotecas Python para desarrollo de aplicaciones GUI. Cuando ejecutas esta aplicación desde tu línea de comandos, obtienes una ventana como la siguiente:

Lista desplegable en PySide6

Al hacer clic sobre esta lista desplegable, los usuarios pueden seleccionar una de las opciones desplegadas. Las listas desplegables también pueden ser de solo lectura o editables y además de texto, también pueden contener pixmaps o ambos.

Botones radiales

El último widget que estudiarás es el botón radial, que puedes crear con la clase QRadioButton. Se trata de un botón circular de opción que puedes seleccionar al hacer clic sobre él. Los botones radiales son útiles cuando necesitas que el usuario seleccione una entre varias opciones.

Todas las opciones en un grupo de botones radiales son visibles al mismo tiempo, pero el usuario solo puede seleccionar una de ellas. Es decir, la selección es excluyente. Considera el siguiente ejemplo:

Python - radio_buttons.py

from PySide6.QtWidgets import (
    QApplication,
    QLabel,
    QRadioButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Botones radiales PySide6")
window.setGeometry(100, 100, 230, 80)
layout = QVBoxLayout()
window.setLayout(layout)
layout.addWidget(QLabel("¿Qué prefieres?"))

foods = ["Pizza", "Hamburguesa", "Pasta", "Pollo asado"]
for food in foods:
    radio = QRadioButton(food)
    layout.addWidget(radio)

window.show()
app.exec()

En este ejemplo, creas una aplicación que muestra un texto descriptivo, "¿Qué prefieres?", seguido de una serie de botones radiales, que representan opciones entre las que el usuario puede elegir. En este caso, las opciones son "Pizza", "Hamburguesa", "Pasta" y "Pollo asado". Para crear los botones, empleas un ciclo for que itera sobre la lista de comidas.

Al hacer clic en uno de los botones, este se activa y los demás se desactivan automáticamente. Esto los hace ideales para preguntas de selección única, como preferencias o respuestas a encuestas:

Botones radiales en PySide6

En este grupo de botones radiales, solo un botón puede estar seleccionado a la vez. Si seleccionas otro botón del grupo, entonces el botón previamente seleccionado se deseleccionará automáticamente.

PySide6 tiene una amplia colección de widgets. Actualmente hay más de cuarenta widgets disponibles. Aquí, has estudiado solo una pequeña muestra. Sin embargo, esta es suficiente para mostrarte el poder y la flexibilidad de este framework GUI.

En la siguiente sección, aprenderás cómo organizar diferentes widgets para construir GUIs modernas y completamente funcionales para tus aplicaciones.

Usando gestores de disposición

Para construir GUI app, necesitas saber cómo organizar un conjunto de widgets para que tu GUI sea intuitiva y funcional. En PySide6, las herramientas para este fin son los llamados gestores de disposición.

Se trata de clases que te permiten dimensionar y posicionar tus widgets en la ventana o formulario de la aplicación. Se adaptan automáticamente a eventos de cambio de tamaño y otros cambios en la GUI, controlando el tamaño y posición de todos sus widgets.

PySide6 proporciona cuatro clases básicas de gestores de disposición:

En las secciones siguientes, aprenderás lo básico de cómo emplear estas clases y crear GUIs ordenadas y funcionales.

Disposición horizontal

La primera clase de gestor de disposición que estudiarás es QHBoxLayout. Esta te permite organizar los widgets horizontalmente de izquierda a derecha. El ejemplo a continuación muestra cómo usar QHBoxLayout para organizar tres botones horizontalmente:

Python - horizontal_layout.py

from PySide6.QtWidgets import (
    QApplication,
    QHBoxLayout,
    QPushButton,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición Horizontal")

layout = QHBoxLayout()
window.setLayout(layout)

positions = ["Izquierda", "Centro", "Derecha"]
for position in positions:
    button = QPushButton(position)
    layout.addWidget(button)

window.show()
app.exec()

En este ejemplo, creas una instancia de QHBoxLayout llamada layout. Luego agregas los tres botones en un ciclo usando el método .addWidget(). La aplicación resultante luce como se muestra a continuación:

Gestor de disposición horizontal en PySide6

La figura anterior muestra tres botones en disposición horizontal. Los botones se muestran de izquierda a derecha en el mismo orden en que los agregaste en tu código.

Disposición vertical

La siguiente clase de gestor de disposición es QVBoxLayout. Esta clase te permite organizar los widgets verticalmente de arriba a abajo, facilitando la construcción de diseños verticales en tu GUI.

A continuación, un ejemplo de cómo puedes usar QVBoxLayout para organizar tres botones verticalmente:

Python - vertical_layout.py

from PySide6.QtWidgets import (
    QApplication,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición Vertical")
window.setGeometry(100, 100, 230, 80)

layout = QVBoxLayout()
window.setLayout(layout)

positions = ["Arriba", "Centro", "Abajo"]
for position in positions:
    button = QPushButton(position)
    layout.addWidget(button)

window.show()
app.exec()

En este ejemplo, creas una instancia de QVBoxLayout llamada layout. En el ciclo for, añades tres botones a layout empleando .addWidget(). Cuando ejecutas esta aplicación de ejemplo, obtienes una ventana que se ve como la siguiente:

Gestor de disposición vertical en PySide6

Esta captura muestra tres botones en un arreglo vertical, uno debajo del otro. Los botones aparecen en el mismo orden en que los agregaste a tu código, de arriba a abajo.

Disposición en cuadrícula

El tercer gestor de disposición que estudiarás es QGridLayout. Esta clase te permite organizar los widgets en una cuadrícula de filas y columnas. Cada widget tendrá una posición relativa en la cuadrícula. Puedes definir la posición de un widget con un par de coordenadas como (fila, columna). Cada coordenada debe ser un número entero. Estos pares de coordenadas definen qué celda en la cuadrícula ocupará un widget determinado.

QGridLayout toma el espacio disponible, lo divide en filas y columnas, y coloca cada widget hijo en su propia celda.

A continuación, se muestra un ejemplo de cómo organizar una GUI con este gestor de disposición:

Python - grid_layout.py

from PySide6.QtWidgets import (
    QApplication,
    QGridLayout,
    QPushButton,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición en Cuadrícula")

layout = QGridLayout()
window.setLayout(layout)

button_names = [
    "Botón (0, 0)",
    "Botón (0, 1)",
    "Botón (0, 2)",
    "Botón (1, 0)",
    "Botón (1, 1)",
    "Botón (1, 2)",
    "Botón (2, 0)",
]
for i, name in enumerate(button_names):
    button = QPushButton(name)
    layout.addWidget(button, i // 3, i % 3)

layout.addWidget(
    QPushButton("Botón (2, 1) + 2 Columnas de Amplitud"),
    2,
    1,
    1,
    2,
)

window.show()
app.exec()

En este ejemplo, creas una aplicación que utiliza un objeto QGridLayout para organizar sus widgets en la pantalla. Nuevamente, para añadir los botones, empleas un ciclo for y el método .addWidget(). Nota que el segundo y tercer argumento que pasas al métodos son números enteros que definen la posición de cada widget en la cuadrícula.

Finalmente, pasas dos argumentos más a .addWidget(). Estos argumentos son rowSpan y columnSpan los cuales sirven para hacer que un widget ocupe más de una fila o columna. En este ejemplo, el último botón ocupa una fila y dos columnas.

Si ejecutas este código desde tu línea de comandos, obtendrás una ventana que luce así:

Gestor de disposición en cuadrícula en PySide6

En esta figura, puedes ver tus botones organizados en una cuadrícula de filas y columnas. El último botón ocupa dos columnas en la cuadrícula.

Disposición de formulario

El último gestor de disposición que estudiarás es el QFormLayout. Con esta clase, puedes organizar los widgets en un diseño de dos columnas. La primera columna generalmente muestra texto en etiquetas, mientras que la segunda columna pueden contener widgets de entrada de datos como QLineEdit, QComboBox, QSpinBox, entre otros.

El siguiente ejemplo muestra cómo crear una aplicación que utiliza un objeto QFormLayout para organizar sus widgets:

Python - form_layout.py

from PySide6.QtWidgets import (
    QApplication,
    QFormLayout,
    QLineEdit,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición de Formulario")
window.setGeometry(100, 100, 280, 80)

layout = QFormLayout()
window.setLayout(layout)

labels = ["Nombre:", "Edad:", "Ocupación:", "Dirección:"]
for label in labels:
    layout.addRow(label, QLineEdit())

window.show()
app.exec()

QFormLayout tiene un método llamado .addRow() que puedes usar para agregar una fila de dos widgets al formulario. El primer argumento de .addRow() debe ser una etiqueta o una cadena. El segundo argumento puede ser cualquier widget que permita al usuario ingresar o editar datos. En este ejemplo específico, has usado campos de entrada de texto, QLineEdit.

Si ejecutas este código, obtendrás una ventana similar a la siguiente:

Gestor de disposición para formulario en PySide6

Esta ventana muestra un diseño de formulario. La primera columna contiene etiquetas para comunicar al usuario la información deseada. La segunda columna muestra widgets que permiten al usuario ingresar la información.

Creando ventanas y diálogos

Las aplicaciones de escritorio GUI en PySide6 generalmente están conformadas por dos tipos de ventanas:

Ventana principal: La ventana en la que se desarrolla la mayor parte de la interacción del usuario.
Diálogos: Ventanas auxiliares de la aplicación que solicitan o muestran información al usuario.

En las secciones siguientes, aprenderás sobre ambos tipos de ventanas y cómo crearlas en PySide6 de manera que puedas construir aplicaciones funcionales y atractivas.

Ventanas principales

La mayoría de las veces, tus aplicaciones tendrán una ventana que incluye barra de menú, algunas barras de herramientas, una barra de estado y un widget central que será el elemento principal de la GUI. Para crear este tipo de ventana en PySide6, puedes heredar de la clase QMainWindow.

Una instancia de una clase que deriva de QMainWindow se considera la ventana principal de la aplicación y debe ser única.

La clase QMainWindow proporciona un marco para construir la GUI de tu aplicación rápidamente. Esta clase tiene su propio diseño incorporado, que acepta los siguientes componentes gráficos:

Componente	Posición	Descripción
Una barra de menú	Arriba	Contiene el menú principal de la aplicación
Una o más barras de herramientas	Cualquiera de los lados	Puede contener botones de herramienta y otros widgets, como `QComboBox`, `QSpinBox`, y más
Un widget central	Centro	Contiene el widget central de la ventana, que puede ser de cualquier tipo, incluyendo un widget compuesto
Uno o más widgets acoplables	Alrededor del widget central	Son ventanas pequeñas, movibles y ocultables
Una barra de estado	Abajo	Contiene la barra de estado de la app, que muestra información de estado

No puedes crear una ventana principal sin un widget central. Puedes establecer el widget central de la ventana con el método .setCentralWidget(). El diseño de la ventana principal te permitirá tener un único widget central, que puede ser simple o compuesto.

El siguiente ejemplo muestra cómo usar QMainWindow para crear una aplicación con ventana principal:

Python - main_window.py

from PySide6.QtWidgets import (
    QApplication,
    QLabel,
    QMainWindow,
    QStatusBar,
    QToolBar,
)

class Window(QMainWindow):
    def __init__(self):
        super().__init__(parent=None)
        self.setWindowTitle("QMainWindow")
        self.setCentralWidget(QLabel("Soy el Widget Central"))
        self._createMenu()
        self._createToolBar()
        self._createStatusBar()

    def _createMenu(self):
        menu = self.menuBar().addMenu("&Menú")
        menu.addAction("&Salir", self.close)

    def _createToolBar(self):
        tools = QToolBar()
        tools.addAction("Salir", self.close)
        self.addToolBar(tools)

    def _createStatusBar(self):
        status = QStatusBar()
        status.showMessage("Soy la Barra de Estado")
        self.setStatusBar(status)

if __name__ == "__main__":
    app = QApplication([])
    window = Window()
    window.show()
    app.exec()

Primeramente, creas una clase llamada Window que hereda de QMainWindow. Dentro del método .__init__(), llamas al inicializador de la clase base. El argumento parent se establece en None porque esta es la ventana principal de tu aplicación, por lo que no debe tener una ventana padre.

Luego, estableces el título de la ventana y creas un objeto QLabel para usar como widget central de la ventana. Finalmente, llamas los métodos no públicos ._createMenu(), ._createToolBar(), ._createStatusBar() para crear el menú principal, una barra de herramientas y la barra de estado.

El widget central y la barra de estado muestran mensajes identificativos. El menú y la barra de herramientas mostrarán una opción para salir de la aplicación.

En macOS, cuando ejecutas la aplicación de ejemplo anterior, obtendrás una ventana como la siguiente:

Ventana principal en PySide6 - macOS

Como puedes confirmar, tu aplicación tiene los siguientes componentes:

Un menú principal llamado genéricamente Menú que se muestra en la barra superior del escritorio macOS. En otras plataformas, el menú principal aparece en la misma ventana de la aplicación justo debajo de la barra de título.
Una barra de herramientas que contiene un botón Salir.
Un widget central compuesto por un objeto QLabel que muestra un mensaje identificativo.
Una barra de estado en la parte inferior de la ventana que también muestra un mensaje identificativo.

¡Eso es todo! Has aprendido a construir una aplicación con ventana principal usando Python y PySide6. Lo siguiente es aprender un poco sobre cómo crear diálogos.

Diálogos y formularios

También es común que tus aplicaciones tengan varios diálogos para llevar a cabo acciones secundarias que dependen de la entrada del usuario. Para crear un diálogo, necesitas crear una clase que herede de QDialog, que es la clase base de todas las ventanas de diálogo en PySide6.

En PySide6, los diálogos pueden ser:

Modal: Bloquea la entrada a cualquier otra ventana visible en la misma aplicación. Puedes mostrar un diálogo modal llamando a su método .exec().
No modal: Opera independientemente de otras ventanas en la misma aplicación. Puedes mostrar un diálogo no modal usando su método .show().

Puedes emplear diálogos como formularios de entrada de datos, ventanas de configuración, entre otras. Por esto, los diálogos también pueden proporcionar un valor de retorno y tener botones predeterminados, como Aplicar, Ok y Cancelar.

Un diálogo es siempre una ventana independiente. Si un diálogo tiene un widget padre (parent), entonces se mostrará centrado sobre dicho widget.

A continuación un ejemplo de cómo emplear QDialog para desarrollar una diálogo:

Python - dialog_form.py

from PySide6.QtWidgets import (
    QApplication,
    QDialog,
    QDialogButtonBox,
    QFormLayout,
    QLineEdit,
    QVBoxLayout,
)

class Window(QDialog):
    def __init__(self):
        super().__init__(parent=None)
        self.setWindowTitle("QDialog")

        layout = QVBoxLayout()
        self.setLayout(layout)

        form_layout = QFormLayout()
        labels = ["Nombre:", "Edad:", "Ocupación:", "Dirección:"]
        for label in labels:
            form_layout.addRow(label, QLineEdit())

        layout.addLayout(form_layout)
        buttons = QDialogButtonBox()
        buttons.setStandardButtons(
            QDialogButtonBox.StandardButton.Cancel |
            QDialogButtonBox.StandardButton.Ok
        )
        layout.addWidget(buttons)

app = QApplication([])
window = Window()
window.show()
app.exec()

En este ejemplo, usas la clase QDialog como la base para crear una ventana de diálogo. Para definir el diseño del diálogo, usas un QVBoxLayout y un QFormLayout. Con ellos, estableces el diseño principal que consiste en un formulario para entrada de datos y dos botones para aceptar o cancelar la entrada de datos.

Empleas la clase QDialogButtonBox para gestionar los botones estándar del diálogo OK y Cancel. Este widget es muy útil porque gestiona automáticamente las interacciones comunes de los botones como cerrar el cuadro de diálogo o confirmar acciones.

El código anterior mostrará una ventana que se verá así:

Ventana de diálogo en PySide6

Esta figura muestra el diálogo creado con un QFormLayout para organizar los widgets y un QVBoxLayout para el diseño global.

Mensajes y diálogos estándar

PySide6 también proporciona una forma rápida de crear cuadros de mensaje para el usuario. La clase QMessageBox te permite crear pequeñas ventanas diseñados para mostrar mensajes al usuario. PySide6 ofrece varios tipos de cuadros de mensajes predefinidos:

QMessageBox.information(): Permite mostrar un mensaje informativo, como una confirmación o un aviso simple.
QMessageBox.warning(): Permite mostrar una advertencia sobre posibles problemas.
QMessageBox.critical(): Muestra mensajes de error críticos.
QMessageBox.question(): Presenta una pregunta al usuario con opciones como Sí y No.

Además, PySide6 tiene diálogos estándar predefinidos que facilitan la interacción con el usuario, ya sea para permitirle seleccionar archivos, carpetas, colores o fuentes. Aquí tienes un resumen de ellos:

QFileDialog: Permite al usuario seleccionar un archivo existente para abrirlo. Con el método .getOpenFileName(), seleccionas un archivos. Con .getSaveFileNames(), seleccionas múltiples archivos. Por su parte, .getSaveFileName() te permite seleccionar la ubicación y el nombre para guardar un archivo. Finalmente, .getExistingDirectory() permite seleccionar una carpeta en lugar de un archivo.
QColorDialog: Presenta un diálogo selector de colores que permite al usuario elegir un color. El método empleado es .getColor().
QFontDialog: Representa un selector de fuentes que permite al usuario seleccionar una fuente, tamaño y estilo. El método empleado es .getFont().
QInputDialog: Permite al usuario ingresar datos simples, como un texto, un número o una opción de una lista. Los métodos correspondientes son .getText() para entrada de texto, .getInt() para entrada de un número entero, y .getItem() para selección de un elemento de una lista.

A continuación, un ejemplo que muestra algunos de elementos en acción:

Python - standard_dialogs.py

from PySide6.QtWidgets import (
    QApplication,
    QColorDialog,
    QFileDialog,
    QFontDialog,
    QInputDialog,
    QMessageBox,
)

app = QApplication([])

# Mostrar un mensaje
QMessageBox.information(
    None,
    "Información",
    "Este es un mensaje.",
)

# Abrir un archivo
file_path, _ = QFileDialog.getOpenFileName(None, "Abrir Archivo")
if file_path:
    QMessageBox.information(
        None,
        "Archivo Seleccionado",
        f"Seleccionaste: {file_path}",
    )

# Seleccionar un color
color = QColorDialog.getColor()
if color.isValid():
    QMessageBox.information(
        None, "Color Seleccionado", f"Seleccionaste: {color.name()}"
    )

# Seleccionar una fuente
ok, font = QFontDialog.getFont()
if ok:
    QMessageBox.information(
        None, "Fuente Seleccionada", f"Seleccionaste: {font.family()}"
    )

# Entrada de texto
text, ok = QInputDialog.getText(None, "Entrada de Texto", "Escribe algo:")
if ok and text:
    QMessageBox.information(None, "Texto Ingresado", f"Escribiste: {text}")

app.exec()

En esta aplicación, lo primero que haces es mostrar un mensaje empleando QMessageBox.information(). Luego, empleas QFileDialog.getOpenFileName() para generar un diálogo que te permite abrir un archivo seleccionado. Seguidamente, creas diálogos para seleccionar un color y una fuente. Finalmente, creas un diálogo que le da al usuario la posibilidad de introducir un número entero de manera rápida.

Los cuadros de mensaje y los diálogos estándar son herramientas esenciales para cualquier aplicación PySide6 que requiera interacción con el usuario.

Conclusión

Las aplicaciones con interfaz gráfica de usuario (GUI) representan una parte sustancial en el desarrollo de software. Python ofrece varios frameworks y bibliotecas que pueden ayudarte a desarrollar aplicaciones GUI modernas y robustas.

En este tutorial, aprendiste cómo usar PySide6, que es una de las bibliotecas más populares y sólidas para el desarrollo de aplicaciones GUI en Python. Es además, el enlace oficial de Python con Qt.

En este tutorial, has aprendido a:

Instalar PySide6 y configurarlo en tu computadora
Desarrollar aplicaciones con GUI basadas en PySide6
Organizar una GUI usando gestores de disposición
Crear ventanas principales y diálogos en tus aplicaciones PySide6

Ahora puedes usar tus conocimientos de Python y PySide6 para dar vida a tus propias aplicaciones GUI de escritorio.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Sentencias condicionales

2025-01-21T18:40:00+01:00

Python te permite crear varios tipos de sentencias condicionales. En este tutorial, aprenderás lo básico sobre cómo funcionan y cómo crear condicionales en Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Condiciones
Condicionales simples con if
Condicionales con cláusula else
Condicionales múltiples con elif
Conclusiones

Condiciones

Una condición es una expresión que evalúa si algo es verdadero (True) o falso (False). Las condiciones se emplean para controlar el flujo de un programa, permitiendo ejecutar diferentes bloques de código según el resultado obtenido al evaluarlas.

En Python, puedes crear varios tipos de condiciones. Por ejemplo, las siguientes condiciones comparan valores numéricos:

Python REPL

>>> 5 > 3
True

>>> 5 < 3
False

>>> 2 == 2
True

>>> 2 != 2
False

Las condiciones más comunes usan operadores de comparación como ==, !=, >, <, >=, y <=. En estos casos, siempre obtendrás un valor booleano (True o False).

Las expresiones de pertenencia también son empleadas como condiciones:

Python REPL

>>> 3 in [1, 2, 3]
True
>>> 5 in [1, 2, 3]
False

>>> "banana" in ["manzana", "banana", "cereza"]
True
>>> "naranja" in ["manzana", "banana", "cereza"]
False

Estas expresiones permiten determinar si un valor u objeto específico forma parte de una serie de valores o colección.

También puedes crear condiciones empleando los operadores lógicos and, or, y not:

Python REPL

>>> 5 > 2 and 1 == 1
True

>>> 5 > 2 or 1 < 1
True

>>> not 5 > 2
False

En el primer ejemplo, utilizas el operador and para combinar dos expresiones de comparación. Si ambas son verdaderas, obtienes True. En el segundo ejemplo, empleas el operador or. En este caso, si al menos una de las expresiones evaluadas es verdadera, entonces obtienes True. Finalmente, el operador not te permite negar el resultado de evaluar una expresión o condición.

Finalmente, también es posible emplear valores y objetos individuales como condiciones. Esto es posible porque todos los objetos en Python tienen un valor de verdad inherente.

Python emplea las siguientes reglas para determinar el valor de verdad de los objetos:

Por defecto, un objeto se considera verdadero a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva cero cuando se llama con el objeto. A continuación, se muestran la mayoría de los objetos incorporados considerados como falsos:

Constantes definidas como falsas: None y False

Cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

Cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0) (Fuente)

Condicionales simples con `if`

El condicional if permite ejecutar un bloque de código solo si una condición es verdadera. Su sintaxis es la siguiente:

Sintaxis de Python

if condition:
    <code block>

El bloque de código se ejecuta únicamente si la condición es verdadera. Considera el siguiente ejemplo:

Python REPL

>>> x = 10

>>> if x > 5:
...     print("x es mayor que 5")
...
x es mayor que 5

>>> if x == 5:
...     print("x es igual a 5")
...

La primera condición es verdadera, por lo tanto la función print() se ejecuta. Si la condición es falsa, el código dentro del bloque if no se ejecuta, tal y como sucede en el segundo ejemplo.

Como ya sabes, todos los objetos en Python tienen un valor de verdad y por lo tanto los puedes emplear como condiciones en una sentencia condicional. Un ejemplo común es verificar si una lista contiene algún valor:

Python REPL

>>> if [1, 2, 3]:
...     print("la lista no está vacía")
...
la lista no está vacía

>>> if []:
...     print("la lista no está vacía")
...

En el primer ejemplo, la lista contiene valores y por lo tanto su valor de verdad es True. En este caso, el bloque de código se ejecuta. En el segundo ejemplo, la lista está vacía y su valor de verdad es False. Por esta razón, el bloque de código no se ejecuta.

Condicionales con cláusula `else`

La cláusula else te permite manejar el caso en que la condición del if es falsa. La sintaxis es la siguiente:

Sintaxis de Python

if condition:
    <if block>
else:
    <else block>

El bloque bajo la cláusula else se ejecuta si la condición es falsa:

Python REPL

>>> x = 3

>>> if x > 5:
...     print("x es mayor que 5")
... else:
...     print("x no es mayor que 5")
...
x no es mayor que 5

El bloque else es opcional y solo se ejecuta si la condición en el if no se cumple.

Condicionales múltiples con `elif`

Cuando necesitas evaluar más de una condición, puedes usar la cláusula elif (abreviatura de else if). Esta permite verificar varias condiciones una detrás de otra. La sintaxis es la siguiente:

Sintaxis de Python

if condition_1:
    <block 1>
elif condition_2:
    <block 2>
elif condition_3:
    <block 3>
...
elif condition_N:
    <block N>
else:
    <else block>

Puedes tener cualquier número de cláusulas elif, pero solo un if que es requerido y un else que es opcional. Python evalúa las condiciones en orden. Una vez que encuentra una condición verdadera, el bloque correspondiente se ejecuta y los bloques restantes se ignoran. Si ninguna condición resulta verdadera, el bloque else (si existe) se ejecuta.

Considera el ejemplo a continuación:

Python REPL

>>> x = 10

>>> if x > 15:
...     print("x es mayor que 15")
... elif x > 5:
...     print("x es mayor que 5 pero no mayor que 15")
... else:
...     print("x es 5 o menos")
...
x es mayor que 5 pero no mayor que 15

En este ejemplo, Python comienza evaluando la condición x > 15 la cual resulta falsa. Luego evalúa la siguiente condición x > 5 en la cláusula elif. Como esta condición es verdadera, el bloque se ejecuta y la cláusula else se ignora.

Conclusiones

Has aprendido a escribir sentencias condicionales en Python empleando las palabras clave if, else y elif. Las sentencias condicionales te permiten controlar el flujo de ejecución de un programa en función del cumplimiento de ciertas condiciones.

Comprender y utilizar correctamente las condicionales es fundamental para cualquier desarrollador de Python, pues ellas te permiten tomar decisiones en tiempo de ejecución. Esto es esencial para desarrollar aplicaciones que respondan adecuadamente a diferentes escenarios.

Ahora que sabes lo básico de las condicionales en Python, puedes aplicarlas para crear programas más complejos, y desarrollar aplicaciones que requieran lógica de decisión.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo instalar Python en tu sistema operativo Debian o Ubuntu Linux?

2025-01-20T15:45:00+01:00

Emplearás apt que es el gestor de paquetes de tu distribución Debian/Ubuntu y derivadas. Es recomendable que tengas experiencia de trabajo en sistemas Linux basados en Debian, como puede ser Ubuntu o Linux Mint, para poder seguir esta guía de instalación de Python.

Es especialmente importante que tengas conocimientos básicos sobre la terminal del sistema y sepas cómo emplearla.

Contenidos

Prerequisitos
Instalar Python en Debian o Ubuntu Linux con apt
Paso 1: Actualizar la lista de paquetes disponibles
Paso 2: Instalar Python desde los repositorios del sistema
Paso 3: Verificar la instalación
Resumiendo

Prerequisitos

Para completar los pasos de esta guía de instalación de Python en Linux, necesitas una computadora con alguna distribución basada en Debian como Ubuntu o Linux Mint. Además, necesitas tener privilegios root y una conexión a Internet.

¡Lo demás es solo seguir las instrucciones más abajo!

Instalar Python en Debian o Ubuntu Linux con `apt`

La manera recomendada para instalar Python en una computadora con Linux es emplear el gestor de paquetes de tu distribución. En distribuciones basadas en Debian y Ubuntu, el gestor de paquetes es apt. Los pasos para completar la instalación son los siguientes:

Actualizar la lista de paquetes disponibles con sudo apt update.
Instalar Python desde los repositorios del sistema con sudo apt install python3.
Verificar que la instalación se completó con éxito.
🐍

A continuación encontrarás una explicación detallada de estos pasos. Presta especial atención al paso número dos. De él dependerá el éxito de la instalación.

Paso 1: Actualizar la lista de paquetes disponibles

Lo primero es abrir una terminal del sistema o línea de comandos. Para esto, puedes presionar Ctrl+Alt+T en tu teclado o buscar el terminal entre las aplicaciones de tu sistema. En Ubuntu, el terminal luce de la siguiente manera:

Ventana de la Terminal o línea de comandos en Ubuntu Linux

Una vez que tengas la terminal abierta, puedes ejecutar el siguiente comando para actualizar la lista de paquetes disponibles en los repositorios de tu distribución:

Terminal

$ sudo apt update

Para poder ejecutar este comando, debes suministrar la contraseña del usuario root. De esto se encarga el comando sudo.

Durante la ejecución de apt update, el comando descargará los índices del repositorio y los actualizará en tu ordenador. De este modo, tendrás acceso a las últimas versiones disponibles para cada paquete de tu distribución. Con este paso, estás listo para instalar Python.

Paso 2: Instalar Python desde los repositorios del sistema

Ahora que tienes la lista de paquetes actualizada, puedes instalar Python desde los repositorios de tu distribución con el siguiente comando:

Terminal

$ sudo apt install python3

Este comando descarga Python desde los repos y lo instala en tu ordenador. Esta será la instalación Python del sistema.

En Ubuntu, el paquete python3 no incluye todas las funcionalidades que vienen con el instalador oficial de Python para otros sistemas operativos como Windows y macOS. Por ejemplo, si necesitas trabajar con entornos virtuales, deberás instalar python3-venv.

De modo similar, si deseas usar pip, que es el instalador de paquetes para Python, deberás instalar el paquete python3-pip.

Puedes disponer de estas dos herramientas al ejecutar el siguiente comando:

Terminal

$ sudo apt install python3-venv python3-pip

Al concluir la ejecución de este comando, tendrás acceso a crear nuevos entornos virtuales e instalar paquetes Python usando pip.

Finalmente, si planeas crear aplicaciones con interfaz gráfica (GUI) basada en Tkinter, debes instalar el paquete python3-tk.

Paso 3: Verificar la instalación

Una vez que hayas ejecutado los pasos anteriores, Python estará instalado en tu sistema operativo. Para confirmar que lo tienes, ejecuta el comando siguiente:

Terminal

$ python3 --version 
Python 3.10.12

Este comando imprime la versión de Python que tienes instalada por defecto. Con esto has concluido la instalación de Python usando el gestor de paquetes de tu distribución Linux. Ahora estás listo para escribir tu primer programa.

Es importante que sepas que la versión de Python disponible en los repositorios oficiales de Debian, Ubuntu y derivados puede estar relativamente actualizada con respecto a las últimas versiones liberadas. Para instalar la última versión de Python, deberás compilarla desde sus fuentes o emplear herramientas como pyenv que te permiten gestionar varias versiones de Python en tu computadora.

Resumiendo

Instalar Python en tu ordenador es el primer paso en tu empeño de aprender a programar con el lenguaje. Nuevamente, recuerda que los pasos a seguir para completar la instalación en tu distribución Linux basada en Debian o Ubuntu son los siguientes:

Actualizar la lista de paquetes disponibles con sudo apt update.
Instalar Python desde los repositorios del sistema con sudo apt install python3.
Verificar que la instalación se completó con éxito.
🐍

Luego de completados estos pasos, estás listo para comenzar a explorar las bondades de Python como lenguaje de programación.

Iniciando con Tkinter para desarrollo GUI

2025-01-06T15:15:00+01:00

Tkinter es una de las bibliotecas más empleadas en el desarrollo rápido de aplicaciones GUI puesto que viene incluida con la instalación oficial de Python como parte de la biblioteca estándar.

Aprender los conceptos básicos para construir aplicaciones GUI usando Python y Tkinter es una excelente habilidad para cualquier desarrollador Python.

En este tutorial, aprenderás cómo:

Instalar Tkinter y configurarlo en tu computadora
Crear aplicaciones con interfaces gráficas de usuario basadas en Tkinter
Organizar una GUI usando los gestores de geometría de Tkinter
Crear ventanas principales y diálogos en tus aplicaciones

Para aprovechar al máximo de este tutorial, debes conocer lo básico de programación con Python, especialmente temas relacionados con la programación orientada a objetos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Conociendo Tkinter
Instalando Tkinter
- En Windows y macOS
- En Linux
Creando una aplicación Tkinter
Explorando widgets comunes de Tkinter
Usando gestores de geometría
Creando ventanas y diálogos
Conclusión

Conociendo Tkinter

Tkinter es un paquete que forma parte de la biblioteca estándar de Python y está diseñado para crear interfaces gráficas de usuario (GUI). Provee acceso a las clases y objetos de la biblioteca Tcl/Tk y proporciona una manera rápida y sencilla de crear aplicaciones GUI en Python.

Tkinter es compatible con Windows, macOS y Linux, lo que te permite desarrollar aplicaciones multiplataforma sin preocuparte por las diferencias entre sistemas operativos.

Tkinter ofrece una variada gama de widgets y herramientas que puedes usar para crear interfaces de usuario interactivas. Desde botones y etiquetas hasta cuadros de texto y menús. Tkinter tiene todo lo que necesitas para desarrollar aplicaciones de escritorio en Python.

Sin embargo, a diferencia de otros frameworks y bibliotecas GUI que ofrecen componentes gráficos (widgets) y otras herramientas tales como clases para manipulación de bases de datos, trabajo con redes, y similares, Tkinter se enfoca en los componentes gráficos, la gestión de eventos y el soporte para menús y diálogos.

Instalando Tkinter

La mayoría de las distribuciones de Python ya incluyen Tkinter por defecto. Por lo tanto, es muy probable que no necesites instalarlo por separado. Sin embargo, si resulta que Tkinter no está disponible en tu sistema, puedes instalarlo de manera rápida.

En Windows y macOS

Si instalaste Python empleando el instalador oficial para Windows y macOS, entonces Tkinter ya estará instalado. Si no está disponible, puedes reinstalar Python asegurándote de que la opción de instalación de Tkinter esté habilitada.

En macOS, podría ser necesario instalar Xcode o Xcode Command Line Tools para que Tkinter funcione correctamente.

En Linux

En sistemas Linux basados en Debian, como Ubuntu, puede que al instalar Python desde los repositorios oficiales de la distribución, Tkinter no venga en el paquete. En estos casos, puedes instalar Tkinter usando el siguiente comando:

Terminal

$ sudo apt install python3-tk

Este comando descargará e instalará Tkinter en tu sistema. Es decir, Tkinter estará disponible en la instalación global de Python.

Creando una aplicación Tkinter

Con Tkinter disponible, estás listo para crear tu primera aplicación GUI. Para comenzar, crearás una aplicación "Hola, mundo!". Aquí están los pasos a seguir:

Importa tkinter como tk.
Crea una instancia de la clase Tk.
Define la GUI de la aplicación.
Ejecuta el bucle de eventos de la aplicación con .mainloop().

Crea un nuevo archivo Python llamado app.py en tu directorio de trabajo actual y escribe el siguiente código:

Python - app.py

import tkinter as tk

En esta línea de código, importas el módulo tkinter y lo renombras como tk para facilitar su uso. Con esto, has cumplido con el primer paso.

Para completar el segundo paso, necesitas crear una instancia de Tk, la cual usualmente llamarás root:

Python - app.py

import tkinter as tk

root = tk.Tk()

En esta línea de código, creas la instancia de Tk. Esto inicializa la aplicación y prepara el entorno para comenzar a añadir widgets a la GUI de tu aplicación.

El tercer paso consiste en crear la ventana principal de la aplicación con los elementos gráficos deseados. Para este ejemplo, la GUI se basará en un widget Label que mostrará el mensaje "Hola, mundo!".

Así es como puedes crear la GUI de la aplicación:

Python - app.py

import tkinter as tk

root = tk.Tk()
root.title("Tkinter Demo")
root.geometry("280x80")

hello = tk.Label(root, text="Hola, mundo!", font=("Arial", 24))
hello.pack(pady=20)

En este código, el método .title() te permite establecer el título de la ventana de tu aplicación. En este ejemplo, la ventana de la aplicación mostrará Tkinter Demo en su barra de título.

Puedes usar el método .geometry() para definir el tamaño de la ventana. El argumento es una cadena que especifica el ancho y alto de la ventana en píxeles.

Cada aplicación GUI necesita widgets. Estos son los componentes gráficos que conforman la GUI de la aplicación. En este ejemplo, usas un widget Label llamado hello que te permitirá mostrar el mensaje "Hola, mundo!" en la ventana de tu aplicación.

El método .pack() es un gestor de geometría se utiliza para colocar el widget en la ventana. El argumento pady agrega un poco de espacio vertical alrededor del widget.

Has finalizado el tercer paso, así que puedes continuar con el último paso y preparar tu aplicación Tkinter para su ejecución:

Python - app.py

import tkinter as tk

root = tk.Tk()
root.title("Tkinter Demo")
root.geometry("280x80")

hello = tk.Label(root, text="Hola, mundo!", font=("Arial", 24))
hello.pack(pady=20)

root.mainloop()

En la última línea, inicias el bucle de eventos de la aplicación ejecutando el método .mainloop(). Eso es todo. Ahora puedes ejecutar tu primera aplicación Tkinter con el siguiente comando:

Terminal

$ python app.py

Al ejecutar este comando, verás una ventana que lucirá como la siguiente:

Aplicación 'Hola, Mundo!' con Tkinter y Python

Tu aplicación muestra una ventana basada en Tk. La ventana muestra el mensaje "Hola, mundo!" usando un widget Label. ¡Y con eso, has escrito tu primera aplicación de escritorio GUI usando Tkinter y Python!

Explorando widgets comunes de Tkinter

Los widgets son componentes gráficos rectangulares que colocas en las ventanas de tus aplicación para construir su GUI. Los widgets tienen atributos y métodos que te permiten ajustar su apariencia y comportamiento.

Tkinter tiene una variada colección de widgets, cada uno de los cuales tiene un propósito diferente. Algunos de los widgets más comunes incluyen botones, etiquetas o labels, campos de entrada de texto, listas desplegables, y botones radiales.

Botones

Puedes crear un botón con la clase Button, la cual proporciona un botón de comando clásico. Algunos botones típicos son Ok, Cancelar, Aplicar, Sí, No, Cerrar, similares.

Crea un archivo llamado buttons.py y pon el siguiente código en él:

Python - buttons.py

import tkinter as tk

root = tk.Tk()
root.title("Botones Tkinter")
root.geometry("190x240")

buttons = ["Ok", "Cancelar", "Aplicar", "Sí", "No", "Cerrar"]
for text in buttons:
    button = tk.Button(root, text=text)
    button.pack(fill="x", padx=5, pady=5)

root.mainloop()

En este ejemplo, creas botones en un bucle for que itera sobre una lista de nombres de botones comunes y crea un botón con cada uno de los nombres definidos. Así es como se verá tu aplicación al ejecutarla desde tu terminal:

Botones en Tkinter

Campos de entrada de texto

Los campos de entrada de texto son widgets comunes también. Estos widgets te permiten ingresar una sola línea de texto y puedes crearlos con la clase Entry de Tkinter. Los campos de entrada de texto son útiles cuando necesitas obtener información del usuario en forma de texto.

Como ejemplo, crea un archivo entries.py y escribe el siguiente código en él:

Python - entries.py

import tkinter as tk

root = tk.Tk()
root.title("Campos de texto Tkinter")
root.geometry("250x120")

fields = ["Nombre", "Usuario", "Contraseña"]
for field in fields:
    entry = tk.Entry(root, foreground="lightgrey")
    entry.insert(0, field)
    entry.pack(padx=5, pady=5)

root.mainloop()

En el bucle de este ejemplo, creas tres campos de entrada de texto para permitir que el usuario introduzca su nombre, usuario y contraseña.

La captura a continuación muestra cómo debe lucir tu aplicación:

Campos de entrada de texto en Tkinter

Campos de entrada de texto como estos proporcionan funcionalidades estándar como copiar, pegar y cortar. En la imagen, puedes notar que los campos muestran texto de marcador de posición (placeholder) para informar al usuario qué tipo de información debe introducir.

La clase Entry de Tkinter no tiene la opción de mostrar un texto de marcador de posición, por lo tanto, en este ejemplo lo que hiciste fue cambiar el color del texto para que sea gris claro y así simular un texto de marcador de posición.

Listas desplegables

Las listas desplegables son otro tipo fundamental de widget en aplicaciones GUI. Puedes crearlas usando la clase Combobox del módulo ttk, el cual contiene una serie mejorada de widgets para Tkinter. Una lista desplegable presenta al usuario una serie de opciones de una manera que ocupa un espacio mínimo en la pantalla.

A continuación, un ejemplo de cómo emplear una lista desplegable en Tkinter:

Python - combo_boxes.py

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Lista desplegable Tkinter")
root.geometry("250x100")

options = ["Tkinter", "PyQt", "PySide", "Kivy", "wxPython"]
selected_option = tk.StringVar(root)
selected_option.set(options[0])

combobox = ttk.Combobox(
    root,
    textvariable=selected_option,
    values=options,
    state="readonly",
)
combobox.pack(pady=20)

root.mainloop()

En este ejemplo, creas combobox como una instancia de Combobox. Esta instancia contendrá una lista desplegable con una serie de nombres de bibliotecas Python para desarrollo de aplicaciones GUI. Cuando ejecutas esta aplicación desde tu línea de comandos, obtienes una ventana como la siguiente:

Lista desplegable en Tkinter

Al hacer clic sobre esta lista desplegable, los usuarios pueden seleccionar una de las opciones desplegadas.

Botones radiales

El último widget que estudiarás es el botón radial, que puedes crear con la clase Radiobutton. Se trata de un botón circular de opción que puedes seleccionar al hacer clic sobre él. Los botones radiales son útiles cuando necesitas que el usuario seleccione una entre varias opciones.

Todas las opciones en un grupo de botones radiales son visibles al mismo tiempo, pero el usuario solo puede seleccionar una de ellas. Es decir, la selección es excluyente.

Considera el siguiente ejemplo:

Python - radio_buttons.py

import tkinter as tk

root = tk.Tk()
root.title("Botones radiales Tkinter")
root.geometry("230x150")

label = tk.Label(root, text="¿Qué prefieres?")
label.pack(pady=5)

foods = ["Pizza", "Hamburguesa", "Pasta", "Pollo asado"]
selected_food = tk.StringVar(root, foods[0])

for food in foods:
    radio = tk.Radiobutton(
        root,
        text=food,
        variable=selected_food,
        value=food,
    )
    radio.pack(anchor="w", padx=5)

root.mainloop()

En este ejemplo, creas una aplicación que muestra un texto descriptivo, "¿Qué prefieres?", seguido de una serie de botones radiales, que representan alternativas entre las que el usuario puede elegir. En este caso, las alternativas son "Pizza", "Hamburguesa", "Pasta" y "Pollo asado".

Para crear los botones, empleas un ciclo for que itera sobre la lista de comidas. Por defecto, el primer botón (foods[0]) de la lista estará seleccionado.

Al hacer clic en uno de los botones, este se activa y los demás se desactivan automáticamente. Este comportamiento los hace ideales para preguntas de selección única, como preferencias o respuestas a encuestas:

Botones radiales en Tkinter

Tkinter ofrece una colección aceptable de widgets. Aquí, has estudiado solo una pequeña muestra, suficiente para mostrarte el poder y la flexibilidad de este framework GUI.

En la siguiente sección, aprenderás cómo organizar diferentes widgets para construir GUIs modernas y completamente funcionales para tus aplicaciones.

Usando gestores de geometría

Para construir aplicaciones GUI, necesitas saber cómo organizar un conjunto de widgets para que tu GUI sea intuitiva y funcional. En Tkinter, las herramientas para este fin son los llamados gestores de geometría.

Se trata de métodos que te permiten dimensionar y posicionar tus widgets en la ventana o formulario de la aplicación. Permiten además que tus widgets se adapten automáticamente a eventos de cambio de tamaño de ventana y otros cambios en la GUI.

Tkinter proporciona tres métodos para gestionar la geometría de una GUI determinada:

.pack(): Organiza widgets en bloques de forma sencilla, colocándolos automáticamente en la ventana según el orden especificado (arriba, abajo, izquierda o derecha).
.grid(): Posiciona los widgets en una cuadrícula definida por filas y columnas, proporcionando más control sobre su posición relativa.
.place(): Ubica widgets en posiciones absolutas o relativas especificadas por coordenadas exactas (x, y).

En las secciones siguientes, aprenderás lo básico sobre cómo emplear estos métodos y crear GUIs ordenadas y funcionales.

Disposición por empaquetado con `.pack()`

El método .pack() organiza los widgets en bloques antes o después de los widgets ya empaquetados. Puedes especificar las opciones side, fill y expand para controlar cómo se comportan los widgets empaquetados.

A continuación se muestra un ejemplo de uso de .pack() para gestionar la geometría de una GUI ordenada verticalmente:

Python - pack_vertical.py

import tkinter as tk

root = tk.Tk()
root.title("Disposición vertical")
root.geometry("290x130")

buttons = ["Arriba", "Centro", "Abajo"]
for position in buttons:
    button = tk.Button(root, text=position)
    button.pack(fill="x", padx=5, pady=5)

root.mainloop()

En este ejemplo, el método .pack() coloca los botones uno debajo del otro en la ventana de la aplicación, rellenando horizontalmente el espacio disponible con el argumento fill y añadiendo algo de espacio a ambos lados con padx y pady:

Disposición vertical por empaquetado con .pack() en Tkinter

Nota como el orden de los botones en la GUI coincide con el orden de aparición de los botones en el código.

También puedes emplear .pack() para disponer los widgets horizontalmente:

Python - pack_horizontal.py

import tkinter as tk

root = tk.Tk()
root.title("Disposición horizontal")
root.geometry("290x80")

buttons = ["Izquierda", "Centro", "Derecha"]
for position in buttons:
    button = tk.Button(root, text=position)
    button.pack(side="left", expand=True, padx=5, pady=5)

root.mainloop()

En este ejemplo, asignas "left" al argumento side del método .pack() para alinear los botones horizontalmente y la ventana de tu aplicación lucirá como se muestra a continuación:

Disposición horizontal por empaquetado con .pack() en Tkinter

Con el argumento side de .pack(), puedes lograr una configuración horizontal de los widgets en la GUI de tu aplicación.

Disposición en cuadrícula con `.grid()`

El método .grid() es otro gestor de geometría en Tkinter. Con él, puedes organizar los widgets en una cuadrícula de filas y columnas. Puedes especificar la fila y la columna para cada widget usando índices, lo que te permite controlar su posición exacta en la ventana.

A continuación se muestra un ejemplo de uso de .grid() para posicionar un grupo de botones:

Python - grid_layout.py

import tkinter as tk

root = tk.Tk()
root.title("Disposición en cuadrícula")

positions = ["Botón (0, 0)", "Botón (0, 1)", "Botón (1, 0)", "Botón (1, 1)"]
for i, name in enumerate(positions):
    button = tk.Button(root, text=name)
    button.grid(row=i // 2, column=i % 2, padx=5, pady=5)

button = tk.Button(root, text="Botón (2, 0) + 2 Columnas de Amplitud")
button.grid(row=2, column=0, columnspan=2, padx=5, pady=5)

root.mainloop()

En este ejemplo, los botones se colocan en una cuadrícula de 2x2, lo que permite un control preciso sobre la disposición de los widgets:

Disposición en cuadrícula con .grid() en Tkinter

Los primeros cuatro botones ocupan una sola celda en la cuadrícula. La celda está definida por coordenadas enteras en la forma (fila, columna). El último botón ocupa dos celdas en la cuadricula. Para lograr esto, empleas el argumento columnspan con un valor de 2.

Disposición por posición con `.place()`

El método .place() te permite organizar los widgets en posiciones absolutas y relativas dentro de la ventana. Puedes especificar las coordenadas x e y para cada widget, lo que te permite un control preciso sobre su ubicación:

Python - place_layout.py

import tkinter as tk

root = tk.Tk()
root.title("Disposición por posición")
root.geometry("300x200")

tk.Button(root, text="x=0, y=0").place(x=0, y=0)
tk.Button(root, text="x=50, y=50").place(x=50, y=50)
tk.Button(root, text="x=100, y=100").place(x=100, y=100)
tk.Button(root, text="x=150, y=150").place(x=150, y=150)

root.mainloop()

En este ejemplo, los botones se colocan en posiciones absolutas dentro de la ventana, lo que permite un control preciso sobre su disposición:

Disposición por posición con .place() en Tkinter

Para definir la posición correcta de cada botón, debes saber que el origen de coordenadas es la esquina superior izquierda de la ventana.

Las posiciones absolutas puede ser problemáticas para la adaptabilidad de la GUI, especialmente si el usuario cambia el tamaño de la ventana o si la aplicación se ejecuta en diferentes resoluciones de pantalla. El método .place() te ayuda con estos problemas, permitiéndote especificar posiciones relativas con los parámetros relx, rely, relwidth y relheight.

Creando ventanas y diálogos

Las aplicaciones de escritorio GUI en Tkinter generalmente están conformadas por dos tipos de ventanas:

Ventana principal: La ventana en la que se desarrolla la mayor parte de la interacción del usuario.
Diálogos: Ventanas auxiliares de la aplicación que solicitan o muestran información al usuario.

En las secciones siguientes, aprenderás sobre ambos tipos de ventanas y cómo crearlas en Tkinter de manera que puedas construir aplicaciones funcionales y atractivas.

Ventanas principales

La mayoría de tus aplicaciones tendrán una ventana que puede incluir elementos como menús, botones y cuadros de texto. Para crear este tipo de ventana en Tkinter, utilizarás una instancia de la clase Tk.

La siguiente aplicación muestra cómo crear una ventana principal con un menú:

Python - main_window.py

import tkinter as tk

root = tk.Tk()
root.title("Ventana Principal Tkinter")
root.geometry("250x80")

menubar = tk.Menu(root)
root.config(menu=menubar)

file_menu = tk.Menu(menubar, tearoff=0)
file_menu.add_command(label="Salir", command=root.quit)
menubar.add_cascade(label="Menú", menu=file_menu)

tk.Label(root, text="Soy el Widget Central").pack(pady=20)

root.mainloop()

En este ejemplo, creas un menú con una opción para salir de la aplicación. Un Label actúa como el widget central de la ventana. Cuando ejecutas esta aplicación, obtendrás una ventana que luce como la siguiente:

Ventana principal en Tkinter

La ventana de tu aplicación tiene un menú principal que, en macOS, se visualiza en la barra superior del escritorio. En otros sistemas operativos, el menú principal se muestra inmediatamente debajo de la barra de título de la ventana.

Has aprendido a construir una aplicación con ventana principal usando Python y Tkinter. Lo siguiente es aprender un poco sobre cómo crear diálogos.

Mensajes de alerta y confirmación

Tkinter también proporciona una forma rápida de crear cuadros de mensaje para el usuario. Para esto, puedes emplear el modulo messagebox, el cual contiene funciones para construir diferentes tipos de diálogos de alerta y confirmación:

Función	Descripción
`showinfo()`	Información con un botón Ok
`showwarning()`	Alerta con un botón Ok
`showerror()`	Error con un botón Ok
`askokcancel()`	Confirmación con botones Ok y Cancel
`askyesno()`	Confirmación con botones Yes y No
`askretrycancel()`	Confirmación con botones Retry y Cancel
`askquestion()`	Pregunta con botones Yes y No
`askyesnocancel()`	Pregunta con botones Yes, No y Cancel

Un ejemplo común es el cuadro de diálogo de mensaje, que puedes crear usando messagebox.showinfo(). El siguiente código crea una aplicación con un botón que muestra un mensaje de información al usuario:

Python - message_boxes.py

import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("Diálogo Tkinter")
root.geometry("300x200")

def show_message():
    messagebox.showinfo("Información", "Este es un mensaje informativo.")

tk.Button(root, text="Mostrar Mensaje", command=show_message).pack(pady=20)

root.mainloop()

En este ejemplo, cuando haces clic en el botón Mostrar Mensaje aparece un cuadro de diálogo informativo con un mensaje para el usuario.

Diálogos integrados

También es común que tus aplicaciones tengan diálogos para realizar acciones secundarias que dependen de la entrada del usuario. Tkinter también ofrece diálogos integrados para abrir y guardar archivos, seleccionar colores, entre otros.

A continuación un resumen de los diálogos más usados:

filedialog.askopenfilename(): Diálogo que permite al usuario seleccionar un archivo para abrir. Retorna la ruta completa del archivo seleccionado como una cadena.
filedialog.asksaveasfilename(): Diálogo para que el usuario seleccione la ubicación y nombre de un archivo para guardar. Retorna la ruta completa del archivo elegido como una cadena.
filedialog.askdirectory(): Diálogo para seleccionar una carpeta. Devuelve la ruta completa de la carpeta seleccionada.
colorchooser.askcolor(): Selector de colores que permite al usuario elegir un color. Retorna una tupla con el valor RGB del color seleccionado y su representación hexadecimal.

El siguiente ejemplo muestra cómo usar un diálogo estándar para selecionar un archivo en tu sistema:

Python - file_dialog.py

import tkinter as tk
from tkinter import filedialog, messagebox

root = tk.Tk()
root.title("Diálogo de Archivo Tkinter")
root.geometry("300x200")

def open_file():
    file_path = filedialog.askopenfilename()
    if file_path:
        messagebox.showinfo(
            "Archivo Seleccionado",
            f"Seleccionaste: {file_path}",
        )

tk.Button(root, text="Abrir Archivo", command=open_file).pack(pady=20)

root.mainloop()

En este ejemplo, un botón abre un cuadro de diálogo para seleccionar un archivo. Si se selecciona un archivo, se muestra un cuadro de mensaje con la ruta del archivo elegido.

Es importante que sepas que la función .askopenfilename() no abre el archivo, solo devuelve la ruta del archivo seleccionado. Para manipular el archivo, debes abrirlo explícitamente con Python, usando la función integrada open() u otra herramienta similar.

Conclusión

Las aplicaciones con interfaz gráfica de usuario (GUI) constituyen una parte sustancial del desarrollo de software. Python ofrece varios frameworks y bibliotecas que pueden ayudarte a desarrollar aplicaciones GUI modernas y robustas.

En este tutorial, aprendiste cómo usar Tkinter, que es una de las bibliotecas más accesibles para el desarrollo de aplicaciones GUI en Python.

En este tutorial, has aprendido a:

Instalar Tkinter y configurarlo en tu computadora
Desarrollar aplicaciones con GUI basadas en Tkinter
Organizar una GUI usando gestores de geometría
Crear ventanas principales y diálogos en tus aplicaciones Tkinter

Ahora puedes usar tus conocimientos de Python y Tkinter para dar vida a tus propias aplicaciones GUI de escritorio.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Iniciando con PyQt para desarrollo GUI

2024-12-31T06:00:00+01:00

Para desarrollar este tipo de aplicaciones en Python, puedes emplear una amplia variedad de bibliotecas y frameworks, incluyendo Tkinter, wxPython, PyQt, PySide6, entre otras. Sin embargo, PyQt es una de las bibliotecas más populares y sólidas disponibles.

En este tutorial, aprenderás los conceptos básicos para construir aplicaciones GUI usando Python y PyQt.

En este tutorial, aprenderás cómo:

Instalar PyQt y configurarlo en tu computadora
Crear aplicaciones con interfaces gráficas de usuario basadas en PyQt
Organizar una GUI usando gestores de disposición
Crear ventanas principales y diálogos en tus aplicaciones PyQt

Para obtener el máximo de este tutorial, debes conocer lo básico de programación con Python, especialmente temas relacionados con la programación orientada a objetos.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Conociendo PyQt

PyQt es una biblioteca que proporciona un enlace entre Python y Qt, el cual es un framework de desarrollo en C++ para crear interfaces gráficas de usuario (GUIs). Proporciona clases y herramientas para la creación de GUIs, manejo de XML, comunicación de red, expresiones regulares, hilos, bases de datos SQL, navegación web y otras tecnologías disponibles en Qt.

PyQt es compatible con Windows, Unix, Linux, macOS, iOS y Android, por lo que puedes emplearla para desarrollar aplicaciones multiplataforma que tengan una apariencia nativa en cada plataforma.

Si deseas usar PyQt para crear aplicaciones comerciales, entonces necesitas una licencia comercial. También puedes emplear PyQt para proyectos de código abierto, en cuyo caso la licencia de tu proyecto debe ser compatible con la licencia de Qt que estés empleando.

Instalando PyQt

Para instalar PyQt en tu computadora, la opción recomendada es instalar desde el índice de paquetes de Python, PyPI, usando el comando pip. Para esto, puedes crear un entorno virtual de Python y luego instalar el paquete pyqt6, ejecuta lo siguiente en tu línea de comandos, dependiendo de tu sistema operativo.

En Windows

En Windows, puedes instalar PyQt ejecutando los comandos:

Powershell

PS> python -m venv venv
PS> venv\Scripts\activate.bat
(venv) PS> python -m pip install pyqt6

Con estos comandos, primero creas y activas un entorno virtual Python y luego instalas PyQt dese PyPI.

En Linux y macOS

En Linux y macOS el proceso es el mismo y puedes realizarlo con los siguientes comandos:

Terminal

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install pyqt6

Nuevamente, primero creas un entorno virtual usando el módulo venv de la biblioteca estándar de Python. Luego lo activas, y finalmente instalas PyQt.

Creando una aplicación PyQt

Con PyQt instalado, estás listo para crear tu primera aplicación GUI. Para comenzar, crearás una aplicación de Hola, Mundo!. Aquí están los pasos a seguir:

Importa QApplication y todos los widgets necesarios desde PyQt6.QtWidgets.
Crea una instancia de QApplication.
Define la GUI de la aplicación.
Muestra la GUI de la aplicación.
Ejecuta el bucle de eventos de la aplicación.

Crea un nuevo archivo Python llamado app.py en tu directorio de trabajo actual:

Python - app.py

from PyQt6.QtWidgets import QApplication, QLabel, QWidget

En esta línea de código, importas QApplication, QLabel, y QWidget desde QtWidgets. Con esto, has cumplido con el primer paso.

Para completar el segundo paso, necesitas crear una instancia de QApplication:

Python - app.py

from PyQt6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

En esta línea de código, creas la instancia de QApplication. Es necesario crear esta instancia antes de crear cualquier objeto GUI en PyQt.

Así es como puedes crear la GUI de la app:

Python - app.py

from PyQt6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

window = QWidget()
window.setWindowTitle("PyQt Demo")
window.setGeometry(100, 100, 280, 80)
hello = QLabel("<h1>Hola, Mundo!</h1>", parent=window)
hello.move(60, 15)

En este código, window es una instancia de QWidget, la cual proporciona todas las características que necesitarás para crear la ventana de la aplicación.

Como su nombre sugiere, el método .setWindowTitle() te permite establecer el título de la ventana en tu aplicación. En este ejemplo, la ventana de la app mostrará PyQt Demo en su barra de título.

Has finalizado el tercer paso, así que puedes continuar con los dos últimos pasos y preparar tu aplicación GUI PyQt para ejecutarse:

Python - app.py

from PyQt6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication([])

window = QWidget()
window.setWindowTitle("PyQt Demo")
window.setGeometry(100, 100, 280, 80)
hello = QLabel("<h1>Hola, Mundo!</h1>", parent=window)
hello.move(60, 15)

window.show()
app.exec()

En las dos últimas líneas, llamas el método .show() en window para mostrar la ventana en la pantalla. Luego, inicias el bucle de eventos de la aplicación ejecutando .exec() y ya está.

Puedes ejecutar tu primera aplicación PyQt con el siguiente comando:

Terminal

$ python app.py

Al ejecutar este comando, verás una ventana que lucirá como la siguiente:

Aplicación "Hola, Mundo!" con PyQt y Python

Explorando widgets comunes de PyQt

PyQt tiene una colección variada de widgets, cada uno de los cuales tiene un propósito diferente. Algunos de los widgets más comunes incluyen botones, etiquetas o labels, campos de entrada de texto, listas desplegables, y botones radiales.

Botones

Puedes crear un botón con la clase QPushButton, la cual proporciona un botón de comando clásico. Algunos botones típicos son Ok, Cancelar, Aplicar, Sí, No, Cerrar, similares.

Crea un archivo llamado buttons.py y pon el siguiente código en él:

Python - buttons.py

from PyQt6.QtWidgets import (
    QApplication,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Botones PyQt")
window.setGeometry(100, 100, 180, 50)
layout = QVBoxLayout()
window.setLayout(layout)

for text in ["Ok", "Cancelar", "Aplicar", "Sí", "No", "Cerrar"]:
    button = QPushButton(text, parent=window)
    layout.addWidget(button)

window.show()
app.exec()

Botones en PyQt

Campos de entrada de texto

Para un ejemplo, crea un archivo line_edits.py y escribe el siguiente código:

Python - line_edits.py

from PyQt6.QtWidgets import (
    QApplication,
    QLineEdit,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Campos de texto PyQt")
window.setGeometry(100, 100, 250, 50)
layout = QVBoxLayout()
window.setLayout(layout)

for text in ["Nombre", "Usuario", "Contraseña"]:
    edit = QLineEdit(parent=window)
    edit.setPlaceholderText(text)
    layout.addWidget(edit)

window.show()
app.exec()

En el bucle de este ejemplo, creas tres campos de texto para permitir que el usuario introduzca su nombre, usuario y contraseña:

Campos de texto en PyQt

Listas desplegables

A continuación, un ejemplo de cómo emplear una lista desplegable en PyQt:

Python - combo_boxes.py

from PyQt6.QtWidgets import (
    QApplication,
    QComboBox,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])

window = QWidget()
window.setWindowTitle("Lista desplegable PyQt")
window.setGeometry(100, 100, 250, 50)
layout = QVBoxLayout()
window.setLayout(layout)

combo = QComboBox(parent=window)
combo.addItems(
    ["PyQt", "PySide", "Kivy", "Tkinter", "wxPython"]
)
layout.addWidget(combo)

window.show()
app.exec()

Lista desplegable en PyQt

Botones radiales

Python - radio_buttons.py

from PyQt6.QtWidgets import (
    QApplication,
    QLabel,
    QRadioButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Botones radiales PyQt")
window.setGeometry(100, 100, 230, 80)
layout = QVBoxLayout()
window.setLayout(layout)
layout.addWidget(QLabel("¿Qué prefieres?"))

foods = ["Pizza", "Hamburguesa", "Pasta", "Pollo asado"]
for food in foods:
    radio = QRadioButton(food)
    layout.addWidget(radio)

window.show()
app.exec()

Al hacer clic en uno de los botones, este se activa y los demás se desactivan automáticamente. Esto los hace ideales para preguntas de selección única, como preferencias o respuestas a encuestas:

Botones radiales en PyQt

PyQt tiene una amplia colección de widgets. Actualmente hay más de cuarenta widgets disponibles. Aquí, has estudiado solo una pequeña muestra. Sin embargo, esta es suficiente para mostrarte el poder y la flexibilidad de este framework GUI.

En la siguiente sección, aprenderás cómo organizar diferentes widgets para construir GUIs modernas y completamente funcionales para tus aplicaciones.

Usando gestores de disposición

Para construir GUI app, necesitas saber cómo organizar un conjunto de widgets para que tu GUI sea intuitiva y funcional. En PyQt, las herramientas para este fin son los llamados gestores de disposición.

PyQt proporciona cuatro clases básicas de gestores de disposición:

En las secciones siguientes, aprenderás lo básico de cómo emplear estas clases y crear GUIs ordenadas y funcionales.

Disposición horizontal

Python - horizontal_layout.py

from PyQt6.QtWidgets import (
    QApplication,
    QHBoxLayout,
    QPushButton,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición Horizontal")

layout = QHBoxLayout()
window.setLayout(layout)

positions = ["Izquierda", "Centro", "Derecha"]
for position in positions:
    button = QPushButton(position)
    layout.addWidget(button)

window.show()
app.exec()

Gestor de disposición horizontal en PyQt

La figura anterior muestra tres botones en disposición horizontal. Los botones se muestran de izquierda a derecha en el mismo orden en que los agregaste en tu código.

Disposición vertical

A continuación, un ejemplo de cómo puedes usar QVBoxLayout para organizar tres botones verticalmente:

Python - vertical_layout.py

from PyQt6.QtWidgets import (
    QApplication,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición Vertical")
window.setGeometry(100, 100, 230, 80)

layout = QVBoxLayout()
window.setLayout(layout)

positions = ["Arriba", "Centro", "Abajo"]
for position in positions:
    button = QPushButton(position)
    layout.addWidget(button)

window.show()
app.exec()

Gestor de disposición vertical en PyQt

Esta captura muestra tres botones en un arreglo vertical, uno debajo del otro. Los botones aparecen en el mismo orden en que los agregaste a tu código, de arriba a abajo.

Disposición en cuadrícula

QGridLayout toma el espacio disponible, lo divide en filas y columnas, y coloca cada widget hijo en su propia celda.

A continuación, se muestra un ejemplo de cómo organizar una GUI con este gestor de disposición:

Python - grid_layout.py

from PyQt6.QtWidgets import (
    QApplication,
    QGridLayout,
    QPushButton,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición en Cuadrícula")

layout = QGridLayout()
window.setLayout(layout)

button_names = [
    "Botón (0, 0)",
    "Botón (0, 1)",
    "Botón (0, 2)",
    "Botón (1, 0)",
    "Botón (1, 1)",
    "Botón (1, 2)",
    "Botón (2, 0)",
]
for i, name in enumerate(button_names):
    button = QPushButton(name)
    layout.addWidget(button, i // 3, i % 3)

layout.addWidget(
    QPushButton("Botón (2, 1) + 2 Columnas de Amplitud"),
    2,
    1,
    1,
    2,
)

window.show()
app.exec()

Si ejecutas este código desde tu línea de comandos, obtendrás una ventana que luce así:

Gestor de disposición en cuadrícula en PyQt

En esta figura, puedes ver tus botones organizados en una cuadrícula de filas y columnas. El último botón ocupa dos columnas en la cuadrícula.

Disposición de formulario

El siguiente ejemplo muestra cómo crear una aplicación que utiliza un objeto QFormLayout para organizar sus widgets:

Python - form_layout.py

from PyQt6.QtWidgets import (
    QApplication,
    QFormLayout,
    QLineEdit,
    QWidget,
)

app = QApplication([])
window = QWidget()
window.setWindowTitle("Disposición de Formulario")
window.setGeometry(100, 100, 280, 80)

layout = QFormLayout()
window.setLayout(layout)

labels = ["Nombre:", "Edad:", "Ocupación:", "Dirección:"]
for label in labels:
    layout.addRow(label, QLineEdit())

window.show()
app.exec()

Si ejecutas este código, obtendrás una ventana similar a la siguiente:

Gestor de disposición para formulario en PyQt

Creando ventanas y diálogos

Las aplicaciones de escritorio GUI en PyQt generalmente están conformadas por dos tipos de ventanas:

Ventana principal: La ventana en la que se desarrolla la mayor parte de la interacción del usuario.
Diálogos: Ventanas auxiliares de la aplicación que solicitan o muestran información al usuario.

En las secciones siguientes, aprenderás sobre ambos tipos de ventanas y cómo crearlas en PyQt de manera que puedas construir aplicaciones funcionales y atractivas.

Ventanas principales

Una instancia de una clase que deriva de QMainWindow se considera la ventana principal de la aplicación y debe ser única.

La clase QMainWindow proporciona un marco para construir la GUI de tu aplicación rápidamente. Esta clase tiene su propio diseño incorporado, que acepta los siguientes componentes gráficos:

Componente	Posición	Descripción
Una barra de menú	Arriba	Contiene el menú principal de la aplicación
Una o más barras de herramientas	Cualquiera de los lados	Puede contener botones de herramienta y otros widgets, como `QComboBox`, `QSpinBox`, y más
Un widget central	Centro	Contiene el widget central de la ventana, que puede ser de cualquier tipo, incluyendo un widget compuesto
Uno o más widgets acoplables	Alrededor del widget central	Son ventanas pequeñas, movibles y ocultables
Una barra de estado	Abajo	Contiene la barra de estado de la app, que muestra información de estado

El siguiente ejemplo muestra cómo usar QMainWindow para crear una aplicación con ventana principal:

Python - main_window.py

from PyQt6.QtWidgets import (
    QApplication,
    QLabel,
    QMainWindow,
    QStatusBar,
    QToolBar,
)

class Window(QMainWindow):
    def __init__(self):
        super().__init__(parent=None)
        self.setWindowTitle("QMainWindow")
        self.setCentralWidget(QLabel("Soy el Widget Central"))
        self._createMenu()
        self._createToolBar()
        self._createStatusBar()

    def _createMenu(self):
        menu = self.menuBar().addMenu("&Menú")
        menu.addAction("&Salir", self.close)

    def _createToolBar(self):
        tools = QToolBar()
        tools.addAction("Salir", self.close)
        self.addToolBar(tools)

    def _createStatusBar(self):
        status = QStatusBar()
        status.showMessage("Soy la Barra de Estado")
        self.setStatusBar(status)

if __name__ == "__main__":
    app = QApplication([])
    window = Window()
    window.show()
    app.exec()

El widget central y la barra de estado muestran mensajes identificativos. El menú y la barra de herramientas mostrarán una opción para salir de la aplicación.

En macOS, cuando ejecutas la aplicación de ejemplo anterior, obtendrás una ventana como la siguiente:

Ventana principal en PyQt - macOS

Como puedes confirmar, tu aplicación tiene los siguientes componentes:

Un menú principal llamado genéricamente Menú que se muestra en la barra superior del escritorio macOS. En otras plataformas, el menú principal aparece en la misma ventana de la aplicación justo debajo de la barra de título.
Una barra de herramientas que contiene un botón Salir.
Un widget central compuesto por un objeto QLabel que muestra un mensaje identificativo.
Una barra de estado en la parte inferior de la ventana que también muestra un mensaje identificativo.

¡Eso es todo! Has aprendido a construir una aplicación con ventana principal usando Python y PyQt. Lo siguiente es aprender un poco sobre cómo crear diálogos.

Diálogos y formularios

En PyQt, los diálogos pueden ser:

Modal: Bloquea la entrada a cualquier otra ventana visible en la misma aplicación. Puedes mostrar un diálogo modal llamando a su método .exec().
No modal: Opera independientemente de otras ventanas en la misma aplicación. Puedes mostrar un diálogo no modal usando su método .show().

Un diálogo es siempre una ventana independiente. Si un diálogo tiene un widget padre (parent), entonces se mostrará centrado sobre dicho widget.

A continuación un ejemplo de cómo emplear QDialog para desarrollar una diálogo:

Python - dialog_form.py

from PyQt6.QtWidgets import (
    QApplication,
    QDialog,
    QDialogButtonBox,
    QFormLayout,
    QLineEdit,
    QVBoxLayout,
)

class Window(QDialog):
    def __init__(self):
        super().__init__(parent=None)
        self.setWindowTitle("QDialog")

        layout = QVBoxLayout()
        self.setLayout(layout)

        form_layout = QFormLayout()
        labels = ["Nombre:", "Edad:", "Ocupación:", "Dirección:"]
        for label in labels:
            form_layout.addRow(label, QLineEdit())

        layout.addLayout(form_layout)
        buttons = QDialogButtonBox()
        buttons.setStandardButtons(
            QDialogButtonBox.StandardButton.Cancel |
            QDialogButtonBox.StandardButton.Ok
        )
        layout.addWidget(buttons)

app = QApplication([])
window = Window()
window.show()
app.exec()

El código anterior mostrará una ventana que se verá así:

Ventana de diálogo en PyQt

Esta figura muestra el diálogo creado con un QFormLayout para organizar los widgets y un QVBoxLayout para el diseño global.

Mensajes y diálogos estándar

PyQt también proporciona una forma rápida de crear cuadros de mensaje para el usuario. La clase QMessageBox te permite crear pequeñas ventanas diseñados para mostrar mensajes al usuario. PyQt ofrece varios tipos de cuadros de mensajes predefinidos:

QMessageBox.information(): Permite mostrar un mensaje informativo, como una confirmación o un aviso simple.
QMessageBox.warning(): Permite mostrar una advertencia sobre posibles problemas.
QMessageBox.critical(): Muestra mensajes de error críticos.
QMessageBox.question(): Presenta una pregunta al usuario con opciones como Sí y No.

Además, PyQt tiene diálogos estándar predefinidos que facilitan la interacción con el usuario, ya sea para permitirle seleccionar archivos, carpetas, colores o fuentes. Aquí tienes un resumen de ellos:

QFileDialog: Permite al usuario seleccionar un archivo existente para abrirlo. Con el método .getOpenFileName(), seleccionas un archivos. Con .getSaveFileNames(), seleccionas múltiples archivos. Por su parte, .getSaveFileName() te permite seleccionar la ubicación y el nombre para guardar un archivo. Finalmente, .getExistingDirectory() permite seleccionar una carpeta en lugar de un archivo.
QColorDialog: Presenta un diálogo selector de colores que permite al usuario elegir un color. El método empleado es .getColor().
QFontDialog: Representa un selector de fuentes que permite al usuario seleccionar una fuente, tamaño y estilo. El método empleado es .getFont().
QInputDialog: Permite al usuario ingresar datos simples, como un texto, un número o una opción de una lista. Los métodos correspondientes son .getText() para entrada de texto, .getInt() para entrada de un número entero, y .getItem() para selección de un elemento de una lista.

A continuación, un ejemplo que muestra algunos de elementos en acción:

Python - standard_dialogs.py

from PyQt6.QtWidgets import (
    QApplication,
    QColorDialog,
    QFileDialog,
    QFontDialog,
    QInputDialog,
    QMessageBox,
)

app = QApplication([])

# Mostrar un mensaje
QMessageBox.information(
    None,
    "Información",
    "Este es un mensaje.",
)

# Abrir un archivo
file_path, _ = QFileDialog.getOpenFileName(None, "Abrir Archivo")
if file_path:
    QMessageBox.information(
        None,
        "Archivo Seleccionado",
        f"Seleccionaste: {file_path}",
    )

# Seleccionar un color
color = QColorDialog.getColor()
if color.isValid():
    QMessageBox.information(
        None, "Color Seleccionado", f"Seleccionaste: {color.name()}"
    )

# Seleccionar una fuente
font, ok = QFontDialog.getFont()
if ok:
    QMessageBox.information(
        None, "Fuente Seleccionada", f"Seleccionaste: {font.family()}"
    )

# Entrada de texto
text, ok = QInputDialog.getText(None, "Entrada de Texto", "Escribe algo:")
if ok and text:
    QMessageBox.information(None, "Texto Ingresado", f"Escribiste: {text}")

app.exec()

Los cuadros de mensaje y los diálogos estándar son herramientas esenciales para cualquier aplicación PyQt que requiera interacción con el usuario.

Conclusión

Las aplicaciones con interfaz gráfica de usuario (GUI) representan una parte sustancial en el desarrollo de software. Python ofrece un puñado de frameworks y bibliotecas que pueden ayudarte a desarrollar aplicaciones GUI modernas y robustas.

En este tutorial, aprendiste cómo usar PyQt, que es una de las bibliotecas más populares y sólidas para el desarrollo de aplicaciones GUI en Python.

En este tutorial, has aprendido a:

Instalar PyQt y configurarlo en tu computadora
Desarrollar aplicaciones con GUI basadas en PyQt
Organizar una GUI usando gestores de disposición
Crear ventanas principales y diálogos en tus aplicaciones PyQt

Ahora puedes usar tus conocimientos de Python y PyQt para dar vida a tus propias aplicaciones GUI de escritorio.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Patrones de diseño en Python: Modelo-Vista-Controlador (MVC)

2024-12-12T06:00:00+01:00

Este patrón permite separar la lógica específica de cada uno de los componentes de la aplicación. El modelo maneja la lógica de negocio, la vista es el componente visual y el controlador se ocupa de conectar y controlar el funcionamiento de los dos anteriores.

En este tutorial aprenderás:

Qué es MVC y cómo funciona
Qué rol desempeña cada uno de los componentes del MVC
Cuáles son los beneficios de emplear el MVC en tus aplicaciones

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué es el patrón Modelo-Vista-Controlador?
¿Cómo funciona el patrón MVC?
¿Qué responsabilidades tiene cada componente del patrón MVC?
¿Cómo implementar el MVC? Un demo con Tkinter y Python?
¿Qué beneficios ofrece el patrón MVC?
Resumiendo

¿Qué es el patrón Modelo-Vista-Controlador?

El Modelo-Vista-Controlador (MVC) más que un patrón de diseño, puede ser considerado un patrón de arquitectura de software. La diferencia entre el primero y el segundo es que el segundo tiene un alcance mucho mayor, pues define la arquitectura fundamental de la aplicación o sistema que estés desarrollando.

Este patrón tiene tres componentes:

Modelo es el componente central y representa el conocimiento. El modelo contiene y gestiona la lógica del negocio, los datos, el estado y demás reglas fundamentales de la aplicación. Los datos pueden ser almacenados en el propio modelo o en una base de datos. En este último caso solo el modelo puede tener acceso a esta base de datos.
Vista es el componente visual pues debe proveer una representación visual del modelo que el usuario generalmente puede ver en pantalla. Por ejemplo, las Interfaces Gráficas de Usuario (GUI por sus siglas en inglés), o las salidas de texto en una consola o terminal, los gráficos de barras o de pastel, los documentos, las hojas de cálculo, y similares. La vista se limita a mostrar los datos contenidos en el modelo, sin tener la capacidad de manipularlos o modificarlos.
Controlador es el enlace o medio de comunicación entre el modelo y la vista. El encargado de controlar todo el funcionamiento de ambos. Todo el flujo de comunicación entre el modelo y la vista es gestionado a través del controlador, por tanto, no existirá comunicación directa entre estos. Normalmente, el controlador acepta las acciones y entradas del usuario y delega la representación de los datos en la vista y la manipulación en el modelo.

El MVC permite la aplicación práctica del principio de Separación de intereses (Separation of Concerns) al diseño de aplicaciones, donde cada uno de los componentes del patrón tiene una responsabilidad bien definida y única.

¿Cómo funciona el patrón MVC?

La lógica de funcionamiento del MVC puede ser más fácil de comprender con un ejemplo práctico. Supón que tienes una aplicación con una interfaz gráfica de usuario (GUI) donde puedes realizar acciones o eventos, incluidos hacer clic, presionar teclas, tocar el display táctil, entre otros.

Cuando ejecutas la aplicación, inmediatamente ves su ventana principal en tu escritorio. Si la aplicación está implementada usando el MVC, entonces debe funcionar del siguiente modo:

Ejecutas una acción (evento) sobre la vista o ventana de la aplicación.
La vista recibe la acción e inmediatamente informa o notifica al controlador sobre la acción realizada.
El controlador a su vez, delega la solicitud al modelo y actualiza la vista en consecuencia.
El modelo realiza toda la validación de los datos y las entradas y luego procesa los requerimientos y realiza los cambios de estado solicitados, para finalmente informar al controlador que el cambio de estado correspondiente ha sido realizado.
El controlador recibe la información de cambio de estado generada por el modelo y se la envía a la vista, quien se encargará de mostrarla en pantalla.

Haciendo una analogía, puedes comparar el MVC con un restaurante. La carta sería la vista que contiene la información sobre el menú, el mesero sería el controlador que recibe la orden del cliente y se la transmite al chef, quien representa al modelo y se encarga de confeccionar el plato solicitado por el cliente.

En muchas implementaciones de MVC, especialmente en aplicaciones web, las acciones del usuario no son directamente manejadas por la vista, sino que pasan primero por el controlador. La vista debería ser lo más pasiva posible, simplemente renderizando lo que el controlador le proporciona. El controlador debe ser quien maneje las acciones del usuario y decida qué hacer con ellas, incluyendo actualizar el modelo o cambiar lo que se muestra en la vista.

Una vez que el plato está listo, el chef se lo hace saber al mesero, quien finalmente sirve la comida al cliente en forma de un plato terminado que sería la nueva representación de la vista.

El chef y el cliente no tienen contacto directo, pues todo es gestionado por el mesero. Este es un principio básico de este patrón de diseño.

¿Qué responsabilidades tiene cada componente del patrón MVC?

Para implementar el patrón MVC desde cero, debes asegurarte de crear modelos autónomos que recojan todo el conocimiento y la lógica del negocio. Los controladores deberán ser ligeros y limitarse a canalizar el flujo de información de la vista al modelo y viceversa. Las vistas deben limitarse a mostrar la información de estado del modelo.

Para que el modelo pueda ser considerado autónomo debe:

Contener todas las reglas de validación de entradas y la lógica del negocio
Manipular el estado de la aplicación
Tener acceso directo a los datos de la aplicación (bases de datos, nube, archivos de configuración, etc.)
No depender de la interfaz de usuario

Un controlador es considerado ligero cuando:

Actualiza el modelo cuando el usuario interactúa con la vista
Actualiza la vista cuando hay cambios en el modelo
No muestra datos directamente
No tiene acceso directo a los datos de la aplicación
No contiene reglas de validación ni lógica de negocio

Una vista debe:

Mostrar los datos contenidos en el modelo
Permitir que el usuario interactúe con ella
Realizar un mínimo procesamiento de datos con el fin de mostrarlos al usuario
No almacenar datos
No tener acceso directo a los datos de la aplicación
No contener reglas de validación ni lógica de negocio

¿Cómo implementar el MVC? Un demo con Tkinter y Python?

En las secciones siguientes, desarrollarás una aplicación con una GUI escrita en Tkinter, que es el paquete de desarrollo de aplicaciones de escritorio por defecto de Python y que puedes encontrar en la biblioteca estándar del lenguaje.

Para este ejemplo, desarrollarás una aplicación sencilla que te permitirá mostrar saludos aleatorios en una ventana.

El modelo

Lo primero que debes definir es el modelo de tu aplicación. Crea un archivo Python llamado model.py y escribe el siguiente código en él:

Python - model.py

from random import choice

class Model:
    def __init__(self):
        self.greetings = (
            "Hola, Python!",
            "Hola, Mundo!",
            "Hola, Python Scouts!",
        )

    def get_greeting(self):
        return choice(self.greetings)

La clase Model maneja una serie de saludos almacenados en el atributo .greetings. El método .get_greeting() permite seleccionar un saludo aleatorio empleando la función choice() del módulo random.

Este modelo funciona independientemente de la vista que emplees. Para esto, cuenta con sus propios datos y los métodos necesarios para manipular adecuadamente estos datos.

La vista

La vista es la representación gráfica de tu aplicación. Es lo que el usuario ve y con lo que interactúa directamente. La vista recibe las acciones del usuario, las notifica al controlador y luego refleja los cambios del modelo que resultan de las acciones del usuario.

Crea un archivo llamado view.py y pon en él el siguiente código:

Python - view.py

import tkinter as tk

class Window(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("MVC Demo")
        self.geometry("160x70")
        self.greetings_label = tk.Label(text="Hola, Python Scouts!")
        self.greetings_label.pack()
        self.greetings_button = tk.Button(text="Saludar")
        self.greetings_button.pack()

    def show_greeting(self, greeting):
        self.greetings_label["text"] = greeting

En la vista Window solo incluyes código Tkinter. La vista debe ser autosuficiente, es decir, debe tener todos los métodos necesarios para actualizarse. En este caso, solo necesitas el método .show_greeting().

El controlador

El controlador permite conectar la vista y el modelo. Es el único que debe tener conocimiento del resto de los componentes, vista y modelo. El controlador debe encargarse de guiar y gestionar las operaciones de acceso, modificación y actualización del modelo y de la vista.

Para el controlador, crea un archivo con el nombre app.py y escribe el siguiente código en él:

Python - app.py

from model import Model
from view import Window

class Controller:
    def __init__(self, model, view):
        self._model = model
        self._view = view
        self._view.greetings_button["command"] = self._greet

    def run(self):
        self._view.mainloop()

    def _greet(self):
        self._view.show_greeting(greeting=self._model.get_greeting())

# Client code
controller = Controller(model=Model(), view=Window())
controller.run()

En este archivo, defines una clase llamada Controller. En el método .__init__(), tomas como argumentos el modelo y la vista a emplear. Luego creas atributos para almacenar estos elementos y finalmente, conectas el botón Saludar de la vista con el método ._greet() del controlador.

El método ._greet() es lo que se conoce como un callback. Este método se ejecuta cuando haces clic en el botón Saludar. En este método, primeramente accedes al modelo con el fin de obtener el saludo usando el método .get_greeting(). Luego, le indicas a la vista que muestre el saludo llamando al método .show_greeting().

Fíjate que el controlador usa los métodos del modelo o de la vista en función de la tarea a realizar. El controlador no debe implementar lógica de negocio ni manipular directamente los datos del modelo. Su papel es coordinar las interacciones entre la vista y el modelo.

Además, debes notar que el controlador solo tiene un método público, .run(). El resto de sus métodos y atributos no son públicos pues sus nombres comienzan con un guión bajo.

Una vez definido el controlador, viene el código cliente donde creas una instancia del controlador y llamas el método .run() para ejecutar la aplicación. Para probar cómo funciona tu aplicación, ejecuta el siguiente comando en una ventana del terminal. Asegúrate de estar en el directorio que contiene el archivo app.py de tu aplicación:

Terminal

$ python app.py

Al presionar Enter, verás en pantalla una ventana similar a la siguiente:

MVC demo app with Tkinter and Python

Si presionas continuamente el botón Saludar, verás que aparecen los diferentes saludos de forma aleatoria uno tras otro. En este ejemplo puedes ver cómo cada clase realiza su trabajo y únicamente su trabajo.

¿Qué beneficios ofrece el patrón MVC?

Si empleas coherentemente el patrón de diseño MVC en el desarrollo de tus proyectos de software, obtendrás las ventajas siguientes:

La separación entre la vista y el modelo permite que los diseñadores gráficos puedan dedicarse al diseño de la interfaz a la vez que los programadores se encargan de programar y probar el modelo, sin ninguna interferencia entre ellos. Luego, solo será necesario programar el controlador adecuado y la aplicación quedaría lista.
La poca o nula interdependencia entre el modelo y la vista, permite que cada parte pueda ser modificada de manera independiente sin que se afecte la otra, lo que mejora considerablemente la mantenibilidad de tus aplicaciones.
El proceso de añadir nuevas vistas solo demanda implementar el controlador adecuado.
El modelo no tiene conocimiento de las vistas, por tanto, es posible tener vistas diferentes para un único modelo. Por ejemplo, puedes crear una vista web, otra para el escritorio, y otra para dispositivos móviles.
El trabajo de mantener cada parte es mucho más fácil, debido a que las responsabilidades están claramente definidas.

Resumiendo

Ahora conoces conceptos fundamentales sobre el patrón Modelo-Vista-Controlador. Tienes una idea clara de qué cosa es el patrón de diseño Modelo-Vista-Controlador (MVC), cuáles son sus componentes fundamentales y qué función tiene cada uno de ellos.

Ahora sabes:

Qué es MVC y cómo funciona
Qué rol desempeña cada uno de los componentes del MVC
Cuáles son los beneficios de emplear el MVC en tus aplicaciones

Aplicando estos conocimientos a tus proyectos Python, podrás darles una mejor organización de manera que sean más fáciles de modificar y mantener.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Expresiones

2024-12-09T18:00:00+01:00

Python te permite crear diferentes tipos de expresiones que podrás emplear para obtener valores requeridos en tu código. En este tutorial, aprenderás lo básico sobre cómo funcionan y cómo crear expresiones en Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Aritméticas
Comparación
Lógicas o booleanas
Concatenación y repetición
Precedencia de operadores
Conclusiones

Aritméticas

Las expresiones aritméticas son aquellas expresiones basadas en operadores aritméticos que relacionan valores numéricos y funciones que retornan números:

Python REPL

>>> 12 - 6
6
>>> 150 * 2
300
>>> 42 + pow(10, 2)
142
>>> abs(-15) / 3
5.0
>>> 8**2 + 200 / 2
164.0

En estos ejemplos, construyes expresiones usando operadores aritméticos para combinar valores numéricos y funciones que dan como resultado un número.

Las expresiones aritméticas también pueden emplear variables y constantes en lugar de literales numéricos:

Python REPL

>>> radius = 10
>>> PI = 3.142
>>> circle_area = PI * pow(radius, 2)
>>> circle_area
314.2

En este ejemplo, utilizamos una variable y una constante para crear una expresión que retorna el área de un círculo a partir del radio. Como las expresiones siempre retornan un valor, puedes emplear una variable para mantener una referencia al resultado.

Comparación

Por su parte, las expresiones de comparación son aquellas que nos permiten comparar objetos entre sí. Estas expresiones son útiles para decidir el flujo de ejecución de tus programas en función del cumplimiento de determinadas condiciones.

Por ejemplo, las expresiones siguientes comparan valores empleando operadores de comparación:

Python REPL

>>> a = 10
>>> b = 5

>>> a == b
False
>>> a != b
True
>>> a > b
True
>>> a < b
False
>>> a >= b
True
>>> a <= b
False

Todas las expresiones de comparación retornan un valor lógico, ya sea True o False.

Los ejemplos anteriores comparan valores numéricos, sin embargo, también es posible comparar cadenas, tuplas, listas y cualquier otro objeto que soporte los operadores de comparación.

Lógicas o booleanas

Se pueden formar expresiones lógicas o booleanas empleando los operadores lógicos and, or, y not:

Python REPL

>>> a = 10
>>> b = 5

>>> a > b and b > 0
True
>>> a > b or b > 0
True
>>> not a > b
False

En estos ejemplos las expresiones retornan valores booleanos. Es decir, True o False. Sin embargo, no todas las expresiones lógicas retornan valores booleanos.

Si los operandos involucrados son objetos o expresiones con un valor no booleano, entonces los operadores and y or retornan uno de los operandos dependiendo de sus valores de verdad:

Python REPL

>>> 5 and "Hola"
'Hola'
>>> 10 and 42
42
>>> 0 and 3.14
0

>>> 5 or "Hola"
5
>>> 10 or 42
10
>>> 0 or 3.14
3.14

La siguiente tabla resume el comportamiento de los operadores and y or con operandos cuyos valores no son booleanos:

Operación	Resultado
`x and y`	Si `x` es falso, entonces retorna `x`, si no, retorna `y`
`x or y`	Si `x` es verdadero, entonces retorna `x`, si no, retorna `y`

Estos resultados se obtienen con una evaluación cortocircuitada (short-circuit evaluation). Por ejemplo, si x es falso entonces x and y retorna x, pero no evalúa a y.

Para poder funcionar de esta forma estos operadores siguen una serie de reglas que Python usa internamente para determinar el valor de verdad de cualquier objeto. Estas reglas son las siguientes:

Por defecto, un objeto se considera verdadero a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva cero cuando se llama con el objeto. Aquí están los objetos integrados considerados falsos:

Constantes definidas como falsas: None y False.

Cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1).

Cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0). (Fuente)

Concatenación y repetición

Las expresiones de concatenación se forman con el operador de adición (+). En este caso, los operandos deben ser cadenas de caracteres, listas, o tuplas:

Python REPL

>>> "Hola," + " Mundo" + "!"
'Hola, Mundo!'

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]

>>> ("Juan", 25) + ("Programador", "España")
('Juan', 25, 'Programador', 'España')

En el primer ejemplo, concatenas varias cadenas para formar una cadena final. De modo similar, lo haces con listas y con tuplas. Sin embargo, debes notar que los operandos deben ser del mismo tipo de datos. Considera el ejemplo siguiente:

Python REPL

>>> ("Juan", 25) + ["Programador", "España"]
Traceback (most recent call last):
    ...
TypeError: can only concatenate tuple (not "list") to tuple

Si tratas de concatenar una tupla con una lista, entonces recibirás una excepción TypeError.

En lo que respecta a las expresiones de repetición, debes emplear el operador de repetición (*). Uno de los operandos será un número entero que representa el número de veces que deseas repetir el segundo operando. Este último puede ser una cadena, una lista, o una tupla:

Python REPL

>>> "Hola!" * 3
'Hola!Hola!Hola!'

>>> [1, 2, 3] * 2
[1, 2, 3, 1, 2, 3]

>>> 4 * ("uno", "dos")
('uno', 'dos', 'uno', 'dos', 'uno', 'dos', 'uno', 'dos')

El operador de repetición te permite repetir un objeto un determinado número de veces. Debes notar que el orden de los operandos no altera el resultado.

Precedencia de operadores

Cuando trabajas con expresiones que combinan diferentes tipos de operadores, debes considerar que los operadores tienen un orden de precedencia que define cuál operación se evalúa primero. A continuación un breve resumen de este orden.

Paréntesis (). Los paréntesis tienen la mayor precedencia y se evalúan primero:

Python REPL

>>> (2 + 3) * 4
20

En esta expresión, se evalúa (2 + 3) primero y se obtiene 5. Luego, se desarrolla la multiplicación y resulta en 20.

Exponenciación **. El operador de potencia tiene la segunda mayor precedencia:

Python REPL

>>> 2 * 3**2
18

Se evalúa primero la exponenciación (3**2) y se obtiene 9. Luego, se realiza la multiplicación y se obtiene 18.

Operadores unarios +x, -x, ~x. Los operadores unarios como el negativo - y el positivo + se aplican antes que la mayoría de los operadores. Sin embargo, su precedencia es menor que la del operador de exponenciación:

Python REPL

>>> -3**2
-9

>>> (-3)**2
9

La primera expresión se evalúa como -(3**2) = -9 en lugar de como (-3)**2 = 9 que sería lo esperado en matemáticas.

Multiplicación, División, Módulo y División entera *, /, %, //. Todos estos operadores tienen la misma precedencia y se evalúan de izquierda a derecha según aparecen en las expresiones:

Python REPL

>>> 10 + 5 * 2
20

Se evalúa primero la multiplicación y luego la suma 10 + (5 * 2).

Suma y Resta +, -. Tienen precedencia menor que la multiplicación y se evalúan después de ella:

Python REPL

>>> 10 - 2 + 3
11

Se evalúa de izquierda a derecha: primero 10 - 2 y luego 8 + 3.

Operadores de desplazamiento de bits <<, >>. Los operadores de desplazamiento tienen menor precedencia que los aritméticos:

Python REPL

>>> 1 + 2 << 2
12

Se evalúa como (1 + 2) << 2.

Operadores de comparación <, <=, >, >=. Los operadores de comparación se evalúan después de los aritméticos y de los de desplazamiento:

Python REPL

>>> 3 * 2 < 10
True

Se evalúa como (3 * 2) < 10.

Operadores de igualdad ==, !=. Tienen menor precedencia que los operadores de comparación:

Python REPL

>>> 3 + 2 == 5
True

Se evalúa primero 3 + 2 y luego 5 == 5.

Operadores de bits &, ^, |. Se evalúan en el siguiente orden: & (AND bit a bit), ^ (XOR bit a bit), | (OR bit a bit):

Python REPL

>>> 3 & 2 | 1
1

Se evalúa como (3 & 2) | 1.

Operadores lógicos not, and, or. El operador not tiene mayor precedencia que and, que a su vez tiene mayor precedencia que or:

Python REPL

>>> not True or False and True
False

Se evalúa como (not True) or (False and True).

Operadores de pertenencia e identidad in, not in, is, is not. Estos operadores tienen precedencia baja y se evalúan antes que los operadores lógicos:

Python REPL

>>> "m" in "mango" and None is not None
False

Se evalúa como ("m" in "mango") and (None is not None).

Operadores de asignación =, +=, -=, *=, /=, //=, **=, y %=. Los operadores de asignación tienen la menor precedencia, lo cual permite que los cálculos se realicen antes de asignar el valor final:

Python REPL

>>> x = 3 + 2 * 5
>>> x
13

Primero se evalúa 3 + (2 * 5) y luego se asigna el resultado a la variable x.

Conclusiones

Has aprendido sobre las expresiones en Python y cómo formarlas usando diferentes tipos de operadores, como los aritméticos, de comparación, lógicos, de concatenación y repetición. También has conocido la importancia de la precedencia de operadores en la evaluación de expresiones complejas.

Entender cómo formar expresiones en Python es fundamental, pues es la base de para una manipulación y transformación efectiva de datos.

Ahora que dominas estos conceptos, puedes continuar explorando el uso de expresiones y operadores para maximizar la eficiencia y legibilidad de tu código Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Operadores

2024-11-04T06:00:00+01:00

Python tiene varios tipos de operadores que se pueden emplear en diferentes contextos. En este tutorial, aprenderás lo básico sobre cómo funcionan y cómo emplear cada tipo de operador.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Aritméticos
Asignación
Concatenación
Repetición
Comparación
Lógicos
Pertenencia
Identidad
Bitwise
Conclusiones

Aritméticos

Los operadores aritméticos son probablemente los más conocidos y empleados. Ellos permiten realizar operaciones aritméticas básicas entre valores numéricos:

Python REPL

>>> # Adición
>>> 10 + 5
15

>>> # Sustracción
>>> 10 - 5
5
 
>>> # Multiplicación
>>> 10 * 5
50

>>> # División
>>> 10 / 3
3.3333333333333335

>>> # Módulo
>>> 10 % 3
1

>>> # Exponenciación
>>> 2**3
8

>>> # División entera
>>> 10 // 3
3
>>> -10 // 3  # No -3, porque -4 es el mayor entero <= -3.333
-4

Los operadores de adición, sustracción, multiplicación y división son casi idénticos a los que empleas en matemáticas.

El operador de módulo (%) devuelve el resto de la división entera. El operador de exponenciación o potenciación te permite elevar números a una determinada potencia. Finalmente, el operador de división entera realiza una división que devuelve el mayor entero menor o igual al resultado de la división normal. Esto se conoce como división de piso.

Asignación

Los operadores de asignación se emplean para asignar valores u objetos a variables o nombres:

Python REPL

>>> # Asignación
>>> number = 5
>>> number
5

>>> # Suma aumentada
>>> number += 5  # Equivale a number = number + 5
>>> number
10

>>> # Resta aumentada
>>> number -= 5  # Equivale a number = number - 5
>>> number
5

>>> # Multiplicación aumentada
>>> number *= 3  # Equivale a number = number * 3
>>> number
15

>>> # División aumentada
>>> number /= 3  # Equivale a number = number / 3
>>> number
5.0

>>> # Módulo aumentado
>>> number %= 3  # Equivale a number = number % 3
>>> number
2.0

>>> # Potencia aumentada
>>> number **= 3  # Equivale a number = number ** 3
>>> number
8.0

>>> # División entera aumentada
>>> number //= 3  # Equivale a number = number // 3
>>> number
2.0

En la práctica, Python tiene un operador de asignación (=) y varios operadores de asignación aumentada. Los operadores de asignación aumentada son atajos que permiten actualizar el valor de una variable de forma rápida y concisa.

Concatenación

Los operadores de concatenación te permiten unir cadenas de caracteres, listas y otros tipos de datos:

Python REPL

>>> # Concatenación de cadenas
>>> "Hola, " + "mundo!"
'Hola, mundo!'
>>> "Python " + "es " + "genial"
'Python es genial'

>>> # Concatenación aumentada en cadenas
>>> greeting = "Hola"
>>> greeting += ", mundo!"
>>> greeting
'Hola, mundo!'
>>> message = "Python"
>>> message += " es genial"
>>> message
'Python es genial'

>>> # Concatenación de listas
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> ["a", "b"] + ["c", "d"]
['a', 'b', 'c', 'd']

>>> # Concatenación aumentada en listas
>>> numbers = [1, 2, 3]
>>> numbers += [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6]
>>> letters = ["a", "b"]
>>> letters += ["c", "d"]
>>> letters
['a', 'b', 'c', 'd']

Nuevamente, Python tiene un operador de concatenación (+) y varios operadores de concatenación aumentada.

Repetición

Puedes usar los operadores de repetición para repetir un valor un número determinado de veces:

Python REPL

>>> # Repetición de cadenas
>>> "Hola " * 3
'Hola Hola Hola '

>>> 2 * "Python! "
'Python! Python! '

>>> # Repetición de listas
>>> [1, 2, 3] * 2
[1, 2, 3, 1, 2, 3]

>>> 3 * ["a", "b"]
['a', 'b', 'a', 'b', 'a', 'b']

El operador de repetición comúnmente se emplea con cadenas de caracteres cuando queremos repetir una determinada cadena. Nota que este operador requiere de un operando entero que representa el número de repeticiones y que puede estar a la derecha o izquierda del operador.

Comparación

Cuando necesitas comparar valores u objetos, puedes utilizar los operadores de comparación:

Python REPL

>>> # Igual a
>>> 5 == 5
True
>>> 5 == 10
False

>>> # Mayor que
>>> 10 > 5
True
>>> 5 > 10
False

>>> # Menor que
>>> 5 < 10
True
>>> 10 < 5
False

>>> # Mayor o igual que
>>> 10 >= 5
True
>>> 5 >= 5
True
>>> 5 >= 10
False

>>> # Menor o igual que
>>> 5 <= 10
True
>>> 5 <= 5
True
>>> 10 <= 5
False

>>> # Diferente de
>>> 10 != 5
True
>>> 5 != 5
False

Estos operadores son casi idénticos a los que usamos en las matemáticas. El operador de igualdad que se representa con dos símbolos de igualdad (==) para diferenciarlo del operador de asignación. El operador de desigualdad se representa como !=.

Lógicos

Los operadores lógicos o booleanos permiten crear expresiones lógicas que generalmente se utilizan en condiciones. Python tiene tres operadores booleanos: and, or, y not. Los siguientes ejemplos muestran el funcionamiento de cada operador:

Python REPL

>>> # Operador and (y)
>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False

>>> # Operador or (o)
>>> True or False
True
>>> False or True
True
>>> False or False
False
>>> True or True
True

>>> # Operador not (no)
>>> not True
False
>>> not False
True

Estos ejemplos expresan lo que se conoce como tabla de verdad de los operadores lógicos. Esta tabla resume los valores de verdad que retornan los operadores en función del valor de verdad de los operandos.

Los operadores lógicos en Python también funcionan con objetos distintos de True and False. Todos los objetos tienen un valor de verdad en Python. Las reglas para determinar estos valores de verdad son las siguientes:

Por defecto, un objeto se considera verdadero a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva cero cuando se llama con el objeto. A continuación, se muestran la mayoría de los objetos incorporados considerados como falsos:

Constantes definidas como falsas: None y False

Cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

Cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0) (Fuente)

Cuando empleas los operadores and y or con objetos distintos de True o False, obtienes uno de los objetos como resultado en lugar de un valor booleano.

Python REPL

>>> "Hola" and [1, 2, 3]
[1, 2, 3]
>>> "" and [1, 2, 3]
''

>>> "" or [1, 2, 3]
[1, 2, 3]
>>> "Hola" or [1, 2, 3]
'Hola'

El operador and retorna el operando derecho si el izquierdo es verdadero. Si el operando izquierdo es falso, entonces and lo retorna inmediatamente sin evaluar el operando derecho. Esto se denomina evaluación de cortocircuito.

En contraste, or retorna el operando derecho si el izquierdo es falso. Si el operando izquierdo es verdadero, entonces or lo retorna inmediatamente.

Pertenencia

Los operadores de pertenencia se emplean cuando necesitas determinar si un valor u objeto determinado forma parte de una serie de valores o colección. Python tiene dos operadores de pertenencia: in y not in.

El operador in devuelve True si el objeto está presente en la colección de valores, de lo contrario devuelve False:

Python REPL

>>> # Verificar si un elemento está en una lista
>>> fruits = ["manzana", "banana", "cereza"]
>>> "banana" in fruits
True
>>> "naranja" in fruits
False

>>> # Verificar si una subcadena está en una cadena
>>> texto = "Hola, mundo!"
>>> "Hola" in texto
True
>>> "adiós" in texto
False

>>> # Verificar si un elemento está en un conjunto
>>> numbers = {1, 2, 3, 4, 5}
>>> 3 in numbers
True
>>> 6 in numbers
False

>>> # Verificar si una clave está en un diccionario
>>> person = {"name": "Juan", "age": 30}
>>> "name" in person
True
>>> "address" in person
False

Por otro lado, el operador not in permite determinar si un valor no pertenece a una serie de valores. Este operador devuelve True cuando el valor no es parte de la colección de valores:

Python REPL

>>> # Verificar si un elemento NO está en una lista
>>> fruits = ["manzana", "banana", "cereza"]
>>> "naranja" not in fruits
True
>>> "banana" not in fruits
False

>>> # Verificar si una subcadena NO está en una cadena
>>> texto = "Hola, mundo!"
>>> "adiós" not in texto
True
>>> "Hola" not in texto
False

>>> # Verificar si un elemento NO está en un conjunto
>>> numbers = {1, 2, 3, 4, 5}
>>> 6 not in numbers
True
>>> 3 not in numbers
False

>>> # Verificar si una clave NO está en un diccionario
>>> person = {"name": "Juan", "age": 30}
>>> "address" not in person
True
>>> "name" not in person
False

Los operadores de pertenencia funcionan con diferentes colecciones de datos como listas, duplas, conjuntos y diccionarios. Sin embargo, cuando necesitas realizar pruebas de pertenencia repetidamente, la opción más eficiente es emplear conjuntos.

Identidad

En Python, cada objeto que se crea tiene una identidad única. En CPython, esta identidad es un número entero que se corresponde con la dirección de memoria donde el objeto está almacenado.

Python tiene dos operadores que permiten verificar si dos objetos tienen la misma identidad o no. Estos operadores son is e is not y se conocen como operadores de identidad.

El operador is devuelve True si dos variables hacen referencia al mismo objeto, es decir, si apuntan a la misma ubicación en memoria:

Python REPL

>>> a = [1, 2, 3]
>>> b = a
>>> c = [1, 2, 3]

>>> a is b  # True, b se refiere a la misma lista que a
True
>>> a is c  # False, c es una lista independiente con el mismo contenido
False

El operador is not devuelve True si dos variables no hacen referencia al mismo objeto en memoria:

Python REPL

>>> a is not b
False
>>> a is not c
True

Python realiza el caché de valores enteros en el rango de -5 a 256. Esto significa que cualquier número en este rango siempre apunta al mismo objeto en memoria:

Python REPL

>>> x = 100
>>> y = 100
>>> x is y  # True, por estar en el rango de valores en caché
True

>>> n = 400
>>> m = 400
>>> n is m  # False, por NO estar en el rango de valores en caché
False

Esta comportamiento de Python es una optimización de uso de memoria y se basa en el hecho de que posiblemente los enteros más comúnmente empleados están en ese rango de valores.

Bitwise

Los operadores de bits permiten manipular los bits de los números enteros directamente. Python cuenta con seis operadores de bit o bitwise. A continuación, algunos ejemplos que muestran cómo funcionan estos operadores:

Python REPL

>>> # AND bit a bit
>>> 5 & 3  # (En binario: 5 = 101 y 3 = 011, 101 & 011 = 001)
1
>>> 6 & 2  # (En binario: 6 = 110 y 2 = 010, 110 & 010 = 010)
2

>>> # OR bit a bit
>>> 5 | 3  # (En binario: 5 = 101 y 3 = 011, 101 | 011 = 111)
7
>>> 6 | 2  # (En binario: 6 = 110 y 2 = 010, 110 | 010 = 110)
6

>>> # XOR bit a bit
>>> 5 ^ 3  # (En binario: 5 = 101 y 3 = 011, 101 ^ 011 = 110)
6
>>> 6 ^ 2  # (En binario: 6 = 110 y 2 = 010, 110 ^ 010 = 100)
4

>>> # NOT bit a bit
>>> ~5  # (En binario: 5 = 0000 0101, ~5 = 1111 1010 que es -6 en complemento a dos)
-6
>>> ~1  # (En binario: 1 = 0000 0001, ~1 = 1111 1110 que es -2 en complemento a dos)
-2

>>> # Desplazamiento a la izquierda
>>> 5 << 1  # (En binario: 5 = 0000 0101, 5 << 1 = 0000 1010 que es 10)
10
>>> 3 << 2  # (En binario: 3 = 0000 0011, 3 << 2 = 0000 1100 que es 12)
12

>>> # Desplazamiento a la derecha
>>> 5 >> 1  # (En binario: 5 = 0000 0101, 5 >> 1 = 0000 0010 que es 2)
2
>>> 12 >> 2  # (En binario: 12 = 0000 1100, 12 >> 2 = 0000 0011 que es 3)
3

Los operadores a nivel de bits no son tan comunes en el desarrollo de aplicaciones de alto nivel. Sin embargo, son muy útiles en aplicaciones que requieren manipulación de datos a nivel de bits, incluidas la programación de sistemas, el procesamiento de señales, la criptografía, las redes, y los gráficos.

Conclusiones

Has aprendido sobre los distintos tipos de operadores en Python, incluyendo aritméticos, de asignación, concatenación, repetición, comparación, lógicos, pertenencia, identidad y bitwise.

El conocimiento de los operadores es esencial para cualquier desarrollador de Python, pues con ellos puedes manipular y evaluar datos, controlar el flujo de ejecución, y realizar otras tareas de programación.

Ahora puedes aplicar tus conocimientos para resolver problemas complejos, optimizar tus programas y desarrollar aplicaciones más robustas y eficientes.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo saber si todos los elementos en una lista son iguales en Python?

2024-10-29T06:00:00+01:00

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Convertir la lista en un conjunto y comprobar si contiene un único elemento
Usar la función all() para comparar el primer elemento con los restantes
Ordenar la lista y comparar el primer y el último elemento
En resumen

Convertir la lista en un conjunto y comprobar si contiene un único elemento

Una vía rápida para determinar si todos los elementos de una lista son iguales es convertir la lista en un conjunto usando la clase set().

Como premisa y en aras de la simplicidad, asumiremos que se trata de una lista no vacía que contiene elementos del mismo tipo de dato, ya sea números, cadenas, u otros.

Los conjuntos son tipos de datos que no pueden contener elementos repetidos. Por tanto, si conviertes tu lista en un conjunto y terminas con un conjunto de un único elemento, entonces puedes concluir que todos los elementos de tu lista son iguales:

Python REPL

>>> numbers = [2, 2, 2, 2, 2, 2]
>>> len(set(numbers)) == 1
True

>>> letters = ["a", "b", "a"]
>>> len(set(letters)) == 1
False

En estos ejemplos, combinas las funciones set() y len(). Si terminas con un conjunto de un solo elemento, entonces sabes que todos los elementos de tu lista original son iguales.

Usar la función `all()` para comparar el primer elemento con los restantes

Puedes emplear la función all() para determinar si todos los elementos de una lista son iguales. Esta función te permite comprobar si todos los elementos de un iterable son verdaderos. Para cumplir con tu tarea, puedes comparar el primer elemento de tu lista con el resto de los elementos.

A continuación el código que te permite hacerlo:

Python REPL

>>> numbers = [2, 2, 2, 2, 2, 2]
>>> all(item == numbers[0] for item in numbers[1:])
True

>>> letters = ["a", "b", "a"]
>>> all(item == letters[0] for item in letters[1:])
False

Esta técnica para determinar si todos los elementos de una lista son iguales emplea una expresión generadora que produce valores booleanos que resultan de evaluar la expresión item == letters[0]. Luego, all() verifica si todos los elementos resultantes son True.

Ordenar la lista y comparar el primer y el último elemento

Otra manera de saber si todos los elementos de una lista son iguales es ordenar la lista y comparar el primer y el último elemento.

Debes saber que esta técnica puede ser muy ineficiente especialmente cuando tienes una lista muy larga, pues el algoritmo de ordenamiento puede tomar un tiempo considerable. Además, ordenar la lista modifica el orden original de los elementos, lo cual puede no ser deseado.

Considera los siguientes ejemplos:

Python REPL

>>> numbers = [2, 2, 2, 2, 2, 2]
>>> numbers.sort()
>>> numbers[0] == numbers[-1]
True

>>> letters = ["a", "b", "a"]
>>> letters.sort()
>>> letters
['a', 'a', 'b']
>>> letters[0] == letters[-1]
False

En este ejemplo, ordenas la lista con el método .sort() y luego comparas el primer y el último elemento usando una comparación de igualdad. Si estos elementos son iguales, entonces todos los elementos de tu lista son iguales.

En resumen

En esta guía, has aprendido tres técnicas diferentes para determinar si todos los elementos en una lista de Python son iguales:

Convertir la lista en un conjunto y verificar su longitud
Utilizar la función all() con una expresión generadora
Ordenar la lista y comparar el primer y el último elemento

Cada técnica ofrece una forma útil de abordar el problema, proporcionando flexibilidad según las necesidades específicas de tu programa. Con estas habilidades, puedes implementar verificaciones de uniformidad de manera eficiente y rápida en tus proyectos de Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Constantes

2024-10-26T06:00:00+02:00

Python no tiene una sintaxis específica para las constantes como otros lenguajes de programación sí la tienen. Por esta razón, las constantes en Python son realmente variables que no cambian su valor durante la ejecución del código.

Al igual que las variables, las constantes consisten en dos cosas: un nombre y un valor asociado. El nombre describe claramente de qué trata la constante. El valor es la expresión concreta de la constante.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Constantes comunes
Constantes en Python
Tipos de datos y constantes
Nombres de constantes
Ventajas de usar constantes
Conclusiones

Constantes comunes

La vida, y particularmente la ciencia, está llena de ejemplos de valores constantes, o valores que nunca cambian. Algunos ejemplos incluyen los siguientes:

3.141592653589793: Una constante denotada por π, conocida como Pi, que representa la relación entre la circunferencia de un círculo y su diámetro.
2.718281828459045: Una constante denotada por e y conocida como el número de Euler, que está estrechamente relacionada con el logaritmo natural y el interés compuesto.
-273.15: Una constante que representa el cero absoluto en grados Celsius, que es igual a 0 kelvins en la escala de temperatura Kelvin.

Estos ejemplos son valores constantes que se utilizan comúnmente en la vida cotidiana como en la ciencia. En programación, a menudo te encontrarás manejando estos y muchos otros valores similares.

Constantes en Python

Para crear una constante en Python, se emplea la misma sintaxis que para crear una variable. Esto es, el operador de asignación (=) separando el nombre de la constante a la izquierda y el valor a la derecha.

Como Python no tiene una sintaxis dedicada para definir constantes, la comunidad Python ha asumido y establecido una convención para definir los nombres de las constantes: emplear letras en mayúsculas separando las palabras con guiones bajos o caracteres de subrayado:

Python REPL

>>> PI = 3.1416
>>> EULER_NUMBER = 2.718281828459045
>>> LIGHT_SPEED = 299792458
>>> BASE_PATH = "/proyectos"

En estos ejemplos, has creado algunas variables mediante la asignación de valores numéricos o de cadena de caracteres.

Como regla general, emplearemos nombres de constantes en idioma inglés puesto que este es el idioma base para la programación actualmente.

A partir de este momento, puedes usar los nombres de estas constantes cuando quieras referirte a sus respectivos valores en tu código:

Python REPL

>>> PI
3.1416
>>> EULER_NUMBER
2.718281828459045
>>> LIGHT_SPEED
299792458
>>> BASE_PATH
'/proyectos'

Puedes usar las constantes para referirte a los valores que estas referencian. Estos valores se encuentran almacenados en posiciones específicas de la memoria de tu computadora. La constante es solo una vía para llegar al valor referenciado a través de un nombre legible.

Es importante notar que durante la ejecución de tu código, las constantes que has definido no deben cambiar su valor. Es decir, no deberías reasignar una constante luego de haberla creado. Aunque técnicamente puedes asignar un nuevo valor a estas variables, hacerlo violaría la intención de usarlas como constantes.

Tipos de datos y constantes

Al igual que las variables, las constantes no tienen un tipo de dato estático. Cuando se habla del tipo de dato de una constante, en realidad se trata del tipo de dato del objeto al que la constante apunta, ya sea un valor numérico o cualquier otro tipo de valor. Python determina este tipo de dato dinámicamente.

Nombres de constantes

Los nombres de constantes en Python pueden tener cualquier longitud y consistir en letras mayúsculas (A-Z), dígitos (0-9) y el carácter de subrayado o guión bajo (_). La única restricción es que, aunque un nombre de constante puede contener dígitos, el primer carácter del nombre no puede ser un dígito.

Para una comprensión más profunda de las convenciones de estilo en Python, puedes consultar la Guía de Estilo para el Código Python (PEP 8).

El uso de mayúsculas sostenidas es una convención y no una restricción del lenguaje. Python no te restringe en este sentido. Es decir, técnicamente, puedes nombrar una constante usando minúsculas, pero estarías violando la convención generalmente aceptada.

Ventajas de usar constantes

Algunas ventajas de usar constantes en lugar de sus valores directamente en tu código incluyen:

Ventaja	Descripción
Mejora en la legibilidad	Un nombre descriptivo que representa un valor en un programa siempre es más legible y explícito que el valor en sí.
Mejor mantenibilidad	Las constantes te permiten usar un único nombre para identificar un valor en todo el código. Si necesitas actualizar el valor de la constante, solo debes modificar el valor en la definición de la constante.
Menor riesgo de errores	Una constante que representa un valor en todo un programa es menos propensa a errores que tener múltiples instancias explícitas del valor en sí.
Menos necesidad de depuración	Las constantes permanecen sin cambios durante la ejecución del programa. Dado que siempre tendrán el mismo valor, no deberían causar errores ni bugs.

Como ves en esta tabla, las constantes son un concepto importante en programación. Ellas pueden hacer que tu vida sea más fácil y tu código más confiable, mantenible y legible.

Conclusiones

Has aprendido cómo funcionan las constantes en Python, incluyendo su creación y uso. También has explorado cómo gestionar los nombres de constantes según las convenciones de nombrado empleadas en Python.

Comprender las constantes es esencial para cualquier desarrollador de Python, pues ellas son fundamentales para manipular y gestionar datos en tus programas.

Con estas habilidades, estás preparado para explorar conceptos más avanzados y desarrollar aplicaciones más complejas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Variables

2024-10-12T06:00:00+02:00

En Python, las variables no almacenan objetos concretos. Las variables son como etiquetas que puedes asociar con un valor determinado en la memoria de tu computadora para luego acceder al valor empleando un nombre descriptivo.

Python utiliza asignación basada en referencias, donde las variables son nombres que apuntan a objetos en la memoria.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Variables en Python
Tipos de datos y variables
Nombres de variables
Conclusiones

Variables en Python

Para crear una variable en Python, se emplea el operador de asignación (=) como se muestra a continuación:

Python REPL

>>> number = 42
>>> temperature = 76.7
>>> language = "Python"
>>> message = "Bienvenidos a pythonscouts.com"

En estos ejemplos, has creado algunas variables mediante la asignación de valores numéricos o de cadena de caracteres.

Como regla general, emplearemos nombres de variables en idioma inglés puesto que este es el idioma base para la programación actualmente.

A partir de este momento, puedes usar el nombre de estas variables cuando quieras referirte al valor asignado en tu código:

Python REPL

>>> number
42
>>> temperature
76.7
>>> language
'Python'
>>> message
'Bienvenidos a pythonscouts.com'

Puedes usar las variables para referirte a los valores que estas referencian. Estos valores se encuentran almacenados en posiciones específicas de la memoria de tu computadora. La variable solo es una vía para llegar al valor referenciado.

Durante la ejecución de tu código, tus variables pueden variar el valor referenciado. Es por eso que las llamamos variables. Por ejemplo, el siguiente contador incrementa su valor de uno en uno durante la ejecución del código:

Python REPL

>>> count = 0
>>> count += 1
>>> count
1
>>> count += 1
>>> count
2
>>> count += 1
>>> count
3

Para cambiar el valor referenciado por una variable, lo que hacemos es reasignar la variable para que apunte a otro valor u objeto.

Tipos de datos y variables

Python es un lenguaje de tipado dinámico, lo que significa que el tipo de objeto al que una variable hace referencia puede cambiar durante la ejecución del programa.

En realidad, las variables en Python no tienen tipo de dato. Los que tienen tipo de dato asociado son los objetos a los que las variables se refieren o apuntan.

Debido a esto, una variable en Python puede referirse a una cadena en un momento determinado, a un valor numérico en otro momento, y a cualquier otro objeto más tarde:

Python REPL

>>> value = 42
>>> value
42

>>> # Más tarde...
>>> value = "Una cadena"
>>> value
'Una cadena'

Aunque esto es posible hacer que una variable se refiera a objetos de diferentes tipos de dato en diferentes momentos de su vida, esta práctica no es recomendable pues puede ocasionar errores durante la ejecución del código:

Python REPL

>>> value.upper()
'UNA CADENA'

En este ejemplo, puedes ver cómo inicialmente la variable referencia un objeto de tipo cadena al cual le puedes aplicar el método .upper() para convertir todas las letras en mayúsculas.

Ahora supongamos que un rato más tarde, el código reasigna la variable para referirse a un valor numérico entero. Cuando tratas de aplicar el método .upper(), recibes una excepción AttributeError:

Python REPL

>>> value = 42
>>> value.upper()
Traceback (most recent call last):
    ...
AttributeError: 'int' object has no attribute 'upper'

Los enteros no implementan el método .upper() y esto provoca que tu código falle. Debido a problemas como este, es recomendable que tus variables no cambien el tipo de objetos al que apuntan durante su vida.

Nombres de variables

Los nombres de variables en Python pueden tener cualquier longitud y consistir en letras mayúsculas (A-Z) y minúsculas (a-z), dígitos (0-9) y el carácter de guión bajo (_). La única restricción es que, aunque un nombre de variable puede contener dígitos, el primer carácter de un nombre de variable no puede ser un dígito.

La guía de estilo de programación de Python, el PEP 8, recomienda que escribas los nombres de variables en minúsculas con guiones bajos para separar las palabras:

Python REPL

>>> name = "Juan"
>>> family_name = "Valdés"
>>> age = 19
>>> birth_day = "02-10-2008"

Las variables identifican objetos y, por esta razón, generalmente se emplean sustantivos para los nombres de variables.

En el caso de nombres que requieren más de una palabra, se emplea un guión bajo para separar las palabras. En este caso, es común emplear un adjetivo junto con un sustantivo.

Las variables que apuntan a valores Booleanos (True o False) generalmente usan los prefijos is_* y has_* en inglés:

Python REPL

>>> is_active = True
>>> has_permission = False

El uso de estos prefijos es una convención de estilo que ayuda a mejorar la legibilidad del código. No es un requisito estricto del lenguaje.

Conclusiones

Has aprendido cómo funcionan las variables en Python, incluyendo su creación, asignación y uso. También has explorado el concepto de tipado dinámico y cómo gestionar los nombres de variables según las convenciones más empleadas en Python.

Comprender las variables es esencial para cualquier desarrollador de Python, pues ellas son fundamentales para manipular y gestionar datos en tus programas.

Con estas habilidades, estás preparado para explorar conceptos más avanzados y desarrollar aplicaciones más complejas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python a través de ejemplos: Valores

2024-10-03T20:20:00+02:00

Los valores o literales más comunes son los valores numéricos. También encontrarás valores para definir cadenas de caracteres que te sirven para representar texto.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Valores numéricos
Valores de cadena de caracteres
- Literales de cadena
- Literales de cadena sin formato
Conclusiones

Valores numéricos

Los números son una parte fundamental de cualquier programa de computadoras. En la mayoría de los lenguajes de programación, los valores numéricos son representados de manera muy similar a la que se emplea en las matemáticas.

Números enteros

Para definir valores enteros, puedes emplear números positivos y negativos tal y como los usarías en tu clase de matemáticas:

Python REPL

>>> 0  # Cero como un entero
0

>>> 42  # Un entero positivo
42

>>> -100  # Un entero negativo
-100

También puedes añadir un guión bajo como separador de miles en números de más de tres cifras:

Python REPL

>>> 1000000  # Sin separador de miles en el literal
1000000

>>> 1_000_000  # Con separador de miles en el literal
1000000

Esta forma de escribir números enteros mejora significativamente la legibilidad del código.

Números decimales

Para crear valores de coma flotante o decimales, debes añadir un punto (.) luego de la parte entera y finalmente la fracción decimal:

Python REPL

>>> 3.14  # Un decimal positivo
3.14

>>> -0.001  # Un decimal negativo
-0.001

>>> 0.0  # Cero como número decimal
0.0

>>> 1.23e3  # Equivalente a 1.23 * 10^3
1230.0

>>> 5.67E-2  # Equivalente a 5.67 * 10^-2
0.0567

>>> .5  # Sin cero a la izquierda del punto
0.5

>>> 10.  # Sin fracción decimal especificada
10.0

>>> 1_000_000.02  # Con separador de miles en el literal
1000000.02  # Sin separador de miles en la salida

Dependiendo del contexto, puedes escribir los números decimales de diferentes maneras, que son muy similares a como los escribes en matemáticas.

Sin embargo, la notación científica es un poco diferente. Para expresar un número en esta notación, debes usar la letra e o E seguida del exponente.

Números complejos

Finalmente, tienes los valores de números complejos:

Python REPL

>>> 2 + 3j
(2+3j)

>>> 5j
5j

>>> 2.5 + 7.8j
(2.5+7.8j)

>>> 3j + 6
(6+3j)

>>> 2 - 3j
(2-3j)

Los números complejos tienen una parte real y otra imaginaria. En notación matemática, generalmente se emplea la letra i para la parte imaginaria, pero en Python se usa la j.

Valores de cadena de caracteres

Cuando necesitas trabajar con cadenas de caracteres o texto, puedes emplear valores o literales que generalmente se forman con el texto entre comillas.

Literales de cadena

En Python, puedes usar diferentes tipos de comillas para definir literales de cadenas de caracteres:

Python REPL

>>> 'Texto entre comillas simples'
'Texto entre comillas simples'

>>> "Texto entre comillas dobles"
'Texto entre comillas dobles'

>>> '''Texto entre comillas simples triplicadas
... que ocupa varias líneas físicas'''
'Texto entre comillas simples triplicadas\nque ocupa varias líneas físicas'

>>> """Texto entre comillas dobles triplicadas
... que ocupa varias líneas físicas"""
'Texto entre comillas dobles triplicadas\nque ocupa varias líneas físicas'

Para crear cadenas de texto que ocupen una única línea física, puedes emplear comillas simples o dobles. Para crear cadenas de texto que ocupen múltiples líneas, emplea comillas simples o dobles triplicadas.

Ahora bien, ¿qué puedes hacer si necesitas incluir los caracteres de comillas en una cadena de texto? En este caso, puedes alternar las comillas:

Python REPL

>>> 'Alterna "comillas" para incluirlas en el texto'
'Alterna "comillas" para incluirlas en el texto'

En este caso, usaste las comillas simples para delimitar la cadena y así poder incluir las comillas dobles en el texto.

Otra forma de hacerlo es escapar las comillas con una barra invertida (\) como en el siguiente ejemplo:

Python REPL

>>> "Escapa las \"comillas\" con un backslash"
'Escapa las "comillas" con un backslash'

Python tiene varias otras secuencias de escape que puedes emplear en tus cadenas de caracteres. Estas secuencias implican el uso de la barra invertida y son útiles cuando necesitas incluir caracteres con significado especial en tus cadenas.

Literales de cadena sin formato

Los literales de cadenas pueden tener como prefijo la letra r o R. Estos son literales de cadena sin formato (raw strings) y tratan las barras invertidas como caracteres literales, por lo que son muy útiles y comunes en expresiones regulares.

Por ejemplo, la expresión regular siguiente te permite identificar direcciones de correo electrónico:

Python REPL

>>> r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'

Cuando necesitas incluir barras invertidas y otros caracteres que pueden tener significados especiales en tus cadenas, puedes usar cadenas sin formato.

Finalmente, están las f-strings o literales formateados. Estos te permiten interpolar y formatear valores en tus cadenas empleando campos de reemplazo delimitados por llaves ({}) en el literal:

Python REPL

>>> balance = 5425.9292

>>> f"Balance general: ${balance:,.2f}"
'Balance general: $5,425.93'

El campo de reemplazo en esta f-string contiene una variable llamada balance. Esta variable provee el valor que necesitamos interpolar en la cadena. Luego tenemos el especificador de formato que comienza con el caracter de dos puntos (:). En este caso, formateas el valor como un valor decimal con dos lugares después del punto y empleando una coma (,) como separador de miles.

Conclusiones

Ahora sabes lo básico sobre los valores o literales en Python, incluidos valores numéricos como los números enteros, decimales y complejos. También aprendiste sobre los valores de cadenas de caracteres.

Entender los valores y cómo crearlos es fundamental para cualquier desarrollador de Python, pues estos son la base sobre la que se construyen expresiones y sentencias más elaboradas.

Ahora que dominas estos conceptos, tienes las puertas abiertas para explorar temas más avanzados en Python.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo ejecutar un script Python?

2024-03-21T18:40:00+01:00

Ser capaz de ejecutar tus scripts y programas es una de las habilidades más importantes que debes tener como programador Python. En realidad ejecutar el código es la única forma de asegurarte que funciona como esperas. Además, para qué escribir código sino para ejecutarlo y que haga cosas por ti?

En este tutorial, aprenderás qué es un script o programa ejecutable en Python, cómo ejecutar scripts usando el comando python o el propio script como un comando. Finalmente, aprenderás que también es posible ejecutar tus scripts desde tu IDE o editor de texto favorito, lo cual es muy conveniente durante el proceso de desarrollo.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

Scripts y programas en Python
Ejecutar scripts con el comando python
Ejecutar scripts directamente como un comando
- En sistemas Unix
- En sistemas Windows
Ejecutar scripts desde un IDE o editor de texto
Resumiendo

Scripts y programas en Python

En informática, el término script se emplea para designar un archivo que contiene una secuencia lógica de órdenes o comandos que un ordenador puede ejecutar. Con esto en mente, puedes definir un script Python como una secuencia de instrucciones escritas en este lenguaje y que se almacena en un archivo de texto plano. Este archivo está diseñado para ser ejecutado directamente por el usuario.

El término script también suele emplearse para designar archivos que contienen código interpretado. Es decir, código que requiere un intérprete que lo ejecute. Por ejemplo, los scripts que regularmente se emplean en sistemas Unix y que son escritos en lenguaje Bash u otro lenguaje shell.

Los scripts pueden categorizarse como programas ejecutables. La diferencia es que los scripts son más simples que los programas o aplicaciones. Generalmente, se encargan de tareas específicas y poco complejas. Por ejemplo, puedes tener scripts para renombrar archivos en tu disco duro, automatizar la descarga de archivos, actualizar tu sistema, u otras tareas similares.

En contraste, los programas suelen ser más complejos y tener muchas más funcionalidades. Un editor de texto, un navegador, un particionador de discos son todos ejemplos de programas o aplicaciones. En cualquier caso, si usas Python para crear proyectos complejos como estos, tendrás un script de entrada (entry-point script) que te permite ejecutar el programa en cuestión.

Ejecutar scripts con el comando `python`

Probablemente la manera más comúnmente empleada para ejecutar un script Python es usando el comando python desde la línea de comandos o terminal del sistema operativo. Antes de entrar en el comando específico, abre tu editor de texto favorito, crea un nuevo archivo .py y escribe el código siguiente en él:

Python - hello.py

print('Hola, Mundo!')

Este script es el típico programa "Hola, Mundo!" que generalmente escribes cuando comienzas a aprender un lenguaje de programación. Guarda el archivo en tu directorio de trabajo y llámalo hello.py.

Abre una ventana de terminal en tu directorio de trabajo actual y ejecuta el siguiente comando:

Terminal

$ python hello.py
Hola, Mundo!

Inmediatamente después de presionar Enter, verás en pantalla la frase Hola, Mundo!. Con eso acabas de ejecutar tu primer script Python! Es muy probable que uses esta forma de ejecutar scripts a menudo en tu ciclo de desarrollo o incluso en tus tareas diarias.

En sistemas Windows, además del comando python, también puedes emplear el lanzador py desde PowerShell:

Powershell

PS> py hello.py
Hola, Mundo!

El lanzador py está disponible en todas las versiones de Python a partir de 3.3, así que no debes tener problemas para emplearlo.

Ejecutar scripts directamente como un comando

Si estás acostumbrado a crear scripts Python utilitarios para automatizar tareas repetitivas en tu entorno de trabajo, entonces es probable que desees simplificar el proceso de ejecución. En la mayoría de los casos sería más práctico ejecutar el script directamente como un comando independiente sin el auxilio del comando python.

En las secciones siguientes, aprenderás cómo preparar tus scripts Python para ejecución directa desde la terminal de tu sistema operativo.

En sistemas Unix

En sistemas Unix, como macOS y Linux, es posible ejecutar un script directamente desde la línea de comandos con unos pequeños arreglos. Primeramente, debes añadir un comentario especial a tu script justo en la primera línea:

Python - hello.py

#!/usr/bin/env python3

print('Hola, Mundo!')

Este comentario especial es conocido como shebang y lo puede incluir en tu código fuente para decirle al shell de tu sistema operativo dónde puede encontrar el intérprete requerido para ejecutar el código del archivo.

Para ejecutar un script Python que ya incluye el shebang apropiado, debes también asignarle permisos de ejecución con el siguiente comando:

Terminal

$ chmod +x hello.py

Con este comando, le asignas permisos de ejecución a tu script. Ahora estás listo para ejecutarlo directamente empleando el nombre del archivo en la terminal:

Terminal

$ ./hello.py
Hola, Mundo!

Listo! Tu script ahora funciona como si fuese un comando. Si deseas que tu script se parezca aún más a un comando estándar, puedes remover de su nombre la extensión .py. Adicionalmente, puedes añadir el directorio que contiene tu script en el PATH de tu sistema y lo tendrás disponible como un comando real desde cualquier directorio de trabajo.

En sistemas Windows

En sistemas Windows con Python instalado, puedes ejecutar un script directamente desde una ventana de PowerShell abierta en el directorio que contiene el script:

Powershell

PS> .\hello.py
Hola, Mundo!

Esta técnica funciona gracias a que Windows automáticamente asocia los archivos .py y .pyw con los programas python.exe y pythonw.exe, respectivamente.

Ejecutar scripts desde un IDE o editor de texto

Otra vía que puedes emplear para ejecutar tus scripts Python es usar un IDE (Integrated Development Environment, por sus siglas en inglés) como PyCharm o un editor de código avanzado, como puede ser Visual Studio Code.

Existe una amplia variedad de estos programas, muchos de ellos disponibles para las distintas plataformas (Windows, Linux, macOS) y que además, se pueden descargar libremente desde Internet.

El IDE por defecto incluido en cualquier instalación estándar de Python es IDLE y lo puedes emplear para escribir, ejecutar, depurar y modificar tus scripts.

Resumiendo

Ya sabes cómo correr o ejecutar scripts Python por diferentes vías y en diferentes plataformas. Ahora puedes ejecutar tus scripts desde la línea de comandos o terminal de tu sistema, ya sea usando el comando python o usando el script directamente como un programa ejecutable. También aprendiste que los IDEs y editores de código generalmente incluyen opciones para la ejecución de tus scripts y programas.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

¿Cómo instalar Python en tu sistema operativo Windows?

2023-09-25T17:30:00+02:00

En esta guía, emplearás el instalador oficial para Windows que puedes descargar desde Python.org. También conocerás cómo instalar Python desde la tienda de aplicaciones Microsoft Store. Esta última opción es la recomendada por Microsoft, aunque el instalador oficial funciona perfectamente.

Para seguir esta guía de instalación de Python, es recomendable que tengas experiencia de trabajo en Windows. Es también importante que tengas experiencia de trabajo con la terminal del sistema, PowerShell.

Contenidos

Prerequisitos
Instalar Python en Windows usando el instalador oficial
Instalar Python desde Microsoft Store
Resumiendo

Prerequisitos

Para completar los pasos de esta guía de instalación de Python en Windows, necesitas una computadora con Windows 10 o superior y conexión a Internet. Además, puedes requerir privilegios administrativos en dependencia del tipo de instalación que decidas hacer.

Lo demás es seguir las instrucciones debajo, las cuales te guiarán en la instalación tanto usando el instalador oficial como el que está disponible en la tienda de aplicaciones de Microsoft.

Instalar Python en Windows usando el instalador oficial

En general, la manera recomendada para instalar Python en una computadora con Windows es emplear el instalador oficial que provee la Python Software Foundation (PSF) en el sitio web del lenguaje, Python.org. Los pasos para completar la instalación son los siguientes:

Descargar el instalador de Python para Windows desde la página de descargas.
Ejecutar el instalador y seguir las instrucciones en pantalla.
Verificar que la instalación se completó con éxito.
🐍

A continuación encontrarás una explicación detallada de estos pasos. Presta especial atención al paso número dos, pues de él depende el éxito de la instalación.

Paso 1: Descargar el instalador de Python para Windows

El primer paso para instalar Python en Windows es descargar el instalador desde la página oficial de descargas de Python.org:

Sitio oficial de Python

Una vez en esta página, selecciona la opción Downloads. Generalmente, cuando seleccionas esta opción, el sitio reconoce tu sistema operativo actual y te lleva directamente a la página de descargas correspondiente.

Deberás ver la siguiente página en tu pantalla:

Página de descargas de Python para Windows

Una vez en la página de descargas, es recomendable que descargues la versión más reciente de Python que aparecerá como la primera opción. De esta manera, tendrás acceso a las últimas novedades del lenguaje y estarás al día con las correcciones de errores y los parches de seguridad.

En esta guía, emplearás el instalador ejecutable (.exe) que puedes obtener haciendo clic en el botón amarillo.

Luego de estas consideraciones, haz clic en la versión de tu preferencia para comenzar la descarga del instalador de Python. Concluida la descarga, estás listo para el próximo paso.

Paso 2: Ejecutar el instalador de Python

Ejecuta el instalador de Python, ya sea desde tu carpeta de descargas o desde tu navegador de Internet. Al ejecutar el programa, aparecerá la ventana siguiente en tu pantalla:

Instalador de Python, ventana inicial

Es la ventana inicial del instalador de Python. Sí, está en inglés, pero no hay de qué preocuparse. Tómalo como una práctica necesaria. Además, es probable que en tu ordenador te aparezca en español.

En esta pantalla, inicia el instalador de Python 3.11.5 (64-bit) para Windows. Hay algo importante que debes hacer ahora y es seleccionar la opción Add python.exe to PATH:

Instalador de Python, ventana inicial - Añadir Python al path del sistema

Con esto, el instalador añadirá el ejecutable de Python al path (ruta) del sistema operativo. Así, podrás ejecutar el comando python directamente desde la terminal PowerShell y Windows sabrá donde encontrar el ejecutable.

Una vez hecha la selección, tienes dos opciones. Puedes hacer clic en:

Install Now (Instalar Ahora) para comenzar la instalación standard de Python
Customize installation (Personalizar instalación) para personalizar la instalación con opciones adicionales

En esta guía, seleccionarás la segunda opción, la cual te lleva a la segunda ventana del instalador, Optional Features (Características Opcionales), que luce así:

Instalador de Python, segunda ventana - Características Opcionales

En esta ventana, todas las opciones están seleccionadas por defecto, lo cual es recomendable. Sin embargo, si no tienes pensado emplear IDLE en tu proceso de aprendizaje y desarrollo, entonces puedes desmarcar esta opción. El resto de las opciones deberías mantenerlas seleccionadas para evitar futuros problemas.

IDLE es el entorno de desarrollo integrado (IDE) por defecto de Python. Este programa provee una interfaz gráfica para trabajo con el lenguaje y su intérprete. Como regla general, está incluido en el instalador oficial en todas sus versiones.

Una vez que hayas decidido las características opcionales que deseas, puedes hacer clic en el botón Next (Siguiente) para continuar. Te aparecerá la siguiente ventana:

Instalador de Python, tercera ventana - Opciones Avanzadas

En esta ventana, tienes unas cuantas opciones avanzadas:

Install for all users (Instalar para todos los usuarios): Recomendada si no eres el único usuario que usará Python en esta computadora. Requiere privilegios administrativos.
Associate files with Python (Asociar archivos con Python): Recomendada porque esta opción asocia los archivos Python con el lanzador y el editor de código.
Create shortcuts for installed applications (Crear accesos directos para las aplicaciones instaladas): Recomendada, pues crea accesos directos que te permitirán acceder a Python y sus aplicaciones de forma rápida.
Add Python to environment variables (Añadir Python a las variables de entorno): Recomendada porque habilita la ejecución directa de Python.
Precompile standard library (Precompilar la biblioteca estándar): No requerida. Esta opción precompila los archivos Python de la biblioteca estándar, lo cual puede demorar la instalación.
Download debugging symbols and Download debug binaries: Recomendadas cuando planeas crear extensiones en C o C++.

Para seguir esta guía, deberás seleccionar la primera opción:

Instalador de Python, tercera ventana - Selección de Opciones Avanzadas

Notarás que la opción de precompilar la instalación se selecciona automáticamente. Este comportamiento tiene el fin de optimizar el funcionamiento de Python cuando lo instalas para varios usuarios y estos pueden no tener acceso de escritura en el directorio destino, el cual también cambia automáticamente.

Luego, haz clic en el botón Install (Instalar) para comenzar la instalación de Python. Verás la siguiente ventana en tu pantalla:

Instalador de Python - Ventana de instalación

La instalación no debe tomar mucho tiempo. En cualquier caso, puedes recostarte y relajarte mientras el instalador hace su trabajo. Una vez concluido el proceso, aparecerá la ventana de instalación exitosa:

Instalador de Python - Ventana de resumen

Esta ventana es la confirmación de que ha concluido la instalación de Python en tu sistema operativo Windows. Es recomendable que visites el link a la página sobre cómo usar Python en Windows. Allí encontrarás información valiosa que puede servirte de mucho.

Paso 3: Verificar la instalación de Python

Una vez que hayas ejecutado los pasos anteriores, Python estará instalado en tu sistema operativo. Para confirmar que lo tienes, abre una ventana de PowerShell y ejecuta el comando siguiente:

Powershell

PS> python --version
Python 3.11.5

Este comando imprime la versión de Python que tienes instalada por defecto. Con esto has concluido la instalación de Python usando el instalador oficial para Windows. Ahora estás listo para escribir tu primer programa.

Instalar Python desde Microsoft Store

Para los usuarios que comienzan con Python en un sistema operativo Windows, Microsoft recomienda instalar la aplicación desde su tienda de aplicaciones. Si prefieres instalar Python de esta forma, entonces puedes seguir los pasos siguientes:

Ve al menú Inicio y escribe Microsoft Store.
Haz clic en el enlace para abrir la tienda.
Selecciona la barra de Búsqueda y escribe Python.
Selecciona qué versión de Python que te gustaría usar. Nuevamente, deberías usar la versión más reciente para que tengas disponibles las nuevas características del lenguaje.
Haz clic en Obtener (Get) para descargar e instalar la versión seleccionada.

Una vez ejecutados esto pasos, deberás tener Python instalado en tu sistema operativo. Nuevamente, para confirmar que la instalación fue exitosa, abre tu PowerShell y ejecutar el comando siguiente:

Powershell

PS> Python --version
Python 3.11.5

El instalador de Python disponible en la tienda de aplicaciones Microsoft Store también incluye pip, el gestor de paquetes por defecto de Python. Puedes confirmar que pip también está instalado ejecutando pip --version en tu sesión de PowerShell.

Resumiendo

Instalar Python en tu ordenador es el primer paso en tu empeño de aprender a programar con el lenguaje. Nuevamente, recuerda que los pasos a seguir para completar la instalación con el instalador oficial para Windows son los siguientes:

Descargar el instalador de Python para Windows desde la página de descargas.
Ejecutar el instalador y seguir las instrucciones en pantalla.
Verificar que la instalación se completó con éxito.
🐍

Luego de completados estos pasos, estás listo para comenzar a explorar las bondades de Python como lenguaje de programación.

¿Cómo instalar Python en tu sistema operativo macOS?

2023-08-29T19:00:00+02:00

Para instalar Python, emplearás el instalador oficial para macOS que puedes descargar desde Python.org. Es recomendable que tengas experiencia de trabajo en sistemas macOS para poder seguir esta guía de instalación de Python. Es especialmente importante tener conocimientos básicos sobre la terminal del sistema y cómo emplearla.

Contenidos

Prerequisitos
Instalar Python en macOS usando el instalador oficial
Paso 1: Descargar el instalador de Python para macOS
Paso 2: Ejecutar el instalador de Python
Paso 3: Verificar la instalación
Resumiendo

Prerequisitos

Para completar los pasos de esta guía de instalación de Python en macOS, necesitas una computadora con este sistema operativo. Además, requieres tener privilegios root y una conexión a Internet.

Lo demás es solo seguir las instrucciones más abajo!

Instalar Python en macOS usando el instalador oficial

La manera recomendada para instalar Python en una computadora Mac es emplear el instalador oficial que provee la Python Software Foundation (PSF) en el sitio web del lenguaje, Python.org. Los pasos para completar la instalación son los siguientes:

Descargar el instalador de Python para macOS desde la página de descargas.
Ejecutar el instalador y seguir las instrucciones en pantalla.
Verificar que la instalación se completó con éxito.
🐍

A continuación encontrarás una explicación detallada de estos pasos. Presta especial atención al paso número dos. De él dependerá el éxito de la instalación.

Paso 1: Descargar el instalador de Python para macOS

Lo primero que debes hacer es descargar el instalador de Python para macOS desde el sitio oficial del lenguaje, Python.org, que luce de la manera siguiente:

Sitio oficial de Python

Deberás ver la siguiente página en tu pantalla:

Página de descargas de Python para macOS

Una vez en la página de descargas, es recomendable que descargues la versión más reciente que aparecerá como la primera opción. De esta manera, tendrás acceso a las últimas novedades del lenguaje y estarás al día con las correcciones de errores y los parches de seguridad.

También puedes seleccionar una versión más antigua si lo deseas. Para esto, desplázate hacia abajo en la página de descargas e identifica la versión deseada.

En esta guía, emplearás el instalador universal (.pkg) de 64-bit para macOS 10.9 o superior. Este instalador provee la versión 3.11.5 de Python. Puedes descargarlo directamente haciendo clic en el botón amarillo.

Luego de estas consideraciones, haz clic en la versión de tu preferencia para comenzar la descarga del instalador de Python. Una vez concluida la descarga, estás listo para el próximo paso.

Paso 2: Ejecutar el instalador de Python

Ejecuta el instalador de Python ya sea desde tu carpeta de descargas, desde tu navegador, o desde el dock de tu escritorio macOS. Al ejecutar el programa, aparecerá la ventana siguiente en tu pantalla:

Instalador de Python, ventana inicial

En esta pantalla, Python 3.11.5 te da la bienvenida a su instalador. Se trata de la versión diseñada para macOS 10.9 o superior.

Puedes hacer clic en el botón Continue (Continuar) para proseguir con la instalación. Esta acción te lleva a la segunda ventana del instalador, Read Me, la cual luce de la manera siguiente:

Instalador de Python, segunda ventana: Readme

En esta ventana, encontrarás información importante sobre la instalación. Puedes leer todo el contenido si lo deseas. Una vez que concluyas la lectura, haz clic nuevamente en el botón Continue. Accederás a la tercera ventana del instalador:

Instalador de Python, tercera ventana: Licencia

Aquí encontrarás información sobre la licencia de software bajo la cual se distribuye Python. Nuevamente, puedes leerla si es un tema que te interesa. Para tu tranquilidad, la licencia de Python permite el uso del lenguaje tanto en aplicaciones de código abierto, como en proyectos comerciales.

Haz clic en el botón Continue y acepta los términos de la licencia para proseguir. La siguiente ventana te permitirá seleccionar el disco de tu Mac donde deseas instalar Python. Si tu Mac tiene la configuración de discos por defecto, entonces el disco destino será Macintosh HD:

Instalador de Python, cuarta ventana: Disco destino

Con la configuración de discos por defecto, no tienes que realizar ningún paso adicional. Solo haz clic nuevamente en el botón Continue del instalador.

La próxima ventana te permitirá seleccionar el tipo de instalación. Aquí tienes dos opciones:

Instalación estándar
Instalación personalizada

La ventana de instalación estándar luce como se muestra a continuación:

Instalador de Python, quinta ventana: Instalación estándar

Este tipo de instalación incluye todas las funcionalidades de Python para macOS. Por lo tanto, es la instalación recomendada si estás comenzando con Python.

Si deseas personalizar tu instalación, puedes seleccionar el botón Customize para acceder a la vista siguiente:

Instalador de Python, quinta ventana: Instalación personalizada

En esta ventana, puedes hacer clic en cada una de las opciones para obtener información adicional. Por ejemplo, si pinchas la opción GUI Applications, obtendrás la siguiente vista:

Instalador de Python, quinta ventana: Instalación personalizada, opciones

Si no tienes pensado emplear IDLE en tu proceso de aprendizaje y desarrollo, entonces puedes desmarcar esta opción. El resto de las opciones son recomendables para evitar futuros problemas, así que no deberías desmarcarlas.

Una vez que hayas personalizado tu instalación, puedes hacer clic en el botón Install para comenzar. Deberás introducir tu nombre de usuario y tu contraseña. Ten en cuenta que debes tener privilegios administrativos para concluir la instalación.

El proceso de instalación comenzará:

Instalador de Python, sexta ventana: Instalación

La instalación no debe tomar mucho tiempo. En cualquier caso, puedes recostarte y relajarte mientras el instalador de Python hace su trabajo. Una vez concluido el proceso, recibirás un resumen de la instalación:

Instalador de Python, séptima ventana: Resumen instalación

Esta ventana es la confirmación de que ha concluido la instalación de Python en tu sistema operativo macOS. Es importante que instales los certificados SSL para evitar problemas de conexión cuando emplees algunas de las herramientas de Python.

Para instalar los certificados, ve a la carpeta de aplicaciones de tu Mac, localiza la carpeta Python 3.11, haz clic derecho sobre el archivo Install Certificates.command y selecciona la opción Abrir con -> Terminal.app.

Paso 3: Verificar la instalación

Una vez que hayas ejecutados los pasos anteriores, Python estará instalado en tu sistema operativo. Para confirmar que lo tienes, abre una ventana de Terminal y ejecuta el comando siguiente:

Terminal

$ python --version 
Python 3.11.5

Este comando imprime la versión de Python que tienes instalada por defecto. Con esto has concluido la instalación de Python usando el instalador oficial para macOS. Ahora estás listo para escribir tu primer programa.

Resumiendo

Instalar Python en tu ordenador es el primer paso en tu empeño de aprender a programar con el lenguaje. Nuevamente, recuerda que los pasos a seguir para completar la instalación son los siguientes:

Descargar el instalador de Python para macOS desde la página de descargas.
Ejecutar el instalador y seguir las instrucciones en pantalla.
Verificar que la instalación se completó con éxito.
🐍

Luego de completados estos pasos, estás listo para comenzar a explorar las bondades de Python como lenguaje de programación.

Cómo escribir tu primer programa en Python: Hola, mundo!

2023-08-15T20:00:00+02:00

Aquí aprenderás:

Qué es Python y para qué puedes emplearlo
Cómo escribir el Hola, mundo! en Python

Para seguir esta guía, deberías tener conocimientos básicos de trabajo en la línea de comandos o terminal de tu sistema operativo actual.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Contenidos

¿Qué es Python?
¿Cómo escribes el Hola, mundo! en Python?
- Hola, mundo! desde una sesión interactiva
- Hola, mundo! desde un archivo .py
Resumiendo

¿Qué es Python?

Python es un lenguaje de programación de alto nivel. Su sintaxis es muy clara y legible. Sus construcciones sintácticas se asemejan mucho al idioma inglés. Estas, y otras características, han propiciado que Python se convierta en un lenguaje muy popular, llegando a convertirse en una herramienta imprescindible para muchos profesionales de distintas disciplinas e industrias.

He aquí cómo la documentación oficial define a Python:

Python es un lenguaje interpretado, interactivo y orientado a objetos. Incorpora módulos, excepciones, tipado dinámico, tipos de datos de muy alto nivel y clases. Python combina un poder destacado con una sintaxis muy clara. Tiene interfaces a muchas llamadas de sistema y bibliotecas, así como a varios sistemas de ventana, y es extensible en C o C++. También es usable como un lenguaje de extensión para aplicaciones que necesitan una interfaz programable. Por último, Python es portable: corre en muchas variantes de Unix, en Mac y en Windows 2000 y posteriores. (Fuente)

Como puedes ver, Python es un lenguaje de programación con mucho potencial. Puede que no sea apropiado para escribir un sistema operativo, pero puedes usarlo en casi todo lo demás. Las aplicaciones prácticas de Python incluyen las siguientes:

Desarrollo web
Desarrollo de aplicaciones de escritorio
Creación de herramientas de consola
Ciencia de datos
Desarrollo de juegos
Aprendizaje automático
Inteligencia artificial
DevOps y automatización
Sistemas embebidos
Robótica

Ten en cuenta que esta lista es solo una muestra de todo el amplio espectro de disciplinas donde Python se ha ganado un lugar importante.

¿Cómo escribes el `Hola, mundo!` en Python?

Ahora que sabes de qué va Python Scouts y principalmente qué es Python y dónde puedes emplearlo, es tiempo de escribir tu primer programa en el lenguaje. Como es tradición, el primer programa que se escribe cuando comienzas a aprender un lenguaje de programación es el Hola, mundo!.

Se trata de un programa muy elemental que muestra la frase Hola, mundo! en la pantalla de tu computadora.

Python ofrece dos modos básicos de trabajo. Puedes trabajar en modo:

Interactivo
Script

El modo interactivo consiste en ejecutar el intérprete Python desde tu línea de comandos o terminal usando el comando python. Este modo de trabajo es útil cuando deseas probar ideas y fragmentos de código de manera rápida.

Por otro lado, el modo script es cuando pones tu código en un archivo con extensión .py y corres este archivo en tu ordenador como un programa ejecutable.

En las secciones siguientes, aprenderás a crear tu Hola, mundo! usando Python en los dos modos de trabajo descritos.

`Hola, mundo!` desde una sesión interactiva

Para comenzar una sesión interactiva de Python, abre una ventana de línea de comandos o terminal en tu computadora. Los pasos para abrir una terminal variarán en dependencia de tu sistema operativo. En macOS y Linux, generalmente encontrarás una aplicación llamada Terminal. Si trabajas en Windows, entonces puedes usar algo como PowerShell.

Una vez que tengas tu terminal abierta, ejecuta el siguiente comando:

Terminal

$ python

Este comando inicia el intérprete Python. El intérprete es el programa que te permite interpretar y ejecutar código escrito en lenguaje Python.

En general, notarás que las personas usan el término Python para referirse tanto al lenguaje como al intérprete, pero debes saber que hay diferencias entre estos conceptos para que puedas identificar de qué se está hablando en cada contexto.

Una vez que ejecutes el comando anterior, verás en pantalla un mensaje de presentación de tu versión actual de Python e inmediatamente te aparecerá el indicador (prompt) primario del intérprete. Este indicador consiste en tres signos de mayor que, >>>.

Ahora escribe el siguiente código y presiona Enter al final:

Python REPL

>>> print("Hola, mundo!")
Hola, mundo!

Al presionar Enter, Python ejecuta el código que has introducido e inmediatamente imprime Hola, mundo! en la siguiente línea. Y eso es todo! Ya escribiste tu Hola, mundo! en Python.

Hay dos cosas fundamentales que debes saber sobre esta línea de código. Primeramente, se trata de una llamada a la función integrada (built-in) print(). Como su nombre sugiere, esta función te permite imprimir texto en la salida estándar de tu computadora. Esta salida es tu pantalla por defecto.

Como argumento a la función print(), empleas la frase o mensaje que deseas imprimir en pantalla. En este caso, el habitual saludo Hola, mundo! Y con eso ya escribiste tu primer programa Python.

`Hola, mundo!` desde un archivo `.py`

Para escribir tu programa Hola, mundo! y ejecutarlo desde un archivo Python, abre tu editor de código preferido y crea un nuevo archivo llamado hello_world.py en tu carpeta de trabajo. Luego añade el mismo código de la sección anterior y salva los cambios:

Python - hello_world.py

print("Hola, mundo!")

Una vez que hayas creado tu archivo hello_world.py y añadido el código necesario, puedes abrir una nueva terminal y ejecutar el siguiente comando:

Terminal

$ python hello_world.py
Hola, mundo!

En este caso, el intérprete Python corre en modo script usando tu archivo hello_world.py como entrada. El intérprete lee tu código y lo ejecuta línea por línea produciendo la salida deseada.

Resumiendo

Has aprendido a escribir tu primer programa, el Hola, mundo! usando Python. Los pasos necesarios para escribir y ejecutar este programa se resumen en:

Crea un archivo Python (hello_world.py) en tu editor de código favorito
Añade la línea de código print("Hola, mundo!") y salva los cambios
Abre una ventana de línea de comandos o terminal en tu carpeta de trabajo
Ejecuta el comando python hello_world.py para correr el programa

Una vez que hayas ejecutado estos pasos, verás la frase Hola, mundo! en la pantalla de tu ordenador. Eso es todo! Ya has escrito tu primer programa en Python! Más importante aún, has aprendido a ejecutar código Python. Estos conocimientos te servirán de base en tu empeño de aprender el lenguaje.

Puedes encontrar el código Python de este artículo en el repositorio de ejemplos de Python Scouts. ¡Te agradeceríamos mucho si nos dejas una estrella (⭐) en el repositorio!

Python Scouts

Estructuras de datos en Python: Colas (queues)

¿Qué es una cola o queue?

Operaciones comunes en una cola

Implementación de una cola en Python

Ejemplo de uso de la cola

Inicialización

Encolar y desencolar elementos

Consultar el frente

Eliminar un elemento específico

Longitud y pertenencia

Iteración

Conclusión

Estructuras de datos en Python: Pilas (stacks)

¿Qué es una pila o stack?

Operaciones comunes en una pila

Implementación de una pila en Python

Ejemplo de uso de la pila

Inicialización

Empujar y extraer elementos

Consultar la cima

Longitud y pertenencia

Iteración

Conclusión

Palabras clave en Python: case

Sintaxis

Ejemplos prácticos

Uso de case

Resumiendo

Palabras clave en Python: match

Sintaxis

Ejemplos prácticos

Uso de match

Resumiendo

Palabras clave en Python: type

Sintaxis

Ejemplos prácticos

Uso de type

Resumiendo

Python a través de ejemplos: Ciclos o bucles while

Conociendo los ciclos while

Iterando con ciclos while en Python

Acumulando con un ciclo while

Procesando datos de entrada del usuario

Recorriendo colecciones con un ciclo while

Controlando la iteración con break y continue

Implementando ciclos infinitos con while True

Usando la cláusula else en ciclos while

Usando ciclos while anidados

Conclusiones

Palabras clave en Python: await

Sintaxis

Ejemplos prácticos

Uso de await

Resumiendo

Palabras clave en Python: async

Sintaxis

Ejemplos prácticos

Uso de async

Resumiendo

Palabras clave en Python: nonlocal

Sintaxis

Ejemplos prácticos

Uso de nonlocal

Resumiendo

Palabras clave en Python: global

Sintaxis

Ejemplos prácticos

Uso de global

Resumiendo

Palabras clave en Python: finally

Sintaxis

Ejemplos prácticos

Uso de finally

Resumiendo

Palabras clave en Python: except

Sintaxis

Ejemplos prácticos

Uso de except

Resumiendo

Uso de `case`

Uso de `match`

Uso de `type`

Conociendo los ciclos `while`

Iterando con ciclos `while` en Python

Acumulando con un ciclo `while`

Recorriendo colecciones con un ciclo `while`

Controlando la iteración con `break` y `continue`

Implementando ciclos infinitos con `while True`

Usando la cláusula `else` en ciclos `while`

Usando ciclos `while` anidados

Uso de `await`

Uso de `async`

Uso de `nonlocal`

Uso de `global`

Uso de `finally`

Uso de `except`

Uso de `is`

Uso de `try`

Uso de `in`

Uso de `not`

Uso de `yield`

Uso de `from`

Uso de `or`

Uso de `raise`

Uso de `elif`