Tutorial pandas în Python: ghidul suprem pentru începători

Instalează pandas

Instalează pandas cu comanda pip install în terminal. pandas 3 necesită Python 3.11 sau mai nou; pe un Python mai vechi, pip va instala cea mai nouă versiune pandas 2.x pe care o suportă Pythonul tău.

pip install pandasFuncționează cu

Alternativ, îl poți instala prin conda:

conda install pandasFuncționează cu

După instalarea pandas, e o bună practică să verifici versiunea instalată pentru a te asigura că totul funcționează corect:

import pandas as pd
print(pd.__version__)  # Prints the pandas versionFuncționează cu

Aceasta confirmă că pandas este instalat corect și îți permite să verifici compatibilitatea cu alte pachete.

Ce s-a schimbat în pandas 3.0 și 3.1

pandas 3.0, lansat în ianuarie 2026, a schimbat modul în care funcționează copiile, șirurile și atribuirea, iar pandas 3.1 (octombrie 2026) a deprecat majoritatea utilizărilor lui inplace=True. Codul din tutorialele mai vechi rulează în mare parte încă, dar patru schimbări îi încurcă pe mulți:

• Copy-on-Write este implicit. Orice submulțime sau rezultat al unei metode se comportă ca o copie, așa că modificarea ei nu schimbă niciodată DataFrame-ul original. SettingWithCopyWarning a dispărut, la fel și nevoia de apeluri defensive .copy().
• Atribuirea în lanț nu mai funcționează. df["Age"][0] = 35 actualizează o copie temporară și lasă df neschimbat, iar pandas avertizează cu un ChainedAssignmentError. Folosește în schimb un singur apel .loc[].
• Șirurile au propriul tip de date. Coloanele de text sunt acum deduse ca str în loc de object, susținute de PyArrow când este instalat.
• inplace=True este deprecat pentru sort_values(), reset_index(), dropna(), drop_duplicates(), rename() și alte câteva metode. Reatribuie rezultatul în schimb: df = df.dropna().

Iată schimbarea privind atribuirea în lanț pe un DataFrame mic:

import pandas as pd

patients = pd.DataFrame({"name": ["Ana", "Ben", "Chloe"], "age": [34, 51, 28]})

patients["age"][0] = 35      # chained assignment: patients is not changed
patients.loc[0, "age"] = 35  # a single .loc[] call: patients is updated
print(patients.dtypes)Funcționează cu

name      str
age     int64
dtype: objectFuncționează cu

Fiecare exemplu din acest tutorial urmează regulile pandas 3. Pentru lista completă de schimbări, vezi notele oficiale de lansare pentru pandas 3.0 și pandas 3.1. Dacă întreții cod mai vechi, ghidul nostru despre SettingWithCopyWarning explică comportamentul înlocuit de Copy-on-Write.

Importul de date în pandas

Pentru a începe lucrul cu pandas, importă pachetul Python pandas ca mai jos. Când imporți pandas, cel mai comun alias este pd.

import pandas as pdFuncționează cu

Importul fișierelor CSV

Folosește read_csv() cu calea către fișierul CSV pentru a citi un fișier cu valori separate prin virgulă (vezi tutorialul nostru despre importul de date cu read_csv() pentru mai multe detalii).

df = pd.read_csv("diabetes.csv")Funcționează cu

Această operațiune încarcă fișierul CSV diabetes.csv într-un DataFrame pandas numit df. Pe parcursul acestui tutorial folosim setul de date Pima Indians Diabetes: 768 de pacienți, opt măsurători de sănătate precum Glucose, BMI și Age, și o coloană Outcome în care 1 înseamnă că pacientul a fost diagnosticat cu diabet.

Importul fișierelor text

Citirea fișierelor text este similară cu fișierele CSV. Singura nuanță este că trebuie să specifici un separator cu argumentul sep, ca mai jos. Separatorul este caracterul care separă valorile (coloanele) pe fiecare linie. Cele mai comune sunt virgula (sep=","), tabul (sep="\t"), două puncte (sep=":") și spațiile albe (sep=r"\s+"). r"\s+" este o expresie regulată care potrivește unul sau mai multe caractere de spațiu; prefixul r o face șir brut, astfel încât Python nu tratează \s ca o secvență de escape invalidă.

df = pd.read_csv("diabetes.txt", sep=r"\s+")Funcționează cu

Importul fișierelor Excel (o singură foaie)

Citește fișiere Excel cu funcția read_excel(), folosind calea fișierului ca input. pandas are nevoie de un pachet suplimentar de engine pentru Excel: instalează openpyxl pentru fișiere .xlsx sau xlrd pentru fișiere .xls vechi.

df = pd.read_excel('diabetes.xlsx')Funcționează cu

Poți specifica și alte argumente, precum header pentru a indica ce rând devine antetul DataFrame-ului. Valoarea implicită este 0, care indică primul rând drept anteturi sau nume de coloane. Poți, de asemenea, să specifici nume de coloane ca listă în argumentul names. Argumentul index_col (implicit None) poate fi folosit dacă fișierul conține un index de rând.

