Pandas & NumPy Academy · Lezione

Ordinare in base ai valori delle colonne

Ordini un DataFrame in base a una o più colonne con sort_values(), controlli l'ordine crescente o decrescente e gestisca il posizionamento di NaN.

Ordinare in base ai valori delle colonne è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Perché l'ordinamento è importante

Ordinare un DataFrame è importante per la presentazione (report dei primi N elementi, classifiche), la correttezza (le operazioni sulle serie temporali richiedono un ordine cronologico) e le prestazioni (la ricerca binaria su un indice ordinato è O(log n) invece di O(n)). Il metodo sort_values() di Pandas è lo strumento principale per ordinare in base al contenuto delle colonne e restituisce un nuovo DataFrame senza modificare quello originale.

import pandas as pd

df = pd.DataFrame({
    'name': ['Dave', 'Alice', 'Carol', 'Bob'],
    'score': [75, 92, 88, 65]
})

# Sort by score descending (highest first)
ranked = df.sort_values('score', ascending=False)
print(ranked)
#     name  score
# 1  Alice     92
# 2  Carol     88
# 0   Dave     75
# 3    Bob     65

sort_values() — Utilizzo di base

DataFrame.sort_values(by) ordina le righe in base ai valori della colonna specificata. L'argomento by accetta il nome di una singola colonna (stringa) o un elenco di nomi di colonne per un ordinamento su più chiavi. Per impostazione predefinita, l'ordinamento è crescente (dal più piccolo al più grande). Passi ascending=False per ottenere un ordine decrescente.

import pandas as pd

df = pd.DataFrame({
    'product': ['B', 'A', 'C', 'A', 'B'],
    'price': [20, 10, 30, 15, 25]
})

# Ascending by price (default)
print(df.sort_values('price'))
#   product  price
# 1       A     10
# 3       A     15
# 0       B     20
# 4       B     25
# 2       C     30

Ordinare in base a più colonne

Passare un elenco di nomi di colonne a sort_values(by=) ordina prima in base alla prima colonna, poi risolve i casi di parità usando la seconda colonna e così via. Anche il parametro ascending può essere un elenco di valori booleani corrispondenti all'ordine delle colonne, consentendo di usare direzioni diverse per ogni chiave.

import pandas as pd

df = pd.DataFrame({
    'dept': ['HR', 'Eng', 'HR', 'Eng', 'Sales'],
    'salary': [50000, 90000, 60000, 80000, 70000],
    'name': ['Alice', 'Bob', 'Carol', 'Dave', 'Eve']
})

# Sort by dept A-Z, then by salary descending within each dept
sorted_df = df.sort_values(
    by=['dept', 'salary'],
    ascending=[True, False]
)
print(sorted_df)
#     dept  salary   name
# 1    Eng   90000    Bob
# 3    Eng   80000   Dave
# 2     HR   60000  Carol
# 0     HR   50000  Alice
# 4  Sales   70000    Eve

Posizionamento dei NaN con na_position

Per impostazione predefinita, i valori NaN vengono ordinati alla fine del risultato, indipendentemente dall'ordine crescente o decrescente. Utilizzi il parametro na_position per controllare questa posizione: 'last' (predefinito) o 'first'. Decidere dove visualizzare i NaN è importante nelle tabelle ordinate per rango: i valori mancanti potrebbero rappresentare "sconosciuto" e dovrebbero essere chiaramente separati dalle voci valide.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Carol', 'Dave'],
    'score': [92, np.nan, 88, np.nan]
})

# NaN last (default)
print(df.sort_values('score', ascending=False, na_position='last'))
#     name  score
# 0  Alice   92.0
# 2  Carol   88.0
# 1    Bob    NaN
# 3   Dave    NaN

# NaN first
print(df.sort_values('score', na_position='first').head(2))

Ordinamento stabile e parametro kind=

Pandas utilizza per impostazione predefinita un ordinamento stabile (mergesort, che è O(n log n)): quando due righe hanno valori uguali nella chiave di ordinamento, il loro ordine relativo originale viene preservato. Questa stabilità è importante quando si ordina prima in base a una chiave primaria e poi a una secondaria: tra gli elementi a pari merito per la chiave secondaria viene mantenuto l'ordine della chiave primaria. Può cambiare l'algoritmo con kind='quicksort' (più veloce ma non stabile) o kind='heapsort'.

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'B', 'A', 'B'],
    'value': [10, 10, 20, 20],
    'original_row': [0, 1, 2, 3]
})

# Stable sort: equal values keep original relative order
result = df.sort_values('value', kind='mergesort')
print(result)
#    group  value  original_row
# 0      A     10             0
# 1      B     10             1   <- row 0 before row 1 (stable)
# 2      A     20             2
# 3      B     20             3

inplace=True e riassegnazione

Come la maggior parte dei metodi Pandas, sort_values() restituisce per impostazione predefinita un nuovo DataFrame. Passare inplace=True modifica il DataFrame direttamente e restituisce None. L'uso di inplace è generalmente sconsigliato nelle versioni moderne di Pandas perché rende il codice più difficile da concatenare e sottoporre a debug; è più semplice riassegnare sempre il risultato: df = df.sort_values('col').

import pandas as pd

df = pd.DataFrame({'x': [3, 1, 4, 1, 5]})

# Preferred: reassign
df = df.sort_values('x')
print(df['x'].tolist())  # [1, 1, 3, 4, 5]

# Alternative: inplace (not recommended for pipelines)
df2 = pd.DataFrame({'x': [3, 1, 4]})
df2.sort_values('x', inplace=True)
print(df2['x'].tolist())  # [1, 3, 4]

Reimpostare l'indice dopo l'ordinamento

