Fila 1

Sem 1 si 2
În fișierul [Link] se află date privind procentul aportului de energie (kcal) din
diferite tipuri de alimente în țări din întreaga lume. Să se scrie o aplicație care să realizeze:
- Citirea datelor într-o listă de tupluri, câte un tuplu cu valori numerice pentru fiecare instanță.
Numele variabilelor și numele instanțelor vor fi citite într-o listă separată.
- Calculul aportului total pentru toate tipurile de alimente avute
- Calculul mediilor, abaterilor standard și a coeficienților de variație pentru fiecare variabilă
- Filtrarea țărilor cu aportul peste 1 la variabila Alcoholic Beverages
- Sortarea descrescătoare a datelor după variabila Alcoholic Beverages
- Selecția datelor pentru variabilele Alcoholic Beverages, Eggs și Fish-Seafood
- Salvarea rezultatelor obținute la cerințele anterioare în fișiere csv sub numele de
[Link], X fiind numărul cerinței Observație Vor fi folosite structuri de date și funcții din
biblioteca standard builtins

[Link]
import math #Importă modulul math pentru a utiliza funcții matematice, cum ar fi sqrt

def f1(tabel, instante):

t = dict() #Inițializează un dicționar gol.
for i in range(len(tabel)): #Iterează prin fiecare rând din tabel.
t[instante[i]] = sum(tabel[i]) #Calculează suma valorilor din rând și o asociază etichetei instante[i].
return t #Returnează dicționarul care mapează etichetele la suma fiecărui rând.

#Input: O listă de liste (tabel) și o listă de etichete pentru rânduri (instante).

#Ieșire: Un dicționar în care fiecare etichetă din instante este asociată cu suma valorilor
corespunzătoare din acel rând.

def f2(tabel, variabile):

t = dict() # Inițializează un dicționar gol.
m = len(variabile) # Numărul de coloane (variabile).
n = len(tabel) # Numărul de rânduri.
for j in range(m): # Iterează prin fiecare coloană, indexată de j.
x = [tabel[i][j] for i in range(n)] # Extrage valorile din coloana j.
media = sum(x) / n # Calculează media valorilor din coloană.
std = [Link](sum([(v - media) * (v - media) for v in x]) / n) # Calculează abaterea standard.
cv = std / media # Calculează coeficientul de variație.
t[variabile[j]] = (media, std, cv) # Salvează statistici (media, std, cv) pentru variabila curentă
return t # Returnează dicționarul cu statistici pentru fiecare variabilă.
# Funcție care verifică dacă o valoare dintr-o listă asociată unui tuplu este mai mare decât o
valoare dată
def f3(x, k, v):
# Returnează True dacă valoarea de pe poziția `k` din lista x[1] este mai mare decât `v`
return x[1][k] > v

# Funcție care extrage o valoare dintr-o listă asociată unui tuplu, pe baza unui indice `k`
def f4(x, k):
# Returnează valoarea din poziția `k` din lista asociată lui x[1]
return x[1][k]
# Funcție care selectează anumite elemente dintr-o listă asociată unui tuplu, pe baza unei
liste de indici
def f5(x, k):
# Creează un nou tuplu cu cheia x[0] și o sublistă de valori de la pozițiile `k` din lista x[1]
return (x[0], [x[1][i] for i in k])

# Funcție pentru salvarea unui dicționar într-un fișier CSV

def salvare_dictionar(t, coloane, nume_index="", fout="[Link]"):
"""
Salvează un dicționar într-un fișier CSV.

t: Dicționarul care trebuie salvat. Cheile sunt indexuri, valorile sunt liste.
coloane: O listă cu numele coloanelor din fișierul CSV.
nume_index: Numele coloanei pentru indexuri.
fout: Numele fișierului de ieșire (implicit "[Link]").
"""
# Deschide fișierul pentru scriere în modul text
fisier = open(fout, "wt")

# Scrie prima linie (antetul), formatată ca nume_index + numele coloanelor

[Link](nume_index + "," + ",".join(coloane) + "\n")

# Verifică dacă t este un dicționar (altfel va apărea o eroare)

assert isinstance(t, dict)

# Iterează prin fiecare pereche (cheie, valoare) din dicționar

for ch, v in [Link]():
# Convertește valorile listei `v` în șiruri de caractere
linie_str = [str(valoare) for valoare in v]
# Scrie o linie în fișier, cu cheia `ch` urmată de valorile din `v`
[Link](ch + "," + ",".join(linie_str) + "\n")

# Închide fișierul
[Link]()

#f1: Calcularea sumelor pentru fiecare rând dintr-un tabel de date (de exemplu, pentru
analiza unor tranzacții sau scoruri).
#f2: Calcularea statisticilor descriptive pentru fiecare variabilă (coloană), utile în analiza
datelor pentru a înțelege distribuția fiecărei variabile.

[Link]
from functii import * # Importă funcțiile f1 și f2 definite în fișierul [Link]

fisier = open("[Link]") # Deschide fișierul "[Link]" pentru

citire
linii = [Link]() # Citește toate liniile din fișier într-o listă

# Prelucrează prima linie (antetul fișierului)

linia0 = linii[0][:-1].split(",") # Elimină caracterul '\n' și separă valorile după ','
print(linia0)

# Prima valoare din antet este eticheta rândurilor (nume_instante)

nume_instante = linia0[0]

# Restul valorilor din antet sunt etichetele coloanelor (variabile)

variabile = linia0[1:]

# Inițializează lista pentru datele tabelului și lista pentru instanțele (etichetele rândurilor)
tabel_date = []
instante = []

# Numărul de rânduri din fișier (excluzând antetul)

n = len(linii) - 1

# Iterează prin fiecare rând din fișier (mai puțin antetul)

for i in range(n):
linie = linii[i + 1][:-1].split(",") # Elimină '\n' și separă valorile după ','
[Link](linie[0]) # Prima valoare din rând este eticheta rândului (instanta)

# Convertim valorile din coloane în float sau 0 dacă sunt goale

tabel_date.append(tuple([0 if v == '' else float(v) for v in linie[1:]]))

# Afișează tabelul procesat

print("Tabelul de date:")
for v in zip(instante, tabel_date):
print(v) # Afișează fiecare rând ca o pereche (eticheta rândului, valori)

# Cerința 1: Calculează suma valorilor pe rânduri folosind f1

print("--> Cerinta 1")
cerinta1 = f1(tabel_date, instante) # Apelăm f1 pentru a obține suma fiecărui rând
for v in cerinta1:
print(v, cerinta1[v]) # Afișează eticheta rândului și suma calculată

# Cerința 2: Calculează statistici descriptive pe coloane folosind f2

print("--> Cerinta 2")
cerinta2 = f2(tabel_date, variabile) # Apelăm f2 pentru a obține statistici pentru fiecare
coloană
for v in cerinta2:
print(v, cerinta2[v]) # Afișează eticheta coloanei și statisticile (media, std, cv)
# Setăm variabile pentru filtrare
variabila_filtru = "Alcoholic Beverages" # Variabila pe baza căreia se face filtrarea
valoare_filtru = 3 # Valoarea minimă necesară pentru a trece filtrul
# Cerința 3: Filtrare
# Creăm un dicționar `cerinta3` care păstrează doar acele instanțe unde valoarea pentru
variabila_filtru este > valoare_filtru
cerinta3 = dict(filter(
lambda x: f3(x, [Link](variabila_filtru), valoare_filtru), # Aplicăm filtrul
zip(instante, tabel_date))) # Combinăm instanțele cu datele tabelului

print("\n--> Cerinta 3")

# Afișăm rezultatele filtrate
for ch, v in [Link]():
print(ch, v, sep=":")

# Setăm variabila pentru sortare

variabila_sortare = "Meat" # Variabila pe baza căreia se face sortarea

# Cerința 4: Sortare
# Creăm un dicționar `cerinta4` care sortează instanțele descrescător după valoarea
variabilei specifice
print(“\n→ Cerinta 4”)

cerinta4 = dict(sorted(
zip(instante, tabel_date), # Combinăm instanțele cu datele tabelului
key=lambda x: f4(x, [Link](variabila_sortare)), # Sortăm pe baza valorii variabilei
de sortare
reverse=True ))
# Afișăm instanțele sortate
for ch, v in [Link]():
print(ch, v, sep=":")

# Selectăm variabilele dorite pentru cerința 5

variabile_selectate = ["Alcoholic Beverages", "Eggs", "Fish-Seafood"]
# Variabilele de interes
# Obținem indicii acestor variabile în lista principală
k = [[Link](v) for v in variabile_selectate]
# Cerința 5: Selectare
# Creăm un dicționar `cerinta5` care păstrează doar valorile variabilelor selectate pentru
fiecare instanță
cerinta5 = dict(map( lambda x: f5(x, k),
# Extragem doar valorile selectate
zip(instante, tabel_date) # Combinăm instanțele cu datele tabelului
))+-
print("\n--> Cerinta 5")
# Afișăm instanțele și valorile selectate
for ch, v in [Link]():
print(ch, v, sep=":")
# Salvăm rezultatele în fișiere CSV
# Salvăm cerinta5 într-un fișier CSV (doar variabilele selectate)
salvare_dictionar( cerinta5,
# Dicționarul de salvat variabile_selectate
# Numele coloanelor (variabilele selectate)
nume_instante,
# Numele coloanei index
"[Link]"
# Numele fișierului de ieșire
)

