<jupyter_start><jupyter_text>Parte 2 - Alterazione e unione di datasets  Alterazione:  Esercizio 2:- Importare Pandas- Caricare il dataset avocado- Creare un subset del dataset chiamato "organic_avocado_df" dove la colonna "type" è di tipo "organic"- Ordinare il dataset in base alla data [Suggerimento: utilizzate il metodo **sort_values(by="Nome colonna", ascending=True)**]<jupyter_code>import pandas as pd
organic_avocado_df = pd.read_csv("../datasets/avocado.csv")
organic_avocado_df = organic_avocado_df[organic_avocado_df["type"]=="organic"]
organic_avocado_df.sort_values(by="Date", ascending=True, inplace=True)<jupyter_output><empty_output><jupyter_text>Creiamo un nuovo dataframe dove per ogni colonna avremo tutte le "region" e ogni riga rappresenterà la media mobile creata precedentemente per un ogni giorno:es:    California | Florida | New York2015&emsp;&emsp;&emsp;1.4&emsp;&emsp;&emsp;&emsp;1.8&emsp;&emsp;&emsp;&emsp;2 2016&emsp;&emsp;&emsp;1.3&emsp;&emsp;&emsp;&emsp;1.7&emsp;&emsp;&emsp;&emsp;2<jupyter_code>media_mobile_df = pd.DataFrame()

for region in organic_avocado_df["region"].unique():
    #print(region)
    region_df = organic_avocado_df[organic_avocado_df["region"] == region]
    region_df.set_index("Date", inplace=True)
    region_df.sort_index(inplace=True)
    region_df[region] = region_df["AveragePrice"].rolling(25).mean()
    
    #print(region_df.tail())
    
    if media_mobile_df.empty:
        media_mobile_df = region_df[[region]] #.. , [], []
    else:
        media_mobile_df = media_mobile_df.join(region_df[region])
