Python

Python es un lenguaje de programación interpretado y de alto nivel. Fue creado por Guido van Rossum y lanzado por primera vez en 1991. Python se destaca por su legibilidad y sintaxis clara, lo que lo hace ideal tanto para principiantes como para programadores experimentados.

Una de las características más destacadas de Python es su filosofía de diseño, que enfatiza la legibilidad del código y la facilidad de uso. El lenguaje utiliza una sintaxis limpia y utiliza el espaciado en blanco de manera significativa para estructurar el código, lo que lo hace fácil de leer y entender.

🔑 Nota: Para profundizar en conceptos básicos de Python, se recomienda estudiar del curso Introducción a Python.

Nomenclatura

Sintaxis

Hola mundo!

Escribamos nuestro primer programa de Python, “¡Hola, mundo!”. Es un programa simple que imprime Hello World! en el dispositivo de salida estándar (pantalla).

# imprimir "Hola Mundo!"
print("Hola Mundo!");

Hola Mundo!

Variables

Las variables son contenedores que se utilizan para almacenar datos. Estos datos pueden ser números, cadenas de texto, listas, diccionarios, y más. En Python, no necesitas declarar el tipo de variable antes de asignarle un valor; el tipo de variable se determina automáticamente según el valor que se le asigne.

Además, las variables pueden contener una amplia variedad de tipos de datos, que determinan el tipo de valores que pueden almacenar y las operaciones que se pueden realizar con ellos.

# Variables numéricas
numero_entero = 10
numero_flotante = 3.14

# Variables de cadena de texto
nombre = "Juan"
mensaje = 'Hola, mundo!'

# Variables booleanas
verdadero = True
falso = False

# Variables nulas
mi_variable_nula = None

# Imprimiendo los valores de las variables
print("Valor de numero_entero:", numero_entero)
print("Valor de numero_flotante:", numero_flotante)
print("Valor de nombre:", nombre)
print("Valor de mensaje:", mensaje)
print("Valor de verdadero:", verdadero)
print("Valor de falso:", falso)
print("Valor de mi_variable_nula:", mi_variable_nula)

Valor de numero_entero: 10
Valor de numero_flotante: 3.14
Valor de nombre: Juan
Valor de mensaje: Hola, mundo!
Valor de verdadero: True
Valor de falso: False
Valor de mi_variable_nula: None

Operaciones

Puedes realizar una variedad de operaciones en diferentes tipos de datos. Estas operaciones pueden ser aritméticas, de comparación, lógicas, de asignación, de pertenencia e identidad. A continuación, se describen los principales tipos de operaciones:

Operaciones Aritméticas

Las operaciones aritméticas se utilizan para realizar cálculos matemáticos simples. Algunas de las operaciones aritméticas básicas incluyen:

Suma (+)
Resta (-)
Multiplicación (*)
División (/)
Potenciación (**)
División entera (//)
Módulo (%)

# Operaciones Aritméticas
a = 10
b = 3

suma = a + b
resta = a - b
multiplicacion = a * b
division = a / b
potenciacion = a ** b
division_entera = a // b
modulo = a % b

print("Operaciones Aritméticas:")
print("Suma:", suma)
print("Resta:", resta)
print("Multiplicación:", multiplicacion)
print("División:", division)
print("Potenciación:", potenciacion)
print("División entera:", division_entera)
print("Módulo:", modulo)

Operaciones Aritméticas:
Suma: 13
Resta: 7
Multiplicación: 30
División: 3.3333333333333335
Potenciación: 1000
División entera: 3
Módulo: 1

Operaciones de Comparación

Las operaciones de comparación se utilizan para comparar valores y devolver un valor booleano (Verdadero o Falso). Algunas operaciones de comparación comunes son:

Igualdad (==)
Desigualdad (!=)
Mayor que (>)
Menor que (<)
Mayor o igual que (>=)
Menor o igual que (<=)

# Operaciones de Comparación
igualdad = (a == b)
desigualdad = (a != b)
mayor_que = (a > b)
menor_que = (a < b)
mayor_igual = (a >= b)
menor_igual = (a <= b)

print("Operaciones de Comparación:")
print("Igualdad:", igualdad)
print("Desigualdad:", desigualdad)
print("Mayor que:", mayor_que)
print("Menor que:", menor_que)
print("Mayor o igual que:", mayor_igual)
print("Menor o igual que:", menor_igual)

Operaciones de Comparación:
Igualdad: False
Desigualdad: True
Mayor que: True
Menor que: False
Mayor o igual que: True
Menor o igual que: False

Operaciones Lógicas

Las operaciones lógicas se utilizan para realizar operaciones booleanas en valores booleanos. Algunas operaciones lógicas comunes incluyen:

Y lógico (and)
O lógico (or)
Negación lógica (not)

# Operaciones Lógicas
verdadero = True
falso = False

y_logico = verdadero and falso
o_logico = verdadero or falso
negacion = not verdadero

print("Operaciones Lógicas:")
print("Y lógico:", y_logico)
print("O lógico:", o_logico)
print("Negación:", negacion)

Operaciones Lógicas:
Y lógico: False
O lógico: True
Negación: False

Operaciones de Asignación

Las operaciones de asignación se utilizan para asignar valores a variables. Algunas operaciones de asignación pueden combinar operaciones aritméticas con la asignación. Por ejemplo:

# Operaciones de Asignación
x = 5
x += 2  # Equivalente a x = x + 2

print("Operaciones de Asignación:")
print("Valor de x después de la asignación:", x)

Operaciones de Asignación:
Valor de x después de la asignación: 7

Operaciones con strings

Puedes realizar varias operaciones con cadenas de texto (strings) para manipular y trabajar con ellas de diversas formas. A continuación, se describen algunas operaciones comunes con ejemplos y resultados:

cadena1 = "Hola"
cadena2 = "mundo"

# Concatenación de cadenas
resultado_concatenacion = cadena1 + " " + cadena2
print("Concatenación:", resultado_concatenacion)

Concatenación: Hola mundo

cadena = "Python"
# Repetición de una cadena
resultado_repeticion = cadena * 3
print("Repetición:", resultado_repeticion)

Repetición: PythonPythonPython

# Indexación para obtener el primer carácter de la cadena
primer_caracter = cadena[0]
print("Indexación:", primer_caracter)

Indexación: P

# Obtención de la longitud de la cadena
longitud = len(cadena)
print("Longitud:", longitud)

Longitud: 6

# Slicing para obtener una subcadena de la cadena original
subcadena = cadena[2:5]
print("Slicing:", subcadena)

Slicing: tho

Control de Flujo

Condicional if-elif-else

Los condicionales if, elif y else son estructuras fundamentales en Python que te permiten ejecutar diferentes bloques de código dependiendo de ciertas condiciones. A continuación se explica cómo funcionan:

Estructura básica

La estructura básica de un condicional if es la siguiente:

if condicion:
    # Código a ejecutar si la condición es verdadera

Si la condición es verdadera, se ejecuta el bloque de código indentado debajo de la declaración if. Si la condición es falsa, este bloque de código se omite.

Condicional if-else

Puedes agregar un bloque else para ejecutar un código alternativo cuando la condición en el if es falsa:

if condicion:
    # Código a ejecutar si la condición es verdadera
else:
    # Código a ejecutar si la condición es falsa

Condicional if-elif-else

Si tienes múltiples condiciones, puedes usar la estructura elif (abreviatura de “else if”) para verificarlas en secuencia:

if condicion1:
    # Código a ejecutar si la condicion1 es verdadera
elif condicion2:
    # Código a ejecutar si la condicion2 es verdadera
else:
    # Código a ejecutar si ninguna de las condiciones anteriores es verdadera

Ejemplo

edad = 20

if edad < 18:
    print("Eres menor de edad")
elif edad >= 18 and edad < 65:
    print("Eres adulto")
else:
    print("Eres un adulto mayor")

Eres adulto

Bucle While

El bucle while es una estructura de control que permite repetir un bloque de código mientras una condición especificada sea verdadera. A continuación se explica cómo funciona:

Estructura básica

La estructura básica de un bucle while es la siguiente:

while condicion:
    # Código a repetir mientras la condición sea verdadera

El bloque de código indentado debajo del while se ejecutará repetidamente mientras la condición sea verdadera. Una vez que la condición se evalúa como falsa, la ejecución del bucle se detiene y el programa continúa con la siguiente instrucción después del bucle.

Ejemplo

contador = 0

while contador < 5:
    print("El contador es:", contador)
    contador += 1

print("¡Bucle completado!")

El contador es: 0
El contador es: 1
El contador es: 2
El contador es: 3
El contador es: 4
¡Bucle completado!

Ciclo `For` con la Función Range()

El ciclo for se utiliza para iterar sobre una secuencia (como una lista, una tupla, un diccionario, etc.) y realizar una acción en cada elemento de la secuencia. La función range() es comúnmente utilizada junto con un ciclo for para generar una secuencia de números en un rango específico. A continuación se explica cómo funciona:

Estructura básica

La estructura básica de un ciclo for con range() es la siguiente:

for variable in range(inicio, fin, paso):
    # Código a ejecutar en cada iteración

La función range() genera una secuencia de números que comienza desde el valor de “inicio” hasta el valor de “fin” (sin incluirlo), con un incremento definido por el valor de “paso”. El bloque de código indentado debajo del for se ejecutará una vez para cada valor en la secuencia generada por range().

Ejemplo

for i in range(5):
    print("El valor de i es:", i)

print("¡Ciclo completado!")

El valor de i es: 0
El valor de i es: 1
El valor de i es: 2
El valor de i es: 3
El valor de i es: 4
¡Ciclo completado!

Salir o Continuar un Ciclo

Puedes controlar el flujo de ejecución de un ciclo for o while utilizando las palabras clave break y continue. Estas palabras clave te permiten detener la ejecución del ciclo de forma prematura o saltar a la siguiente iteración del ciclo, respectivamente. A continuación se explica cómo funcionan:

Salir de un Ciclo con break

La palabra clave break se utiliza para salir de un ciclo de forma prematura si se cumple una cierta condición. Cuando se encuentra una instrucción break, el ciclo se detiene inmediatamente y la ejecución del programa continúa con la primera instrucción después del ciclo.

Ejemplo

# Ejemplo de salir de un ciclo con break

contador = 0

while True:
    contador += 1

    # Salir del ciclo si el contador llega a 5
    if contador == 5:
        print("¡El contador llegó a 5! Saliendo del ciclo.")
        break

    print("El valor del contador es:", contador)

print("¡Ciclo completado!")

El valor del contador es: 1
El valor del contador es: 2
El valor del contador es: 3
El valor del contador es: 4
¡El contador llegó a 5! Saliendo del ciclo.
¡Ciclo completado!

Continuar con la Siguiente Iteración con continue

La palabra clave continue se utiliza para saltar a la siguiente iteración del ciclo si se cumple una cierta condición. Cuando se encuentra una instrucción continue, el ciclo se detiene temporalmente y se pasa a la siguiente iteración del ciclo, omitiendo cualquier código restante dentro del bloque de ciclo para esa iteración en particular.

Ejemplo

# Ejemplo de continuar con la siguiente iteración con continue

contador = 0

while contador < 5:
    contador += 1

    # Saltar a la siguiente iteración si el contador es par
    if contador % 2 == 0:
        print("El contador es par. Continuando con la siguiente iteración.")
        continue

    print("El valor del contador es:", contador)

print("¡Ciclo completado!")

El valor del contador es: 1
El contador es par. Continuando con la siguiente iteración.
El valor del contador es: 3
El contador es par. Continuando con la siguiente iteración.
El valor del contador es: 5
¡Ciclo completado!

Estructura de datos

Existen varias estructuras de datos integradas que te permiten almacenar y organizar colecciones de elementos de diferentes maneras. Algunas de las estructuras de datos más comunes son las listas, las tuplas, los conjuntos y los diccionarios. A continuación, se explican cada una de ellas con ejemplos y resultados impresos.

Listas

Una lista en Python es una colección ordenada y mutable de elementos. Puedes acceder a los elementos de una lista utilizando índices, y puedes modificar la lista agregando, eliminando o cambiando elementos.

# Crear una lista vacía
lista_vacia = []
print("Lista vacía:", lista_vacia)

Lista vacía: []

# Crear una lista con elementos de diferentes tipos
lista_mixta = [1, "dos", 3.0, True]
print("Lista mixta:", lista_mixta)

Lista mixta: [1, 'dos', 3.0, True]

# Acceder a elementos de una lista utilizando índices positivos y negativos
mi_lista = ['a', 'b', 'c', 'd', 'e']
print("Primer elemento:", mi_lista[0])
print("Último elemento:", mi_lista[-1])

Primer elemento: a
Último elemento: e

# Rebanado (slicing) de listas
print("Rebanado:", mi_lista[1:3])

Rebanado: ['b', 'c']

# Modificar elementos de una lista
mi_lista[0] = 'z'
print("Lista modificada:", mi_lista)

Lista modificada: ['z', 'b', 'c', 'd', 'e']

# Agregar elementos a una lista
mi_lista.append('f')
print("Lista después de agregar un elemento:", mi_lista)

Lista después de agregar un elemento: ['z', 'b', 'c', 'd', 'e', 'f']

# Extender una lista con otra lista
mi_otra_lista = ['g', 'h', 'i']
mi_lista.extend(mi_otra_lista)
print("Lista después de extenderla con otra lista:", mi_lista)

Lista después de extenderla con otra lista: ['z', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

# Insertar un elemento en una posición específica
mi_lista.insert(2, 'nuevo')
print("Lista después de insertar un nuevo elemento:", mi_lista)

Lista después de insertar un nuevo elemento: ['z', 'b', 'nuevo', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

# Eliminar un elemento de una lista
mi_lista.remove('c')
print("Lista después de eliminar un elemento:", mi_lista)

Lista después de eliminar un elemento: ['z', 'b', 'nuevo', 'd', 'e', 'f', 'g', 'h', 'i']

# Eliminar el último elemento de una lista y devolverlo
ultimo_elemento = mi_lista.pop()
print("Último elemento eliminado:", ultimo_elemento)
print("Lista después de eliminar el último elemento:", mi_lista)

Último elemento eliminado: i
Lista después de eliminar el último elemento: ['z', 'b', 'nuevo', 'd', 'e', 'f', 'g', 'h']

# Buscar el índice de un elemento en una lista
indice = mi_lista.index('e')
print("Índice del elemento 'e':", indice)

Índice del elemento 'e': 4

# Contar la cantidad de veces que aparece un elemento en una lista
cantidad = mi_lista.count('a')
print("Cantidad de veces que aparece 'a':", cantidad)

Cantidad de veces que aparece 'a': 0

# Revertir el orden de los elementos en una lista
mi_lista.reverse()
print("Lista después de revertir el orden:", mi_lista)

Lista después de revertir el orden: ['h', 'g', 'f', 'e', 'd', 'nuevo', 'b', 'z']

# Ordenar los elementos de una lista (si son del mismo tipo)
numeros = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
numeros.sort()
print("Lista de números ordenada:", numeros)

Lista de números ordenada: [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]

# Copiar una lista
copia_lista = mi_lista.copy()
print("Copia de la lista:", copia_lista)

Copia de la lista: ['h', 'g', 'f', 'e', 'd', 'nuevo', 'b', 'z']

# Vaciar una lista
mi_lista.clear()
print("Lista después de vaciarla:", mi_lista)

Lista después de vaciarla: []

Tuplas

Una tupla en Python es una colección ordenada e inmutable de elementos. Puedes acceder a los elementos de una tupla utilizando índices, pero no puedes modificar la tupla después de crearla.

# Crear una tupla vacía
tupla_vacia = ()
print("Tupla vacía:", tupla_vacia)

Tupla vacía: ()

# Crear una tupla con elementos de diferentes tipos
tupla_mixta = (1, "dos", 3.0, True)
print("Tupla mixta:", tupla_mixta)

Tupla mixta: (1, 'dos', 3.0, True)

# Acceder a elementos de una tupla utilizando índices positivos y negativos
mi_tupla = ('a', 'b', 'c', 'd', 'e')
print("Primer elemento:", mi_tupla[0])
print("Último elemento:", mi_tupla[-1])

Primer elemento: a
Último elemento: e

# Rebanado (slicing) de tuplas
print("Rebanado:", mi_tupla[1:3])
# No se puede modificar una tupla después de crearla
# mi_tupla[0] = 'z'  # Esto producirá un error

Rebanado: ('b', 'c')

# Concatenar tuplas
otra_tupla = ('f', 'g')
concatenacion = mi_tupla + otra_tupla
print("Concatenación de tuplas:", concatenacion)

Concatenación de tuplas: ('a', 'b', 'c', 'd', 'e', 'f', 'g')

# Multiplicar una tupla
multiplicacion = otra_tupla * 3
print("Multiplicación de tupla:", multiplicacion)

Multiplicación de tupla: ('f', 'g', 'f', 'g', 'f', 'g')

# Obtener la longitud de una tupla
longitud = len(mi_tupla)
print("Longitud de la tupla:", longitud)

Longitud de la tupla: 5

# Buscar un elemento en una tupla
if 'c' in mi_tupla:
    print("El elemento 'c' está en la tupla.")
else:
    print("El elemento 'c' no está en la tupla.")

El elemento 'c' está en la tupla.

# Contar la cantidad de veces que aparece un elemento en una tupla
cantidad = mi_tupla.count('b')
print("Cantidad de veces que aparece 'b':", cantidad)

Cantidad de veces que aparece 'b': 1

# Encontrar el índice de un elemento en una tupla
indice = mi_tupla.index('d')
print("Índice del elemento 'd':", indice)

Índice del elemento 'd': 3

Conjuntos

Un conjunto en Python es una colección desordenada y mutable de elementos únicos. Puedes realizar operaciones de conjuntos como unión, intersección y diferencia entre conjuntos.

# Crear un conjunto vacío
conjunto_vacio = set()
print("Conjunto vacío:", conjunto_vacio)

Conjunto vacío: set()

# Crear un conjunto con elementos
mi_conjunto = {1, 2, 3, 4, 5}
print("Conjunto:", mi_conjunto)

Conjunto: {1, 2, 3, 4, 5}

# Agregar elementos a un conjunto
mi_conjunto.add(6)
print("Conjunto después de agregar un elemento:", mi_conjunto)

Conjunto después de agregar un elemento: {1, 2, 3, 4, 5, 6}

# Eliminar un elemento de un conjunto
mi_conjunto.remove(3)
print("Conjunto después de eliminar un elemento:", mi_conjunto)

Conjunto después de eliminar un elemento: {1, 2, 4, 5, 6}

# Verificar si un elemento está en un conjunto
if 4 in mi_conjunto:
    print("El elemento 4 está en el conjunto.")
else:
    print("El elemento 4 no está en el conjunto.")

El elemento 4 está en el conjunto.

# Realizar operaciones de conjunto
conjunto1 = {1, 2, 3, 4, 5}
conjunto2 = {4, 5, 6, 7, 8}

# Unión de conjuntos
union = conjunto1.union(conjunto2)
print("Unión de conjuntos:", union)

Unión de conjuntos: {1, 2, 3, 4, 5, 6, 7, 8}

# Intersección de conjuntos
interseccion = conjunto1.intersection(conjunto2)
print("Intersección de conjuntos:", interseccion)

Intersección de conjuntos: {4, 5}

# Diferencia entre conjuntos
diferencia = conjunto1.difference(conjunto2)
print("Diferencia entre conjuntos 1 y 2:", diferencia)

Diferencia entre conjuntos 1 y 2: {1, 2, 3}

# Comprobar si un conjunto es subconjunto de otro
if conjunto1.issubset(conjunto2):
    print("El conjunto 1 es un subconjunto del conjunto 2.")
else:
    print("El conjunto 1 no es un subconjunto del conjunto 2.")

El conjunto 1 no es un subconjunto del conjunto 2.

# Vaciar un conjunto
conjunto1.clear()
print("Conjunto 1 después de vaciarlo:", conjunto1)

Conjunto 1 después de vaciarlo: set()

Diccionarios

Un diccionario en Python es una colección desordenada y mutable de pares clave-valor. Puedes acceder a los valores utilizando las claves, y puedes agregar, modificar o eliminar elementos del diccionario.

# Crear un diccionario vacío
diccionario_vacio = {}
print("Diccionario vacío:", diccionario_vacio)

Diccionario vacío: {}

# Crear un diccionario con elementos
mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}
print("Diccionario:", mi_diccionario)

Diccionario: {'nombre': 'Juan', 'edad': 30, 'ciudad': 'Madrid'}

# Acceder a valores utilizando claves
print("Nombre:", mi_diccionario["nombre"])
print("Edad:", mi_diccionario["edad"])

Nombre: Juan
Edad: 30

# Modificar valores en un diccionario
mi_diccionario["edad"] = 31
print("Diccionario después de modificar la edad:", mi_diccionario)

Diccionario después de modificar la edad: {'nombre': 'Juan', 'edad': 31, 'ciudad': 'Madrid'}

# Agregar un nuevo par clave-valor
mi_diccionario["profesión"] = "Ingeniero"
print("Diccionario después de agregar una profesión:", mi_diccionario)

Diccionario después de agregar una profesión: {'nombre': 'Juan', 'edad': 31, 'ciudad': 'Madrid', 'profesión': 'Ingeniero'}

# Eliminar un par clave-valor
del mi_diccionario["ciudad"]
print("Diccionario después de eliminar la ciudad:", mi_diccionario)

Diccionario después de eliminar la ciudad: {'nombre': 'Juan', 'edad': 31, 'profesión': 'Ingeniero'}

# Verificar si una clave está en el diccionario
if "nombre" in mi_diccionario:
    print("La clave 'nombre' está en el diccionario.")
else:
    print("La clave 'nombre' no está en el diccionario.")

La clave 'nombre' está en el diccionario.

# Obtener todas las claves y valores del diccionario
claves = mi_diccionario.keys()
print("Claves del diccionario:", claves)
valores = mi_diccionario.values()
print("Valores del diccionario:", valores)

Claves del diccionario: dict_keys(['nombre', 'edad', 'profesión'])
Valores del diccionario: dict_values(['Juan', 31, 'Ingeniero'])

# Obtener pares clave-valor del diccionario como tuplas
items = mi_diccionario.items()
print("Pares clave-valor del diccionario:", items)

Pares clave-valor del diccionario: dict_items([('nombre', 'Juan'), ('edad', 31), ('profesión', 'Ingeniero')])

# Copiar un diccionario
copia_diccionario = mi_diccionario.copy()
print("Copia del diccionario:", copia_diccionario)

Copia del diccionario: {'nombre': 'Juan', 'edad': 31, 'profesión': 'Ingeniero'}

# Vaciar un diccionario
mi_diccionario.clear()
print("Diccionario después de vaciarlo:", mi_diccionario)

Diccionario después de vaciarlo: {}

Funciones

Definiciones

Una función es un bloque de código que realiza una tarea específica y puede ser llamado desde cualquier parte del programa. Las funciones pueden tener parámetros (datos que se pasan a la función) y pueden devolver un resultado. Al utilizar funciones, podemos dividir el código en partes más pequeñas y manejables, lo que facilita la comprensión y la depuración.

Sintaxis

La sintaxis básica de una función en Python es la siguiente:

def nombre_funcion(parametros):
    # Cuerpo de la función
    # Realizar operaciones
    return resultado

def: Es una palabra clave que indica que se está definiendo una función.
nombre_funcion: Es el nombre que le damos a la función. Debe seguir las mismas reglas de nomenclatura que las variables.
parámetros: Son los datos que la función espera recibir. Pueden ser opcionales.
return: Es una palabra clave que indica el valor que la función devolverá. Puede devolver cero o más valores.

# Definir una función sin parámetros y sin valor de retorno
def saludar():
    print("¡Hola!")

# Llamar a la función
saludar()

¡Hola!

# Definir una función con parámetros y sin valor de retorno
def saludar_persona(nombre):
    print("¡Hola,", nombre, "!")

# Llamar a la función con un argumento
saludar_persona("Juan")

¡Hola, Juan !

# Definir una función con parámetros y con valor de retorno
def sumar(a, b):
    return a + b

# Llamar a la función y almacenar el resultado en una variable
resultado = sumar(3, 5)
print("Resultado de la suma:", resultado)

Resultado de la suma: 8

# Función con parámetros con valores predeterminados
def multiplicar(a, b=2):
    return a * b

# Llamar a la función con un solo argumento
resultado1 = multiplicar(3)
print("Resultado de la multiplicación (con valor predeterminado):", resultado1)

# Llamar a la función con dos argumentos
resultado2 = multiplicar(3, 4)
print("Resultado de la multiplicación (con argumento específico):", resultado2)

Resultado de la multiplicación (con valor predeterminado): 6
Resultado de la multiplicación (con argumento específico): 12

# Función con un número variable de argumentos
def promedio(*args):
    return sum(args) / len(args)

# Llamar a la función con diferentes cantidades de argumentos
resultado1 = promedio(2, 4, 6)
print("Promedio de 2, 4 y 6:", resultado1)

resultado2 = promedio(1, 3, 5, 7, 9)
print("Promedio de 1, 3, 5, 7 y 9:", resultado2)

Promedio de 2, 4 y 6: 4.0
Promedio de 1, 3, 5, 7 y 9: 5.0

# Función con argumentos de palabra clave
def mostrar_info(nombre, edad):
    print("Nombre:", nombre)
    print("Edad:", edad)

# Llamar a la función utilizando argumentos de palabra clave
mostrar_info(nombre="Ana", edad=25)

Nombre: Ana
Edad: 25

# Función con retorno de múltiples valores
def dividir(a, b):
    cociente = a // b
    resto = a % b
    return cociente, resto

# Llamar a la función y almacenar los valores de retorno en variables separadas
cociente, resto = dividir(10, 3)
print("Cociente:", cociente)
print("Resto:", resto)

Cociente: 3
Resto: 1

# Funciones anidadas
def exterior():
    print("Función exterior")
    
    def interior():
        print("Función interior")
    
    interior()

# Llamar a la función exterior, que también llama a la función interior
exterior()

Función exterior
Función interior

Excepciones

En Python, los errores se dividen principalmente en tres categorías: errores de sintaxis, excepciones y errores semánticos. Cada uno de estos tipos de errores tiene sus propias características y se manejan de manera diferente en el código.

Errores de Sintaxis

Los errores de sintaxis en Python ocurren cuando el código no sigue las reglas gramaticales del lenguaje. Estos errores se detectan durante la fase de análisis del código y generalmente provocan que el intérprete de Python detenga la ejecución del programa y muestre un mensaje de error que indica la ubicación y la naturaleza del error. Aquí hay una lista de algunos errores de sintaxis comunes y ejemplos de cómo corregirlos:

Falta de paréntesis, corchetes o llaves

# Error de sintaxis: Falta un paréntesis de cierre
print("Hola mundo"

  Cell In[73], line 2
    print("Hola mundo"
                      ^
SyntaxError: unexpected EOF while parsing

Falta de comillas

# Error de sintaxis: Falta una comilla de cierre
mensaje = "Hola mundo

  Cell In[74], line 2
    mensaje = "Hola mundo
                         ^
SyntaxError: EOL while scanning string literal

Falta de dos puntos

# Error de sintaxis: Falta dos puntos al final de la declaración if
if True
    print("Es verdadero")
# Solución: Agregar dos puntos al final de la declaración if
if True:
    print("Es verdadero")

  Cell In[75], line 2
    if True
           ^
SyntaxError: invalid syntax

Indentación incorrecta

# Error de sintaxis: Declaración indentada incorrectamente
if True:
print("Es verdadero")

  Cell In[76], line 3
    print("Es verdadero")
    ^
IndentationError: expected an indented block

Uso incorrecto de palabras clave

# Error de sintaxis: Uso incorrecto de la palabra clave 'else'
if True:
    print("Es verdadero")
elsee:
    print("Es falso")

  Cell In[77], line 4
    elsee:
          ^
SyntaxError: invalid syntax

Excepciones

Las excepciones en Python son eventos que ocurren durante la ejecución del programa y pueden alterar el flujo normal de ejecución. Cuando una excepción se produce, Python detiene la ejecución del programa y busca un bloque de código que pueda manejar la excepción. Aquí se presentan algunos tipos comunes de excepciones en Python y cómo manejarlos:

Excepción de tipo SyntaxError

# Error de sintaxis: Falta un paréntesis de cierre
print("Hola mundo"

  Cell In[78], line 2
    print("Hola mundo"
                      ^
SyntaxError: unexpected EOF while parsing

Excepción de tipo NameError

# Error de nombre: Variable no definida
print(variable_no_definida)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[79], line 2
      1 # Error de nombre: Variable no definida
----> 2 print(variable_no_definida)

NameError: name 'variable_no_definida' is not defined

Excepción de tipo TypeError

# Error de tipo: Suma entre tipos incompatibles
resultado = 10 + "20"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[80], line 2
      1 # Error de tipo: Suma entre tipos incompatibles
----> 2 resultado = 10 + "20"

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Excepción de tipo ValueError

# Error de valor: Argumento fuera de rango
import math
raiz_negativa = math.sqrt(-9)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[81], line 3
      1 # Error de valor: Argumento fuera de rango
      2 import math
----> 3 raiz_negativa = math.sqrt(-9)

ValueError: math domain error

Excepción de tipo ZeroDivisionError

# Error de división por cero
division = 10 / 0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[82], line 2
      1 # Error de división por cero
----> 2 division = 10 / 0

ZeroDivisionError: division by zero

Excepción de tipo OverflowError

# Error de desbordamiento: Número demasiado grande para ser representado
numero_grande = 20.0 ** 20.0 ** 20.0

---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
Cell In[83], line 2
      1 # Error de desbordamiento: Número demasiado grande para ser representado
----> 2 numero_grande = 20.0 ** 20.0 ** 20.0

OverflowError: (34, 'Result too large')

Manejo de Excepciones

try:
    # Código propenso a generar una excepción
    resultado = 10 / 0
except ZeroDivisionError:
    # Manejar la excepción
    print("Error: División por cero")

Error: División por cero

Errores Semánticos

Los errores semánticos en Python son más difíciles de detectar que los errores de sintaxis o las excepciones porque el código puede ejecutarse sin generar mensajes de error, pero produce resultados inesperados o incorrectos debido a una lógica incorrecta en el programa. Aquí se presentan algunos ejemplos de errores semánticos comunes en Python:

Operaciones incorrectas

# Error semántico: Operación incorrecta
resultado = 10 / 0  # División por cero

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[85], line 2
      1 # Error semántico: Operación incorrecta
----> 2 resultado = 10 / 0  # División por cero

ZeroDivisionError: division by zero

Lógica incorrecta

# Error semántico: Lógica incorrecta
def calcular_promedio(valores):
    suma = 0
    for valor in valores:
        suma += valor
    promedio = suma / len(valores)
    return promedio

# Llamar a la función con una lista vacía
valores = []
promedio = calcular_promedio(valores)
print("El promedio es:", promedio)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[86], line 11
      9 # Llamar a la función con una lista vacía
     10 valores = []
---> 11 promedio = calcular_promedio(valores)
     12 print("El promedio es:", promedio)

Cell In[86], line 6, in calcular_promedio(valores)
      4 for valor in valores:
      5     suma += valor
----> 6 promedio = suma / len(valores)
      7 return promedio

ZeroDivisionError: division by zero

En este caso, si la lista valores está vacía, se generará un error al intentar dividir por cero, lo cual es un error semántico en el contexto del programa.

Uso incorrecto de estructuras de datos

# Error semántico: Uso incorrecto de una lista
numeros = [1, 2, 3, 4, 5]
ultimo_numero = numeros[10]  # Acceso a un índice fuera de rango

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[87], line 3
      1 # Error semántico: Uso incorrecto de una lista
      2 numeros = [1, 2, 3, 4, 5]
----> 3 ultimo_numero = numeros[10]  # Acceso a un índice fuera de rango

IndexError: list index out of range

Valores incorrectos

# Error semántico: Asignación incorrecta de valores
edad = -10  # Edad negativa

Lógica de negocio incorrecta

# Error semántico: Cálculo incorrecto
precio = 100
descuento = 200  # Descuento mayor que el precio
precio_final = precio - descuento

Cómo Identificar Errores Semánticos

Los errores semánticos generalmente se detectan cuando el programa produce resultados inesperados o incorrectos. Para identificar y corregir estos errores, es importante comprender la lógica del programa y revisar cuidadosamente el código en busca de posibles problemas. La depuración paso a paso y las pruebas exhaustivas del programa pueden ayudar a identificar y corregir los errores semánticos de manera efectiva.

Python

Nomenclatura

Sintaxis

Operaciones

Control de Flujo

Condicional if-elif-else

Bucle While

Ciclo For con la Función Range()

Salir o Continuar un Ciclo

Estructura de datos

Listas

Tuplas

Conjuntos

Diccionarios

Funciones

Definiciones

Sintaxis

Excepciones

Errores de Sintaxis

Excepciones

Errores Semánticos

Ciclo `For` con la Función Range()