# Salvăm cerinta2 într-un fișier CSV (statistici pentru fiecare variabilă)

salvare_dictionar( cerinta2,
# Dicționarul de salvat
["Media", "Abaterea Standard", "Coeficient Variatie"],
# Numele coloanelor
"Variabile",
# Numele coloanei index
"[Link]"
# Numele fișierului de ieșire
)
# Salvăm cerinta1 într-un fișier CSV (aport caloric total pentru fiecare instanță)
salvare_dictionar( cerinta1,
# Dicționarul de salvat
["Aport Calorii"],
# Numele coloanei de date
nume_instante,
# Numele coloanei index
"[Link]"
# Numele fișierului de ieșire
)
+ Fisier csv "[Link]”

Seminar 3
(Tema2 pdf pe online ase)
Să se implementeze pentru fișierul de date prelucrat la tema 1 următoarele:
- Înlocuirea valorilor lipsă cu media
- Standardizarea și centrarea datelor
- Calculul matricelor de corelație și covarianță totale și pe grupe (dacă există criteriu de
grupare)
- Aplicarea testelor de concordanță pentru verificarea distribuției normal-gaussiene.
Vor fi folosite testele Kolmogorov-Smirnov, Shapiro, Anderson și se va implementa testul
Chi2.

[Link]

# Importăm bibliotecile necesare

import numpy as np # Pentru operații matematice și manipulare de matrici
import pandas as pd # Pentru lucrul cu tabele de date și salvarea în fișiere CSV
from [Link] import shapiro # Pentru testul Shapiro-Wilk de normalitate
# Funcție pentru înlocuirea valorilor lipsă (NaN) din matrice
def nan_replace(x):
"""
Înlocuiește valorile NaN din matricea x cu media coloanei respective.
"""
y = [Link](x) # Identificăm valorile NaN
k = [Link](y) # Obținem coordonatele valorilor NaN
# Înlocuim valorile NaN cu media pe coloana respectivă
x[k] = [Link](x[:, k[1]], axis=0)

# Funcție pentru standardizarea datelor

def standardizare(x, nlib=0, scalare=True):
"""
Standardizează matricea x, astfel încât să aibă media 0 și (opțional) deviația standard 1.
- nlib: Numărul de grade de libertate pentru deviația standard.
- scalare: Dacă este True, normalizează deviația standard la 1.
"""
x_ = x - [Link](x, axis=0) # Scădem media fiecărei coloane
if scalare:
# Împărțim la deviația standard a coloanei
x_ = x_ / [Link](x, axis=0, ddof=nlib)
return x_ # Returnăm matricea standardizată

# Funcție pentru salvarea datelor într-un fișier CSV

def salvare(x, nume_linii=None, nume_coloane=None, fisier_output="[Link]"):
"""
Salvează matricea x într-un fișier CSV.
- nume_linii: Lista cu numele rândurilor.
- nume_coloane: Lista cu numele coloanelor.
- fisier_output: Numele fișierului de ieșire.
"""
t = [Link](x, nume_linii, nume_coloane) # Creăm un DataFrame Pandas
t.to_csv(fisier_output) # Salvăm DataFrame-ul ca fișier CSV

# Funcție pentru testele de concordanță (Shapiro-Wilk)

def teste_concordanta(x: [Link]):
"""
Verifică dacă datele din fiecare coloană a matricei x urmează o distribuție normală.
Returnează o matrice de rezultate booleene.
- x: Matricea de intrare ([Link]).
"""
n, m = [Link] # Obținem dimensiunile matricei
t = [Link](shape=(m, 4), dtype=bool) # Inițializăm o matrice goală pentru rezultate
 for j in range(m): # Iterăm prin fiecare coloană
t_shapiro = shapiro(x[:, j]) # Aplicăm testul Shapiro-Wilk
t[j, 0] = t_shapiro[1] > 0.01 # Salvăm rezultatul testului (True dacă p > 0.01)
return t # Returnăm matricea rezultatelor

# Exemplu de utilizare:
# x = [Link](10, 3) # Generăm o matrice de exemple (10x3)
# nan_replace(x) # Înlocuim valorile NaN (dacă există)
# x_std = standardizare(x) # Standardizăm matricea
# salvare(x_std, nume_coloane=["Col1", "Col2", "Col3"]) # Salvăm matricea în fișier
# rezultate = teste_concordanta(x_std) # Testăm distribuția normală
# print(rezultate) # Afișăm rezultatele testului

[Link]

# Importăm bibliotecile și funcțiile personalizate

import numpy as np # Pentru lucrul cu matrici și calcule numerice
import pandas as pd # Pentru manipularea datelor structurate
from functii import nan_replace, standardizare, salvare, teste_concordanta # Importăm
funcțiile definite anterior

# Setări pentru afișare

