Aprender Python

Bienvenido a Python

Python es un lenguaje de programación versátil y de alto nivel conocido por su legibilidad y amplio apoyo de la comunidad. Desarrollado a principios de la década de 1990, enfatiza la sintaxis clara y concisa, lo que lo convierte en una excelente opción tanto para principiantes como para profesionales. La extensa biblioteca estándar de Python y su próspero ecosistema de paquetes de terceros permiten su uso en muchos campos, desde desarrollo web y análisis de datos hasta inteligencia artificial y computación científica. Su facilidad de aprendizaje, junto con sus poderosas capacidades, hacen de Python una habilidad valiosa para cualquiera que busque sumergirse en la programación o avanzar en su carrera tecnológica.

Introducción a Python

Cómo instalar Python y escribir tu primer "¡Hola, mundo!" programa.

Python es uno de los lenguajes de programación más populares debido a su simplicidad y versatilidad. Ya seas un codificador principiante o experimentado, instalar Python y ejecutar tu primer script es un proceso sencillo.

Paso 1: descargar e instalar Python

1. Visite el sitio web oficial
   Vaya a Python.org y descargue la última versión estable de Python para su sistema operativo (Windows, macOS o Linux).

2. Ejecute el instalador

• Para Windows: haga doble clic en el archivo .exe descargado y marque "Agregar Python a la RUTA" antes de hacer clic en "Instalar". Ahora".

• Para Mac: descargue el instalador de macOS y siga las instrucciones de configuración.

• Para Linux: use el administrador de paquetes (por ejemplo, para Ubuntu).

  shCopy
  sudo apt install python3
  

3. Verificar la instalación
   Abra una terminal o símbolo del sistema y escriba:

shCopy
python --version

o

shCopy
python3 --version

Esto debería mostrar la versión de Python instalada.

Paso 2: Elija un IDE o editor de código

Python viene con IDLE, un entorno de desarrollo integrado (IDE) integrado, que es ideal para principiantes. Sin embargo, los usuarios más avanzados suelen preferir editores como:

• Código VS – Ligero y potente, con extensiones de Python.

• PyCharm – IDE rico en funciones para desarrolladores profesionales.

• Jupyter Notebook: lo mejor para ciencia de datos y codificación interactiva.

Para principiantes, iniciar IDLE (instalado con Python) es la forma más sencilla de comenzar a codificar.

Paso 3: escriba y ejecute su primer script de Python

1. Usando IDLE:

   • Abrir IDLE.

   • Haga clic en Archivo → Nuevo archivo.

   Escriba el siguiente código:

   pythonCopy
   print("Hello, World!")
   

   • Guarde el archivo con una extensión .py (por ejemplo, hello.py).

   • Ejecútelo seleccionando Ejecutar → Ejecutar módulo o presionando F5.

2. Usando la línea de comando:

   • Abra una terminal o símbolo del sistema.

   • Navega a la carpeta donde guardaste hello.py.

   • Ejecute el script escribiendo:

   python hola.py
   

   • Deberías ver el resultado:

   ¡Hola mundo!
   

¡Felicitaciones! Ha instalado Python con éxito y ha ejecutado su primer script. 🎉

Para más detalles, visite la documentación oficial de Python en docs.python.org. ¡Feliz codificación! 🚀

Sintaxis de Python

1. Sangría de Python (sin llaves para bloques)

Python usa indentation (espacios en blanco) para definir bloques de código en lugar de llaves {} como en otros lenguajes. Esto hace que el código Python sea más legible pero también significa que una sangría incorrecta provocará errores.

Ejemplo correcto:

pythonCopy
if 5 > 3:
    print("Five is greater than three")  # Proper indentation

Ejemplo incorrecto (genera error de sangría):

pythonCopy
if 5 > 3:
print("This will cause an error!")  # No indentation

Python aplica la sangría para mejorar la estructura y la legibilidad del código. La sangría recomendada es 4 espacios por nivel.

2. Indexación de base cero

Python sigue indexación basada en cero, lo que significa que el primer elemento de una secuencia (como una lista, cadena o tupla) comienza en index 0, no 1.

Ejemplo:

pythonCopy
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # Outputs: apple
print(fruits[2])  # Outputs: cherry

Ejemplo incorrecto (IndexError):

pythonCopy
print(fruits[3])  # IndexError: list index out of range

Dado que Python comienza a contar desde 0, intentar acceder a un índice que es igual o mayor que la longitud de la secuencia genera un error.

3. Comentarios en Python

Los comentarios ayudan a los desarrolladores a comprender el código agregando explicaciones. Python admite comentarios de una sola línea y de varias líneas.

Comentario de una sola línea:

pythonCopy
# This is a single-line comment
print("Hello, World!")  # Inline comment

Comentario de varias líneas:

pythonCopy
"""
This is a multi-line comment.
It is often used for documentation.
"""
print("Hello, World!")

Aunque las comillas triples se pueden utilizar para comentarios de varias líneas, están destinadas principalmente a docstrings, que son comentarios especiales colocados dentro de funciones de documentación.

4. Sensibilidad a mayúsculas y minúsculas

Python distingue entre mayúsculas y minúsculas, lo que significa que trata las letras mayúsculas y minúsculas de manera diferente. Los nombres de variables, nombres de funciones y palabras clave se deben utilizar de forma coherente.

Ejemplo:

pythonCopy
myVar = 5
MyVar = 10

print(myVar)  # Outputs: 5
print(MyVar)  # Outputs: 10 (different variable)

Aquí, myVar y MyVar se consideran dos variables diferentes debido a su capitalización.

Ejemplo incorrecto:

pythonCopy
Print("Hello")  # NameError: name 'Print' is not defined

Las funciones integradas de Python como print() deben escribirse en minúsculas.

5. Variables y escritura dinámica

Python está tipificado dinámicamente, lo que significa que no es necesario declarar explícitamente el tipo de una variable. El tipo se determina automáticamente en función del valor asignado.

Ejemplo:

pythonCopy
x = 10       # Integer
y = 3.14     # Float
z = "Hello"  # String

print(type(x))  # Outputs: <class 'int'>
print(type(y))  # Outputs: <class 'float'>
print(type(z))  # Outputs: <class 'str'>

Reasignación de diferentes tipos de datos:

pythonCopy
a = 5        # Initially an integer
a = "Python" # Now reassigned as a string
print(a)     # Outputs: Python

Dado que Python permite la escritura dinámica, el tipo de una variable puede cambiar durante la ejecución.

Conclusión

Comprender la sintaxis básica de Python es esencial para escribir código limpio y eficiente. Las conclusiones clave incluyen:

• Python aplica indentación en lugar de llaves para los bloques de código.

• Indexación basada en cero significa que el primer elemento de una secuencia está en el índice 0.

• Comentarios mejoran la legibilidad del código y pueden ser de una sola línea (#) o multilínea (""" """).

• Python distingue entre mayúsculas y minúsculas, por lo que Var y var se tratan como diferentes variables.

• Python admite tipificación dinámica, lo que permite que las variables cambien de tipo.

Dominar estos conceptos básicos proporcionará una base sólida para aprender conceptos más avanzados de Python. ¡Feliz codificación! 🚀

imprimir

La función print() en Python se utiliza para mostrar la salida en la pantalla. Es una de las funciones más utilizadas, especialmente para la depuración y la interacción del usuario. En esta breve guía, exploraremos diferentes formas de usar print() de manera efectiva, incluido cómo imprimir múltiples valores, formatear la salida y controlar los separadores y caracteres finales.

1. Básico print() Uso

La forma más sencilla de utilizar print() es pasar una cadena o un número dentro del paréntesis:

pythonCopy
print("Hello, World!")  # Outputs: Hello, World!
print(42)               # Outputs: 42

Puedes imprimir múltiples valores separándolos con una coma ,:

pythonCopy
print("Hello", "Python")  # Outputs: Hello Python

De forma predeterminada, Python inserta un espacio entre los valores.

2. Usando el sep Parámetro

El parámetro sep controla el separador entre múltiples valores en print(). Por defecto, es un espacio, pero puedes cambiarlo por cualquier otra cosa:

pythonCopy
print("apple", "banana", "cherry", sep=", ")  
# Outputs: apple, banana, cherry

pythonCopy
print("Python", "is", "fun", sep="-")  
# Outputs: Python-is-fun
```<h2><span style="font-family: Roboto;">3. Usando el parámetro <code inline="">end</code></span></h2>
<p><span style="font-family: Roboto;">De forma predeterminada, <code inline="">print()</code> agrega una nueva línea (<code inline="">\n</code>) al final de la salida. Puede cambiar este comportamiento utilizando el parámetro <code inline="">end</code>:</span></p>


```python
print("Hello", end=" ")
print("World!")  
# Outputs: Hello World! (on the same line)

Aquí, end=" " reemplaza la nueva línea predeterminada con un espacio.

4. Variables de impresión

Puedes imprimir variables como cadenas literales:

pythonCopy
name = "Alice"
age = 25
print("Name:", name, "Age:", age)  
# Outputs: Name: Alice Age: 25

Como alternativa, puede utilizar f-strings para obtener una salida más limpia:

pythonCopy
print(f"Name: {name}, Age: {age}")  
# Outputs: Name: Alice, Age: 25

5. Impresión de caracteres especiales

Utilice secuencias de escape para formatear la salida:

pythonCopy
print("Hello\nWorld!")  # \n adds a new line
print("This is a tab:\tPython")  # \t adds a tab space
```<hr />
<h2><span style="font-family: Roboto;">Conclusión</span></h2>
<p><span style="font-family: Roboto;">La función <code inline="">print()</code> es una poderosa herramienta en Python que le permite mostrar la salida de varias maneras. Conclusiones clave:</span></p>
<ul>
<li>
<p><span style="font-family: Roboto;">Utilice <code inline="">print(valor1, valor2,…)</code> para imprimir múltiples valores.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Cambie el separador usando <code inline="">sep="custom_separator"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Control de finales de línea con <code inline="">end="custom_end"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Utilice <code inline="">f-strings</code> para un mejor formato.</span></p>
</li>
</ul>
<p><span style="font-family: Roboto;">Dominar <code inline="">print()</code> hará que la depuración y el manejo de resultados en Python sean mucho más fáciles.</span></p>

Operaciones binarias en Python

1. Operadores aritméticos

Los operadores aritméticos realizan cálculos matemáticos entre dos operandos. Python admite suma, resta, multiplicación, división, módulo, división mínima y exponenciación.

Ejemplos:

pythonCopy
a = 15
b = 4

print(a + b)   # 19 (addition)
print(a - b)   # 11 (subtraction)
print(a * b)   # 60 (multiplication)
print(a / b)   # 3.75 (true division)
print(a // b)  # 3 (floor division)
print(a % b)   # 3 (modulus)
print(a ** b)  # 50625 (exponentiation)

Los operadores aritméticos siempre devuelven un nuevo valor sin cambiar las variables originales.

2. Operadores de comparación

Los operadores de comparación comparan dos valores y devuelven un resultado booleano (True o False). Estos incluyen igualdad, desigualdad, mayor/menor que y sus combinaciones.

Ejemplos:

pythonCopy
x = 7
y = 10

print(x == y)   # False (equal to)
print(x != y)   # True (not equal to)
print(x > y)    # False
print(x < y)    # True
print(x >= 7)   # True
print(y <= 7)   # False

Los resultados de la comparación se utilizan a menudo dentro de if declaraciones o bucles para controlar el flujo del programa.

3. Operadores lógicos

Los operadores lógicos combinan valores booleanos y devuelven True o False. Los tres operadores son y, or y not (unario).

Ejemplos:

pythonCopy
is_sunny = True
is_warm = False

print(is_sunny and is_warm)   # False (both must be True)
print(is_sunny or is_warm)    # True  (at least one is True)
print(not is_warm)            # True  (negates the value)

Los operadores lógicos se utilizan con frecuencia en condiciones, p. comprobar varios requisitos a la vez.

4. Operadores bit a bit

Los operadores bit a bit actúan sobre las representaciones binarias de números enteros. Incluyen & (Y), | (O), ^ (XOR), << (desplazamiento a la izquierda) y >> (desplazamiento a la derecha).

Ejemplos:

pythonCopy
a = 6   # binary: 110
b = 3   # binary: 011

print(a & b)   # 2 (binary 010)
print(a | b)   # 7 (binary 111)
print(a ^ b)   # 5 (binary 101)
print(a << 1)  # 12 (binary 1100, shifted left by 1)
print(b >> 1)  # 1 (binary 001, shifted right by 1)

Las operaciones bit a bit se utilizan a menudo en programación de bajo nivel, criptografía u optimización del rendimiento.

5. Operadores de asignación

Los operadores de asignación asignan valores a las variables. También pueden combinar la asignación con operaciones aritméticas o bit a bit.

Ejemplos:

pythonCopy
x = 10   # simple assignment
x += 5   # equivalent to x = x + 5 → 15
x -= 3   # equivalent to x = x - 3 → 12
x *= 2   # equivalent to x = x * 2 → 24
x //= 4  # equivalent to x = x // 4 → 6
x %= 4   # equivalent to x = x % 4 → 2
x **= 3  # equivalent to x = x ** 3 → 8

Los operadores de asignación son una forma abreviada de actualizar una variable en su lugar, lo que hace que el código sea más conciso.

Enteros

Los números enteros son números enteros, ya sean positivos, negativos o cero. Son uno de los tipos numéricos básicos de Python y se utilizan para operaciones matemáticas.

1. Creando números enteros

Se pueden crear números enteros asignando valores enteros a las variables:

pythonCopy
a = 10
b = -5
c = 0
print(a, b, c)

2. Operaciones con números enteros

Los números enteros admiten varias operaciones aritméticas:

pythonCopy
print(5 + 3)   # Addition
print(5 - 3)   # Subtraction
print(5 * 3)   # Multiplication
print(5 / 3)   # Division (returns float)
print(5 // 3)  # Floor division
print(5 % 3)   # Modulus

3. Conversión de tipo

Conversión de otros tipos a números enteros:

pythonCopy
num = int("123")
print(num)  # Outputs: 123

num = int(3.1415)
print(num)  # Outputs: 3

Flotadores

Los flotantes representan números reales que pueden tener partes fraccionarias. Son otro tipo numérico básico en Python y son esenciales para los cálculos decimales.

1. Creando flotantes

Los flotantes se pueden crear asignando valores decimales a las variables:

pythonCopy
a = 3.1415
b = -0.5
c = 100.0
print(a, b, c)

2. Operaciones flotantes

Los flotadores admiten varias operaciones aritméticas:

pythonCopy
print(2.5 + 1.5)  # Addition
print(5.0 / 2)    # Division
print(3.1415 ** 2) # Exponentiation
print(7.3 % 3)    # Modulus

3. Conversión de tipo

Conversión de otros tipos a flotantes:

pythonCopy
num = float("123.45")
print(num)  # Outputs: 123.45

num = float(3)
print(num)  # Outputs: 3.0

num = float(5.5)
print(num)  # Outputs: 5.5

Cadenas

Las cadenas son secuencias de caracteres utilizados para representar texto. Son inmutables y se pueden definir mediante comillas simples, dobles o triples para cadenas de varias líneas.

1. Creando cadenas

Se pueden crear cadenas usando diferentes tipos de comillas:

pythonCopy
a = 'Hello, World!'
b = "Python is great"
c = """This is a
multi-line string"""
print(a, b, c, sep='\n')

2. Operaciones de cadena

Las cadenas admiten varias operaciones como concatenación y repetición:

pythonCopy
print("Hello" + " World")  # Concatenation
print("Hello" * 3)        # Repetition
print("Hello"[0])        # Accessing characters
print("Hello"[1:3])      # Slicing

3. Métodos de cadena

Las cadenas tienen varios métodos integrados para su manipulación:

pythonCopy
text = "hello world"
print(text.upper())      # Outputs: HELLO WORLD
print(text.lower())      # Outputs: hello world
print(text.replace("world", "earth"))  # Outputs: hello earth

Funciones de cadena

Las cadenas tienen muchos métodos útiles para recortar, dividir y reemplazar texto.

Recortar con .strip()

pythonCopy
text = "   hello world   "
print(text.strip())   # "hello world"
print(text.lstrip())  # "hello world   "
print(text.rstrip())  # "   hello world"

División de cadenas

pythonCopy
line = "apple,banana,cherry"
print(line.split(","))   # ['apple', 'banana', 'cherry']

words = "one two three".split()
print(words)             # ['one', 'two', 'three']

Reemplazar texto

pythonCopy
sentence = "I like cats"
print(sentence.replace("cats", "dogs"))
# "I like dogs"

Unir cadenas

pythonCopy
parts = ["2025", "09", "26"]
date = "-".join(parts)
print(date)   # "2025-09-26"

Errores comunes

• .strip() elimina los espacios en blanco de forma predeterminada, pero puedes pasar caracteres: "hello!!".strip("!").
• .split() sin argumentos se divide en cualquier espacio en blanco, no solo espacios.
• .replace() reemplaza todas las ocurrencias, a menos que pase un tercer argumento (recuento máximo).
• .join() requiere que todos los elementos sean cadenas (no números).

Formato de cadenas y métodos de mayúsculas y minúsculas

Python ofrece varios métodos para formatear cadenas y ajustar mayúsculas y minúsculas. Esto ayuda a crear resultados dinámicos y controlar la apariencia del texto.

Formateando con .format()

pythonCopy
# Insert values into placeholders {}
template = "The sum of {0} and {1} is {2}"
msg = template.format(2, 4, 2+4)
print(msg)   # The sum of 2 and 4 is 6

# Named placeholders
info = "Name: {name}, Age: {age}".format(name="Alice", age=30)
print(info)

Conversión de caso

pythonCopy
text = "Hello World"
print(text.upper())   # "HELLO WORLD"
print(text.lower())   # "hello world"

Partición de cadenas

pythonCopy
line = "user:password"
print(line.partition(":"))
# ('user', ':', 'password')

.partition() se divide en una tupla de 3 partes: texto anterior, el propio separador y texto posterior.

Errores comunes

• El uso de .format() con claves faltantes o incorrectas genera KeyError o IndexError.
• .upper() / .lower() crean una nueva cadena, no modifican la original.
• .partition() solo se divide en la primera aparición del separador.

Listas

Las listas son secuencias versátiles y mutables que se utilizan para almacenar colecciones de elementos. Se definen entre corchetes [] y admiten una variedad de operaciones de modificación y acceso.

1. Creando una lista

Definir una lista con varios elementos:

pythonCopy
my_list = [1, 2, 3, "Python", True]
print(my_list)

2. Acceso y modificación de listas

Las listas admiten indexación, división y métodos para modificar su contenido:

pythonCopy
# Accessing an element
print(my_list[3])  # Outputs: Python

# Changing an element
my_list[1] = "changed"
print(my_list)

# Appending a new element
my_list.append("new item")
print(my_list)

3. Lista de comprensiones

Las listas por comprensión proporcionan una forma concisa de crear listas iterando sobre secuencias y, opcionalmente, aplicando condiciones:

pythonCopy
# Creating a list of squares for numbers 0 to 9
squares = [x**2 for x in range(10)]
print(squares)

Listas de indexación

En Python, las listas son colecciones ordenadas y puede acceder a los elementos utilizando su index. La indexación comienza en 0 para el primer elemento. Los índices negativos cuentan desde el final de la lista, siendo -1 el último elemento.

Indización básica

pythonCopy
fruits = ["apple", "banana", "cherry"]
print(fruits[0])   # Outputs: apple
print(fruits[-1])  # Outputs: cherry

Modificación de elementos mediante índice

pythonCopy
numbers = [10, 20, 30]
numbers[1] = 25
print(numbers)  # Outputs: [10, 25, 30]

Errores comunes

• IndexError: Accediendo a un índice fuera del rango de la lista.
• Mutable vs Inmutable: Solo las listas mutables se pueden modificar mediante indexación; las tuplas no admiten la asignación.

Listas de corte

Slicing le permite extraer una parte de una lista usando la sintaxis list[start:stop:step]. El índice start es inclusivo, stop es exclusivo y step define el intervalo.

Rebanado básico

pythonCopy
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])    # Outputs: [1, 2, 3]
print(numbers[:3])     # Outputs: [0, 1, 2]
print(numbers[3:])     # Outputs: [3, 4, 5]
print(numbers[::2])    # Outputs: [0, 2, 4] - every 2nd element

Invertir una lista

pythonCopy
print(numbers[::-1])  # Outputs: [5, 4, 3, 2, 1, 0]

Errores comunes

• El índice de parada es exclusivo; list[start:stop] no incluye el elemento en stop.
• Los índices negativos pueden ser complicados; asegúrese de que se utilicen correctamente con la longitud de la lista.
• Slicing devuelve una nueva lista; no modifica el original a menos que se le vuelva a asignar.

Funciones y métodos específicos de la lista

Python proporciona muchas funciones y métodos integrados específicamente para que las listas manipulen, consulten y transformen datos de manera eficiente.

Métodos comunes

pythonCopy
fruits = ["apple", "banana", "cherry"]
fruits.append("date")      # Add element at the end
fruits.insert(1, "blueberry")  # Insert at index 1
fruits.remove("banana")    # Remove element by value
popped = fruits.pop()      # Remove and return last element
print(fruits, popped)

Otros métodos útiles

pythonCopy
numbers = [3, 1, 4, 2]
numbers.sort()     # Sorts in ascending order
numbers.reverse()  # Reverses the list
print(numbers)

Funciones integradas para listas

pythonCopy
nums = [1, 2, 3, 4]
print(len(nums))   # Number of elements
print(sum(nums))   # Sum of elements
print(max(nums))   # Maximum value
print(min(nums))   # Minimum value

Trabajar con varias listas

pythonCopy
# enumerate() gives index + value when looping
animals = ["cat", "dog", "mouse"]
for index, animal in enumerate(animals):
    print(index, animal)

# zip() pairs elements from multiple lists
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(name, "scored", score)

enumerate() es útil cuando necesita tanto la posición como el valor de un elemento de lista. zip() es útil cuando se combinan dos o más listas elemento por elemento.

Errores comunes

• Métodos como sort() y reverse() modifican la lista en su lugar y devuelven None.
• Eliminar elementos que no existen genera ValueError.
• Tenga cuidado con pop() en listas vacías; genera IndexError.
• zip() se detiene en la longitud de lista más corta.

Tuplas

Las tuplas son secuencias inmutables que se utilizan para almacenar una colección de elementos. Se definen entre paréntesis () y son útiles cuando desea garantizar la integridad de los datos.

1. Creando una tupla

Una tupla simple que contiene diferentes tipos de datos:

pythonCopy
my_tuple = (10, "hello", 3.14)
print(my_tuple)

2. Accediendo a elementos de tupla

Acceda a los elementos por su índice, similar a las listas:

pythonCopy
# Accessing the first element
print(my_tuple[0])  # Outputs: 10

# Slicing the tuple
print(my_tuple[1:])  # Outputs: ('hello', 3.14)

Dado que las tuplas son inmutables, sus valores no se pueden cambiar después de su creación.

Diccionarios

Los diccionarios almacenan datos en pares clave-valor, lo que hace que la búsqueda de datos sea eficiente. Se crean usando llaves {} y se puede acceder a ellos mediante sus claves.

1. Crear un diccionario

Un diccionario básico que asigna frutas a sus colores:

pythonCopy
fruit_colors = {
    "apple": "red",
    "banana": "yellow",
    "cherry": "red"
}

2. Acceso y modificación de datos

Acceda a un valor usando su clave, agregue un nuevo par clave-valor o actualice uno existente:

pythonCopy
# Accessing a value
print(fruit_colors["apple"])  # Outputs: red

# Adding a new entry
fruit_colors["orange"] = "orange"

# Updating an entry
fruit_colors["banana"] = "green"

Recorrer claves y valores usando el método items():

pythonCopy
for fruit, color in fruit_colors.items():
    print(f"{fruit} is {color}")

Funciones del diccionario

Diccionarios (dict) almacenan datos como pares clave-valor. Python proporciona métodos como .keys() y .values() para acceder a las claves y valores por separado.

Claves de acceso

pythonCopy
person = {"name": "Alice", "age": 25, "city": "Zurich"}

print(person.keys())   # dict_keys(['name', 'age', 'city'])

# Loop through keys
for key in person.keys():
    print("Key:", key)

Acceso a valores

pythonCopy
print(person.values())  # dict_values(['Alice', 25, 'Zurich'])

# Loop through values
for value in person.values():
    print("Value:", value)

Usar claves y valores juntos

pythonCopy
# Often combined with a for-loop
for key in person.keys():
    print(key, "->", person[key])

Errores comunes

• .keys() y .values() devuelven vistas especiales, no listas normales. Si necesita una lista, envuélvala con list().
• Los diccionarios están desordenados antes de Python 3.7. En Python moderno, mantienen el orden de inserción.

Variables

Las variables se utilizan para almacenar datos en Python. Actúan como contenedores con nombre para valores de diferentes tipos (números, cadenas, etc.). Las variables de Python deben seguir ciertas reglas de nomenclatura:

• El nombre de una variable debe comenzar con una letra o un guión bajo (_).
• El nombre de una variable no puede comenzar con un número.
• Una variable no puede usar palabras clave reservadas de Python (consulte el módulo keyword).

1. Creando variables

En Python, las variables se crean automáticamente cuando les asignas un valor usando el operador de asignación =. No se necesita ninguna declaración explícita.

pythonCopy
a = 10
b = "Hello"
c = 3.14
print(a, b, c)   # Outputs: 10 Hello 3.14

2. Asignación de múltiples variables

En los casos de modificar dos o más variables a la vez y utilizar ciertos valores para cálculos en curso, es útil cambiarlo simultáneamente.

pythonCopy
a, b = 4, 5
print(a)   # Outputs: 4
print(b)   # Outputs: 5
```<h2><span style="font-family: Roboto;">3. Uso de entradas para crear variables</span></h2>
<p><span style="font-family: Roboto;">
Las variables también se pueden crear a partir de la entrada del usuario usando la función <code>input()</code>. 
De forma predeterminada, <code>input()</code> devuelve una cadena, pero puedes convertirla a otros tipos si es necesario.
</span></p>


```python
name = input("Enter your name: ")
age = int(input("Enter your age: "))  # type conversion to integer
print("Hello", name, "you are", age, "years old.")

4. Conversión de tipo

A veces es posible que necesite realizar conversiones entre tipos de datos (por ejemplo, de cadena a entero). Las funciones comunes incluyen int(), float() y str().

pythonCopy
num_str = "123"
num = int(num_str)   # convert string to integer
print(num, type(num))  # Outputs: 123 <class 'int'>

pi = 3.1415
print(str(pi))        # convert float to string → "3.1415"

5. Operadores y variables

Las variables se pueden utilizar junto con arithmetic, comparación, y otros operadores de asignación. Consulte las secciones dedicadas a operadores para obtener detalles y ejemplos.

Condicionales: if, elif y else

Las declaraciones condicionales en Python le permiten ejecutar bloques de código en función de si una condición es Verdadera o Falsa. La estructura básica usa if, seguido opcionalmente de elif (si no) y else como respaldo.

1. Declaración if básica

Utilice la instrucción if para ejecutar código solo cuando se cumpla una condición:

pythonCopy
x = 10
if x > 5:
    print("x is greater than 5")  
    # Outputs: x is greater than 5

2. Declaración if-else

Incluye un bloque else para ejecutar código cuando no se cumple la condición:

pythonCopy
x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")  
    # Outputs: x is not greater than 5

3. if-elif-else Cadena

Para múltiples condiciones, use elif para verificar condiciones adicionales:

pythonCopy
x = 5
if x > 5:
    print("x is greater than 5")
elif x == 5:
    print("x is exactly 5")
else:
    print("x is less than 5")
    # Outputs: x is exactly 5

Estas construcciones le permiten crear estructuras sólidas de toma de decisiones en sus programas Python.

para-bucle (Conceptos básicos)

Un bucle for en Python repite el código para cada elemento de una secuencia (como una lista, cadena o rango de números). A diferencia de while, el número de repeticiones normalmente se conoce de antemano.

Contando con range()

pythonCopy
for i in range(5):
    print("Number:", i)
# Prints 0, 1, 2, 3, 4

range(5) genera números desde 0 hasta (pero sin incluir) 5.

Recorrer una lista

pythonCopy
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print("I like", fruit)

El bucle visita cada elemento de la lista uno por uno.

Recorriendo una cadena

pythonCopy
word = "hi!"
for char in word:
    print(char)
# Prints h, i, !

Usando break y continue

pythonCopy
for num in range(1, 6):
    if num == 3:
        continue   # skip number 3
    if num == 5:
        break      # stop the loop completely
    print(num)
# Prints 1, 2, 4

Errores comunes

• Errores uno por uno: Recuerde que range(n) se detiene antes de n.
• Olvidar que en verifica los elementos: para x en la lista proporciona elementos, no índices.
• Mezcla interrupción y continuar: break finaliza el ciclo, continue solo omite el paso actual.

while-bucle (Conceptos básicos)

A while el bucle repite un bloque de código siempre que su condición sea True. A diferencia de los bucles for, el número de repeticiones no está fijado de antemano. La condición se verifica antes de cada repetición.

Importante: Tenga cuidado con la condición. Si nunca se convierte en False, el bucle se ejecutará para siempre (un bucle infinito).

Ejemplo de conteo simple

pythonCopy
x = 0
while x < 5:
    print("Counted to:", x)
    x += 1   # Important: update the counter!

Este bucle comienza en x = 0 y se detiene una vez que x ya no es menor que 5.

Detención anticipada con break

pythonCopy
x = 10
while True:       # runs "forever" unless stopped
    if x % 7 == 0:
        print("Found a multiple of 7:", x)
        break     # exit the loop
    x += 1

Aquí usamos mientras que True pero escapamos con break una vez que se cumple una condición.

Omitiendo iteraciones con continue

pythonCopy
x = -3
while x <= 3:
    x += 1
    if x == 0:       # skip division by zero
        continue
    print("1/", x, "=", 1/x)

La instrucción continue omite el paso del ciclo actual y pasa al siguiente.

Errores básicos

• Olvidar actualizar la variable: Si falta x += 1, la condición nunca cambia, y el bucle se ejecuta para siempre.
• Condiciones demasiado amplias: mientras que True es seguro solo si incluye un break.
adecuado

Declaraciones de control de bucle: break, continue y pass

Python proporciona declaraciones especiales que alteran el flujo normal de los bucles. Son útiles para un control detallado de la iteración, el manejo de casos excepcionales y hacer que el código sea más expresivo.

break — Salir de un bucle

break termina inmediatamente el bucle circundante más cercano, independientemente de la condición del bucle. Se usa comúnmente cuando se cumple una condición objetivo y no se necesita más iteración.

pythonCopy
nums = [1, 4, 7, 10]
for n in nums:
    if n > 5:
        print(f"Found {n}, stopping loop.")
        break
# Only iterates until 7, then exits

continue — Saltarse una iteración

continue omite el resto de la iteración actual y salta directamente a la siguiente. A menudo se utiliza para filtrar casos no deseados.

pythonCopy
for n in range(5):
    if n % 2 == 0:
        continue
    print(f"Odd: {n}")
# Prints Odd: 1, 3

pass — Declaración de marcador de posición

pass no hace nada y actúa como un marcador de posición sintáctico. Es útil cuando se requiere sintácticamente un bloque de código pero aún no se debe realizar ninguna acción (por ejemplo, durante el desarrollo o en métodos de clase abstractos).

pythonCopy
for n in range(3):
    if n == 1:
        pass  # Placeholder for future logic
    else:
        print(n)
# Prints 0 and 2, does nothing on 1
```<h2 class="error">Errores comunes</h2>
<ul>
<li><strong>Confuso <code>break</code> con <code>return</code>:</strong> <code>break</code> sale solo del bucle, no de la función. Utilice <code>return</code> para salir de una función por completo.</li>
<li><strong>Bucles infinitos con <code>continue</code>:</strong> En <code> while</code> bucles, colocar <code>continue</code> antes de actualizar las variables del bucle puede causar la condición para no cambiar nunca.</li>
<li><strong>Mal uso de <code>pass</code>:</strong> Dado que <code>pass</code> no hace nada, dejarlo en el código de producción sin querer puede ocultar lógica faltante o errores.</li>
</ul>

<h2>Comparación rápida</h2>
<ul>
<li><code>break</code>: Salir del ciclo por completo.</li>
<li><code>continue</code>: Saltar a la siguiente iteración.</li>
<li><code>pass</code>: no hacer nada, solo marcador de posición.</li>
</ul>

Bucles anidados

Los bucles anidados son bucles dentro de bucles. El bucle exterior se ejecuta una vez por cada iteración del bucle interior, multiplicando el total de iteraciones. Son esenciales para trabajar con datos multidimensionales, combinatoria y problemas algorítmicos.

Producto cartesiano

pythonCopy
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
for color in colors:
    for size in sizes:
        print(color, size)

Anidado mientras

pythonCopy
i = 1
while i <= 3:
    j = 1
    while j <= 2:
        print(i, j)
        j += 1
    i += 1

Errores

Explosión de complejidad: Dos bucles anidados sobre n elementos dan como resultado O(n²) complejidad. Agregar más niveles aumenta drásticamente el tiempo de ejecución.

Sombreado de variables: La reutilización accidental de nombres de variables en bucles internos y externos puede anular valores inesperadamente.

Funciones y expresiones Lambda

Las funciones en Python se definen utilizando la palabra clave def y le permiten encapsular código para su reutilización. Además, las expresiones lambda proporcionan una abreviatura para crear pequeñas funciones anónimas.

1. Definición de funciones

Utilice def para definir una función, opcionalmente con parámetros:

pythonCopy
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  
# Outputs: Hello, Alice!

2. Funciones Lambda

Las expresiones Lambda crean pequeñas funciones anónimas. Son útiles para funciones breves y simples:

pythonCopy
# A lambda that adds two numbers
add = lambda a, b: a + b
print(add(3, 4))  # Outputs: 7

Tanto las funciones regulares como las expresiones lambda son herramientas esenciales para organizar y simplificar su código.

Importación de módulos en Python

Python le permite ampliar la funcionalidad importando modules (archivos que contienen código, funciones y clases de Python). Los módulos pueden integrarse, personalizarse o instalarse desde fuentes externas (como PyPI).

1. Sintaxis de importación básica

Utilice la instrucción import para incorporar un módulo a su programa.

pythonCopy
import math
print(math.sqrt(16))   # Outputs: 4.0

2. Importación de funciones o alias específicos

Puede importar funciones específicas o cambiar el nombre de los módulos para su comodidad.

pythonCopy
from math import pi, sin
print(pi)        # Outputs: 3.141592653589793
print(sin(90))   # Uses radians by default

import numpy as np
arr = np.array([1, 2, 3])
print(arr)
```<h2><span style="font-family: Roboto;">3. Módulos integrados de uso común</span></h2>
<p><span style="font-family: Roboto;">Algunos de los módulos integrados más útiles incluyen:</span></p>
<ul>
<li><span style="font-family: Roboto;"><code>math</code> → Funciones matemáticas (sqrt, pi, sin, cos...)</span></li>
<li><span style="font-family: Roboto;"><code>random</code> → Números aleatorios, barajado, opciones</span></li>
<li><span style="font-family: Roboto;"><code>datetime</code> → Fechas y horas</span></li>
<li><span style="font-family: Roboto;"><code>os</code> → Interacciones del sistema operativo (archivos, directorios)</span></li>
<li><span style="font-family: Roboto;"><code>sys</code> → Parámetros y funciones específicos del sistema</span></li>
<li><span style="font-family: Roboto;"><code>json</code> → Trabajar con datos JSON</span></li>
</ul>

<h2><span style="font-family: Roboto;">4. Instalación de módulos externos</span></h2>
<p><span style="font-family: Roboto;">
Muchos módulos populares no están integrados y deben instalarse a través de <code>pip</code> (administrador de paquetes de Python).
</span></p>


```bash
pip install numpy
pip install requests

pythonCopy
import requests
response = requests.get("https://api.github.com")
print(response.status_code)
```<h2><span style="font-family: Roboto;">5. Resolución de errores de importación</span></h2>
<p><span style="font-family: Roboto;">
Problemas comunes al importar módulos:
</span></p>
<ul>
<li><span style="font-family: Roboto;"><strong>ModuleNotFoundError</strong>: El módulo no está instalado.  
➝ Solución: ejecute <code>pip install modulename</code>.</span></li>
<li><span style="font-family: Roboto;"><strong>ImportError</strong>: No se puede importar una función/clase específica.  
➝ Solución: consulte la documentación del módulo para conocer los nombres de funciones correctos.</span></li>
<li><span style="font-family: Roboto;"><strong>Conflictos de versión</strong>: Es posible que una versión del módulo no sea compatible con su versión de Python.  
➝ Solución: actualice con <code>pip install --upgrade modulename</code>.</span></li>
<li><span style="font-family: Roboto;"><strong>Problemas del entorno virtual</strong>: El módulo está instalado en un entorno diferente.  
➝ Solución: active el entorno correcto antes de ejecutar el script.</span></li>
</ul>

<h2><span style="font-family: Roboto;">6. Comprobación de módulos instalados</span></h2>


```bash
pip list        # Shows installed modules
pip show numpy  # Details about a specific module

Saber cómo importar y administrar módulos le permite extender la funcionalidad de Python mucho más allá de sus características principales.

Métodos básicos de archivo

La función incorporada open() devuelve un objeto de archivo que puede usar para leer o escribir archivos en el disco. El modo determina las acciones permitidas: 'r' (leer, predeterminado), 'w' (escribir, sobrescribir), 'a' (añadir). Al abrir un archivo no se leen ni se escriben datos por sí solo; debe llamar a los métodos de archivo que se muestran a continuación. Cierre siempre los archivos cuando haya terminado (o, preferiblemente, utilice un administrador de contexto).

Modos: ejemplos rápidos

pythonCopy
# implicit read mode (same as 'r')
f = open("example.txt")
f.close()

# explicit read
f = open("example.txt", "r")
f.close()

# open for writing (will overwrite)
f = open("output.txt", "w")
f.write("line 1\n")
f.close()

# open for appending (adds to end)
f = open("output.txt", "a")
f.write("another line\n")
f.close()

.read() - leer el contenido completo

read() devuelve el resto del archivo como una sola cadena. Si se vuelve a llamar cuando ya está al final, devuelve una cadena vacía.

pythonCopy
f = open("notes.txt", "r", encoding="utf-8")
all_text = f.read()
print(len(all_text))   # number of characters read
more = f.read()        # already at EOF → returns ''
print(repr(more))      # shows ''
f.close()

.readline() - lee la siguiente línea

readline() devuelve la siguiente línea (incluida la nueva línea final si está presente). Al llamarlo repetidamente se avanza a través del archivo. Un argumento size (por ejemplo, readline(50)) limita el número de caracteres devueltos; not selecciona la “enésima línea”.

pythonCopy
f = open("notes.txt", "r", encoding="utf-8")
first = f.readline()
second = f.readline()
print("First:", first)
print("Second:", second)
# to get the 3rd line specifically, iterate 3 times or use itertools.islice
f.close()
```<h2><span style="font-family: Roboto;">.readlines(): obtiene todas las líneas como una lista</span></h2>
<p><span style="font-family: Roboto;">
<code>readlines()</code> devuelve una lista donde cada elemento está a una línea del archivo (incluidos los caracteres de nueva línea). Úselo con cuidado en archivos muy grandes.
</span></p>


```python
f = open("notes.txt", "r", encoding="utf-8")
lines = f.readlines()
print("Number of lines:", len(lines))
print("Line 0:", lines[0])
f.close()

.write() — escribe cadenas en un archivo

write() requiere una cadena. Convierta otros tipos con str(). El comportamiento (sobrescribir o agregar) depende del modo utilizado al abrir el archivo.

pythonCopy
# overwrite file
f = open("results.txt", "w", encoding="utf-8")
f.write("score: " + str(42) + "\n")
f.close()

# append
f = open("results.txt", "a", encoding="utf-8")
f.write("score: " + str(100) + "\n")
f.close()

.close() y mejores prácticas

close() libera el identificador del archivo y garantiza que los datos almacenados en el búfer se vacíen al disco. Olvidarse de cerrar puede bloquear otros programas o perder datos. El patrón recomendado es el administrador de contexto que se cierra automáticamente.

pythonCopy
# manual close (works but easy to forget on errors)
f = open("data.txt", "r", encoding="utf-8")
try:
    content = f.read()
finally:
    f.close()

# preferred: context manager (automatic close)
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line.rstrip("\n"))
# file is closed here automatically