Notă: Într-un DataFrame sau o Series pandas, indexul este un identificator care indică poziția unui rând sau a unei coloane într-un DataFrame pandas. Pe scurt, indexul etichetează rândul sau coloana unui DataFrame și îți permite să accesezi un rând sau o coloană specific(ă) folosind indexul său (vei vedea asta mai târziu). Indexul pe rânduri al unui DataFrame poate fi un interval (de ex., 0 la 303), o serie temporală (date sau timestamp-uri), un identificator unic (de ex., employee_ID într-un tabel employees) sau alte tipuri de date. Pentru coloane, de obicei este un șir (care denotă numele coloanei).

Importul fișierelor Excel (mai multe foi)

Citirea fișierelor Excel cu mai multe foi nu e foarte diferită. Trebuie doar să specifici un argument suplimentar, sheet_name, unde poți trece fie un șir pentru numele foii, fie un întreg pentru poziția foii (reține că Python folosește indexare de la 0, unde prima foaie poate fi accesată cu sheet_name = 0)

# Extragem a doua foaie deoarece Python folosește indexare de la 0
df = pd.read_excel('diabetes_multi.xlsx', sheet_name=1)Funcționează cu

Importul fișierelor JSON

Similar funcției read_csv(), poți folosi read_json() pentru tipuri de fișiere JSON, cu numele fișierului JSON ca argument (pentru mai multe detalii citește acest tutorial despre importul de date JSON și HTML în pandas). Codul de mai jos citește un fișier JSON de pe disc și creează un obiect DataFrame df.

df = pd.read_json("diabetes.json")Funcționează cu

Dacă vrei să afli mai multe despre importul de date cu pandas, consultă acest cheat sheet despre importul diverselor tipuri de fișiere în Python. 

Importul de date din baze de date SQL

Pentru a încărca date dintr-o bază de date relațională, folosește pd.read_sql() împreună cu o conexiune la baza de date.

import sqlite3

# Establish a connection to an SQLite database
conn = sqlite3.connect("my_database.db")

# Read data from a table
df = pd.read_sql("SELECT * FROM my_table", conn)Funcționează cu

Pentru alte baze de date, precum PostgreSQL sau MySQL, pasează un engine SQLAlchemy ca conexiune în loc de o conexiune sqlite3. Pentru tabele mari, setează argumentul chunksize pentru a citi rezultatul în loturi.

Importul de date dintr-un API (format JSON)

Dacă datele tale vin dintr-un API web, pandas le poate citi direct cu pd.read_json():

df = pd.read_json("https://api.example.com/data.json")Funcționează cu

Dacă răspunsul API-ului este JSON imbricat, aplatizează-l cu pd.json_normalize(), care transformă cheile imbricate în coloane separate prin punct:

records = [
    {"id": 1, "vitals": {"glucose": 148, "bmi": 33.6}},
    {"id": 2, "vitals": {"glucose": 85, "bmi": 26.6}},
]
pd.json_normalize(records)Funcționează cu

   id  vitals.glucose  vitals.bmi
0   1             148        33.6
1   2              85        26.6Funcționează cu

Exportul de date în pandas

Așa cum pandas poate importa date din diverse tipuri de fișiere, îți permite și să exporți date în diverse formate. Asta se întâmplă mai ales când datele sunt transformate cu pandas și trebuie salvate local pe mașina ta. Mai jos este cum exporți DataFrame-uri pandas în diverse formate.

Exportul unui DataFrame într-un fișier CSV

Un DataFrame pandas (aici folosim df) este salvat ca fișier CSV folosind metoda .to_csv(). Treci calea fișierului și setează index=False dacă nu ai nevoie de indexul rândurilor în fișier (valoarea implicită, index=True, îl scrie ca o coloană suplimentară fără nume). Tutorialul nostru despre salvarea unui DataFrame în CSV acoperă și celelalte argumente.

df.to_csv("diabetes_out.csv", index=False)Funcționează cu

Exportul unui DataFrame într-un fișier JSON

Exportă un obiect DataFrame într-un fișier JSON apelând metoda .to_json().

df.to_json("diabetes_out.json")Funcționează cu

Notă: Un fișier JSON stochează un obiect tabelar precum un DataFrame ca perechi cheie-valoare. Astfel, vei observa antete de coloană repetate într-un fișier JSON.

Exportul unui DataFrame într-un fișier text

Ca și în cazul scrierii DataFrame-urilor în fișiere CSV, poți apela .to_csv(). Singurele diferențe sunt că formatul de ieșire este .txt și trebuie să specifici un separator folosind argumentul sep.

df.to_csv('diabetes_out.txt', header=df.columns, index=None, sep=' ')Funcționează cu

Exportul unui DataFrame într-un fișier Excel

Apelează .to_excel() pe DataFrame pentru a-l salva ca fișier .xlsx (acesta necesită openpyxl). pandas nu mai poate scrie fișiere .xls vechi.

df.to_excel("diabetes_out.xlsx", index=False)Funcționează cu

Vizualizarea și înțelegerea DataFrame-urilor în pandas

După ce citești date tabelare într-un DataFrame, ai nevoie să arunci o privire de ansamblu asupra datelor. Poți fie să vezi un eșantion mic din setul de date, fie un rezumat al datelor sub formă de statistici sumare.

Cum să vizualizezi datele folosind .head() și .tail()

Poți vedea primele sau ultimele rânduri ale unui DataFrame folosind metodele .head() sau .tail(), respectiv. Poți specifica numărul de rânduri prin argumentul n (valoarea implicită este 5).