pd.set_option("display.max_columns", None) # Afișează toate coloanele din tabelele
Pandas
np.set_printoptions(precision=3, threshold=10000, suppress=True) # Setări pentru afișarea
array-urilor numpy

# Citirea setului de date

set_date = pd.read_csv("[Link]", index_col=0) # Citim fișierul CSV și setăm
prima coloană ca index
# print(type(set_date)) # Putem verifica tipul obiectului încărcat (DataFrame)

# Extragem lista de variabile (numele coloanelor)

variabile = list(set_date)
# print(set_date) # Afișăm setul de date (opțional)

# Convertim datele într-o matrice numpy

x = set_date[variabile].values
# print(x, type(x), sep="\n") # Verificăm matricea numpy și tipul ei (opțional)

# Înlocuirea valorilor lipsă (NaN) din matrice

nan_replace(x)
# print(x) # Verificăm matricea după înlocuirea NaN (opțional)

# Standardizare și centrare
x_ = standardizare(x) # Standardizare (media 0, deviația standard 1)
x_c = standardizare(x, scalare=False) # Centrare (doar media 0, fără scalare)

# Salvăm datele standardizate și centrate în fișiere CSV

salvare(x_, set_date.index, variabile, "x_std.csv") # Datele standardizate
salvare(x_c, set_date.index, variabile, "x_c.csv") # Datele centrate

# Calculăm și salvăm matricea de corelație

r = [Link](x, rowvar=False) # Matricea de corelații între variabile (pe coloane)
salvare(r, variabile, variabile, "[Link]") # Salvăm matricea de corelații

# Calculăm și salvăm matricea de covarianță

v = [Link](x, rowvar=False) # Matricea de covarianțe între variabile (pe coloane)
salvare(v, variabile, variabile, "[Link]") # Salvăm matricea de covarianțe

# Teste de concordanță (Shapiro-Wilk) pentru fiecare coloană

teste = teste_concordanta(x) # Aplicăm testele de normalitate
print(teste) # Afișăm rezultatele testelor (True/False pentru fiecare coloană)

SEMINAR 4 + SEMINAR 5

Tema 3.1
În fișierul [Link] se află date privind populația pe etnii la nivelul localităților
conform Recensământului Populației și Locuințelor din 2011. În fișierele
Coduri_Localiatati.csv, Coduri_Judete.csv și Coduri_Regiuni.csv sunt codificările
localităților, județelor, regiunilor și macroregiunilor României.
1. Să se calculeze și să se salveze populația pe etnii la nivelul județelor, regiunilor și
macroregiunilor
2. Să se calculeze și să se salveze procentele pe etnii la nivelul localităților, județelor,
regiunilor și macroregiunilor
3. Să se calculeze și să se salveze indicii de segregare etnică la nivelul județelor. Vor
fi utilizați următorii indici: Indicele de disimilaritate, D = 1 2 ∑ | 𝑥𝑖 𝑇𝑥 − 𝑟𝑖 𝑇𝑟 |

[Link]

import numpy as np
import pandas as pd
from [Link] import shapiro, entropy
from [Link] import is_numeric_dtype

# Funcția pentru înlocuirea valorilor NaN într-un array numpy

def nan_replace(x):
y = [Link](x) # Identifică valorile NaN din array
k = [Link](y) # Găsește indicii unde sunt valori NaN
x[k] = [Link](x[:, k[1]], axis=0) # Înlocuiește valorile NaN cu media pe coloana
respectivă
# Funcția pentru înlocuirea valorilor NaN într-un DataFrame pandas
def nan_replace_df(t: [Link]):
for coloana in [Link]:
if t[coloana].isna().any(): # Verifică dacă există valori NaN în coloană
if is_numeric_dtype(t[coloana]): # Dacă coloana este numerică
t[coloana].fillna(t[coloana].mean(), inplace=True) # Înlocuiește NaN cu media
else:
t[coloana].fillna(t[coloana].mode()[0], inplace=True) # Înlocuiește NaN cu valoarea
cea mai frecventă (mod)

# Funcția pentru standardizarea datelor

def standardizare(x, nlib=0, scalare=True):
x_ = x - [Link](x, axis=0) # Scade media fiecărei coloane
if scalare:
x_ = x_ / [Link](x, axis=0, ddof=nlib) # Împarte prin deviația standard dacă scalarea
este activată
return x_

# Funcția pentru salvarea unui array numpy într-un fișier CSV

def salvare(x, nume_linii=None, nume_coloane=None, fisier_output="[Link]"):
t = [Link](x, nume_linii, nume_coloane) # Creează un DataFrame din array
t.to_csv(fisier_output) # Salvează DataFrame-ul într-un fișier CSV

# Funcția pentru testarea normalității folosind testul Shapiro-Wilk