media_mobile_df.tail()
media_mobile_df.plot(figsize=(8,5), legend=False)<jupyter_output><empty_output><jupyter_text>Esercizio 3:- Convertire la colonna "Date" da stringa a datetime (Suggerimento: Nel notebook precedente abbiamo convertito l'index e non una colonna)<jupyter_code>organic_avocado_df["Date"] = pd.to_datetime(organic_avocado_df["Date"])
#df_avocado["price25ma"] = df_avocado["AveragePrice"].rolling(25).mean()<jupyter_output><empty_output><jupyter_text>**Problema:** Per l'analisi che andremo a fare ci servirà il dataset contentete come region solo gli stati!<jupyter_code>organic_avocado_df["region"].unique()<jupyter_output><empty_output><jupyter_text>In alcuni casi abbiamo il nome della città, in altri casi abbiamo lo stato, in altri casi nome + stato, etc.. Non mi basta mantenere solo gli stati, le colonne stato sono troppo pochePassi che andremo a compiere:1) Separare i nomi uniti2) Mappare le città con il proprio stato3) Raggruppare le città nel proprio stato  Passo 1:  Separare i nomi uniti<jupyter_code>import re

nomi_nuovi = []

for row in organic_avocado_df.itertuples():
    nomi_nuovi.append(" ".join(re.findall('[A-Z][^A-Z]*', row[-1])))

organic_avocado_df["region"] = nomi_nuovi
organic_avocado_df.head()
organic_avocado_df["region"].unique()<jupyter_output><empty_output><jupyter_text>Passo 2: Mappare le città con il proprio statoColleghiamoci a questo [sito](https://worldpopulationreview.com/us-cities)!<jupyter_code>citta_us = pd.read_html("https://worldpopulationreview.com/us-cities")
citta_us<jupyter_output><empty_output><jupyter_text>Quali colonne ci interessano?<jupyter_code>citta_us = citta_us[0]
citta_us = citta_us[["Name","State"]]
citta_us
citta_us.set_index("Name", inplace=True)
citta_us.head()
citta_us_dict = citta_us["State"].to_dict()
citta_us_dict<jupyter_output><empty_output><jupyter_text>Dobbiamo iterare ogni città nel dataset e ottenere dal dizionario lo stato corrispondente<jupyter_code>citta_us_dict = [citta_us_dict[c] for c in organic_avocado_df["region"]]
citta_us_dict<jupyter_output><empty_output><jupyter_text>**Problema**: 'California''New York''Midsouth''West''Northeast''Total US''South Carolina''SouthCentral''West Tex New Mexico''Northern New England'<jupyter_code>organic_avocado_df = organic_avocado_df.drop(organic_avocado_df[(organic_avocado_df['region'] == "California") | 
                                        (organic_avocado_df['region'] == "New York") | 
                                        (organic_avocado_df['region'] == "Midsouth") | 
                                        (organic_avocado_df['region'] == "West") |
                                        (organic_avocado_df['region'] == "Northeast") |
                                        (organic_avocado_df['region'] == "Southeast") |
                                        (organic_avocado_df['region'] == "Total U S") |
                                        (organic_avocado_df['region'] == "South Carolina") |
                                        (organic_avocado_df['region'] == "South Central") |
                                        (organic_avocado_df['region'] == "West Tex New Mexico") |
                                        (organic_avocado_df['region'] == "Great Lakes") |
                                        (organic_avocado_df['region'] == "Northern New England")].index)
organic_avocado_df["region"].unique()<jupyter_output><empty_output><jupyter_text>Potrei sistemare il dataset manualmente**Problema**: '<NAME>''Buffalo Rochester''St Louis''Miami Ft Lauderdale''Baltimore Washington''Richmond Norfolk''Dallas Ft Worth''Harrisburg Scranton''Raleigh Greensboro''Hartford Springfield''Cincinnati Dayton','New Orleans Mobile'<jupyter_code>organic_avocado_df.loc[organic_avocado_df['region'] == 'Phoenix Tucson', 'region'] = 'Phoenix'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Buffalo Rochester', 'region'] = 'Buffalo'
organic_avocado_df.loc[organic_avocado_df['region'] == 'St Louis', 'region'] = 'St. Louis'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Miami Ft Lauderdale', 'region'] = 'Miami'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Baltimore Washington', 'region'] = 'Baltimore'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Richmond Norfolk', 'region'] = 'Richmond'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Harrisburg Scranton', 'region'] = 'Harrisburg'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Raleigh Greensboro', 'region'] = 'Raleigh'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Hartford Springfield', 'region'] = 'Hartford'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Cincinnati Dayton', 'region'] = 'Cincinnati'
organic_avocado_df.loc[organic_avocado_df['region'] == 'New Orleans Mobile', 'region'] = 'New Orleans'
organic_avocado_df.loc[organic_avocado_df['region'] == 'Dallas Ft Worth', 'region'] = 'Dallas'

citta_us_dict["Syracuse"] = "New York"
citta_us_dict["Roanoke"] = "North Carolina"
citta_us_dict["Plains"] = "Georgia"
citta_us_dict["Albany"] = "New York"
citta_us_dict["Harrisburg"] = "Pennsylvania"
citta_us_dict["Hartford"] = "Connecticut"
citta_us_dict = [citta_us_dict[c] for c in organic_avocado_df["region"]]<jupyter_output><empty_output><jupyter_text>Esercizio 4:- Creare nel dataframe "organic_avocado_df" la colonna "state" e assegnarli la lista appena creata<jupyter_code>organic_avocado_df["state"] = citta_us_dict
organic_avocado_df.head()
organic_avocado_df["state"].unique()<jupyter_output><empty_output><jupyter_text>Vogliamo raggruppare gli stati tutti assieme:<jupyter_code>organic_avocado_df = organic_avocado_df.groupby(['Date','state']).mean()
organic_avocado_df.tail(25)<jupyter_output><empty_output><jupyter_text>Esercizio 5:- Ricreare un dataframe dove per ogni colonna avremo tutti gli "state" e per ogni riga la media mobile:<jupyter_code>media_mobile_df = pd.DataFrame()

for state, group in organic_avocado_df.groupby("state"):
    #print(group)
    #break
    group = group.reset_index()
    group[state] = group["AveragePrice"].rolling(25).mean()
    
    if media_mobile_df.empty:
        media_mobile_df = group.set_index("Date")[[state]]
    else:
        media_mobile_df = media_mobile_df.join(group.set_index("Date")[[state]])
        