df.head()Funcționează cu

Primele cinci rânduri ale DataFrame-ului 

df.tail(n = 10)Funcționează cu

Ultimele 10 rânduri ale DataFrame-ului

Înțelegerea datelor folosind .describe()

Metoda .describe() afișează statisticile sumare pentru toate coloanele numerice, precum număr, medie, abatere standard, interval și quartilele coloanelor numerice.

df.describe()Funcționează cu

Obține statistici sumare cu .describe()

Îți oferă rapid o privire asupra scării, asimetriei și intervalului datelor numerice.

Poți, de asemenea, să modifici quartilele folosind argumentul percentiles. Aici, de exemplu, ne uităm la percentilele de 30%, 50% și 70% ale coloanelor numerice din DataFrame-ul df.

df.describe(percentiles=[0.3, 0.5, 0.7])Funcționează cu

Obține statistici sumare cu percentile specifice 

Poți, de asemenea, să izolezi tipuri de date specifice în ieșirea de rezumat folosind argumentul include. Aici, de exemplu, sumarizăm doar coloanele cu tip de date integer. 

df.describe(include=[int])Funcționează cu

Obține statistici sumare doar pentru coloane integer 

În mod similar, ai putea exclude anumite tipuri de date folosind argumentul exclude.

df.describe(exclude=[int])Funcționează cu

              BMI  DiabetesPedigreeFunction
count  768.000000                768.000000
mean    31.992578                  0.471876
std      7.884160                  0.331329
min      0.000000                  0.078000
25%     27.300000                  0.243750
50%     32.000000                  0.372500
75%     36.600000                  0.626250
max     67.100000                  2.420000Funcționează cu

Adesea, practicienii consideră mai ușor să vizualizeze astfel de statistici transpunându-le cu atributul .T.

df.describe().TFuncționează cu

Transpune statisticile sumare cu .T

Pentru mai multe despre descrierea DataFrame-urilor, consultă următorul cheat sheet.

Înțelegerea datelor folosind .info()

Metoda .info() este o modalitate rapidă de a vedea tipurile de date, valorile lipsă și dimensiunea datelor unui DataFrame. Aici setăm argumentul show_counts la True, ceea ce afișează numărul de valori nenule din fiecare coloană. Setăm, de asemenea, memory_usage la True, ceea ce arată utilizarea totală a memoriei de către elementele DataFrame-ului. Când verbose este setat la True, se tipărește rezumatul complet din .info(). 

df.info(show_counts=True, memory_usage=True, verbose=True)Funcționează cu

<class 'pandas.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Pregnancies               768 non-null    int64  
 1   Glucose                   768 non-null    int64  
 2   BloodPressure             768 non-null    int64  
 3   SkinThickness             768 non-null    int64  
 4   Insulin                   768 non-null    int64  
 5   BMI                       768 non-null    float64
  6   DiabetesPedigreeFunction  768 non-null    float64
 7   Age                       768 non-null    int64  
 8   Outcome                   768 non-null    int64  
dtypes: float64(2), int64(7)
memory usage: 54.1 KBFuncționează cu

Înțelegerea datelor tale folosind .shape

Numărul de rânduri și coloane ale unui DataFrame poate fi identificat folosind atributul .shape al DataFrame-ului. Returnează un tuplu (rânduri, coloane) și poate fi indexat pentru a obține doar numărul de rânduri sau doar numărul de coloane.

df.shape # Obține numărul de rânduri și coloane
df.shape[0] # Obține doar numărul de rânduri
df.shape[1] # Obține doar numărul de coloaneFuncționează cu

(768,9)
768
9Funcționează cu

Obținerea tuturor coloanelor și a numelor de coloane

Apelarea atributului .columns al unui obiect DataFrame returnează numele coloanelor sub forma unui obiect Index. Reamintim, un index pandas este adresa/eticheta rândului sau coloanei.

df.columnsFuncționează cu

Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI',
       'DiabetesPedigreeFunction', 'Age', 'Outcome'],
      dtype='str')Funcționează cu

Poate fi convertit într-o listă folosind funcția list().

list(df.columns)Funcționează cu

['Pregnancies',
 'Glucose',
 'BloodPressure',
 'SkinThickness',
 'Insulin',
 'BMI',
 'DiabetesPedigreeFunction',
 'Age',
 'Outcome']Funcționează cu

Verificarea valorilor lipsă în pandas cu .isnull()

DataFrame-ul de exemplu nu are valori lipsă. Hai să introducem câteva ca să devină mai interesant. Metoda .copy() face o copie a DataFrame-ului original. Lucrul pe o copie păstrează df original intact pentru exemplele care urmează. Folosind .loc (acoperit mai târziu), poți seta rândurile etichetate 2 până la 5 din coloana Pregnancies la valori lipsă. Deoarece valorile lipsă sunt stocate ca NaN, un float, pandas convertește coloana din int64 în float64.

df2 = df.copy()
df2.loc[2:5,'Pregnancies'] = None
df2.head(7)Funcționează cu

Poți vedea că acum rândurile 2 până la 5 sunt NaN

Poți verifica dacă fiecare element dintr-un DataFrame lipsește folosind metoda .isnull().

df2.isnull().head(7)Funcționează cu