def teste_concordanta(x: [Link]):
n, m = [Link]
t = [Link](shape=(m, 4), dtype=bool) # Creează o matrice goală de tip boolean
for j in range(m):
t_shapiro = shapiro(x[:, j]) # Aplică testul Shapiro-Wilk pe coloana j
t[j, 0] = t_shapiro[1] > 0.01 # Testează dacă valoarea p este mai mare decât 0.01 (nivel
de semnificație)
return t

# Funcția pentru calcularea procentelor

def calcul_procente(t: [Link]):
return t * 100 / [Link]() # Înmulțește fiecare element din serie cu 100 și împarte la suma
totală

# Funcția pentru calcularea disimilarității

def disimilaritate(t: [Link]):
x = [Link][:, :-1] # Extrage valorile din DataFrame, excluzând ultima coloană
r = ([Link](x, axis=1) - x.T).T # Calculează restul după eliminarea valorilor coloanelor
tx = [Link](x, axis=0) # Suma fiecărei coloane
tr = [Link](r, axis=0) # Suma valorilor restului pe coloane
tx[tx == 0] = 1 # Evită împărțirea la zero, înlocuind cu 1
tr[tr == 0] = 1 # Evită împărțirea la zero pentru resturi
d = 0.5*[Link]([Link](x/tx - r/tr), axis=0) # Calculează disimilaritatea între seturi
return [Link](d, [Link][:-1]) # Returnează disimilaritatea sub formă de serie
# Funcția pentru calculul entropiei
def entropie(t: [Link]):
x = [Link][:, :-1] # Extrage valorile din DataFrame, excluzând ultima coloană
p = (x.T / [Link](x, axis=1)).T # Calculează probabilitățile prin împărțirea valorilor pe linii

# Înlocuiește valorile zero cu un număr foarte mic pentru a evita

log(0) p[p == 0] = 1e-10
# Calculează entropia pe rânduri folosind formula: -Σ(p * log2(p))
entropii = -[Link](p * np.log2(p), axis=1)
# Creează un DataFrame cu entropiile calculate și returnează-l
return [Link](entropii, index=[Link], name="Entropie")

[Link]

import numpy as np # Importă biblioteca NumPy pentru operații matematice avansate.

import pandas as pd # Importă biblioteca Pandas pentru manipularea datelor.
from functii import nan_replace, standardizare, salvare, teste_concordanta
# Importă funcții definite într-un modul separat numit "functii".

# Configurări pentru afișarea datelor:

pd.set_option("display.max_columns", None) # Setează afișarea completă a coloanelor din
DataFrame.
np.set_printoptions(3, threshold=10000, suppress=True)
# Configurări pentru afișarea array-urilor NumPy: până la 3 zecimale, suprimă notația
științifică.

# Încarcă setul de date dintr-un fișier CSV, folosind prima coloană ca index.
set_date = pd.read_csv("[Link]", index_col=0)

# Listează toate variabilele (coloanele) din setul de date.

variabile = list(set_date)

# Extrage valorile din DataFrame sub forma unui array NumPy.

x = set_date[variabile].values

# Înlocuiește valorile lipsă (NaN) folosind funcția `nan_replace`.

nan_replace(x)

# Standardizează și centrează datele:

x_ = standardizare(x) # Standardizare completă (scalare și centrare).
x_c = standardizare(x, scalare=False) # Doar centrare (fără scalare).

# Salvează rezultatele standardizate și centrate în fișiere CSV.

salvare(x_, set_date.index, variabile, "x_std.csv")
salvare(x_c, set_date.index, variabile, "x_c.csv")

# Calculează matricea de corelație și o salvează:

r = [Link](x, rowvar=False) # Corelații între coloane (variabile).
salvare(r, variabile, variabile, "[Link]")

# Calculează matricea de covarianță și o salvează:

v = [Link](x, rowvar=False) # Covarianțe între coloane (variabile).
salvare(v, variabile, variabile, "[Link]")

# Rulează teste de concordanță statistică pe date și afișează rezultatele.

teste = teste_concordanta(x)
print(teste)

Main_tema3.py
import pandas as pd # Importă biblioteca Pandas pentru manipularea datelor.

from functii import calcul_procente, disimilaritate

# Importă funcții definite într-un fișier extern, numit `functii`.

# Încarcă datele privind etniile dintr-un fișier CSV. Prima coloană este folosită ca index.
t_etnii = pd.read_csv("data_in_tema3/[Link]", index_col=0)

# Verifică dacă există valori lipsă (NaN) în tabelul `t_etnii`.

exista_nan = t_etnii.isna().any().any()
# `exista_nan` va fi True dacă există cel puțin o valoare NaN, altfel False.

# Obține o listă cu toate etniile (coloanele din fișier, mai puțin prima coloană).
etnii = list(t_etnii)[1:]

