Seminar Python 2
1 Operații cu fișiere în Python
Funcția built-in open() returnează un obiect file (fișier). Citirea din fișiere text se face cu metodele
read() , readline() și readlines() .
Funcția open() are două argumente importante: numele fișierului și modul de deschidere:
"r" – read only – implicit. Deschide fișierul pentru citire; dă eroare dacă fișierul nu există.
"r+" – citire și scriere (actualizare);
"a" - append: adăugare (scriere) la sfârșitul fișierului; dacă nu există, fișierul este creat;
"w" - write only: deschide pentru scriere; dacă nu există, fișierul este creat; dacă există, conținutul este
șters;
"x" - create: creează un fișier; dă eroare dacă fișierul există deja.
Metoda read() citește tot conținutul fișierului și returnează un șir (string). Se poate specifica numărul maxim
de caractere de citit: read(100)
Metoda readline() citește și returnează o linie (încheiată cu caracterul \n ). Returnează un șir vid dacă
s-a atins sfârșitul de fișier (EOF).
readlines() citește toate liniile din fișier într-o listă de șiruri.
In [ ]:
path="" #setați calea către fișierele de date, după caz
#Exemplul 1.a
f = open(path+"Data1.txt", "r")
print(f.read())
f.close()
In [ ]:
#Exemplul 1.b: citire 100 caractere
f = open(path+"Data1.txt", "r")
print(f.read(100))
In [ ]:
#Exemplul 1.c
print(f.readline( )) #readline() se oprește la sfârșit de linie
print(f.readline())
f.close()
In [ ]:
#Exemplul 1.d
f = open(path+"Data1.txt", "r")
for line in f: #iterare în obiectul file
print(line, end='')
f.close()
Al doilea argument (mode) poate specifica tipul fișierului:
"t" - Text - implicit, fișier text.
"b" - Binary –
fișier binar (de ex. fișier imagine)
f = open("Data1.txt") este echivalent cu f = open("Data1.txt", "rt")
Fișierele trebuiesc închise cu f.close() .
O tehnică recomandată este folosirea instrucțiunii with , care asigură închiderea automată a fișierului.
In [ ]:
#Exemplul 2: utilizare "with"
with open(path+'Data1.txt') as f:
lines=f.readlines() #rcitește toate liniile într-o listă
print(len(lines), 'linii citite din fișier.')
for i in range(20): #afișază primele 20 linii
print('Linia',i+1,':',lines[i],end='')
Metoda write() scrie un șir de caractere în fișier. Delimitatorii de linie sunt inserați automat.
In [ ]:
#Exemplul 3: Adaugă date din Data2.txt în Data1.txt
f1 = open(path+'Data1.txt', 'a')
f2 = open(path+'Data2.txt', 'r')
for line in f2:
f1.write(line)
f1.close(); f2.close()
print(len(open(path+'Data1.txt').readlines()), 'linii în Data1.txt.')
2 Pachetul pandas
Pandas conține obiecte și funcții pentru prelucrarea datelor tabelare (asemănătoare cu foile de calcul sau
bazele de date relaționale); oferă mecanisme avansate de indexare și funcții de procesare complexe. Pentru
o prezentare mai detaliată v. acest link (https://pandas.pydata.org/docs/getting_started/overview.html).
2.1 Structuri de date fundamentale
Datele în pandas sunt structurate ca serii unidimensionale (obiectul Series) și ca tabele (obiectul
DataFrame). Fiecare coloană din DataFrame este un obiect Series.
Rândurile sunt considerate ca axa 0 din DataFrame, iar coloanele ca axa 1. Unele metode au un argument
axis pentru a diferenția între prelucrarea de rânduri și coloane (de ex. drop() , v. secțiunea 2.6).
Obiectele DataFrame conțin un index - implicit acesta conține valori întregi (0, 1, ...) asociate fiecărui rând.
Prin intermediul indexului se pot accesa anumite rânduri. Atributul index permite accesarea indexului (ca
obiect).
Coloanele au nume (etichete) de coloane (câmpuri, variabile).
Citirea datelor csv într-un obiect DataFrame se face cu metoda read_csv() . Metode similare există pentru
citirea din alte formate: read_excel() , read_json() , read_sql() .
Pentru salvarea datelor în fișiere se folosesc metodele to_csv() , to_excel() , to_json() ,
to_sql() .
Metodele head() and tail() returnează primele, respectiv ultimele n (implicit 5) rânduri.
In [ ]:
#Exemplul 4: import date din Csv, afișarea unor informații despre DataFrame
import pandas
df = pandas.read_csv(path+'clienti_leasing20.csv')
print(df.index)
print('-'*40)
print(df.columns)
print('-'*40)
print(df.head())
print('-'*40)
#print(df.tail())
2.2 Selecția datelor, indexare
Pentru a accesa anumite date (rânduri și coloane) din DataFrame sunt disponibile două atribute:
iloc : localizare după index - accesarea datelor folosind indecși întregi ai rândurilor și coloanelor
(asemănător cu elementele dintr-o matrice);
loc : accesarea datelor după nume de coloane și etichete de rînduri (sau index).
a. Utilizarea iloc
In [ ]:
#Exemplul 5: tilizarea iloc pentru a afișa anumite rânduri
import pandas as pd
pd.set_option('display.width', 120) #setare lățime de afișare (caractere)
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.iloc[2], '\n', type(df.iloc[2])) #afișare rândul 3 ==> obiect Series
print('-'*40)
print(df.iloc[[1,3,5]], '\n', type(df.iloc[[1,3,5]])) #anumite rânduri (ca listă),
# ==> obiect DataFrame
Pentru a selecta anumite coloane se indică un al doilea element în lista aferentă iloc .
In [ ]:
#Exemplul 6
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.iloc[2, 0]) #valoarea din rândul 3, prima coloană
print('-'*40)
print(df.iloc[[1,3,5], [0,2]]) #anumite rânduri și coloane
Notația slice poate fi folosită pentru a specifica rânduri/coloane multiple. Atributul iloc cu slice se
comportă conform mecanismului obișnuit (include limita inferioară, dar nu include limita superioară - v.
Seminar 1, Liste).
In [ ]:
#Exemplul 7: Utilizare iloc cu notația slice
import pandas as pd
pd.set_option('display.width', 120)
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.iloc[3:6]) # slice pe rânduri
#print(df.iloc[:5])
#print(df.iloc[15:])
print('-'*40)
print(df.iloc[7:10, 2:5]) # rânduri 7 - 9, coloane 2 - 4
#print(df.iloc[0, :]) #primul rând, toate coloanele
b. Utilizare loc - Accesarea datelor folosind nume de coloane
In [ ]:
#Exemplul 8: Utilizare loc pentru afișare rânduri (înregistrări)
# și coloane, după nume (etichetă)
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[ : ,'NAME_CLIENT'])
# când se selectează o singură coloană se poat folosi și următoarele expresii:
#print(df['NAME_CLIENT']) # indexare de tip dicționar
#print(df.NAME_CLIENT) # coloană ca atribut (dacă numele de coloană este string)
print('-'*40)
print(df.loc[5, 'NAME_CLIENT']) # rd. 5, col. NAME_CLIENT
print('-'*40)
print(df.loc[[5,10],['NAME_CLIENT','JOB']]) # listă rânduri, listă coloane
Notația slice se poate folosi cu .loc (nume de coloane), dar rezultatul va include limita superioară din
slice (!)
In [ ]:
#Exemplul 9: Utilizare .loc cu slice
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[ :10, 'ID_CLIENT':'JOB']) # ! limita superioară inclusă !
#print(df.loc[0, :'JOB']) # slice cu lim. sup.
#print(df.loc[1, 'JOB':]) # slice cu lim. inf.
#print(df.loc[[0,3], : ]) # slice vid (toate coloanele)
2.3 Selectarea condiționată a datelor
Este posibil să se selecteze (filtreze) date pe baza unor condiții aplicate asupra loc / iloc (selectare
condiționată / indexare booleană):
In [ ]:
#Exemplul 10.a
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[(df['AGE']==35),['NAME_CLIENT']]) # clienți cu vârsta = 35
Expresia df['AGE']==35 generează un obiect Series - vector de valori bool, conținând True/False pentru
fiecare rând, în funcție de condiție. Această serie este dată ca argument în df.loc pentru a selecta
rândurile care au o valoare asociată True. Pentru mai multe informații despre indexarea booleană, v. acest
link (https://pandas.pydata.org/docs/user_guide/indexing.html#boolean-indexing).
In [ ]:
#Exemplul 10.b
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
#print(df.loc[ (df['AGE']==35), ['NAME_CLIENT']])
print(df['AGE']==35)
Pentru formularea unor condiții complexe se utilizează operatorii logici: | pt. SAU, & pt ȘI, ~ pt negație.
Expresiile trebuiesc grupate în paranteze ().
In [ ]:
#Exemplul 11: Afișare clienți cu vârsta = 35, care sunt bărbați
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[(df['AGE']==35)&(df['SEX']=='m'),['NAME_CLIENT','JOB','SEX','AGE']])
In [ ]:
#Exemplul 12: Afișare clienți care nu sunt ingineri
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[df['JOB'] != 'Engineer', 'NAME_CLIENT':'INCOME_PER_YEAR'])
Utilizarea metodelor pe șiruri în condiții
Metodele de prelucrare a șirurilor de caractere se pot accesa prin atributul .str al obiectului Series. În
general, acestea au aceleși nume ca metodele clasei string: str.len(), str.lower(), str.upper(),
str.strip(), str.startswith(), str.endswith() etc.
In [ ]:
#Exemplul 13: Afișare clienți al căror nume se termină cu 'a'
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[df['NAME_CLIENT'].str.endswith("a"),['NAME_CLIENT','SEX']])
In [ ]:
#Exemplul 14:Afișare clienți al căror nume începe cu 'Ha'
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[df['NAME_CLIENT'].str.startswith("Ha"),['NAME_CLIENT','SEX']])
Metoda DataFrame.isin() permite verificarea existenței valorilor într-o listă.
In [ ]:
#Exemplul 15: Afișare clienți care sunt ingineri sau profesori
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[df['JOB'].isin(['Engineer', 'Professor']),['NAME_CLIENT','SEX', 'JOB']])
2.4 Modificarea datelor din DataFrame
Notația .loc / .iloc permite atribuirea pentru a modifica valorile datelor.
In [ ]:
#Exemplul 16: Modificarea venitului pentru primul rând
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.loc[0, 'INCOME_PER_YEAR'])
df.loc[0,'INCOME_PER_YEAR'] = 30000
print(df.loc[0, 'INCOME_PER_YEAR'])
In [ ]:
#Exemplul 17: Modificare condiționată: crește veniturile mai mici decât 5000,
# dacă vârsta e mai mare decât 30.
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
df1=df.copy() # creare dataframe nou
# situație inițială:
print(df1.loc[(df1['INCOME_PER_YEAR']<5000)&(df1['AGE']>30),
['NAME_CLIENT','INCOME_PER_YEAR', 'AGE']])
print('-'*40)
# actualizare venit :
df1.loc[(df1['INCOME_PER_YEAR']<5000)&(df1['AGE']>30),'INCOME_PER_YEAR']=10000
# situație finală:
print(df1.loc[(df1['INCOME_PER_YEAR']==10000)&(df1['AGE']>30),
['NAME_CLIENT','INCOME_PER_YEAR', 'AGE']])
2.5 Calcularea indicatorilor statistici de bază
Metoda describe() returnează un sumar statistic pentru toate coloanele numerice, sau pentru coloanele
specificate.
Pentru a afișa statistici pentru toate coloanele se utilizează argumentul include="all" . Observăm că
pentru coloanele de tip object se calculează alți indicatori decât pt. coloanele numerice.
In [ ]:
#Exemplul 18: the describe() method
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv',
usecols=['NAME_CLIENT','JOB','SEX','CURRENCY','INCOME_PER_YEAR','DATE','AGE'])
print(df.describe())
#print(df.describe(include="all"))
print('\n***** describe() pt. coloana JOB *****')
print(df['JOB'].describe())
print('\n***** describe() pt. coloana AGE *****')
print(df['AGE'].describe())
Statistici descriptive : methodele sum(), mean(), median(), nunique(), max(), min()
In [ ]:
#Exemplul 19: Statistici descriptive pentru venit (INCOME_PER_YEAR)
#import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv',
usecols=['NAME_CLIENT','JOB','SEX','CURRENCY','INCOME_PER_YEAR','DATE','AGE'])
print('Venit total', df['INCOME_PER_YEAR'].sum())
print('Venit mediu', df['INCOME_PER_YEAR'].mean())
print('Mediana venit', df['INCOME_PER_YEAR'].median())
print('Nr. valori unice', df['INCOME_PER_YEAR'].nunique())
print('Venit maxim', df['INCOME_PER_YEAR'].max())
print('Venit minim', df['INCOME_PER_YEAR'].min())
2.6 Alte operații cu DataFrame
Tipurile de date ale coloanelor sunt recunoscute automat de read_csv() .
Acestea sunt memorate în atributul .dtypes .
În unele cazuri, este necesar să setăm manual tipul de date al coloanelor.
In [ ]:
#Exemplul 20: Afișarea și modificarea tipului de date al coloanelor
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
print(df.dtypes) # ce tip au coloanele AGE, DATE ?
print('-'*40)
df = pd.read_csv(path+'clienti_leasing20.csv', parse_dates = ['DATE']) #citire 'DATE' c
a dată calendaristică
df.AGE = df.AGE.astype(float) #conversie tip AGE în float
print(df.dtypes)
Înlocuirea valorilor lipsă (missing values) se face cu fillna() .
Se poate folosi și dropna() pentru a șterge rândurile care conțin valori lipsă.
In [ ]:
#Exemplul 21: Înlocuirea valorilor lipsă
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20missing.csv',
usecols=['NAME_CLIENT','JOB','SEX','CURRENCY','INCOME_PER_YEAR','DATE','AGE'])
print(df['AGE']) # verificați dacă există valori lipsă!
#print(df.loc[df['AGE'].isnull()]) # afișare rânduri cu valori lipsă pt. AGE
print('-'*40)
print(df['AGE'].fillna('lipsa')) # înlocuire cu un șir
In [ ]:
#Exemplul 22: Înlocuirea valorilor lipsă cu media valorilor
#import pandas as pd
df = pd.read_csv(path+'clienti_leasing20missing.csv',
usecols=['NAME_CLIENT','JOB','SEX','CURRENCY','INCOME_PER_YEAR','DATE','AGE'])
mean_age = int(df['AGE'].mean())
df['AGE'] = df['AGE'].fillna(value = mean_age)
print(df.AGE)
Ștergerea de rânduri și coloane se fae cu metoda drop() . Argumentul axis indică dacă se vor șterge
rânduri ( axis=0 ) sau coloane ( axis=1 ).
drop() returnează un nou DataFrame. Dacă se utilizează
argumentul inplace=True , se modifică obiectul curent.
In [ ]:
#Exemplul 23: Ștergere coloane
import pandas as pd
pd.set_option('display.width', 120)
#pd.show_versions()
df = pd.read_csv(path+'clienti_leasing20.csv')
# Ștergere coloană - axis = 1
df1 = df.drop("ID_CLIENT", axis=1)
print(df1.head())
print('-'*40)
# Ștergere coloană utilizând arg. columns
df2 = df.drop(columns="AGE") #doar în pandas ver. 0.21.0+ ! verifică pd.show_versions
()
print(df2.head())
print('-'*40)
# Ștergere coloane (ca listă), salvare într-un nou fișier csv
df3 = df.drop(["JOB", "SEX"], axis=1)
print(df3.head())
df3.to_csv('clienti_df.csv', index = False)
print('-'*40)
#Ștergere coloană – modifică dataframe curent:
# inplace = True, drop() returnează None
df.drop("INCOME_PER_YEAR", axis=1, inplace = True)
print(df.head())
In [ ]:
#Exemplul 24: Ștergere rânduri (înregistrări)
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
# Șterge rânduri 3, 5, 8
df4 = df.drop([3,5,8], axis=0)
print(df4.head(10))
Indexul implicit al rândurilor (nr. întreg) poate fi înlocuit cu valori din coloane ale DataFrame-ului, folosind
metoda set_index() .
In [ ]:
#Exemplul 25
import pandas as pd
pd.set_option('display.width', 120)
df = pd.read_csv(path+'clienti_leasing20.csv')
# Șterge clienți care sunt Ingineri.
# set_index() setează coloana JOB ca index.
# Astfel putem folosi valori din JOB pentru a selecta rânduri.
df5 = df.set_index("JOB")
df5.drop("Engineer", axis=0, inplace = True)
print(df5.head())
Modificări la importul datelor din csv
La citirea din fișiere csv putem selecta anumite coloane (argumentul usecols ) și putem exclude anumite
rânduri (arg. skiprows/skipfooter ).
Numărul de rânduri ce vor fi citite este specificat cu nrows .
In [ ]:
#Exemplul 26:
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv',
usecols = ['NAME_CLIENT','JOB'],
skiprows = [6,7,9])
print(df)
In [ ]:
#Exemplul 27: Restricționează nr. de rânduri citite (nrows)
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv',
nrows=6,
usecols = ['NAME_CLIENT','INCOME_PER_YEAR'])
print(df)
Sortarea înregistrărilor din DataFrame
Metoda sort_values() returnează un obiect DataFrame nou, sortat. Pt. mai multe detalii v. acest link
(https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.sort_values.html?
highlight=sort_values#pandas.DataFrame.sort_values).
In [ ]:
#Exemplul 28: Exemple de sortare
import pandas as pd
df = pd.read_csv(path+'clienti_leasing20.csv')
df7 = df.sort_values(by='INCOME_PER_YEAR') # sortare 1 col., crescător (implicit)
print(df7.loc[ : , ['NAME_CLIENT','INCOME_PER_YEAR']].head(10))
print('-'*40)
df8=df.sort_values(by='AGE', ascending=False) # sortare desc.
print(df8.loc[ : , ['NAME_CLIENT','AGE']].head(10))
print('-'*40)
df9=df.sort_values(by=['JOB', 'AGE']) # sortare multiplă
print(df9.loc[ : , ['NAME_CLIENT','JOB', 'AGE']].head(10))
print('-'*40)
df10=df.sort_values(by=['JOB', 'INCOME_PER_YEAR'], ascending=[True, False]) #sortare mu
ltiplă cu direcție
print(df10.loc[ : , ['NAME_CLIENT','JOB', 'INCOME_PER_YEAR']].head(10))
Metoda rename() redenumește coloane. Argumentul columns primește un dicționar cu numele curente
(chei) și numele noi (valori).
In [ ]:
#Exemplul 29
import pandas as pd
df = pd.read_csv('clienti_leasing20.csv')
#df = df.rename(columns={"ID_CLIENT": "Id"})
#df = df.rename(columns={"JOB": "Position"})
df=df.rename(columns={"ID_CLIENT": "ID", "JOB": "Position"})
print(df.columns)
print('-'*40)
# Aplicarea unei funcții pe șiruri la numele coloanelor
df=df.rename(columns=str.lower)
print(df.columns)
3 Utilizarea modulului csv pentru citirea din fișiere csv
Un obiect csv.reader este creat și utlizat pentru a accesa datele, pe baza unui fișier text (csv) deschis.
Acest obiect poate fi iterat într-o structură for , pentru a procesa fiecare linie.
La deschiderea fișierului csv se folosește argumentul newline="" pentru a asigura tratarea corectă a
delimitatorilor sfârșit de linie.
In [ ]:
#Exemplul 30: Utilizare csv.reader
import csv
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for row in reader:
print (row)
In [ ]:
#Exemplul 31: Citirea unei coloane din fișier .csv
import csv
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for row in reader:
print (row[1])
In [ ]:
#Exemplul 32: Citire coloane
#import csv
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for row in reader:
print (row[1],row[7]) # col. NAME_CLIENT și AGE
#print(row[0:3]) # primele 3 col.
Funcția built-in enumerate() se utilizează pentru a genera un contor automat la iterarea cu for ... in
... . Este aplicabilă și pentru iterarea rândurilor într-un obiect reader. (v. și doc. enumerate()
(https://docs.python.org/3.7/library/functions.html?highlight=enumerate#enumerate)).
In [ ]:
#Exemplul 33: utilizare enumerate() pentru a citi primele 10 înreg.
#import csv
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for i, row in enumerate(reader):
print(row)
if(i >= 10):
break
În același scop se poate folosi și un obiect islice din modulul itertools (v. doc. islice
(https://docs.python.org/3.7/library/itertools.html#itertools.islice)).
In [ ]:
#Exemplul 34: Citirea primelor 10 înreg. cu islice
#import csv
from itertools import islice
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for row in islice(reader, 10):
print(row)
In [ ]:
#Exemplul 35: Citirea coloanelor csv în liste
id_client = []
name_client = []
sex = []
with open(path+'clienti_leasing20.csv', 'r', newline='') as f:
reader = csv.reader(f)
for row in reader:
id_client.append(row[0])
name_client.append(row[1])
sex.append(row[3])
print(id_client)
print(name_client)
print(sex)
In [ ]:
#Exemplul 36: Citire date din csv și procesare (afișare cu format)
#import sys
#print(sys.version) #afișază versiune python
#import csv
with open(path+'angajati.txt', newline='') as f:
reader = csv.reader(f, delimiter=',') # specificare delimitator
line_count = 0
for row in reader:
if line_count == 0:
#print('Nume coloane: {}'.format(", ".join(row))) #Python version < 3.6
print(f'Nume coloane: {", ".join(row)}') #Python 3.6+ ! vezi sys.version()
line_count += 1
else:
#print('\t{} lucrează in dep.: {}, născut în: {}'.format(row[0],row[1],row
[2])) # Python ver. < 3.6
print(f'\t{row[0]} lucrează in dep.: {row[1]}, născut în: {row[2]}.') #Pyth
on 3.6+
line_count += 1
#print('S-au procesat {} linii.'.format(line_count)) #Python ver. < 3.6
print(f'S-au procesat {line_count} linii.') #Python 3.6+
Obiectul csv.DictReader poate fi folosit în locul lui reader pentru a citi date într-un dicționar. (v. doc.
csv.DictReader (https://docs.python.org/3.7/library/csv.html#csv.DictReader))
In [ ]:
#Exemplul 37: Citire date din fișier csv în dicționar.
# Prima linie din fișier conține numele de câmpuri (coloane)
#import csv
with open(path+'angajati.txt', newline='') as f:
reader = csv.DictReader(f, delimiter=',')
for row in reader:
print(row)
In [ ]:
#Exemplul 38: utilizare DictReader, se specifică delimitatorul ';'
#import csv
with open(path+'angajati1.txt', newline='') as f:
reader = csv.DictReader(f, delimiter =';')
for row in reader:
print(row)
Scrierea într-un fișier csv se face cu obiectele csv.writer sau csv.DictWriter , folosind metoda
writerow() .
In [ ]:
#Exemplul 39: utilizare csv.writer, writerow()
#import csv
with open(path+'angajati.csv', mode='w', newline='') as f: #creare fișier
writer = csv.writer(f)
writer.writerow(['Nume', 'Departament', 'Luna'])
writer.writerow(['Cosmin Antonescu', 'Marketing', 'Noiembrie'])
writer.writerow(['Eugenia Marin', 'Vanzari', 'Iulie'])
#afișare conținut fișier:
with open(path+'angajati.csv', newline='') as f:
reader = csv.reader(f)
for row in reader:
print(row)
In [ ]:
#Exemplul 40: utilizare csv.DictWriter
#import csv
with open(path+'angajati1.csv', mode='w', newline='') as f:
fieldnames = ['Nume', 'Departament', 'Luna']
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
writer.writerow({'Nume': 'Constantinescu Andrei', 'Departament': 'Contabilitate',
'Luna': 'aprilie'})
writer.writerow({'Nume': 'Iliescu Emil', 'Departament': 'IT', 'Luna': 'mai'})
#afișare conținut fișier:
with open(path+'angajati1.csv', newline='') as f:
reader = csv.reader(f)
for row in reader:
print(row)
4 Citirea datelor din fișiere JSON cu modulul json
In [ ]:
#Exemplul 41: utilizare modul json, metoda json.load()
import json
from pprint import pprint #"pretty print"-afișare mai lizibilă a str. de date
with open('clienti_daune100.json') as f:
data = json.load(f) # încărcare date într-o listă de dicționare
pprint(data[0]) # afișare prima înreg.
In [ ]:
#Exemplul 42: Procesare date json
# Calculul frecvenței de apariție a cuvintelor în câmpul "Dauna"
import json
from pprint import pprint
#deschide fișier, încarcă datele
with open ('clienti_daune100.json') as f:
data=json.load(f)
# construire listă a tuturor cuvintelor din câmpul "Dauna"
word_list=[]
for rec in data:
word_list=word_list + rec['Dauna'].lower().split()
print(word_list[:100], '...', len(word_list), 'cuvinte în total.' )
# calcul frecvențe, memorare în dicționar
dict = {}
for word in word_list:
if word not in dict:
dict[word] = 1
else:
dict[word] += 1
# Creare listă a cuvintelor și frecvențelor, sortare desc. și afișare
w_freq = []
for key, value in dict.items():
w_freq.append((value, key)) #adăugare tuplu la listă
w_freq.sort(reverse=True)
pprint(w_freq[:100])
Referințe
Pandas Documentation, https://pandas.pydata.org/docs/getting_started/index.html
(https://pandas.pydata.org/docs/getting_started/index.html)
J. VanderPlas, Python Data Science Handbook - https://jakevdp.github.io/PythonDataScienceHandbook/
(https://jakevdp.github.io/PythonDataScienceHandbook/)
https://realpython.com/python-csv/ (https://realpython.com/python-csv/)
https://www.shanelynn.ie/python-pandas-read_csv-load-data-from-csv-files/
(https://www.shanelynn.ie/python-pandas-read_csv-load-data-from-csv-files/)
https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/
(https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/)
5 Exerciții
1) Să se creeze un nou set de date din clienti_leasing500.csv, având coloanele name_client, deposit_amount
și prescoring, dacă val_credits_ron = 0 și deposit_amount > 1000 și să se modifice coloana prescoring = 6
dacă deposit_amount > 5000. Salvați setul modificat într-un nou fișier csv.
In [ ]:
2) La exemplul 43 se vor afișa cuvintele a căror frecvență de apariție >= 30, eliminându-se cuvintele the, and,
to, a.
In [ ]:
