“El código limpio siempre parece que fue fácil de Apéndice

escribir.” Capítulo
— Martin Fowler

Autor de Refactoring "Patterns of Enterprise Application

II
2

Architecture". Ha contribuido significativamente a la prác-

tica de la ingeniería de software, especialmente en el área
de diseño de código limpio y arquitecturas empresariales.

PROGRAMACIÓN AVANZADA
EN PYTHON

Objetivos:

Desarrollar habilidades avanzadas de programación en Python.

Implementar estructuras de control avanzadas y manejo de errores.

Contenido:

1. Sintaxis avanzada de Python.

F
2. Operadores y expresiones complejas.
R

3. Condicionales avanzadas (if, else, elif) y estructuras anidadas.

SW

4. Bucles avanzados (for, while) y comprensión de listas.

5. Manejo de errores y excepciones avanzadas.

1. Sintaxis Avanzada de Python

La sintaxis avanzada de Python permite escribir código más eficiente y legible. Esta sección
cubre conceptos como listas por comprensión, funciones lambda, y el uso de decoradores.

1.1. Listas por Comprensión

Las listas por comprensión son una manera concisa de crear listas. Aquí hay un ejemplo
simple:

# Crear una lista de los cuadrados de los números del 1 al 10

cuadrados = [x**2 for x in range(1, 11)]
print(cuadrados)

16
Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

1.2. Funciones Lambda

Las funciones lambda son pequeñas funciones anónimas que se definen usando la palabra
clave lambda. Son útiles para operaciones simples que se utilizan una sola vez:

# Función lambda para sumar dos números

suma = lambda a, b: a + b
print(suma(3, 5))

1.3. Decoradores

Los decoradores son funciones que modifican el comportamiento de otras funciones. Se

utilizan comúnmente para la autenticación, logging, y control de acceso:

# Decorador para imprimir el nombre de la función antes de ejecutarla

def decorador(func):
def wrapper(*args, **kwargs):
print(f"Ejecutando {func.__name__}")
return func(*args, **kwargs)
return wrapper
F
R
@decorador
def saludar():
SW

print("Hola, Mundo")

saludar()

2. Operadores y Expresiones Complejas

Python ofrece una variedad de operadores que se pueden utilizar para escribir expresiones
complejas. Estos incluyen operadores aritméticos, lógicos, de comparación y bit a bit.

2.1. Operadores Aritméticos

Los operadores aritméticos básicos incluyen la suma (+), resta (-), multiplicación (*),
división (/), división entera (//), módulo ( %), y potencia (**).

# Ejemplo de operadores aritméticos

a = 10
b = 3

Universidad Nacional de Ingeniería (UNI) 17

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

print(a + b) # Suma
print(a - b) # Resta
print(a * b) # Multiplicación
print(a / b) # División
print(a // b) # División entera
print(a % b) # Módulo
print(a ** b) # Potencia

2.2. Operadores Lógicos

Los operadores lógicos (and, or, not) se utilizan para combinar expresiones booleanas.

# Ejemplo de operadores lógicos

x = True
y = False
print(x and y) # False
print(x or y) # True
print(not x) # False
F
2.3. Operadores de Comparación
R
Los operadores de comparación (==, !=, >, <, >=, <=) se utilizan para comparar valores.
SW

# Ejemplo de operadores de comparación

a = 5
b = 10
print(a == b) # False
print(a != b) # True
print(a > b) # False
print(a < b) # True
print(a >= b) # False
print(a <= b) # True

2.4. Operadores Bit a Bit

Los operadores bit a bit (&, |, ˆ, ˜, «, ») se utilizan para realizar operaciones a nivel de
bits.

Universidad Nacional de Ingeniería (UNI) 18

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

# Ejemplo de operadores bit a bit

a = 60 # 0011 1100
b = 13 # 0000 1101
print(a & b) # 0000 1100
print(a | b) # 0011 1101
print(a ^ b) # 0011 0001
print(~a) # 1100 0011
print(a << 2) # 1111 0000
print(a >> 2) # 0000 1111

3. Condicionales Avanzadas y Estructuras Anidadas

Las condicionales avanzadas y estructuras anidadas permiten escribir código más complejo
y con más lógica.

3.1. Condicionales Anidadas

Las condicionales anidadas permiten evaluar múltiples condiciones.

# Ejemplo de condicionales anidadas

F
x = 10
if x > 0:
R
print("x es positivo")
SW

if x % 2 == 0:
print("x es par")
else:
print("x es impar")
else:
print("x es negativo o cero")

3.2. Expresiones Condicionales (if-elif-else)

Las expresiones condicionales permiten evaluar múltiples condiciones de manera secuen-

cial.

# Ejemplo de if-elif-else
nota = 85
if nota >= 90:
print("A")
elif nota >= 80:

Universidad Nacional de Ingeniería (UNI) 19

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

print("B")
elif nota >= 70:
print("C")
elif nota >= 60:
print("D")
else:
print("F")

4. Bucles Avanzados y Comprensión de Listas

Los bucles avanzados y la comprensión de listas permiten iterar y manipular datos de

manera eficiente.

4.1. Bucles for y while Avanzados

Los bucles for y while se pueden utilizar para realizar iteraciones más complejas.

# Ejemplo de bucle ‘for‘ con ‘else‘

for i in range(5):
print(i)
F
else:
print("Bucle terminado")
R
SW

# Ejemplo de bucle ‘while‘ con ‘break‘ y ‘continue‘

i = 0
while i < 10:
i += 1
if i % 2 == 0:
continue
print(i)

4.2. Comprensión de Listas

La comprensión de listas permite crear nuevas listas basadas en las existentes de manera
concisa.

# Ejemplo de comprensión de listas

numeros = [1, 2, 3, 4, 5]
cuadrados = [x**2 for x in numeros if x % 2 == 0]
print(cuadrados) # [4, 16]

Universidad Nacional de Ingeniería (UNI) 20

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

5. Manejo de Errores y Excepciones Avanzadas

El manejo de errores y excepciones permite controlar el flujo del programa y manejar

situaciones inesperadas.

5.1. Manejo Básico de Excepciones

El manejo básico de excepciones se realiza con las palabras clave try, except, else y
finally.

# Ejemplo de manejo básico de excepciones

try:
numero = int(input("Ingrese un número: "))
print(f"El número ingresado es: {numero}")
except ValueError:
print("Entrada no válida. Por favor, ingrese un número entero.")
else:
print("Operación completada sin errores.")
finally:
print("Fin del manejo de excepciones.")
F
5.2. Definición de Excepciones Personalizadas
R

Las excepciones personalizadas permiten definir y manejar errores específicos del dominio
SW

de la aplicación.

# Ejemplo de excepción personalizada

class ErrorPersonalizado(Exception):
pass

def verificar_numero(numero):
if numero < 0:
raise ErrorPersonalizado("El número no puede ser negativo")

try:
numero = int(input("Ingrese un número positivo: "))
verificar_numero(numero)
except ErrorPersonalizado as e:
print(e)
except ValueError:

Universidad Nacional de Ingeniería (UNI) 21

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

print("Entrada no válida. Por favor, ingrese un número entero.")

Este capítulo proporciona una comprensión más profunda de las técnicas avanzadas de pro-
gramación en Python, con ejemplos prácticos que demuestran cómo aplicar estos conceptos
en la codificación diaria.

Lecturas Propuestas. "Fluent Python"de Luciano Ramalho, Capítulo 2.

Capítulo 2: An Array of Sequences

El capítulo 2 de "Fluent Python"se centra en las secuencias en Python, un tipo de colección

muy utilizada. Se examinan varios tipos de secuencias, incluyendo listas, tuplas, y arrays.
A continuación, se resumen los puntos principales tratados en este capítulo:

Tipos de Secuencias

1. Contenedores: - Las listas y tuplas son ejemplos de secuencias contenedoras. - Estas

pueden almacenar elementos de diferentes tipos y hacer referencia a otros objetos.

2. Secuencias Planas: - Los arrays y los objetos del módulo array son secuencias planas. -
Almacenan datos en un formato más compacto y homogéneo.

Listas
F
- Las listas son mutables, lo que significa que pueden cambiarse después de su creación. -
R
Permiten agregar, eliminar y modificar elementos.
SW

Tuplas

- Las tuplas son inmutables, lo que significa que una vez creadas, no pueden modificarse. -
Se usan para agrupar datos heterogéneos. - Se pueden utilizar como claves en diccionarios
debido a su inmutabilidad.

Arrays

- Los arrays se utilizan para almacenar grandes volúmenes de datos numéricos. - Ofrecen un
mejor rendimiento en comparación con las listas cuando se trata de operaciones matemáticas
y numéricas.

Métodos y Operaciones Comunes

- Indexación y Segmentación: Tanto las listas como las tuplas soportan indexación y
segmentación. - Iteración: Se pueden recorrer usando bucles for. - Comprensión de Listas:
Una forma concisa de crear listas mediante expresiones. - Métodos de Lista: Métodos como
append, extend, insert, remove, y pop permiten modificar listas.

Universidad Nacional de Ingeniería (UNI) 22

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

Comprensiones y Generadores

- Las comprensiones de listas y generadores son herramientas poderosas para crear y manejar
secuencias de manera eficiente. - Permiten crear listas de forma más compacta y legible.

Usos y Aplicaciones

- Las secuencias se utilizan en una variedad de contextos en la programación en Python,

desde el almacenamiento de datos hasta la manipulación de colecciones de objetos. - El
conocimiento profundo de las secuencias y sus operaciones es fundamental para escribir
código Python eficiente y efectivo.

Este capítulo proporciona una base sólida en la comprensión y el uso de secuencias en

Python, lo que es esencial para aprovechar al máximo las capacidades del lenguaje.

6. Ejercicio Práctico: Análisis y Cálculo de la Eficiencia de una Estructura de

Vigas

Descripción: En este ejercicio, se desarrollará un programa en Python para analizar y

calcular la eficiencia de una estructura de vigas en términos de la relación entre la resistencia
y el peso. Se pedirá al usuario que ingrese las dimensiones y propiedades de varias vigas,
y el programa calculará la resistencia total, el peso total y la eficiencia de la estructura.
F
Este ejercicio utilizará listas por comprensión, funciones lambda, decoradores, operadores
avanzados, estructuras condicionales y manejo de excepciones.
R

Objetivos del Ejercicio:

SW

1. Practicar la lectura de entradas del usuario.

2. Utilizar operaciones aritméticas y condicionales.

3. Aplicar estructuras de control secuenciales, for y while.

4. Modularizar el código utilizando funciones y decoradores.

5. Manejar errores y excepciones para asegurar la robustez del programa.

Enunciado del Problema

Una estructura de vigas se compone de varias vigas de diferentes dimensiones y materiales.

Cada viga tiene una longitud, un área de la sección transversal, una densidad del material
y un factor de resistencia específico. El objetivo es calcular la eficiencia de la estructura en
términos de la relación entre la resistencia total y el peso total.

Fórmulas:

Universidad Nacional de Ingeniería (UNI) 23

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

Resistencia de una viga:

Resistencia = Área de la Sección Transversal × Factor de Resistencia

Peso de una viga:

Peso = Longitud × Área de la Sección Transversal × Densidad del Material

Eficiencia de la estructura:

Resistencia Total
Eficiencia =
Peso Total

Escribe un programa en Python que:

1. Solicite al usuario que ingrese el número de vigas.

2. Solicite al usuario que ingrese las dimensiones y propiedades de cada viga.

3. Calcule la resistencia total y el peso total de la estructura.

4. Calcule la eficiencia de la estructura.

F
5. Maneje errores y excepciones para entradas inválidas.
R

6. Muestre los resultados.

SW

Solución

Aquí está el código Python para resolver el problema:

def decorador(func):
def wrapper(*args, **kwargs):
print(f"Ejecutando {func.__name__}...")
return func(*args, **kwargs)
return wrapper

@decorador
def leer_dato_positivo(mensaje):
while True:
try:
valor = float(input(mensaje))
if valor > 0:

Universidad Nacional de Ingeniería (UNI) 24

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

return valor
else:
print("El valor debe ser positivo.")
except ValueError:
print("Entrada no válida. Por favor, ingrese un número.")

@decorador
def calcular_resistencia(area_seccion, factor_resistencia):
return area_seccion * factor_resistencia

@decorador
def calcular_peso(longitud, area_seccion, densidad_material):
return longitud * area_seccion * densidad_material

def calcular_eficiencia(resistencia_total, peso_total):

try:
eficiencia = resistencia_total / peso_total
return eficiencia
except ZeroDivisionError:
F
print("Error: El peso total no puede ser cero.")
R
return None
SW

def main():
num_vigas = int(leer_dato_positivo("Ingrese el número de vigas en la estructura: "))

vigas = []
for i in range(num_vigas):
print(f"\nIngresando datos para la viga {i+1}:")
longitud = leer_dato_positivo("Ingrese la longitud de la viga (m): ")
area_seccion = leer_dato_positivo("Ingrese el área de la sección transversal de la viga
densidad_material = leer_dato_positivo("Ingrese la densidad del material de la viga (kg/
factor_resistencia = leer_dato_positivo("Ingrese el factor de resistencia de la viga: ")

resistencia = calcular_resistencia(area_seccion, factor_resistencia)

peso = calcular_peso(longitud, area_seccion, densidad_material)

[Link]((resistencia, peso))

Universidad Nacional de Ingeniería (UNI) 25

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

resistencia_total = sum([viga[0] for viga in vigas])

peso_total = sum([viga[1] for viga in vigas])
eficiencia = calcular_eficiencia(resistencia_total, peso_total)

print(f"\nResultados:")
print(f"Resistencia total de la estructura: {resistencia_total:.2f} unidades de resisten
print(f"Peso total de la estructura: {peso_total:.2f} kg")
if eficiencia is not None:
print(f"Eficiencia de la estructura: {eficiencia:.6f} unidades de resistencia por kg")

if __name__ == "__main__":
main()

Explicación del Código

1. Definición de Funciones:

decorador(func): Un decorador para imprimir el nombre de la función antes

de ejecutarla.
F
leer_dato_positivo(mensaje): Lee un valor positivo desde el usuario, asegu-
R

rando que la entrada sea válida.

SW

calcular_resistencia(area_seccion, factor_resistencia): Calcula la re-

sistencia de una viga.

calcular_peso(longitud, area_seccion, densidad_material): Calcula el

peso de una viga.

calcular_eficiencia(resistencia_total, peso_total): Calcula la eficien-

cia de la estructura, manejando la división por cero.

2. Lectura de Entradas y Cálculos:

Se leen las dimensiones y propiedades de cada viga.

Se calculan la resistencia y el peso de cada viga.

Se almacenan los resultados en una lista de tuplas vigas.

Se suman las resistencias y pesos para obtener los totales.

Se calcula la eficiencia de la estructura.

Universidad Nacional de Ingeniería (UNI) 26

Capítulo II. PROGRAMACIÓN AVANZADA EN PYTHON

3. Mostrar Resultados:

Se muestran la resistencia total, el peso total y la eficiencia de la estructura.

Explicación de los Resultados

1. Resistencia Total:

Viga 1: 0,02 m2 × 250 = 5 unidades de resistencia

Viga 2: 0,025 m2 × 300 = 7,5 unidades de resistencia

Resistencia Total: 5 + 7,5 = 12,5 unidades de resistencia

2. Peso Total:

Viga 1: 10 m × 0,02 m2 × 7850 kg/m3 = 1570 kg

Viga 2: 12 m × 0,025 m2 × 7850 kg/m3 = 2352 kg

Peso Total: 1570 + 2352 = 3922 kg

3. Eficiencia:

Eficiencia: 12,5
3922 ≈ 0,003187 unidades de resistencia por kg
F
Este ejercicio práctico proporciona una aplicación más elaborada de la programación en un
contexto de ingeniería civil, utilizando conceptos avanzados de Python para resolver un
R

problema realista de ingeniería civil.

SW

Universidad Nacional de Ingeniería (UNI) 27