Pequeños ejemplos prácticos

pythonCopy
# Example: copy a file line-by-line (memory-friendly)
with open("source.txt", "r", encoding="utf-8") as src, \
     open("copy.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line)

# Example: read the 3rd line safely
from itertools import islice
with open("notes.txt", "r", encoding="utf-8") as f:
    third_line = next(islice(f, 2, 3), "")  # returns "" if missing
```<h2><span style="font-family: Roboto;">Errores comunes y soluciones rápidas</span></h2>
<ul>
<li><span style="font-family: Roboto;"><strong>FileNotFoundError</strong>: verifique la ruta o use una ruta absoluta.</span></li>
<li><span style="font-family: Roboto;"><strong>PermissionError</strong>: asegúrese de tener permisos de escritura/lectura para la carpeta de destino.</span></li>
<li><span style="font-family: Roboto;"><strong>UnicodeDecodeError</strong>: especifique la <code>codificación</code> correcta (por ejemplo, <code>"utf-8"</code>, <code>"latin-1"</code>) o abrir en modo binario <code>"rb"</code> para bytes sin formato.</span></li>
</ul>

NumPy — Instalar e importar

NumPy es el paquete principal para la computación numérica en Python (matrices, matemáticas rápidas, álgebra lineal). Instálelo con pip o su administrador de paquetes, luego impórtelo (convencionalmente como np).

Instalar

shellCopy
# with pip
pip install numpy

# or with conda
conda install numpy

Importar

pythonCopy
import numpy as np
# now use np.array, np.linspace, np.zeros, ...

Errores comunes

• Asegúrese de instalar en el mismo entorno Python que ejecuta (problemas de entorno virtualenv/conda).
• La importación como cualquier otra cosa que no sea np está permitida pero es poco común; otras personas esperan np.

NumPy Arrays: crear, indexar, dividir

NumPy son como listas pero con tipos numéricos fijos y operaciones vectorizadas rápidas. Puede convertir listas, crear matrices anidadas (2D) e indexarlas o dividirlas.

Crear a partir de listas

pythonCopy
import numpy as np

a = np.array([1, 2, 3, 4])            # 1D array
b = np.array([[1, 2, 3], [4, 5, 6]])  # 2D array
print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

Indexación (1D y 2D)

pythonCopy
print(a[0])      # first element -> 1
print(b[1, 2])   # second row, third column -> 6
print(b[0][1])   # alternative syntax -> 2

Rebanado

pythonCopy
c = np.arange(10)       # array([0,1,2,...,9])
print(c[1:5])             # [1 2 3 4]
print(b[0:2, 1:3])        # rows 0..1 and cols 1..2 (2x2 subarray)

Errores comunes

• Las matrices NumPy requieren un tipo d uniforme: los objetos Python mixtos conducen a dtype=object.
• Los sectores son **vistas**, no copias; modificar un sector puede cambiar la matriz original.

Forma de matriz y la propiedad .shape

.shape devuelve una tupla con el tamaño de cada dimensión. Es una propiedad (sin paréntesis).

Ejemplos

pythonCopy
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([[1,2,3],[4,5,6]])

print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

# reshape if needed
c = a.reshape((2,2))
print(c.shape)   # (2, 2)

Errores comunes

• Llamar a .shape() entre paréntesis es incorrecto: es una propiedad, no una función.
• reshape requiere tamaños que se multipliquen al mismo número de elementos (o use -1 para inferencia automática).

NumPy — Funciones básicas (linspace, ceros, aleatorio, ...)

NumPy ofrece prácticos constructores y ayudantes para matrices y secuencias de uso común.

Constructores comunes

pythonCopy
import numpy as np

# even spacing: start, stop, num-values
x = np.linspace(0, 1, num=5)    # [0.  0.25 0.5  0.75 1. ]

# zeros with shape / dtype
Z = np.zeros((2,3), dtype=float)  # 2x3 array of zeros

# arange like Python range -> integers
r = np.arange(0, 10, 2)           # [0 2 4 6 8]

Números aleatorios

pythonCopy
# modern usage (numpy >= 1.17) prefers Generator, but simple forms below:
rand = np.random.rand(3)       # 3 uniform floats in [0,1)
rnorm = np.random.randn(3)     # 3 standard normal samples
rint = np.random.randint(0, 10, size=4)  # 4 ints in [0,10)

Comportamiento del tipo de datos

pythonCopy
a = np.array([1, 2, 3], dtype=int)
a[0] += 0.2
print(a)  # still integer array; fractional part lost (a[0] remains 1)

• Si una matriz tiene un tipo d entero, las operaciones in situ se convertirán a ese tipo d (posible truncamiento).
• Para permitir flotantes, cree la matriz con dtype=float o transmita con .astype().

Matplotlib — Instalar e importar

Matplotlib es la biblioteca de trazado estándar para Python. Instálelo con su administrador de paquetes e importe el módulo pyplot (comúnmente como plt).

Instalar

shellCopy
# with pip
pip install matplotlib

# or with conda
conda install matplotlib

Importar

pythonCopy
import matplotlib.pyplot as plt
# optionally import numpy for data
import numpy as np

Errores comunes

• Instale en el entorno activo (virtualenv/conda) utilizado por su script o cuaderno.
• En algunos entornos (por ejemplo, servidores sin cabeza) es posible que necesite un backend no interactivo para guardar cifras.

Matplotlib — Uso básico (plt.plot, plt.show, save)

Flujo de trabajo de trazado simple: cree datos, llame a funciones de trazado y luego muestre o guarde la figura.

Gráfico de líneas simple

pythonCopy
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)       # plot the line
plt.show()           # display the plot window (or inline in notebooks)

Varias series y guardado

pythonCopy
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.savefig('sincos.png')  # save to file
plt.show()

Errores comunes

• Llame a plt.show() después de configurar el gráfico; de lo contrario, es posible que algunos servidores no muestren el estilo completo.
• Al trazar varias figuras, utilice plt.figure() o fig, ax = plt.subplots() para mantenerlas separadas.

Matplotlib — Modificadores y estilos (título, leyenda, ejes, aspecto)

Utilice etiquetas, límites, leyendas y métodos de ejes para ajustar la apariencia y el diseño de los gráficos.

Etiquetas, título, leyenda

pythonCopy
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.xlabel('x (rad)')
plt.ylabel('value')
plt.title('Sine & Cosine')
plt.legend()  # show labels in top-right by default
plt.show()

Límites y aspecto del eje

pythonCopy
plt.plot([0,1,2], [0,1,4])
plt.xlim(0, 2)        # set x limits
plt.ylim(0, 5)        # set y limits

ax = plt.gca()        # get current Axes
ax.set_aspect('equal')   # equal scaling for x and y units
plt.show()

Ocultar ejes o ticks

pythonCopy
ax = plt.gca()
ax.xaxis.set_visible(False)   # hide x-axis
ax.yaxis.set_visible(False)   # hide y-axis

Errores comunes

• Cambiar las propiedades del eje requiere un objeto Axes (de plt.gca() o el retorno de plt.subplots()).
• Muchas opciones de estilo son persistentes en la figura/ejes actuales: llámalas en el orden correcto o crea una nueva figura para gráficos separados.

Conceptos avanzados de Python

Más allá de lo básico, Python ofrece muchas funciones avanzadas para escribir código conciso, eficiente y sólido. Temas como comprensión de listas, generadores y manejo de excepciones pueden ayudarlo a llevar sus habilidades de programación al siguiente nivel.

1. Lista de comprensiones

Las listas por comprensión proporcionan una forma concisa de crear listas. Pueden reemplazar bucles en muchos casos:

pythonCopy
# Traditional loop
squares = []
for i in range(10):
    squares.append(i ** 2)

# Using list comprehension
squares = [i ** 2 for i in range(10)]
print(squares)

2. Manejo de excepciones

Utilice bloques try-except para manejar correctamente errores y excepciones:

pythonCopy
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    # is executed if try did not work
    # and the exception is not the same as in except
    print("Not execute but no ZeroDivisionError.")
finally:
    # is always executed
    print("Execution complete.")
    # Outputs an error message 
    # and a final execution statement

3. Generadores

Los generadores le permiten iterar sobre grandes conjuntos de datos de manera eficiente sin almacenar la secuencia completa en la memoria:

pythonCopy
def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for number in count_up_to(5):
    print(number)
    # Outputs: 1 2 3 4 5

Explorar estos temas avanzados puede mejorar significativamente sus capacidades de programación en Python.