Dopo l'ordinamento, l'indice delle righe riflette le posizioni originali. In una tabella ordinata in modo decrescente, la riga 0 potrebbe avere ora indice 4. Chiami .reset_index(drop=True) per riassegnare indici consecutivi a partire da 0. Questo è importante prima di utilizzare .iloc[0] per ottenere in modo affidabile la riga con il rango più alto o prima di esportare in un file in cui gli indici non consecutivi possono risultare poco chiari.

import pandas as pd

df = pd.DataFrame({'score': [70, 90, 80]})
sorted_df = df.sort_values('score', ascending=False)
print(sorted_df)
#    score
# 1     90
# 2     80
# 0     70

# Clean sequential index
reset_df = sorted_df.reset_index(drop=True)
print(reset_df)
#    score
# 0     90
# 1     80
# 2     70

Ottenere i primi N elementi con nlargest() e nsmallest()

Per selezionare le prime o le ultime N righe in base al valore di una colonna, df.nlargest(n, 'col') e df.nsmallest(n, 'col') sono più efficienti che ordinare l'intero DataFrame e selezionare una porzione. Utilizzano un ordinamento parziale (selezione tramite heap) che ha complessità O(n log k) invece di O(n log n), un aspetto importante per i DataFrame di grandi dimensioni.

import pandas as pd

df = pd.DataFrame({
    'product': ['A', 'B', 'C', 'D', 'E'],
    'revenue': [5000, 12000, 8000, 3000, 15000]
})

# Top 3 by revenue
top3 = df.nlargest(3, 'revenue')
print(top3)
#   product  revenue
# 4       E    15000
# 1       B    12000
# 2       C     8000

# Bottom 2 by revenue
bottom2 = df.nsmallest(2, 'revenue')
print(bottom2)

Ordinare le colonne categoriali secondo l'ordine delle categorie

Quando si ordina una colonna che contiene un dtype Categorical ordinato, sort_values() rispetta l'ordine delle categorie invece dell'ordine alfabetico. Questo è essenziale per ordinare correttamente livelli di priorità, valutazioni di gravità o taglie: 'Small' dovrebbe precedere 'Medium', che a sua volta dovrebbe precedere 'Large', non seguire l'ordine alfabetico in cui 'Large' viene prima.

import pandas as pd

df = pd.DataFrame({
    'size': pd.Categorical(
        ['Large', 'Small', 'Medium', 'Small', 'Large'],
        categories=['Small', 'Medium', 'Large'],
        ordered=True
    ),
    'count': [10, 5, 8, 3, 7]
})

print(df.sort_values('size'))
#      size  count
# 1   Small      5
# 3   Small      3
# 2  Medium      8
# 0   Large     10
# 4   Large      7

Concatenare l'ordinamento con altre operazioni

Poiché sort_values() restituisce un DataFrame, si integra naturalmente nelle catene di metodi. Un modello tipico è: filtrare le righe → aggregare → ordinare → visualizzare i primi N elementi. Le catene mantengono la pipeline di trasformazione lineare e leggibile.

import pandas as pd

df = pd.DataFrame({
    'dept': ['Eng', 'HR', 'Eng', 'Sales', 'HR', 'Eng'],
    'salary': [90000, 50000, 120000, 70000, 55000, 80000]
})

result = (
    df
    .groupby('dept')['salary'].mean()
    .reset_index()
    .sort_values('salary', ascending=False)
    .head(2)
)
print(result)
#    dept    salary
# 0   Eng  96666.67
# 2  Sales  70000.00

Esercitazione: report dei 5 prodotti principali

Ecco un esempio pratico completo per produrre un report dei 5 prodotti principali in base al fatturato: caricare i dati, calcolare il fatturato totale per prodotto, ordinare in modo decrescente, selezionare i primi 5 elementi, reimpostare l'indice per ottenere un numero di posizione ordinato e aggiungere una colonna con la posizione da visualizzare.

import pandas as pd

orders = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B', 'D', 'E', 'A', 'C', 'E'],
    'revenue': [100, 200, 150, 80, 300, 60, 400, 120, 90, 350]
})

top5 = (
    orders
    .groupby('product')['revenue'].sum()
    .reset_index()
    .sort_values('revenue', ascending=False)
    .head(5)
    .reset_index(drop=True)
)
top5.index = top5.index + 1  # rank from 1
top5.index.name = 'rank'
print(top5)

Controllo rapido

Verifichi la Sua comprensione dell'ordinamento dei DataFrame in base ai valori delle colonne.

Riepilogo della lezione

In questa lezione ha imparato che: sort_values(by=) ordina in base a una o più colonne, ascending= può essere un elenco per specificare direzioni diverse per ogni chiave, na_position='last' controlla la posizione dei NaN e nlargest()/nsmallest() estraggono in modo efficiente le prime o le ultime N righe senza ordinare l'intero DataFrame. Dopo l'ordinamento, reimposti sempre l'indice con reset_index() per ottenere un risultato pulito e sequenziale. Ora vedrà come ordinare in base all'indice del DataFrame.

Domande Frequenti

La lezione «Ordinare in base ai valori delle colonne» è gratuita?

Sì — il testo completo di «Ordinare in base ai valori delle colonne» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Ordinare in base ai valori delle colonne»?

Ordini un DataFrame in base a una o più colonne con sort_values(), controlli l'ordine crescente o decrescente e gestisca il posizionamento di NaN. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Ordinare in base ai valori delle colonne»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Ordinare in base ai valori delle colonne
Ordinare in base all'indice
Assegnare ranghi ai valori
Impostare e reimpostare l'indice

← Torna a Pandas & NumPy Academy