media_mobile_df.tail(20)
media_mobile_df.head()
media_mobile_df.dropna().head()<jupyter_output><empty_output><jupyter_text>Osserviamo i risultati:<jupyter_code>media_mobile_df.dropna().plot()<jupyter_output><empty_output><jupyter_text>Meglio togliere la legenda<jupyter_code>media_mobile_df.dropna().plot(legend=False)
media_mobile_df.describe()<jupyter_output><empty_output><jupyter_text>Stampiamo la matrice di correlazione e dopodiché salviamola in una variabile!La correlazione è una misura statistica che descrive come due variabili sono correlate e indica quando una variabile cambia di valore, l'altra variabile tende a cambiare in una direzione specifica.- **Correlazione positiva**: le due variabili si muovono nella stessa direzione (cioè, una variabile aumenta quando l'altra aumenta. Oppure, una diminuisce mentre l'altra diminuisce).- **Correlazione negativa**: le due variabili si muovono in direzioni opposte (cioè, una variabile aumenta mentre l'altra diminuisce, e viceversa)- **Correlazione neutra**: le due variabili non mostrano alcuna relazione tra loro.<jupyter_code>media_mobile_df.corr().head()
media_mobile_corr = media_mobile_df.corr()<jupyter_output><empty_output><jupyter_text>**Importiamo due nuove librerie che ci aiuteranno a visualizzare la matrice di correlazione**<jupyter_code>import matplotlib.pyplot as plt
import numpy as np

plt.matshow(media_mobile_corr)<jupyter_output><empty_output><jupyter_text>**Abbiamo 2 problemi da risolvere per ottenere un plot più leggibile** **Problema 1:**<jupyter_code>fig = plt.figure(figsize=(12,12))
ax = fig.add_subplot(111) # 1 by 1 Grind -> Number 1
ax.matshow(media_mobile_corr, cmap=plt.cm.RdYlGn)
plt.show()
labels = [c[:2] for c in media_mobile_corr.columns]

fig = plt.figure(figsize=(12,12))
ax = fig.add_subplot(111) # 1 by 1 Grind -> Number 1
ax.matshow(media_mobile_corr, cmap=plt.cm.RdYlGn)
ax.set_yticklabels(labels)
ax.set_xticklabels(labels)
plt.show()
fig = plt.figure(figsize=(12,12))
ax = fig.add_subplot(111) # 1 by 1 Grind -> Number 1
ax.matshow(media_mobile_corr, cmap=plt.cm.RdYlGn)

ax.set_yticks(np.arange(len(labels)))
ax.set_xticks(np.arange(len(labels)))

ax.set_yticklabels(labels)
ax.set_xticklabels(labels)
plt.show()<jupyter_output><empty_output><jupyter_text>**Ultimo problema** Bisogna trovare un modo per mappare ogni stato con l'abbreviativo delle 2 lettere corrispondenti Colleghiamoci al sito [infoplease](https://www.infoplease.com/us/postal-information/state-abbreviations-and-state-postal-codes)  Esercizio 6:- Caricare la pagine infoplease all'interno della variabile states_abr (Suggerimento: abbiamo già utilizzato la funzione read_html)<jupyter_code>states_postalcode = pd.read_html("https://www.infoplease.com/us/postal-information/state-abbreviations-and-state-postal-codes")
states_postalcode<jupyter_output><empty_output><jupyter_text>**Ci serve solo la prima parte del dataframe**<jupyter_code>states_postalcode[0]
states_postalcode = states_postalcode[0]
states_postalcode.head()<jupyter_output><empty_output><jupyter_text>**Ora che abbiamo estratto delle informazioni possiamo salvarle in un file .csv In questo modo se in futuro dovremmo averne ancora bisogno abbiamo già il file pronto!**<jupyter_code>states_postalcode.to_csv("../datasets/states_postalcode.csv", index=False)
states_postalcode = pd.read_csv("../datasets/states_postalcode.csv")
states_postalcode.head()<jupyter_output><empty_output><jupyter_text>**Possiamo anche caricare il dataset già con un index**<jupyter_code>states_postalcode = pd.read_csv("../datasets/states_postalcode.csv", index_col=0)
states_postalcode.head()<jupyter_output><empty_output><jupyter_text>**E convertitlo in un dizionario, in questo modo sarà più semplice riutilizzarlo** Esercizio 7:- salvare nella variabile "states_postalcode_dict" il dizionario con chiave l'index stato e valore "Postal Code"<jupyter_code>states_postalcode_dict = states_postalcode[["Postal Code"]].to_dict()
states_postalcode_dict
states_postalcode_dict = states_postalcode_dict["Postal Code"]
states_postalcode_dict<jupyter_output><empty_output><jupyter_text>Esercizio 8:- Per ogni colonna di media_mobile_corr estrai da states_postalcode_dict il Postal Code corrispondente e salvalo nella variabile "labels"<jupyter_code>labels = [states_postalcode_dict[c] for c in media_mobile_corr.columns]
labels
fig = plt.figure(figsize=(12,12))  # figure so we can add axis
ax = fig.add_subplot(111)  # define axis, so we can modify
ax.matshow(media_mobile_corr, cmap=plt.cm.RdYlGn)  # display the matrix
ax.set_xticks(np.arange(len(labels)))  # show them all!
ax.set_yticks(np.arange(len(labels)))  # show them all!
ax.set_xticklabels(labels)  # set to be the abbv (vs useless #)
ax.set_yticklabels(labels)  # set to be the abbv (vs useless #)