Dat fiind că adesea e mai util să știi cât de multe date lipsesc, poți combina .isnull() cu .sum() pentru a număra câte valori nule are fiecare coloană.

df2.isnull().sum()Funcționează cu

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Funcționează cu

Poți face și o dublă sumă pentru a obține numărul total de valori nule din DataFrame.

df2.isnull().sum().sum()Funcționează cu

4Funcționează cu

Sortarea, segmentarea și extragerea datelor în pandas

Pachetul pandas oferă mai multe moduri de a sorta, subselecta, filtra și izola datele din DataFrame-urile tale. Aici vom vedea cele mai comune metode.

Sortarea datelor

Pentru a sorta un DataFrame după o coloană specifică, folosește .sort_values(). Aceasta returnează un nou DataFrame sortat și lasă df neschimbat, așa că atribuie rezultatul unei variabile dacă vrei să îl păstrezi:

df.sort_values(by="Age", ascending=False)  # Sortează după Age în ordine descrescătoareFuncționează cu

Poți sorta după mai multe coloane:

df.sort_values(by=["Age", "Glucose"], ascending=[False, True])Funcționează cu

Resetarea indexului

Sortarea sau filtrarea păstrează etichetele originale ale rândurilor, astfel încât indexul ajunge în dezordine. Folosește .reset_index() pentru a obține un index nou de la 0 (vezi tutorialul nostru despre resetarea indexului în pandas pentru mai multe opțiuni):

df_sorted = df.sort_values(by="Age", ascending=False).reset_index(drop=True)  # drop=True aruncă vechiul index
df_sorted[["Age", "Glucose", "Outcome"]].head(3)Funcționează cu

   Age  Glucose  Outcome
0   81      134        0
1   72      119        0
2   70      145        1Funcționează cu

Izolarea unei coloane folosind [ ] 

Poți izola o singură coloană folosind paranteze pătrate [ ] cu un nume de coloană în interior. Ieșirea este un obiect Series pandas. O Series pandas este un vector unidimensional care conține date de orice tip, inclusiv întregi, zecimale, șiruri, valori booleene, obiecte Python etc. Un DataFrame este compus din multe serii care acționează ca și coloane.

df['Outcome']Funcționează cu

0      1
1      0
2      1
3      0
4      1
      ..
763    0
764    0
765    0
766    1
767    0
Name: Outcome, Length: 768, dtype: int64Funcționează cu

Izolarea a două sau mai multe coloane folosind [[ ]] 

Poți, de asemenea, să furnizezi o listă de nume de coloane în interiorul parantezelor pătrate pentru a prelua mai mult de o coloană. Aici, parantezele pătrate sunt folosite în două moduri diferite. Folosim parantezele exterioare pentru a indica o submulțime a unui DataFrame, iar pe cele interioare pentru a crea o listă.

df[['Pregnancies', 'Outcome']]Funcționează cu

     Pregnancies  Outcome
0              6        1
1              1        0
2              8        1
3              1        0
4              0        1
..           ...      ...
763           10        0
764            2        0
765            5        0
766            1        1
767            1        0

[768 rows x 2 columns]Funcționează cu

Izolarea unui singur rând folosind [ ] 

Un singur rând poate fi preluat trecând o serie booleană cu o singură valoare True. În exemplul de mai jos este returnat al doilea rând cu index = 1. Aici, .index returnează etichetele rândurilor din DataFrame, iar comparația le transformă într-un vector unidimensional de valori booleene.

df[df.index==1]Funcționează cu

Izolarea unui rând în pandas

Izolarea a două sau mai multe rânduri folosind [ ] 

În mod similar, două sau mai multe rânduri pot fi returnate folosind metoda .isin() în locul operatorului ==.

df[df.index.isin(range(2,10))]Funcționează cu

Izolarea unor rânduri specifice în pandas

Folosirea .loc[] și .iloc[] pentru a prelua rânduri

Poți prelua rânduri specifice după etichete sau condiții folosind .loc[] și .iloc[] ("location" și "integer location"). .loc[] folosește o etichetă pentru a indica un rând, o coloană sau o celulă, în timp ce .iloc[] folosește poziția numerică. Ghidul nostru loc vs iloc acoperă toate diferențele; pentru a vedea diferența principală aici, hai să schimbăm indexul lui df2 creat mai devreme astfel încât etichetele și pozițiile să nu mai corespundă.

df2.index = range(1,769)Funcționează cu

Exemplul de mai jos returnează o Series pandas în loc de un DataFrame. În .loc[1], 1 este o etichetă, deci returnează rândul etichetat 1 (primul rând după reindexare). În .iloc[1], 1 este o poziție de la 0, deci returnează al doilea rând, care poartă eticheta 2.

df2.loc[1]Funcționează cu

Pregnancies                   6.000
Glucose                     148.000
BloodPressure                72.000
SkinThickness                35.000
Insulin                       0.000
BMI                          33.600
DiabetesPedigreeFunction      0.627
Age                          50.000
Outcome                       1.000
Name: 1, dtype: float64Funcționează cu

df2.iloc[1]Funcționează cu

Pregnancies                  1.000
Glucose                     85.000
BloodPressure               66.000
SkinThickness               29.000
Insulin                      0.000
BMI                         26.600
DiabetesPedigreeFunction     0.351
Age                         31.000
Outcome                      0.000
Name: 2, dtype: float64Funcționează cu