# Încarcă un fișier care conține coduri pentru localități.

coduri_loc = pd.read_csv("data_in_tema3/Coduri_Localitati.csv", index_col=0)

# Asociază localitățile cu județele lor, adăugând o coloană suplimentară "County".

t_etnii_ = t_etnii[etnii].merge(coduri_loc["County"], left_index=True, right_index=True)

# Grupează datele pe județe și calculează suma populației pentru fiecare etnie în județe.
t_etnii_judet = t_etnii_.groupby(by="County").sum()
assert isinstance(t_etnii_judet, [Link]) # Asigură-te că rezultatul este un
DataFrame.
t_etnii_judet.to_csv("data_out_tema3/Ethnicity_County.csv") # Salvează rezultatul în CSV.

# Încarcă fișierul cu coduri de județe și regiuni.

coduri_jud = pd.read_csv("data_in_tema3/Coduri_Judete.csv", index_col=0)

# Asociază județele cu regiunile lor.

t_etnii_judet_ = t_etnii_judet.merge(coduri_jud["Regiune"], left_index=True,
right_index=True)

# Grupează datele pe regiuni și calculează suma populației pentru fiecare etnie.

t_etnii_regiune = t_etnii_judet_.groupby(by="Regiune").sum()
t_etnii_regiune.to_csv("data_out_tema3/Ethnicity_Region.csv") # Salvează rezultatul în
CSV.

# **Cerinta 2**: Calcularea procentelor populației pentru fiecare etnie.

# Calculează procentele etniilor pentru fiecare localitate.

t_etnii_procente = t_etnii[etnii].apply(func=calcul_procente, axis=1)
assert isinstance(t_etnii_procente, [Link]) # Asigură-te că rezultatul este un
DataFrame.

# Adaugă coloana "City" în tabelul de procente.

t_etnii_procente.insert(0, "City", t_etnii["City"])
t_etnii_procente.to_csv("data_out_tema3/Ethnicity_City_p.csv") # Salvează în CSV.

# Calculează procentele etniilor pentru fiecare județ.

t_etnii_judet_procente = t_etnii_judet.apply(func=calcul_procente, axis=1)
t_etnii_judet_procente.round(3).to_csv("data_out_tema3/Ethnicity_County_p.csv") #
Salvează în CSV.

# Calculează procentele etniilor pentru fiecare regiune.

t_etnii_regiune_p = t_etnii_regiune.apply(func=lambda x: x * 100 / [Link](), axis=1)
t_etnii_regiune_p.round(3).to_csv("data_out_tema3/Ethnicity_Region_p.csv") # Salvează în
CSV.

# **Cerinta 3**: Calcularea disimilarității.

# Calculează disimilaritatea pentru fiecare județ.

t_disim = t_etnii_.groupby(by="County").apply(func=disimilaritate)
t_disim.round(3).to_csv("data_out_tema3/[Link]") # Salvează rezultatul în CSV.

!!!!!!!!!!!!!!!!!!!!! LUAM SET DE DATE 3.1 DE PE ONLINE, DEZARHIVAM , DAM COPY LA

CELE 4 CSV URI SI FACEM FOLDER "DATE" IN FOLDERUL SEMINAR3_1088 SI DAM
PASTE
click dreapta in stanga pe seminar3_1088 new python file numit tema3

Seminar 6
În fișierul [Link] se află informații privind activitatea din industria energetică pe
subactivități, la nivel de județe. Informațiile sunt următoarele: Judet - Indicativul de județ;
c3511, c3512, c3513, c3514, c3521, c3522, c3523, c3530 - Coduri CAEN pentru
subactivități. Valorile acestor indicatori reprezintă coeficienții de localizare pe subactivități la
nivel de județe. Aceștia pot fi mai mari sau mai mici decât 1 după cum activitatea este mai
mult sau mai puțin prezentă în județul respectiv. În fișierul RO_NUTS.csv se află codurile de
regiuni și macroregiuni pentru fiecare județ conform NUTS (Nomenclatorul Unităților
Teritoriale Statistice).
1) Să se calculeze și să se salveze în fișierul [Link] coeficienții de localizare privind
activitatea din industria energetică la nivel de județ. Se calculează ca medie a coeficienților
la nivel de subactivități. Se va salva indicativul de județ și coeficientul de localizare.
Exemplu:
Judet,CoefLocalizare
dj,2.300375
ms,3.066375
...
2) Să se salveze în fișierul [Link] județele la care pentru subactivitatea C3511,
coeficientul de localizare este mai mare decât 1. Pentru fiecare județ se va salva indicativul
și coeficienții de localizare pe subactivități.
Exemplu:
Judet,c3511,c3512,c3513,c3514,c3521,c3522,c3523,c3530
dj,7.7,0.0,4.138,1.795,0.0,0.0,0.0,4.77
tl,1.72,0.0,1.193,0.0,0.0,2.316,0.0,3.521
...
3) Să se salveze în fișierul [Link] activitatea cu coeficientul de localizare cel mai mare
pentru fiecare județ. Se va salva indicativul de județ și activitatea dominantă.
Exemplu:
Judet,ActivitateDominanta
dj,c3511
ms,c3523
...
4) Să se calculeze și să se salveze în fișierul [Link] coeficienții medii de localizare pe
subactivități la nivel de regiuni. Se va salva codul regiunii și coeficienții medii pe subactivități.
Exemplu:
Regiune,c3511,c3512,c3513,c3514,c3521,c3522,c3523,c3530
Bucuresti-Ilfov,0.861,1.217,0.5405,1.3005,1.5345,0.957,1.6735,1.332
...
5) Să se calculeze și să se afișeze în fișierul [Link] județele în care se înregistrează
cei mai mari coeficienți pe subactivități, la nivel de regiuni. Se va salva codul regiunii și
județele cu coeficienții maximi pe subactivități.
Exemplu:
Regiune,c3511,c3512,c3513,c3514,c3521,c3522,c3523,c3530
Bucuresti-Ilfov,b,b,b,b,b,b,b,b
Centru,bv,sb,bv,ab,ab,ms,ms,hr
...

