Lucrul cu date tabulare

Introducere

Pandas este una dintre cele mai populare biblioteci Python pentru manipularea și analiza datelor. Aceasta oferă structuri de date puternice și instrumente pentru a lucra eficient cu date tabulare. În această secțiune, vom explora elementele fundamentale ale bibliotecii pandas.

Pentru a începe, trebuie să instalăm pandas:

# Instalarea pandas
!pip install pandas

După instalare, putem importa biblioteca:

import pandas as pd
import numpy as np

Citire, Scriere

Pandas ne permite să citim date din diverse surse, cum ar fi fișiere CSV, Excel, baze de date etc. Iată cum putem citi un fișier CSV:

# Citirea unui fișier CSV
df = pd.read_csv('date.csv')

# Citirea unui fișier Excel
df_excel = pd.read_excel('date.xlsx', sheet_name='Sheet1')

Pentru a scrie date într-un fișier, putem folosi:

# Scrierea într-un fișier CSV
df.to_csv('output.csv', index=False)

# Scrierea într-un fișier Excel
df.to_excel('output.xlsx', sheet_name='Date', index=False)

Putem crea un DataFrame de la zero folosind diverse metode:

# Crearea unui DataFrame dintr-un dicționar
data = {
    'Nume': ['Ana', 'Bogdan', 'Cristina', 'Dan'],
    'Varsta': [25, 30, 35, 40],
    'Oras': ['București', 'Cluj', 'Iași', 'Timișoara']
}
df = pd.DataFrame(data)

# Crearea unui DataFrame dintr-o listă de liste
data_list = [
    ['Ana', 25, 'București'],
    ['Bogdan', 30, 'Cluj'],
    ['Cristina', 35, 'Iași'],
    ['Dan', 40, 'Timișoara']
]
df_list = pd.DataFrame(data_list, columns=['Nume', 'Varsta', 'Oras'])

Pentru a vizualiza primele câteva rânduri ale unui DataFrame, folosim metoda head():

# Afișarea primelor 5 rânduri (implicit)
print(df.head())

# Afișarea primelor 3 rânduri
print(df.head(3))

Structura unui DataFrame

Un DataFrame în pandas are o structură bine definită. Putem accesa numele coloanelor și valorile din DataFrame astfel:

# Accesarea numelor coloanelor
print(df.columns)

# Accesarea valorilor din DataFrame ca un array NumPy
print(df.values)

# Accesarea tipurilor de date ale coloanelor
print(df.dtypes)

Concatenare

Pandas ne permite să combinăm mai multe DataFrame-uri folosind funcția concat():

# Crearea a două DataFrame-uri
df1 = pd.DataFrame({'A': ['A0', 'A1'], 'B': ['B0', 'B1']})
df2 = pd.DataFrame({'A': ['A2', 'A3'], 'B': ['B2', 'B3']})

# Concatenarea pe verticală (adăugare de rânduri)
result_vertical = pd.concat([df1, df2], axis=0)
print("Concatenare verticală:")
print(result_vertical)

# Concatenarea pe orizontală (adăugare de coloane)
result_horizontal = pd.concat([df1, df2], axis=1)
print("\nConcatenare orizontală:")
print(result_horizontal)

Statistici

Pandas oferă numeroase funcții pentru a obține informații statistice despre datele noastre. Acestea ne ajută să înțelegem mai bine distribuția și caracteristicile datelor.

.info, .describe

Metoda info() oferă un rezumat concis al DataFrame-ului, inclusiv tipurile de date și valorile non-nule:

# Obținerea informațiilor despre DataFrame
df.info()

Metoda describe() generează statistici descriptive pentru coloanele numerice:

# Statistici descriptive pentru coloanele numerice
print(df.describe())

# Statistici descriptive pentru toate coloanele
print(df.describe(include='all'))

.isna, .sum, .nunique

Pentru a detecta valorile lipsă, folosim isna():

# Detectarea valorilor lipsă
print(df.isna())

# Numărul de valori lipsă pe coloană
print(df.isna().sum())

Metoda sum() poate fi folosită pentru a calcula suma valorilor pe coloane sau rânduri:

# Suma valorilor pe coloane
print(df.sum(numeric_only=True))

# Suma valorilor pe rânduri
print(df.sum(axis=1, numeric_only=True))

Metoda nunique() returnează numărul de valori unice pentru fiecare coloană:

# Numărul de valori unice pe coloană
print(df.nunique())

.mean, .median, .std

Pandas oferă funcții pentru a calcula diverse măsuri statistice:

# Calcularea mediei
print(df.mean(numeric_only=True))

# Calcularea medianei
print(df.median(numeric_only=True))

# Calcularea deviației standard
print(df.std(numeric_only=True))

.value_counts

Metoda value_counts() numără frecvența fiecărei valori unice dintr-o coloană:

# Numărarea frecvenței valorilor dintr-o coloană
print(df['Oras'].value_counts())

# Numărarea frecvenței valorilor normalizate (procente)
print(df['Oras'].value_counts(normalize=True))

.pivot_table

Tabelele pivot ne permit să reorganizăm și să rezumăm datele:

# Crearea unui DataFrame mai mare pentru exemplu
data_pivot = {
    'Nume': ['Ana', 'Bogdan', 'Cristina', 'Dan', 'Ana', 'Bogdan'],
    'Produs': ['A', 'B', 'A', 'B', 'B', 'A'],
    'Vanzari': [100, 200, 150, 300, 120, 180],
    'Regiune': ['Nord', 'Sud', 'Nord', 'Sud', 'Nord', 'Sud']
}
df_pivot = pd.DataFrame(data_pivot)

# Crearea unei tabele pivot
pivot = pd.pivot_table(df_pivot, values='Vanzari', index='Nume', columns='Produs', aggfunc='sum')
print(pivot)

.groupby

Metoda groupby() ne permite să grupăm datele după una sau mai multe coloane și să aplicăm funcții de agregare:

# Gruparea după o coloană și calcularea mediei
grouped = df_pivot.groupby('Regiune')['Vanzari'].mean()
print(grouped)

# Gruparea după mai multe coloane și aplicarea mai multor funcții de agregare
grouped_multi = df_pivot.groupby(['Regiune', 'Produs']).agg({
    'Vanzari': ['sum', 'mean', 'count']
})
print(grouped_multi)

Filtrare

Filtrarea datelor este o operație esențială în analiza datelor, permițându-ne să selectăm subseturi de date care îndeplinesc anumite condiții.

Filtrare bazată pe condiții

Putem filtra datele folosind condiții booleene:

# Filtrarea rândurilor unde Varsta > 30
df_varsta = df[df['Varsta'] > 30]
print(df_varsta)

# Filtrarea rândurilor unde Oras este 'București' sau 'Cluj'
df_oras = df[df['Oras'].isin(['București', 'Cluj'])]
print(df_oras)

Utilizarea operatorilor logici

Putem combina mai multe condiții folosind operatorii logici & (și), | (sau) și ~ (negare):

# Filtrarea rândurilor unde Varsta > 30 ȘI Oras este 'Iași'
df_and = df[(df['Varsta'] > 30) & (df['Oras'] == 'Iași')]
print(df_and)

# Filtrarea rândurilor unde Varsta < 30 SAU Oras este 'Timișoara'
df_or = df[(df['Varsta'] < 30) | (df['Oras'] == 'Timișoara')]
print(df_or)

# Filtrarea rândurilor unde Oras NU este 'București'
df_not = df[~(df['Oras'] == 'București')]
print(df_not)

Filtrare pe baza indexului

Putem filtra datele pe baza indexului folosind metodele .loc și .iloc:

# Setarea unui index
df_indexat = df.set_index('Nume')

# Selectarea rândurilor pe baza etichetelor indexului (loc)
df_loc = df_indexat.loc[['Ana', 'Cristina']]
print(df_loc)

# Selectarea rândurilor pe baza poziției (iloc)
df_iloc = df.iloc[0:2]  # Primele două rânduri
print(df_iloc)

Selectia coloanelor

Putem selecta coloane specifice dintr-un DataFrame:

# Selectarea unei singure coloane
nume_col = df['Nume']
print(nume_col)

# Selectarea mai multor coloane
multiple_cols = df[['Nume', 'Varsta']]
print(multiple_cols)

Utilizarea metodelor .loc și .iloc pentru filtrare complexă

Metodele .loc și .iloc pot fi folosite pentru filtrare complexă:

# Folosirea .loc pentru a selecta rânduri și coloane pe baza etichetelor
df_loc_complex = df.loc[df['Varsta'] > 30, ['Nume', 'Oras']]
print(df_loc_complex)

# Folosirea .iloc pentru a selecta rânduri și coloane pe baza poziției
df_iloc_complex = df.iloc[0:2, 0:2]  # Primele două rânduri și primele două coloane
print(df_iloc_complex)

Filtrare cu metoda query()

Pandas oferă și metoda query() pentru a filtra datele folosind expresii:

# Filtrare cu metoda query()
df_query = df.query('Varsta > 30 and Oras == "Iași"')
print(df_query)

Acestea sunt doar câteva dintre funcționalitățile de bază ale bibliotecii pandas. Cu aceste instrumente, puteți începe să explorați, să curățați și să analizați datele dumneavoastră eficient. Pe măsură ce vă familiarizați cu aceste concepte, puteți explora funcționalități mai avansate pentru a vă îmbunătăți analizele.

Lucrul cu date tabulare

On this page