Poți, de asemenea, să preiei mai multe rânduri furnizând un interval în paranteze pătrate. Cei doi accesori tratează capătul intervalului diferit: .loc[100:110] include eticheta 110 și returnează 11 rânduri, în timp ce .iloc[100:110] se oprește înainte de poziția 110 și returnează 10 rânduri.

df2.loc[100:110]Funcționează cu

Izolarea rândurilor în pandas cu .loc[]

df2.iloc[100:110]Funcționează cu

Izolarea rândurilor în pandas cu .iloc[]

Poți, de asemenea, să subselectezi cu .loc[] și .iloc[] folosind o listă în loc de un interval.

df2.loc[[100, 200, 300]]Funcționează cu

Izolarea rândurilor folosind o listă în pandas cu .loc[]

df2.iloc[[100, 200, 300]]Funcționează cu

Izolarea rândurilor folosind o listă în pandas cu .iloc[]

Poți, de asemenea, să selectezi coloane specifice împreună cu rânduri. Aici .iloc[] diferă de .loc[] – necesită poziția coloanei și nu etichetele coloanelor.

df2.loc[100:110, ['Pregnancies', 'Glucose', 'BloodPressure']]Funcționează cu

     Pregnancies  Glucose  BloodPressure
100          1.0      122             90
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Funcționează cu

df2.iloc[100:110, :3]Funcționează cu

     Pregnancies  Glucose  BloodPressure
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Funcționează cu

Pentru fluxuri de lucru mai rapide, poți trece indexul de început al unui rând ca interval.

df2.loc[760:, ['Pregnancies', 'Glucose', 'BloodPressure']]Funcționează cu

     Pregnancies  Glucose  BloodPressure
760          6.0      190             92
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Funcționează cu

df2.iloc[760:, :3]Funcționează cu

     Pregnancies  Glucose  BloodPressure
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Funcționează cu

Poți actualiza valori combinând .loc[] cu operatorul de atribuire =. Construiește condiția din același DataFrame pe care îl actualizezi: o condiție construită din df nu se mai aliniază cu noul index al lui df2, iar pandas ridică o eroare.

df2.loc[df2["Age"] == 81, "Age"] = 80Funcționează cu

Filtrarea rândurilor cu condiții

pandas îți permite să filtrezi datele folosind condiții peste valorile rândurilor/coloanelor. De exemplu, codul de mai jos selectează rândul în care Blood Pressure este exact 122. Aici izolăm rânduri folosind parantezele [ ] ca în secțiunile anterioare. Totuși, în loc să introducem indici de rând sau nume de coloane, introducem o condiție în care coloana BloodPressure este egală cu 122. Denotăm această condiție folosind df.BloodPressure == 122.

df[df.BloodPressure == 122]Funcționează cu

Izolarea rândurilor pe baza unei condiții în pandas 

Exemplul de mai jos preia toate rândurile unde Outcome este 1. Aici df.Outcome selectează acea coloană, df.Outcome == 1 returnează o Series de valori booleene care indică ce Outcome sunt egale cu 1, apoi [] ia o submulțime din df unde acea Series booleană este True.

df[df.Outcome == 1]Funcționează cu

Izolarea rândurilor pe baza unei condiții în pandas 

Poți folosi un operator > pentru a face comparații. Codul de mai jos preia Pregnancies, Glucose și BloodPressure pentru toate înregistrările cu BloodPressure mai mare de 100.

df.loc[df['BloodPressure'] > 100, ['Pregnancies', 'Glucose', 'BloodPressure']]Funcționează cu

     Pregnancies  Glucose  BloodPressure
43             9      171            110
84             5      137            108
106            1       96            122
177            0      129            110
207            5      162            104
362            5      103            108
369            1      133            102
440            0      189            104
549            4      189            110
658           11      127            106
662            8      167            106
672           10       68            106
691           13      158            114Funcționează cu

Curățarea datelor în pandas

Curățarea datelor este una dintre cele mai comune sarcini în data science. pandas îți permite să preprocesezi datele pentru orice utilizare, inclusiv, dar fără a se limita la, antrenarea de modele de machine learning și deep learning. Să folosim DataFrame-ul df2 de mai devreme, care are patru valori lipsă, pentru a ilustra câteva cazuri de curățare a datelor. Ca scurt reminder, iată cum poți vedea câte valori lipsă sunt într-un DataFrame.

df2.isnull().sum()Funcționează cu

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Funcționează cu

Tehnica #1 pentru gestionarea valorilor lipsă: Eliminarea valorilor lipsă

O modalitate de a gestiona valorile lipsă este să le elimini. Acest lucru este util mai ales când ai multe date și pierderea unei părți mici nu va afecta analiza ulterioară. Poți folosi metoda .dropna() ca mai jos. Aici salvăm rezultatele din .dropna() într-un DataFrame df3.

df3 = df2.copy()
df3 = df3.dropna()
df3.shapeFuncționează cu

(764, 9) # this is 4 rows less than df2Funcționează cu

