Pensamiento Computacional · Unidad 6 — Bibliotecas de Python
Filas, orden y tortas con pandas
Con una tabla real se hacen tres preguntas todo el tiempo: quién está arriba, cuántos hay de cada cosa y cómo se reparte el total. Para eso están iloc, sort_values, value_counts y la torta.
La explicación
De qué se trata este tema
Las herramientas ya están explicadas: iloc, loc,
sort_values y value_counts en el tema 6.2, y plt.pie en
el 6.3. Acá se usan juntas, que es como aparecen en un trabajo práctico, y se practica lo que
más se confunde: qué fila es «la primera» después de ordenar.
Posición o etiqueta
t.loc[0] la fila cuyo índice es 0, esté donde esté
t.loc[0, "col"] una celda de esa fila
sort_values mueve las filas con su índice: el número de la izquierda viaja con
la fila. Después de ordenar, «el primero» se pide con iloc[0]. Con
loc[0] aparece la fila que al principio estaba en la posición 0, que puede haber
quedado en cualquier lado.
Los tres de arriba
t = pd.DataFrame({"nombre": ["Lu", "Fede", "Rocío", "Tomi", "Ale"],
"minutos": [31, 27, 35, 24, 29]})
top = t.sort_values("minutos").head(3)
print(top)
top = top.reset_index(drop=True)
print(top.loc[0, "nombre"])
3 Tomi 24
1 Fede 27
4 Ale 29
Tomi
Ordenar y después head(3) da los tres de arriba. En una carrera, el menor tiempo es
el mejor, así que va sort_values sin nada más (de menor a mayor); para «los que más
vendieron» iría ascending=False.
Fijate el índice de top: 3, 1, 4. Ahí top.loc[0] daría
KeyError, porque ninguna de esas tres filas tiene índice 0. reset_index(drop=True)
los vuelve a numerar 0, 1, 2 (el drop=True tira los números viejos en vez de
guardarlos en una columna nueva), y desde ahí loc e iloc coinciden otra vez.
De value_counts a la torta
import matplotlib.pyplot as plt
encuesta = pd.DataFrame({"turno": ["mañana", "noche", "mañana", "tarde",
"mañana", "noche"]})
cuantos = encuesta["turno"].value_counts()
print(cuantos)
plt.pie(cuantos.values, labels=cuantos.index, autopct="%1.1f%%")
plt.title("Inscriptos por turno")
plt.show()
value_counts devuelve una serie: en el índice están las categorías y en los
valores, cuántas veces aparece cada una. Es justo lo que pide plt.pie: los
valores para el tamaño de cada porción y el índice para los nombres. Como cada persona está en
un solo turno, los conteos son partes de un mismo total, y ahí una torta sí tiene sentido.
Una tabla de inscriptos tiene las columnas nombre y carrera. Mostrar cuántos hay en cada carrera, de la más elegida a la menos, y hacer una torta con el reparto.
import matplotlib.pyplot as plt
ins = pd.DataFrame({
"nombre": ["Ari", "Bel", "Ciro", "Dai", "Eli", "Fran"],
"carrera": ["Ingeniería", "Medicina", "Ingeniería",
"Derecho", "Medicina", "Ingeniería"]
})
por_carrera = ins["carrera"].value_counts()
print(por_carrera)
plt.pie(por_carrera.values, labels=por_carrera.index, autopct="%1.1f%%")
plt.title("Inscriptos por carrera")
plt.show()
Lo que imprime:
Ingeniería 3
Medicina 2
Derecho 1
Name: count, dtype: int64
El orden ya viene hecho. value_counts pone primero la categoría más
frecuente, así que «de la más elegida a la menos» no necesita ningún sort_values.
La torta. El total es 3 + 2 + 1 = 6 inscriptos, y cada porción es su parte:
3/6 = 50.0%, 2/6 = 33.3% y 1/6 = 16.7%. Eso es lo que escribe
autopct adentro de cada una.
Control: los conteos tienen que sumar len(ins), que es 6, y los porcentajes
de la torta tienen que sumar 100 (50.0 + 33.3 + 16.7 = 100.0).
Una tabla tiene los tiempos (en minutos) de una carrera de 5 km. Mostrar el podio —los tres más rápidos— numerado 1, 2, 3, y explicar por qué top.loc[0] falla si no se renumera.
t = pd.DataFrame({"nombre": ["Lu", "Fede", "Rocío", "Tomi", "Ale"],
"minutos": [31, 27, 35, 24, 29]})
1. Qué es «más rápido». En una carrera gana el que tarda menos, así que el orden
es de menor a mayor: sort_values("minutos"), sin ascending=False.
Es el detalle que más se erra: por costumbre se pone ascending=False y sale el
podio al revés (Rocío, Lu y Ale).
2. Los tres de arriba.
print(top)
3 Tomi 24
1 Fede 27
4 Ale 29
3. Por qué top.loc[0] falla. Las filas conservaron el índice de la tabla
original: 3, 1 y 4. loc[0] busca la etiqueta 0, que era Lu, y Lu no entró al
podio: KeyError: 0. En cambio top.iloc[0] anda y da Tomi, porque
cuenta posiciones.
4. Renumerar.
top.index = top.index + 1
print(top)
1 Tomi 24
2 Fede 27
3 Ale 29
reset_index(drop=True) numera 0, 1, 2 y tira los índices viejos (sin el
drop=True quedarían guardados en una columna nueva llamada index).
Sumarle 1 al índice lo deja 1, 2, 3, que es como se lee un podio. Ahora
top.loc[1, "nombre"] es Tomi.
Control: el primero del podio tiene que ser el mínimo de la columna:
t["minutos"].min() da 24, que es el tiempo de Tomi ✓.
Dónde se pierde el punto: ordenar de mayor a menor (el podio queda con los más lentos) o
pedir el ganador con loc[0] sobre la tabla ordenada sin renumerar.
Dónde se cae la mayoría
- Pedir «el primero» de una tabla ordenada con loc[0]: loc busca la etiqueta 0, que viajó con su fila.
- Escribir t.sort_values("col") en una línea suelta y seguir usando t como si estuviera ordenada.
- Olvidar ascending=False cuando se quiere el mayor arriba: por defecto ordena de menor a mayor.
- Pasarle a plt.pie la columna de texto en vez del conteo: la torta necesita números.
- Creer que los valores de la torta tienen que sumar 100: matplotlib saca el porcentaje del total.
Hasta acá la explicación. La práctica es la otra mitad: 7 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Además trae una animación que muestra la idea en movimiento.
Practicar Filas, orden y tortas con pandas →Los otros temas de la unidad 6
Bibliotecas de Python