Este artículo presenta una serie de ejercicios prácticos y preguntas conceptuales para afianzar conocimientos básicos de Python.

1. Suma alternada hasta el 99

Calcular la suma de la secuencia: 1-2+3-4+5...-99.

numero_actual = 1
acumulador = 0
while numero_actual < 100:
    if numero_actual % 2 == 0:  # Número par
        acumulador -= numero_actual
    else:
        acumulador += numero_actual
    numero_actual += 1
print("El resultado de la suma es:", acumulador)

2. Suma de los primeros 100 números

Calcular la suma de todos los enteros del 1 al 100.

total = 0
for valor in range(1, 101):
    total += valor
print("Suma con bucle for:", total)

# Forma concisa con la función sum y range
print("Suma con sum y range:", sum(range(1, 101)))

3. Tabla de multiplicar (patrón triangular)

Generar una tabla de multiplicar que solo muestre los productos donde el primer factor es menor o igual al segundo.

for multiplicando in range(1, 10):
    for multiplicador in range(1, multiplicando + 1):
        producto = multiplicando * multiplicador
        print(f"{multiplicador} x {multiplicando} = {producto}", end="\t")
    print()  # Salto de línea al final de cada fila

4. Validación de credenciales con intentos limitados

Permitir hasta tres intentos para iniciar sesión con usuario y contraseña.

intentos_realizados = 0
maximo_intentos = 3
credenciales_correctas = False

while intentos_realizados < maximo_intentos and not credenciales_correctas:
    usuario_ingresado = input("Usuario: ")
    contrasena_ingresada = input("Contraseña: ")
    
    if usuario_ingresado == 'admin' and contrasena_ingresada == 'secreta123':
        print("¡Acceso concedido!")
        credenciales_correctas = True
    else:
        print("Credenciales incorrectas.")
        intentos_realizados += 1
        print(f"Intentos restantes: {maximo_intentos - intentos_realizados}")

if not credenciales_correctas:
    print("Se han agotado los intentos.")

5. Imprimir caracteres con su índice

Dada una cadena de entrada, mostrar cada carácter junto con su posición.

cadena_usuario = input("Introduce un texto: ")
for indice, caracter in enumerate(cadena_usuario):
    print(f"Índice {indice}: '{caracter}'")

6. Formas de ejecutar un script Python

Existen dos métodos principales:

1. Mediante el intérprete interactivo (python o python3).
2. Ejecutando un archivo de código fuente directamente (ej. python mi_script.py). En sistemas Unix/Linux, el archivo puede ejecutarse directamente si tiene permisos de ejecución y la línea shebang (#!/usr/bin/env python3).

7. Relación entre bits y bytes

Un byte está compuesto por 8 bits. Los procesadores computacionales típicamente manejan datos en unidades de bytes (8 bits), aunque el almacenamiento a nivel físico se realiza utilizando bits individuales.

8. Relación entre ASCII, Unicode, UTF-8 y GBK

Estándares de codificación de caracteres:

1. ASCII: Estándar original, cubre 128 caracteres básicos (inglés).
2. Unicode: Estándar universal que asigna un código único a cada carácter de casi todos los sistemas de escritura del mundo. Es un mapa abstracto.
3. UTF-8: Es una codificación (esquema) de transformación de Unicode que utiliza un número variable de bytes (1 a 4) por carácter. Es la codificación más extendida en la web.
4. GBK: Codificación utilizada principalmente para caracteres chinos simplificados.

9. Tamaño en bytes de una cadena en distintas codificaciones

Para la cadena "张三" (dos caracteres chinos):

• En UTF-8: Cada carácter comúnmente ocupa 3 bytes, totalizando 6 bytes.
• En GBK: Cada carácter comúnmente ocupa 2 bytes, totalizando 4 bytes.

10. Comentarios en Python

• Comentario de una línea: Se inicia con el símbolo #.
• Comentario multilínea (o docstring): Se encierra entre triples comillas, ya sean simples (''') o dobles (""").

11. Convenciones para declarar variables

• Pueden contener letras (mayúsculas o minúsculas), números y guiones bajos (_).
• No pueden comenzar con un número.
• Se recomienda evitar usar palabras reservadas del lenguaje como nombres de variable.
• Se recomienda usar nombres descriptivos y en minúsculas con guiones bajos para separar palabras (snake_case).

12. Método para obtener la longitud en bits de un entero

El método .bit_length() devuelve el número de bits necesarios para representar el entero en binario, excluyendo el signo y los ceros a la izqueirda.

numero_entero = 5
bits_necesarios = numero_entero.bit_length()
print(f"El número {numero_entero} requiere {bits_necesarios} bits.")  # Salida: 3

13. Valores booleanos

En Python, los dos valores booleanos literales son True (verdadero) y False (falso). Representan un estado de verdad y son el resultado de operaciones de comparación y lógicas.

14. Ejercicio de lectura de código

Analizar el siguiente fragmento y predecir la salida:

cadena_original = "python"
cadena_modificada = cadena_original.capitalize()
print(cadena_original)
print(cadena_modificada)

Salida esperada:

python
Python

Explicación: El método capitalize() devuelve una nueva cadana con el primer carácter en mayúscula y el resto en minúscula, sin modificar la cadena original.

15. Ejercicios de manipulación de cadenas

Utilizando la variable texto = " ejEmplO ":

texto = " ejEmplO "

# a. Eliminar espacios al inicio y al final
texto_limpio = texto.strip()
print(texto_limpio)  # ejEmplO

# b. Comprobar si empieza con "ej"
empieza_con = texto_limpio.startswith("ej")
print(f"¿Empieza con 'ej'? {empieza_con}")  # True

# c. Comprobar si termina con "O"
termina_con = texto_limpio.endswith("O")
print(f"¿Termina con 'O'? {termina_con}")  # True

# d. Reemplazar 'e' por 'E'
texto_reemplazo = texto_limpio.replace('e', 'E')
print(texto_reemplazo)  # EjEmplO

# e. Dividir la cadena en partes usando 'm'
partes_con_m = texto_limpio.partition('m')
print(f"Partition con 'm': {partes_con_m}")  # ('eje', 'm', 'plO')

# f. Convertir a mayúsculas
en_mayusculas = texto_limpio.upper()
print(en_mayusculas)  # EJEMPLO

# g. Convertir a minúsculas
en_minusculas = texto_limpio.lower()
print(en_minusculas)  # ejemplo

# h. Obtener el segundo carácter (índice 1)
segundo_caracter = texto_limpio[1]
print(f"Segundo carácter: '{segundo_caracter}'")  # j

# i. Obtener los primeros 3 caracteres
primeros_tres = texto_limpio[:3]
print(f"Primeros tres caracteres: '{primeros_tres}'")  # eje

# j. Obtener los últimos 2 caracteres
ultimos_dos = texto_limpio[-2:]
print(f"Últimos dos caracteres: '{ultimos_dos}'")  # lO

# k. Encontrar el índice de 'E'
indice_e = texto_limpio.find('E')
print(f"Índice de 'E': {indice_e}")  # 3 (si 'e' fue reemplazado antes) o 3 en el original limpio.

# l. Obtener subcadena sin el último carácter
cadena_sin_ultimo = texto_limpio[:-1]
print(f"Sin último carácter: '{cadena_sin_ultimo}'")  # ejEmp

16. Iterabilidad de las cadenas

Sí, las cadenas (str) en Python son objetos iterables. Esto significa que se pueden recorrer carácter a carácter usando un bucle for.

mi_cadena = "Iterable"
for letra in mi_cadena:
    print(letra)
# Salida: I, t, e, r, a, b, l, e (en líneas separadas)

17. Unión de elementos con un separador

# a. Unir caracteres de una cadena con guion bajo
secuencia = "abcdef"
cadena_unida = "_".join(secuencia)
print(cadena_unida)  # a_b_c_d_e_f

# b. Unir elementos de una lista con guion bajo
lista_nombres = ["Ana", "Luis", "Eva"]
nombres_unidos = "_".join(lista_nombres)
print(nombres_unidos)  # Ana_Luis_Eva

18. Diferencia entre range en Python 2 y Python 3

En Python 2:

• range() genera inmediatamente una lista completa en memoria.
• xrange() devuelve un objeto generador (similar a Python 3).

En Python 3:

• range() devuelve un objeto generador que produce números sobre la marcha, siendo más eficiente en memoria.
• La función xrange() no existe.

Ejemplo con parámetros de range:

# Incremento de 1 en 1
for i in range(0, 10, 1):
    print(i)

# Decremento de 1 en 1
for j in range(10, 0, -1):
    print(j)

19. Calculadora simple de sumas

Programa que lea una expresión como "5 + 9" o " 5+ 9 " y calcule el resultado.

expresion = input("Introduce la suma (ej: 5+9): ")
# Separar por el operador '+' y limpiar espacios
operandos = [op.strip() for op in expresion.split('+')]
# Convertir a enteros y sumar
resultado = sum(int(num) for num in operandos)
print(f"{operandos[0]} + {operandos[1]} = {resultado}")

20. Contar letras y dígitos en una cadena

entrada = input("Introduce un texto: ")
contador_letras = 0
contador_digitos = 0

for caracter in entrada:
    if caracter.isalpha():
        contador_letras += 1
    elif caracter.isdigit():
        contador_digitos += 1

print(f"Total de letras: {contador_letras}")
print(f"Total de dígitos: {contador_digitos}")

21. Relación entre tipos y literales

int es una clase (un tipo de dato) en Python. El número 9 es un objeto (una instancia) de esa clase. De manera similar, str es la clase para cadenas de caracteres, y "hola" es un objeto de tipo str. En Python, todo es un objeto.

22. Plantilla de mensaje personalizado

nombre = input("¿Cuál es tu nombre? ")
lugar = input("¿En qué lugar te encuentras? ")
actividad = input("¿Qué actividad disfrutas? ")

mensaje = f"¡Hola {nombre}! Cuentan que te encanta {actividad} en {lugar}."
print(mensaje)

23. Generador de código de verificación aleatorio

import random
import string

longitud_codigo = 4
caracteres_disponibles = string.ascii_uppercase + string.digits  # Letras mayúsculas y números

codigo_generado = ''.join(random.choices(caracteres_disponibles, k=longitud_codigo))
print(f"Código de verificación: {codigo_generado}")

24. Filtrado de palabras sensibles

palabra_prohibida = "secreto"
texto_original = input("Introduce un mensaje: ")
texto_filtrado = texto_original.replace(palabra_prohibida, "***")
print("Mensaje filtrado:", texto_filtrado)

25. Generación de una tabla dinámica desde entrada de usuario

registros = []
opciones = {'c': 'continuar', 's': 'salir'}

while True:
    print("\n--- Ingrese un nuevo registro ---")
    nombre = input("Nombre (max 20 chars): ")[:20]
    edad = input("Edad (max 20 chars): ")[:20]
    email = input("Email (max 20 chars): ")[:20]
    
    registros.append({"Nombre": nombre, "Edad": edad, "Email": email})
    
    accion = input("¿Continuar (c) o Salir (s)? ").lower()
    if accion == 's':
        break

# Generar tabla
print("\n{:<20}{:<10}{:<20}".format("Nombre", "Edad", "Email"))
print("-" * 50)
for reg in registros:
    print("{Nombre:<20}{Edad:<10}{Email:<20}".format(**reg))