Argumentul axis îți permite să specifici dacă elimini rânduri sau coloane cu valori lipsă. axis implicit elimină rândurile care conțin NaN-uri. Folosește axis = 1 pentru a elimina coloanele cu una sau mai multe valori NaN. Ca în fiecare exemplu din acest tutorial, reatribuim rezultatul în loc să folosim inplace=True, pe care pandas 3.1 îl depreciază pentru .dropna().

df3 = df2.dropna(axis=1)
list(df3.columns)Funcționează cu

['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age', 'Outcome']Funcționează cu

Implicit, .dropna() elimină un rând dacă oricare dintre valorile lui lipsește. Setează argumentul how la 'all' pentru a elimina doar rândurile în care lipsesc toate valorile. Niciun rând din df2 nu este complet gol, așa că nu se elimină nimic:

df3 = df2.dropna(how="all")
df3.shapeFuncționează cu

(768, 9)Funcționează cu

Tehnica #2 pentru gestionarea valorilor lipsă: Înlocuirea valorilor lipsă

În loc să elimini valorile lipsă, le poți înlocui cu o statistică sumară sau o valoare fixă. De exemplu, dacă lipsește o zi dintr-o săptămână de înregistrări de temperatură, completarea ei cu media săptămânii păstrează rândul și pierde puțină informație. Codul de mai jos completează valorile lipsă din Pregnancies cu media acelei coloane.

df3 = df2.copy()
# Get the mean of Pregnancies
mean_value = df3["Pregnancies"].mean()
# Fill only that column's missing values
df3["Pregnancies"] = df3["Pregnancies"].fillna(mean_value)
df3["Pregnancies"].head(7)Funcționează cu

1    6.000000
2    1.000000
3    3.846859
4    3.846859
5    3.846859
6    3.846859
7    3.000000
Name: Pregnancies, dtype: float64Funcționează cu

Gestionarea datelor duplicate

Hai să adăugăm câteva duplicate la datele originale pentru a învăța cum să eliminăm duplicatele dintr-un DataFrame. Aici folosim funcția pd.concat() pentru a concatena rândurile DataFrame-ului df2 la DataFrame-ul df2, adăugând duplicate perfecte ale fiecărui rând din df2. 

df3 = pd.concat([df2, df2])
df3.shapeFuncționează cu

(1536, 9)Funcționează cu

Poți elimina toate rândurile duplicate (implicit) din DataFrame folosind metoda .drop_duplicates().

df3 = df3.drop_duplicates()
df3.shapeFuncționează cu

(768, 9)Funcționează cu

Redenumirea coloanelor

O sarcină comună de curățare a datelor este redenumirea coloanelor. Pasează metodei .rename() un dicționar columns care mapează numele vechi la cele noi:

df3 = df3.rename(columns={"DiabetesPedigreeFunction": "DPF"})
df3[["Glucose", "BMI", "DPF", "Age"]].head()Funcționează cu

   Glucose   BMI    DPF  Age
1      148  33.6  0.627   50
2       85  26.6  0.351   31
3      183  23.3  0.672   32
4       89  28.1  0.167   21
5      137  43.1  2.288   33Funcționează cu

Poți, de asemenea, să atribui o listă completă de nume la .columns. Lista trebuie să denumească fiecare coloană în ordinea curentă: pandas atribuie nume după poziție, astfel încât o listă în ordine greșită îți etichetează datele în liniște greșit.

df3.columns = ["Pregnancies", "Glucose", "BloodPressure", "SkinThickness", "Insulin", "BMI", "DPF", "Age", "Outcome"]
list(df3.columns)Funcționează cu

['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DPF', 'Age', 'Outcome']Funcționează cu

Pentru mai multe despre curățarea datelor și pentru fluxuri de lucru mai simple și mai previzibile, consultă următoarea listă de verificare, care îți oferă un set cuprinzător de sarcini comune de curățare a datelor. 

Combinarea DataFrame-urilor în pandas

pandas combină DataFrame-urile în două moduri: .merge() îmbină tabele pe coloane cheie comune, ca un join SQL, iar pd.concat() stivuiește tabele unul peste altul sau unul lângă altul.

Îmbinarea DataFrame-urilor cu .merge()

Folosește .merge() când două tabele împart o coloană cheie. Presupune că un al doilea tabel map-ează fiecare cod Outcome la o etichetă ușor de citit. Un left merge pe Outcome adaugă acea etichetă fiecărui rând de pacient:

outcome_labels = pd.DataFrame({"Outcome": [0, 1], "Diagnosis": ["Non-diabetic", "Diabetic"]})

df_labeled = df.merge(outcome_labels, on="Outcome", how="left")
df_labeled[["Glucose", "Outcome", "Diagnosis"]].head(3)Funcționează cu

   Glucose  Outcome     Diagnosis
0      148        1      Diabetic
1       85        0  Non-diabetic
2      183        1      DiabeticFuncționează cu

Argumentul how stabilește tipul de join: "left" păstrează fiecare rând din df, "inner" păstrează doar rândurile cu potrivire în ambele tabele, iar "outer" păstrează toate rândurile din ambele. Tutorialul nostru despre îmbinarea DataFrame-urilor în pandas acoperă .join() și fiecare tip de join în detaliu.

Concatenarea DataFrame-urilor cu pd.concat()

