Pandas & NumPy Academy · Lezione

Creazione di DataFrame

Costruisca DataFrame da dict di liste, liste di dict e array NumPy, quindi ne analizzi shape, columns e dtypes.

Creazione di DataFrame è 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.

Che cos'è un DataFrame?

Un DataFrame è una struttura dati bidimensionale, modificabile nelle dimensioni ed etichettata: in sostanza, una tabella con righe e colonne, simile a un foglio di calcolo o a una tabella SQL. Ogni colonna è una Series Pandas che condivide lo stesso indice delle righe. I DataFrame possono contenere colonne con dtype diversi, il che li rende perfetti per i dataset reali che combinano numeri, testo e date.

import pandas as pd

df = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol'],
                   'age': [30, 25, 35],
                   'score': [88.5, 72.0, 95.3]})
print(df)

Creazione da un dict di liste

Il modo più comune per costruire un DataFrame consiste nell'usare un dict di liste: le chiavi diventano i nomi delle colonne e le liste diventano i valori delle colonne. Tutte le liste devono avere la stessa lunghezza. Per impostazione predefinita, l'indice delle righe è 0, 1, 2, ... a meno che non ne specifichi uno con index=. Questo schema rispecchia il modo in cui i dati CSV vengono spesso rappresentati in Python.

import pandas as pd

df = pd.DataFrame({
    'city': ['Berlin', 'Paris', 'Rome'],
    'pop': [3.6, 2.2, 2.8],
    'country': ['DE', 'FR', 'IT']
})
print(df.shape)    # (3, 3)
print(df.dtypes)

Creazione da una lista di dict

Può anche passare una lista di dict, in cui ogni dict rappresenta una riga. Le chiavi mancanti in un dict producono NaN per la colonna corrispondente. Questo formato è comune quando si utilizzano API JSON che restituiscono un elenco di oggetti record. Pandas allinea automaticamente tutte le chiavi dei dict per formare l'insieme delle colonne.

import pandas as pd

rows = [
    {'name': 'Alice', 'age': 30, 'dept': 'Eng'},
    {'name': 'Bob',   'age': 25},              # 'dept' missing -> NaN
    {'name': 'Carol', 'age': 35, 'dept': 'HR'}
]
df = pd.DataFrame(rows)
print(df)

Creazione da un array NumPy

Passare un array NumPy bidimensionale crea un DataFrame con nomi interi per le colonne (0, 1, 2, ...) e un RangeIndex per impostazione predefinita. Fornisca columns= e index= per aggiungere etichette significative. Questo costituisce il collegamento tra il calcolo numerico di NumPy e l'analisi dei dati etichettati di Pandas.

import pandas as pd
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
df = pd.DataFrame(arr,
                  columns=['x', 'y', 'z'],
                  index=['r1', 'r2', 'r3'])
print(df)

Impostazione di un indice personalizzato alla creazione

Il parametro index= imposta le etichette delle righe al momento della creazione. Tra le scelte comuni vi sono stringhe di date, ID o nomi di categorie che rendono significative le ricerche delle righe. Un indice scelto bene rende intuitivo l'accesso con .loc e abilita potenti operazioni sulle serie temporali quando l'indice è un DatetimeIndex.

import pandas as pd

df = pd.DataFrame(
    {'revenue': [100, 200, 150], 'costs': [80, 160, 90]},
    index=['Jan', 'Feb', 'Mar']
)
print(df)
print(df.loc['Feb'])  # select row 'Feb'

Ispezione di colonne, dtype e indice

Tre attributi comunicano immediatamente la struttura di un DataFrame: df.columns fornisce un Index con i nomi delle colonne, df.dtypes restituisce una Series che associa ogni colonna al relativo dtype e df.index descrive le etichette delle righe. Questi sono i primi controlli da eseguire su ogni nuovo DataFrame per capire quali dati si hanno prima di trasformarli.

import pandas as pd

df = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0], 'c': ['x', 'y']})
print(df.columns)  # Index(['a', 'b', 'c'], dtype='object')
print(df.dtypes)
# a      int64
# b    float64
# c     object
print(df.index)    # RangeIndex(start=0, stop=2, step=1)

Specifica dell'ordine delle colonne

Quando si costruisce un DataFrame da un dict, l'ordine delle colonne segue quello di inserimento delle chiavi nel dict (Python 3.7+). Se serve un ordine specifico, passi il parametro columns= con un elenco di nomi di colonne. Ogni nome non presente nei dati produrrà una colonna NaN; ogni nome presente nei dati ma non nell'elenco verrà escluso. In questo modo può selezionare e ordinare le colonne già in fase di creazione.

import pandas as pd

data = {'c': [3, 6], 'a': [1, 4], 'b': [2, 5]}
df = pd.DataFrame(data, columns=['a', 'b', 'c'])
print(df.columns.tolist())  # ['a', 'b', 'c']

Creazione da un dict di Series

Passare un dict di Series Pandas allinea i dati sull'unione di tutti gli indici. Se una Series non contiene un'etichetta presente in un'altra, la cella corrispondente nel risultato contiene NaN. Questo è il metodo di costruzione più consapevole degli indici e viene usato quando si combinano colonne calcolate separatamente che possono avere un numero diverso di righe o etichette diverse.

import pandas as pd

s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([10, 20], index=['b', 'c'])
df = pd.DataFrame({'col1': s1, 'col2': s2})
print(df)
#    col1  col2
# a   1.0   NaN
# b   2.0  10.0
# c   3.0  20.0

shape, len e size

df.shape restituisce una tupla (nrows, ncols). len(df) restituisce il numero di righe. df.size restituisce il numero totale di celle (righe × colonne). Questi sono i controlli di coerenza più rapidi da eseguire dopo il caricamento dei dati, per verificare di aver ricevuto il numero di record previsto e che non siano state eliminate colonne senza preavviso.

import pandas as pd

df = pd.DataFrame({'a': range(5), 'b': range(5), 'c': range(5)})
print(df.shape)  # (5, 3)
print(len(df))   # 5
print(df.size)   # 15  (5 rows x 3 cols)

Creazione di un DataFrame vuoto

Può creare un DataFrame vuoto con nomi di colonne e dtype specifici da usare come modello o accumulatore. Aggiunga righe con pd.concat([df, new_row])m. Specificare i dtype al momento della creazione evita l'inferenza dei tipi, costosa quando le righe vengono aggiunte in seguito. Un DataFrame vuoto è utile anche come base nei cicli iterativi di raccolta dei dati.

import pandas as pd

df = pd.DataFrame(columns=['name', 'score'])
new_row = pd.DataFrame([{'name': 'Alice', 'score': 90}])
df = pd.concat([df, new_row], ignore_index=True)
print(df)

Copia di un DataFrame

Assegnare un DataFrame a una nuova variabile crea un riferimento, non una copia: modificare uno modifica anche l'altro. Usi df.copy() per creare una copia indipendente. Questo è importante prima di eseguire trasformazioni che non desidera applicare all'originale o quando vuole conservare un backup precedente alla pulizia mentre costruisce una versione ripulita.

import pandas as pd

original = pd.DataFrame({'a': [1, 2, 3]})
ref = original          # same object!
copy = original.copy()  # independent copy

ref['a'] = 99
print(original['a'].tolist())  # [99 99 99] -- ref modified original
print(copy['a'].tolist())      # [1, 2, 3]  -- copy unchanged

Verifica rapida

Verifichi la Sua comprensione della creazione dei DataFrame presentata in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: i DataFrame possono essere creati da dict di liste, liste di dict o array NumPy, gli attributi columns, dtypes e index descrivono la struttura della tabella e df.copy() è necessario per ottenere una copia indipendente anziché un riferimento. Ora selezioneremo colonne e righe specifiche usando la notazione tra parentesi, .loc e .iloc.

Domande Frequenti

La lezione «Creazione di DataFrame» è gratuita?

Sì — il testo completo di «Creazione di DataFrame» è 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 «Creazione di DataFrame»?

Costruisca DataFrame da dict di liste, liste di dict e array NumPy, quindi ne analizzi shape, columns e dtypes. 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 «Creazione di DataFrame»?

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

← Torna a Pandas & NumPy Academy