Python II: funciones y colecciones

El área es 8
6 15 None

• area(3) usa la altura por defecto, 2: da 6. area(3, 5) da 15.
• mostrar_area(4) imprime «El área es 8» en el momento en que se llama, por eso esa línea sale primero. Como no tiene return, devuelve None, y eso es lo que queda guardado en z.

def normalizar(texto):
    """Minúsculas, sin tildes y con un solo espacio entre palabras."""
    sin_tilde = {"á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u"}
    resultado = ""
    for c in texto.lower():
        resultado += sin_tilde.get(c, c)
    # split() sin argumentos corta en cualquier cantidad de espacios
    return " ".join(resultado.split())

print(repr(normalizar("  ¡Qué   RICO el  Pan! ")))
print(repr(normalizar("Canción   de   CUNA")))

'¡que rico el pan!'
'cancion de cuna'

• sin_tilde.get(c, c) busca la letra en el diccionario; si no está, devuelve la misma letra. Así, la ñ y todo lo demás quedan igual.
• repr muestra el texto con comillas, para que se vea que no quedaron espacios en los bordes.

def mediana(valores):
    """El valor del medio de una lista de números."""
    ordenados = sorted(valores)
    n = len(ordenados)
    medio = n // 2
    if n % 2 == 1:
        return ordenados[medio]
    return (ordenados[medio - 1] + ordenados[medio]) / 2

print(mediana([7, 1, 5]), mediana([8, 3, 1, 10]))
matematica = leer_columna("notas.csv", "matematica")
print("Mediana:", mediana(matematica),
      "  Promedio:", round(promedio(matematica), 1))

5 5.5
Mediana: 72.5   Promedio: 69.5

• Con 4 valores, medio es 2 y los del medio están en las posiciones 1 y 2 (recuerda que se cuenta desde 0).
• Se usa sorted, que devuelve una lista nueva, y no valores.sort(), que ordenaría la lista original de quien llamó la función (mira el ejercicio 5).
• La mediana (72,5) queda arriba del promedio (69,5) porque el 40 de Diego tira el promedio hacia abajo, pero a la mediana casi no la mueve.

fahrenheit = [round(celsius_a_fahrenheit(t), 1) for t in semana]
calurosos = [t for t in semana if t > 22]
dias = [d for d, t in enumerate(semana, start=1) if t > 22]
print(fahrenheit)
print(calurosos)
print(dias)

[65.3, 69.8, 74.1, 67.6, 77.2, 72.9, 64.2]
[23.4, 25.1, 22.7]
[3, 5, 6]

En c), cada elemento de enumerate es una tupla (día, temperatura) que se desempaqueta en d, t; se guarda d solo si t pasa de 22.

El primero. Al llamar con_bono(originales), el parámetro lista no recibe una copia: recibe la misma lista, con otro nombre. Cambiar lista[i] adentro de la función cambia la lista de afuera. nuevas y originales son dos nombres para una sola lista. La solución es crear una lista nueva, por ejemplo con una comprensión:

def con_bono(lista):
    return [n + 5 for n in lista]

originales = [70, 45, 88]
nuevas = con_bono(originales)
print("Nuevas:    ", nuevas)
print("Originales:", originales)

Nuevas:     [75, 50, 93]
Originales: [70, 45, 88]

Otra forma es copiar al principio de la función con lista = lista.copy().

El segundo. El método sort ordena la lista en su lugar (la cambia) y devuelve None. Si quieres una lista nueva ordenada, usa sorted; si te da igual cambiar la original, llama sort sin asignar:

notas_curso = [70, 45, 88]
ordenadas = sorted(notas_curso)
print(ordenadas, notas_curso)
notas_curso.sort()
print(notas_curso)

[45, 70, 88] [70, 45, 88]
[45, 70, 88]

Regla práctica: una función que recibe una lista no debería cambiarla, salvo que ese sea justamente su trabajo y lo diga su nombre.

resultado = contar(votos)
print(resultado)

total = len(votos)
for fruta, n in sorted(resultado.items(), key=la_cuenta, reverse=True):
    print(f"{fruta:<8} {n} votos  ({n / total:.0%})")

letras = set()
for fruta in votos:
    for letra in fruta:
        letras.add(letra)
print(len(letras), "letras distintas:", "".join(sorted(letras)))

{'mango': 5, 'plátano': 2, 'uva': 4, 'piña': 2}
mango    5 votos  (38%)
uva      4 votos  (31%)
plátano  2 votos  (15%)
piña     2 votos  (15%)
13 letras distintas: agilmnoptuváñ

• {fruta:<8} rellena el nombre con espacios hasta 8 caracteres, para que las columnas queden alineadas; {n / total:.0%} escribe una proporción como porcentaje sin decimales.
• Para la «á» de plátano, el conjunto la cuenta como una letra distinta de la «a». Si quisieras contarlas juntas, primero pasarías cada voto por normalizar del ejercicio 2.

a = set(limpiar(frase_1).split())
b = set(limpiar(frase_2).split())
print("En las dos:      ", sorted(a & b))
print("Solo en la 1.ª:  ", sorted(a - b))

En las dos:       ['ana', 'corre', 'el', 'en', 'parque']
Solo en la 1.ª:   ['de', 'perro']

Sin limpiar, «parque.» (con punto) y «parque» serían palabras distintas y no aparecerían en común; «El» y «el», tampoco.