Folosește pd.concat() când tabelele au aceleași coloane și vrei să stivuiești rândurile lor, de exemplu înregistrări de pacienți care sosesc în două loturi. Setează ignore_index=True pentru a obține un index nou de la 0 în loc să păstrezi etichetele fiecărui lot:

batch_1 = df.iloc[:500]
batch_2 = df.iloc[500:]

df_combined = pd.concat([batch_1, batch_2], ignore_index=True)
df_combined.shapeFuncționează cu

(768, 9)Funcționează cu

Cu axis=1, pd.concat() plasează tabelele unul lângă altul, potrivind rândurile după etichetele indexului:

measurements = df[["Glucose", "BMI"]]
outcomes = df[["Outcome"]]

pd.concat([measurements, outcomes], axis=1).head(3)Funcționează cu

   Glucose   BMI  Outcome
0      148  33.6        1
1       85  26.6        0
2      183  23.3        1Funcționează cu

Pentru practică hands-on cu ambele metode, încearcă cursul nostru Joining Data with pandas.

Analiza datelor în pandas

Principala valoare a pandas stă în funcționalitatea sa rapidă de analiză a datelor. În această secțiune, ne concentrăm pe un set de tehnici de analiză pe care le poți folosi în pandas.

Operatori de sumar (mean, mode, median)

După cum ai văzut mai devreme, poți obține media fiecărei coloane folosind metoda .mean().

df.mean()Funcționează cu

Pregnancies                   3.845052
Glucose                     120.894531
BloodPressure                69.105469
SkinThickness                20.536458
Insulin                      79.799479
BMI                          31.992578
DiabetesPedigreeFunction      0.471876
Age                          33.240885
Outcome                       0.348958
dtype: float64Funcționează cu

Moda poate fi calculată în mod similar folosind metoda .mode(). 

df.mode()Funcționează cu

Afișarea modei coloanelor în pandas

În mod similar, mediana fiecărei coloane este calculată cu metoda .median()

df.median()Funcționează cu

Pregnancies                   3.0000
Glucose                     117.0000
BloodPressure                72.0000
SkinThickness                23.0000
Insulin                      30.5000
BMI                          32.0000
DiabetesPedigreeFunction      0.3725
Age                          29.0000
Outcome                       0.0000
dtype: float64Funcționează cu

Creează coloane noi pe baza coloanelor existente 

pandas oferă calcul rapid și eficient combinând două sau mai multe coloane ca variabile scalare. Codul de mai jos împarte fiecare valoare din coloana Glucose la valoarea corespunzătoare din coloana Insulin pentru a calcula o coloană nouă numită Glucose_Insulin_Ratio.

df2['Glucose_Insulin_Ratio'] = df2['Glucose']/df2['Insulin']
df2.head()Funcționează cu

Creează o coloană nouă din coloane existente în pandas

Rândurile în care Insulin este 0 afișează inf, deoarece împărțirea la zero dă infinit. În acest set de date, un 0 la Insulin înseamnă că măsurarea lipsește (374 din cele 768 de rânduri), așa că tratează acele zerouri ca lipsă înainte de împărțire:

df2["Glucose_Insulin_Ratio"] = df2["Glucose"] / df2["Insulin"].where(df2["Insulin"] > 0)
df2["Glucose_Insulin_Ratio"].head()Funcționează cu

1         NaN
2         NaN
3         NaN
4    0.946809
5    0.815476
Name: Glucose_Insulin_Ratio, dtype: float64Funcționează cu

.where() păstrează valorile care îndeplinesc condiția și le înlocuiește pe restul cu NaN, astfel încât raportul lipsește în loc să fie infinit pentru acele rânduri. Tutorialul nostru despre adăugarea de coloane în pandas arată mai multe moduri de a deriva coloane noi.

Numărarea folosind .value_counts()

Când o coloană conține categorii, adesea vrei să numeri câte observații intră în fiecare. Metoda .value_counts() face asta. Aici, de exemplu, numărăm câte observații au Outcome diabetic (1) și câte au Outcome nondiabetic (0).

df['Outcome'].value_counts()Funcționează cu

Outcome
0    500
1    268
Name: count, dtype: int64Funcționează cu

Adăugarea argumentului normalize returnează proporții în loc de numărări absolute.

df['Outcome'].value_counts(normalize=True)Funcționează cu

Outcome
0    0.651042
1    0.348958
Name: proportion, dtype: float64Funcționează cu

Oprește sortarea automată a rezultatelor folosind argumentul sort (True implicit). Sortarea implicită se bazează pe numărări în ordine descrescătoare.

df['Outcome'].value_counts(sort=False)Funcționează cu

Outcome
1    268
0    500
Name: count, dtype: int64Funcționează cu

Poți aplica .value_counts() și la un obiect DataFrame și la coloane specifice din acesta, nu doar la o coloană. Aici, de exemplu, aplicăm value_counts() pe df cu argumentul subset, care primește o listă de coloane. 

df.value_counts(subset=['Pregnancies', 'Outcome'])Funcționează cu

Pregnancies  Outcome
1            0          106
2            0           84
0            0           73
3            0           48
4            0           45
0            1           38
5            0           36
6            0           34
1            1           29
3            1           27
7            1           25
4            1           23
8            1           22
5            1           21
7            0           20
2            1           19
9            1           18
6            1           16
8            0           16
10           0           14
             1           10
9            0           10
11           1            7
13           0            5
             1            5