import numpy as np # Importă biblioteca NumPy pentru calcule numerice.

import pandas as pd # Importă biblioteca Pandas pentru manipularea datelor.

# Funcție care găsește activitatea dominantă pentru fiecare regiune.

def f_cerinta5(t: [Link]):
# `t` este un DataFrame care reprezintă datele pentru o regiune specifică.
x = [Link] # Convertește valorile DataFrame-ului într-un array NumPy.
 k = [Link](x, axis=0) # Găsește indexul maxim pentru fiecare coloană (pe axa 0 -
liniile).
v = [Link][k] # Obține indexurile corespunzătoare valorilor maxime.
return [Link](v, [Link]) # Creează un obiect Series cu indexul coloanelor.

# Încarcă fișierul CSV cu informațiile despre activități economice pe localități.

energloc = pd.read_csv("[Link]", index_col=0)

# **Cerinta 1**: Calculul coeficientului de localizare pentru fiecare localitate.

cerinta1 = [Link](func=lambda x: [Link](), axis=1)
# Calculează media valorilor din fiecare rând (localitate).
[Link] = "CoefLocalizare" # Denumește această serie "CoefLocalizare".
cerinta1.to_csv("data_out/[Link]") # Salvează rezultatul în fișierul `[Link]`.

# **Cerinta 2**: Selectarea localităților unde valoarea pentru activitatea "c3511" > 1.
cerinta2 = energloc[energloc["c3511"] > 1] # Filtrare pe coloana `c3511`.
cerinta2.to_csv("data_out/[Link]") # Salvează rezultatul în `[Link]`.

# **Cerinta 3**: Determinarea activității dominante pentru fiecare localitate.

cerinta3 = [Link](func=lambda x: [Link][[Link]()], axis=1)
# Pentru fiecare rând, identifică coloana unde valoarea este maximă (`argmax()`).
[Link] = "Activitate dominanta" # Denumește această serie "Activitate dominanta".
cerinta3.to_csv("data_out/[Link]") # Salvează rezultatul în `[Link]`.

# Încarcă fișierul cu informațiile despre regiuni și localități.

ro_nuts = pd.read_csv("RO_NUTS.csv", index_col=0)

# Adaugă o coloană "Regiune" la tabelul inițial, asociind fiecare localitate cu regiunea sa.
energloc_ = [Link](ro_nuts["Regiune"], left_index=True, right_index=True)

# **Cerinta 4**: Calcularea mediei activităților economice pentru fiecare regiune.

cerinta4 = energloc_.groupby(by="Regiune").mean()
# Grupează datele după "Regiune" și calculează media valorilor pentru fiecare regiune.
cerinta4.to_csv("data_out/[Link]") # Salvează rezultatul în `[Link]`.

# **Cerinta 5**: Determinarea localității cu cea mai mare valoare pentru fiecare activitate, pe
regiune.
cerinta5 = energloc_.groupby(by="Regiune").apply(func=f_cerinta5, include_groups=False)
# Pentru fiecare grup (regiune), funcția `f_cerinta5` determină localitatea dominantă pentru
fiecare activitate.
cerinta5.to_csv("data_out/[Link]") # Salvează rezultatul în `[Link]`.
Fila 2
Vom detalia fiecare cerință pas cu pas, cu exemple clare și explicații, astfel încât să ai o
resursă completă pentru test. Vom folosi metode ușor de înțeles și aplicabile rapid.