# a) Solo con open: la primera línea son los nombres
with open("ventas.csv", encoding="utf-8") as f:
    lineas = f.readlines()
print(lineas[0].strip())
print(len(lineas) - 1, "filas de datos")

# b) Con csv.DictReader y un diccionario producto → total
totales = {}
with open("ventas.csv", encoding="utf-8") as f:
    for fila in csv.DictReader(f):
        producto = fila["producto"]
        cantidad = int(fila["cantidad"])
        totales[producto] = totales.get(producto, 0) + cantidad
print(totales)

dia,producto,cantidad
12 filas de datos
{'pan': 205, 'leche': 55, 'queso': 12}

• f.readlines() lee todo el archivo de una vez y devuelve una lista con una línea por elemento.
• La línea clave de b) es la misma que la de contar palabras, pero sumando cantidad en lugar de 1. Un diccionario que acumula por clave es uno de los patrones más útiles de todo el análisis de datos.
• Sin int(...), totales.get(producto, 0) + cantidad fallaría con un TypeError, porque cantidad llegaría como texto.

a) Un ModuleNotFoundError: No module named 'wordcloud'. Se arregla con una celda que diga:

!pip install wordcloud

Después de instalarlo, vuelve a ejecutar la celda del import.

b) Con import sklearn (o, más común, from sklearn.linear_model import LinearRegression). El nombre para instalar y el nombre para importar no siempre coinciden.

c) pip install descarga e instala un paquete en la computadora: se hace una vez. import carga en tu programa un módulo que ya está instalado: se hace en cada programa que lo use. random viene con Python, así que nunca hace falta instalarlo.

class Contador:
    """Cuenta cuántas veces aparece cada cosa."""

    def __init__(self):
        self.conteo = {}

    def agregar(self, cosa):
        self.conteo[cosa] = self.conteo.get(cosa, 0) + 1

    def agregar_todas(self, cosas):
        for cosa in cosas:
            self.agregar(cosa)

    def mas_comunes(self, k):
        pares = sorted(self.conteo.items(), key=lambda par: par[1],
                       reverse=True)
        return pares[:k]

    def total(self):
        return sum(self.conteo.values())

    def proporcion(self, cosa):
        return self.conteo.get(cosa, 0) / self.total()

c = Contador()
c.agregar_todas(palabras)
print(c.total(), "palabras")
print(f"pan: {c.proporcion('pan'):.1%}   queso: {c.proporcion('queso')}")

63 palabras
pan: 6.3%   queso: 0.0

self.conteo.values() da solo los valores del diccionario (las cuentas), y sum los suma. Los métodos nuevos usan self.conteo, el mismo dato que llenó agregar_todas: eso es lo que hace útil a un objeto.

def leer_notas(archivo):
    """Diccionario nombre → lista de notas (números)."""
    notas = {}
    with open(archivo, encoding="utf-8") as f:
        for fila in csv.DictReader(f):
            nombre = fila["nombre"]
            notas[nombre] = [float(fila[f"trimestre_{t}"])
                             for t in (1, 2, 3)]
    return notas


def reporte(notas, minimo=51):
    """Imprime el reporte del curso."""
    promedios = {n: promedio(v) for n, v in notas.items()}

    print("1. Promedios, del mejor al peor")
    for nombre, p in sorted(promedios.items(), key=la_cuenta,
                            reverse=True):
        print(f"   {nombre:<10} {p:5.1f}")

    reprobados = [n for n, p in promedios.items() if p < minimo]
    print(f"2. Aprueban {len(notas) - len(reprobados)} de {len(notas)}."
          f" No aprueban: {', '.join(reprobados)}")

    print("3. Promedio del curso por trimestre")
    for t in range(3):
        del_trimestre = [v[t] for v in notas.values()]
        print(f"   Trimestre {t + 1}: {promedio(del_trimestre):.1f}"
              f"  (mediana {mediana(del_trimestre):.1f})")

    mejoras = {n: v[2] - v[0] for n, v in notas.items()}
    mejor = max(mejoras, key=mejoras.get)
    print(f"4. Mejoró más: {mejor}, {mejoras[mejor]:+.0f} puntos")


reporte(leer_notas("curso.csv"))

1. Promedios, del mejor al peor
   Fernanda    95.3
   Camila      88.7
   Lucía       78.7
   Andrea      78.3
   Isabel      77.0
   Mateo       69.7
   Gabriel     60.3
   Daniel      54.7
   Benjamín    51.7
   Joaquín     46.7
2. Aprueban 9 de 10. No aprueban: Joaquín
3. Promedio del curso por trimestre
   Trimestre 1: 67.0  (mediana 69.0)
   Trimestre 2: 70.2  (mediana 72.0)
   Trimestre 3: 73.1  (mediana 74.5)
4. Mejoró más: Gabriel, +20 puntos

• leer_notas arma cada lista con una comprensión que lee las columnas trimestre_1, trimestre_2 y trimestre_3.
• max(mejoras, key=mejoras.get) recorre las claves del diccionario y se queda con la que tiene el valor más grande: la misma idea de key que en sorted.
• El promedio del curso sube trimestre a trimestre, pero no todos mejoraron: Daniel y Lucía bajaron. Un promedio general esconde a las personas; por eso conviene mirar también cada caso.
• Para ir más allá: guarda el reporte en un archivo reporte.txt (abre con "w" y usa f.write(...) en lugar de print), o grafica los promedios con plt.barh, como las palabras de la teoría.