12           0            5
11           0            4
12           1            4
14           1            2
15           1            1
17           1            1
Name: count, dtype: int64Funcționează cu

Agregarea datelor cu .groupby() în pandas

pandas îți permite să agregi valori grupându-le după valori specifice ale coloanelor. Poți face asta combinând metoda .groupby() cu o metodă de sumar la alegere. Codul de mai jos afișează media fiecăreia dintre coloanele numerice grupate după Outcome.

df.groupby('Outcome').mean()Funcționează cu

Agregarea datelor după o coloană în pandas

.groupby() permite gruparea după mai mult de o coloană trecând o listă de nume de coloane, ca mai jos.

df.groupby(['Pregnancies', 'Outcome']).mean()Funcționează cu

Agregarea datelor după două coloane în pandas

Orice metodă de sumar poate fi folosită alături de .groupby(), inclusiv .min(), .max(), .mean(), .median(), .sum() și altele. Tutorialul nostru pandas GroupBy acoperă agregări multiple cu .agg() și alte tipare.

Tabele pivot 

pandas îți permite, de asemenea, să calculezi statistici sumare ca tabele pivot. Acest lucru face ușoară formularea de concluzii pe baza unei combinații de variabile. Codul de mai jos alege rândurile ca valori unice ale Pregnancies, valorile coloanelor sunt valorile unice ale Outcome, iar celulele conțin valoarea medie a BMI în grupul corespunzător.

De exemplu, pentru Pregnancies = 5 și Outcome = 0, IMC-ul mediu este 31,1.

pd.pivot_table(df, values="BMI", index='Pregnancies', 
               columns=['Outcome'], aggfunc='mean')Funcționează cu

Outcome              0          1
Pregnancies                      
0            31.727397  39.213158
1            29.616038  37.793103
2            29.679762  34.578947
3            29.231250  32.548148
4            31.255556  33.873913
5            31.100000  36.780952
6            29.591176  31.775000
7            29.975000  34.756000
8            30.693750  32.204545
9            28.840000  33.300000
10           30.114286  31.380000
11           37.125000  39.385714
12           30.560000  34.575000
13           33.280000  36.720000
14                 NaN  35.100000
15                 NaN  37.100000
17                 NaN  40.900000Funcționează cu

Vizualizarea datelor în pandas

pandas oferă învelișuri convenabile peste funcțiile de plotting din Matplotlib pentru a face ușoară vizualizarea DataFrame-urilor tale. Mai jos vei vedea cum să faci vizualizări de date comune folosind pandas.

Grafice de tip linie în pandas

pandas îți permite să trasezi relațiile dintre variabile folosind grafice de tip linie. Mai jos este un grafic al BMI și Glucose în funcție de indexul rândurilor.

df[['BMI', 'Glucose']].plot.line()Funcționează cu

Grafic de linie de bază cu pandas

Poți alege culorile folosind argumentul color.

df[['BMI', 'Glucose']].plot.line(color={"BMI": "red", "Glucose": "blue"})Funcționează cu

Grafic de linie de bază cu pandas, cu culori personalizate

Toate coloanele din df pot fi, de asemenea, plotate pe scări și axe diferite folosind argumentul subplots.

df.plot.line(subplots=True)Funcționează cu

Subploturi pentru grafice de linie cu pandas

Grafice de tip bară în pandas

Pentru coloane discrete, poți folosi un grafic cu bare peste numărările categoriilor pentru a vizualiza distribuția lor. Variabila Outcome cu valori binare este vizualizată mai jos.

df['Outcome'].value_counts().plot.bar()Funcționează cu

Grafice cu bare în pandas

Diagrame boxplot în pandas

Distribuția pe quartile a variabilelor continue poate fi vizualizată folosind un boxplot. Codul de mai jos îți permite să creezi un boxplot cu pandas.

df.boxplot(column=['BMI'], by='Outcome')Funcționează cu

Boxploturi în pandas

Gânduri finale

Acum ai fluxul de lucru de bază în pandas: citești un fișier într-un DataFrame, îl inspectezi cu .head(), .info() și .describe(), selectezi rânduri cu .loc[] și .iloc[], cureți valorile lipsă și duplicatele, îmbini tabele și rezumi cu .groupby() și tabele pivot.

Dacă ai învățat pandas înainte de 2026, un obicei merită schimbat: reatribuie rezultatele în loc să folosești inplace=True și fă fiecare actualizare cu un singur apel .loc[]. Cel mai rapid mod de a fixa restul este să repeți fluxul de lucru pe un set de date care te interesează. Aceste resurse te ajută să mergi mai departe:

• [Cheat Sheet-uri] O multitudine de cheat sheet-uri pentru Python și pandas la care să revii pe parcursul învățării 
• [Antrenamente live] Sesiunile noastre gratuite de code-along, multe dintre ele folosind pandas
• [Cursuri] Manipularea datelor cu pandas și Joining Data with pandas pentru practică interactivă
• [Pregătire pentru interviu] Top întrebări pentru interviuri despre pandas ca să-ți testezi cunoștințele
• [Mai multe tutoriale] Vezi restul tutorialelor noastre despre pandas și ecosistemul PyData, inclusiv cum să implementezi medii mobile în pandas și utilizarea metodei .apply() din pandas