1. Lucrul cu fișiere CSV

Python oferă modulul csv pentru lucrul cu fișiere CSV. Două clase importante sunt:

● [Link] (pentru citire)

● [Link] (pentru scriere)

Citirea fișierelor CSV cu DictReader

import csv

# Citirea unui fișier CSV

with open('[Link]', mode='r', newline='') as file:
reader = [Link](file) # Creează un obiect care citește fiecare linie ca un dicționar
for row in reader:
print(row) # Fiecare rând este un dicționar cu chei bazate pe antetul fișierului

Explicație:

● [Link] convertește fiecare rând într-un dicționar.

● Cheile din dicționar sunt capetele de coloană.

Scrierea fișierelor CSV cu DictWriter

import csv

# Scrierea unui fișier CSV

data = [
{"nume": "Ion", "nota": 10},
{"nume": "Maria", "nota": 9}
]

with open('[Link]', mode='w', newline='') as file:

writer = [Link](file, fieldnames=["nume", "nota"])
[Link]() # Scrie antetul
[Link](data) # Scrie rândurile din listă

Explicație:

● fieldnames definește ordinea coloanelor.

● [Link]() scrie antetul.
 ● [Link]() scrie toate rândurile dintr-o listă de dicționare.

2. Structuri de date Python necesare

Liste și dicționare
# Dicționar pentru date
date = {"Ion": [10, 9, 8], "Maria": [7, 8, 9]}

# Accesarea unei valori

print(date["Ion"]) # Afișează [10, 9, 8]

# Adăugarea unei intrări

date["George"] = [6, 7, 8]

# Listă de dicționare
lista = [{"nume": "Ion", "nota": 10}, {"nume": "Maria", "nota": 9}]

Explicație:

● Dicționarele stochează date prin chei.

● Listele stochează valori în ordine.

3. Funcții de calcul

Media
def calculeaza_media(valori):
return sum(valori) / len(valori)

# Exemplu
note = [8, 9, 10]
print(calculeaza_media(note)) # Afișează 9.0

Abaterea standard
import math

def abatere_standard(valori):
media = calculeaza_media(valori)
varianta = sum((x - media) ** 2 for x in valori) / len(valori)
return [Link](varianta)

# Exemplu
print(abatere_standard(note)) # Afișează abaterea standard
Coeficientul de variație
def coeficient_variatie(valori):
return abatere_standard(valori) / calculeaza_media(valori)

# Exemplu
print(coeficient_variatie(note)) # Coeficientul de variație

4. Filtrarea și sortarea datelor

Filtrare
# Filtrare pe baza unei condiții
data = [{"nume": "Ion", "nota": 10}, {"nume": "Maria", "nota": 8}]
filtrate = [d for d in data if d["nota"] >= 9]
print(filtrate) # Afișează [{"nume": "Ion", "nota": 10}]

Sortare
# Sortare după o cheie
data = [{"nume": "Ion", "nota": 10}, {"nume": "Maria", "nota": 8}]
sortate = sorted(data, key=lambda x: x["nota"], reverse=True)
print(sortate) # Sortare descrescătoare

5. Extragerea și salvarea datelor

Salvarea unui subset într-un CSV

import csv

# Extragerea și salvarea
subset = [{"nume": "Ion", "nota": 10}]
with open('[Link]', mode='w', newline='') as file:
writer = [Link](file, fieldnames=["nume", "nota"])
[Link]()
[Link](subset)

6. Manipulări statistice și teste

Înlocuirea valorilor lipsă

# Înlocuirea valorilor lipsă cu media
def inlocuire_valori_lipse(data):
 media = calculeaza_media([x for x in data if x is not None])
return [x if x is not None else media for x in data]

# Exemplu
date = [10, None, 8, None, 9]
print(inlocuire_valori_lipse(date))

Matrici de corelație și covarianță

import numpy as np

# Matrice de covarianță
date = [[10, 8], [9, 7], [8, 9]]
matrice_cov = [Link]([Link](date).T)
print(matrice_cov) # Afișează matricea de covarianță

7. Indici de diversitate și segregare

Indicele Shannon-Weaver
import math

def shannon_weaver(proportii):
return -sum(p * math.log2(p) for p in proportii if p > 0)

# Exemplu
proportii = [0.5, 0.3, 0.2]
print(shannon_weaver(proportii))

8. Structura recomandată pentru test

1. Citirea fișierelor CSV: Utilizează [Link].

2. Analiza datelor: Calculează medii, abateri standard, etc.
3. Manipulare: Filtrare și sortare.
4. Generarea rezultatelor: Scrie fișiere CSV cu rezultatele relevante.
5. Răspuns organizat: Documentează fiecare pas cu explicații în fișierul testului.

Dacă ai nevoie de alte detalii sau exemple, spune-mi! 😊