plt.show()<jupyter_output><empty_output><jupyter_text>Unione: **Combining Dataset****Obbiettivo:** Trovare una correlazione tra il prezzo degli avocado, il salario minimo e il tasso di disoccupazione per un determinato stato.**Disclaimer**: NON è detto che debba esistere una correlazione, ed è difficile giustificare i risultati o anche solo trarre qualsiasi conclusione, tutto ciò è esclusivamente stato fatto per mostrare le funzionalità di pandas**CARICHIAMO IL DATASET: [US_unemployment](https://www.kaggle.com/jayrav13/unemployment-by-county-us)**<jupyter_code>disocc_us_df = pd.read_csv("../datasets/US_unemployment.csv")
disocc_us_df.head()<jupyter_output><empty_output><jupyter_text>**Controlliamo che il nostro dataset sulla media mobile non presenti valori nulli**<jupyter_code>media_mobile_df.head()<jupyter_output><empty_output><jupyter_text>Esercizio 9:- Eliminare tutte le righe con valori uguali a NaN<jupyter_code>#Delate NaN
media_mobile_df.dropna(inplace=True)
media_mobile_df.head()<jupyter_output><empty_output><jupyter_text>**I nostri dati sul tasso di disoccupazione sono forniti annualmente, mentre il prezzo degli avocado viene fornito ogni tot giorni**<jupyter_code>#GROUP BY DATE
media_mobile_df = media_mobile_df.groupby([media_mobile_df.index.year]).mean()
media_mobile_df.head()<jupyter_output><empty_output><jupyter_text>**Carichiamo adesso il dataset sul salario minimo: [Minimum Wage Data](https://www.kaggle.com/lislejoem/us-minimum-wage-by-state-from-1968-to-2017)**<jupyter_code>#Minimum Wave

data_us_df = pd.read_csv("../datasets/Minimum Wage Data.csv", encoding="Latin")
data_us_df.head()<jupyter_output><empty_output><jupyter_text>**Bisogna trasformarlo nello stesso formato del dataset _media_mobile_sd_, ovvero uno stato per ogni colonna e come riga il salario minimo per quel determinato anno**<jupyter_code>salario_min_us_df = pd.DataFrame()

for name, group in data_us_df.groupby("State"):
    if salario_min_us_df.empty:
        salario_min_us_df = group.set_index("Year")[["Effective.Minimum.Wage.2020.Dollars"]].rename(columns={"Effective.Minimum.Wage.2020.Dollars":name})
    else:
        salario_min_us_df = salario_min_us_df.join(group.set_index("Year")[["Effective.Minimum.Wage.2020.Dollars"]].rename(columns={"Effective.Minimum.Wage.2020.Dollars":name}))

salario_min_us_df.head()<jupyter_output><empty_output><jupyter_text>**C'è la possibilità che nel dataset ci siano dei valori uguali a 0, meglio eliminarli**<jupyter_code>salario_min_us_df = salario_min_us_df.replace(0, np.NaN).dropna(axis=1)
salario_min_us_df.head()<jupyter_output><empty_output><jupyter_text>**IMPORTANTE**: Dobbiamo creare una funzione che ci restituisca il salario minimo dando in input un anno e un stato<jupyter_code>def get_salario_minimo(year, state):
    try:
        return salario_min_us_df.loc[year][state]
    except:
        return np.NaN<jupyter_output><empty_output><jupyter_text>**TESTIAMO LA FUNZIONE:**<jupyter_code>get_salario_minimo(2000, "Texas")<jupyter_output><empty_output><jupyter_text>**Ora possiamo unire il dataset _disocc_us_df_ con il dataset _salario_min_us_df_ Per fare ciò aggiungeremo una colonna "min_wage" al dataset _disocc_us_df_**<jupyter_code>disocc_us_df.head()<jupyter_output><empty_output><jupyter_text>**Per utilazzere la funzione precedentemente creata dobbiamo utilizzare il metodo map:**<jupyter_code>%%time 

disocc_us_df["min_wage"] = list(map(get_salario_minimo, disocc_us_df["Year"], disocc_us_df["State"]))<jupyter_output>CPU times: user 12.9 s, sys: 98.9 ms, total: 13 s
Wall time: 13.1 s<jupyter_text>**Controlliamo il risultato:**<jupyter_code>disocc_us_df.head()<jupyter_output><empty_output><jupyter_text>**Verifichiamo se esiste una correlazione tra questi due dati**<jupyter_code>disocc_us_df[["Rate", "min_wage"]].corr()<jupyter_output><empty_output><jupyter_text>**Come appena fatto per il salario minimo, dobbiamo aggiungere al dataframe _disocc_us_df_ una colonna che indichi il prezzo degli avocado per un determinato stato e anno** Esercizio 10:- Creare una funzione che restituisca il prezzo degli avocado dando in input l'anno e lo stato<jupyter_code>media_mobile_df.head()
def get_prezzo_avocado(year, state):
    try:
        return media_mobile_df.loc[year][state]
    except:
        return np.NaN
get_prezzo_avocado(2006, "Nevada")
get_prezzo_avocado(2015, "Nevada")<jupyter_output><empty_output><jupyter_text>Esercizio 11:- Aggiungere al dataframe _disocc_us_df_ la colonna "avocado_price" utilizzando la funzione map<jupyter_code>%%time 

disocc_us_df["avocado_price"] = list(map(get_prezzo_avocado, disocc_us_df["Year"], disocc_us_df["State"]))
disocc_us_df.head()<jupyter_output><empty_output><jupyter_text>**Non abbiamo i dati per tutti gli stati**<jupyter_code>disocc_us_df = disocc_us_df.dropna()
disocc_us_df
disocc_us_df[["Rate", "avocado_price"]].corr()
disocc_us_df[["min_wage", "avocado_price"]].corr()<jupyter_output><empty_output><jupyter_text>**Correlazione non significa (quasi mai) causalità**, servirebbe un analisi più approfondità! **Ultima analisi di correlazione:**- C'è una corrlazione tra il salario minimo di uno stato e i risultati delle elezioni presidenziali del 2016? **Importiamo il dataframe delle [elezione del 2016](https://www.kaggle.com/stevepalley/2016uspresidentialvotebycounty)**<jupyter_code>risultati_elettorali = pd.read_csv("../datasets/pres16results.csv")
risultati_elettorali.head()
risultati_elettorali.dropna().head()<jupyter_output><empty_output><jupyter_text>**Confrontiamo i due datasets che dobbiamo unire**<jupyter_code>disocc_us_df.tail()<jupyter_output><empty_output><jupyter_text>**Quale porzione del dataset ci interessa?**<jupyter_code>disocc_us_df = disocc_us_df[(disocc_us_df['Year']==2015) & (disocc_us_df['Month']=="February")]
disocc_us_df.tail()<jupyter_output><empty_output><jupyter_text>**Se vogliamo unire i datasets i nomi degli stati devono corrispondere**<jupyter_code>risultati_elettorali['st'].unique()<jupyter_output><empty_output><jupyter_text>Dobbiamo convertire gli stati di risultati_elettorali in POSTAL CODE**Possiamo riutilizzare il dizionario che abbiamo creato prima!**<jupyter_code>states_postalcode_df = pd.read_csv("../datasets/states_postalcode.csv", index_col = 0)
states_postalcode_df.head()<jupyter_output><empty_output><jupyter_text>**Ci interessano solo i Postal Code**<jupyter_code>states_postalcode_df = states_postalcode_df[["Postal Code"]] #Con una sola parentersi quadra ritorna una Serie e non un dataframe
states_postalcode_df.head()
states_postalcode_dict = states_postalcode_df.to_dict()["Postal Code"]
states_postalcode_dict<jupyter_output><empty_output><jupyter_text>Creiamo una nuova colonna del dataframe<jupyter_code>disocc_us_df["State"] = disocc_us_df["State"].map(states_postalcode_dict)
disocc_us_df.head()
disocc_us_df["State"].unique()<jupyter_output><empty_output><jupyter_text>**Ora che i valori sono coerenti controlliamo che i nomi delle colonne corrispondano!**<jupyter_code>risultati_elettorali.columns
disocc_us_df.columns<jupyter_output><empty_output><jupyter_text>**PROBLEMA**: Il nome delle colonne County e State non corrispondono<jupyter_code>risultati_elettorali.rename(columns={"county":"County", "st":"State"}, inplace=True)
risultati_elettorali.head()<jupyter_output><empty_output><jupyter_text>Esercizio 12:- Impostare "County" e "City" come indici per entrmabi i dataset!<jupyter_code>for i_df in [disocc_us_df, risultati_elettorali]:
    i_df.set_index(["County", "State"], inplace = True)
disocc_us_df.head()
risultati_elettorali.dropna().tail()<jupyter_output><empty_output><jupyter_text>**Siamo interessati solo ai canditati principali cioè: <NAME> e <NAME>** **e alla percentuale di voto che hanno ricevuto**<jupyter_code>risultati_elettorali_dt = risultati_elettorali[risultati_elettorali['cand'] == "<NAME>"]
risultati_elettorali_dt = risultati_elettorali_dt[["pct"]]
risultati_elettorali_dt = risultati_elettorali_dt.rename(columns={'pct': 'pct_dt'})

risultati_elettorali_hc = risultati_elettorali[risultati_elettorali['cand'] == "<NAME>"]
risultati_elettorali_hc = risultati_elettorali_hc[["pct"]]
risultati_elettorali_hc = risultati_elettorali_hc.rename(columns={'pct': 'pct_hc'})<jupyter_output><empty_output><jupyter_text>**Eliminiamo i valori nulli**<jupyter_code>risultati_elettorali_hc.dropna(inplace=True)
risultati_elettorali_hc.tail()<jupyter_output><empty_output><jupyter_text>**Siamo pronti a fare il merge dei due datasets!** Iniziamo con il dataframe di Donald Trump!<jupyter_code>merge_df = disocc_us_df.merge(risultati_elettorali_dt, on=["County", "State"])
merge_df.dropna(inplace=True)
merge_df.head()<jupyter_output><empty_output><jupyter_text>Ripetiamo l'operazione con il dataframe di <NAME><jupyter_code>merge_df = merge_df.merge(risultati_elettorali_hc, on=["County", "State"])
merge_df.dropna(inplace=True)
merge_df.head()<jupyter_output><empty_output><jupyter_text>**La colonna "Year" è inutile essendo un dataframe del 2015**<jupyter_code>merge_df.drop("Year", axis=1, inplace=True) #Axis = 1 Indica le colonne
merge_df.head()
merge_df.corr()
merge_df.cov()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11955922865013774, 'fraction_numerical': 0.008034894398530763, 'mean_word_length': 7.2943640517897945, 'pattern_counts': {'":': 4, '<': 226, '<?xml version=': 0, '>': 229, 'https://': 7, 'lorem ipsum': 0, 'www.': 5, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 11, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '55', 'dir': 'jupyter-structured-clean-dedup', 'id': '295634', 'license': 'MIT', 'n_tokens_mistral': 8321, 'n_tokens_neox': 7924, 'n_words': 1452, 'path': 'complete/lesson_2_complete.ipynb', 'repo_name': 'andreascaudo/data_analysis_lab', 'size': '21827'}