<jupyter_start><jupyter_text>Leggo file tweet_finali<jupyter_code>tweet_finali= pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\csv_finali\\final_totali.csv",
               engine="python", encoding="utf-8")
tweet_finali.head()<jupyter_output><empty_output><jupyter_text>Conto numero tweet per gara<jupyter_code>tweetGara=tweet_finali.groupby("gara").count()
tweetGara=tweetGara.reset_index()
tweetGara=tweetGara[["gara","id"]]
tweetGara.columns=["Game","#Tweet"]
tweetGara<jupyter_output><empty_output><jupyter_text>Prendo tuttti i tweet di una gara<jupyter_code>tweetGara=tweet_finali[tweet_finali["gara"]==6]
tweetGara.gara.unique()
tweetGara.head()<jupyter_output><empty_output><jupyter_text>Salvo file tweet gara x (operazione effettuata per ogni gara)<jupyter_code>tweetGara=tweetGara[["id","place_user","team"]]
tweetGara.to_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\gara6\\posizioneTeam_gara6.csv",encoding="utf-8",
                 index=False)<jupyter_output><empty_output><jupyter_text>Ottengo il contenuto place_user tweet più lungo<jupyter_code>tweetGara["place_user"]

field_length = tweetGara.place_user.astype(str).map(len)
print(tweetGara.loc[field_length.idxmax(), 'place_user'])
#type(tweetGara1["place_user"][3])
tweetGara["place_user"]=tweetGara["place_user"].astype(str)
contaVirgole=tweetGara[["id","place_user"]]
contaVirgole["place_user"]=contaVirgole["place_user"].apply(lambda stringa: stringa.count(","))
index=contaVirgole["place_user"].idxmax()
contaVirgole.loc[index]["id"]
contaVirgole.groupby("place_user").count().reset_index()
ris=contaVirgole[contaVirgole["place_user"]==5]["id"]
id_ris=ris.values
tweetGara[tweetGara["id"].isin(id_ris)]<jupyter_output><empty_output><jupyter_text>Sistemo posizione place tweet gara x (operazione effettuata per ogni gara)<jupyter_code>gara_tweet=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\gara6\\posizioneTeam_gara6.csv",
                 engine="python",encoding="utf-8")
gara_tweet.head()
len(gara_tweet)<jupyter_output><empty_output><jupyter_text>Carico csv utili per sistemare le posizioni<jupyter_code>legendaUS=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\citiesUS.csv",
                    engine="python", encoding="utf-8")
legendaCA=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\citiesCA.csv",
                    engine="python", encoding="utf-8")
stati_code=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\countries_codes.csv",
                    engine="python", encoding="utf-8")
cities_world=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\worldcities.csv",
                        engine="python",encoding="utf-8")
stati_code.head()
legendaUS.head()
legendaCA.head()
cities_world.head()
legendaCA[["city","admin","iso2","population"]].head()
cities_world[["city","country","iso3","iso2","admin_name","population"]].head()
cities_world=cities_world[["city","country","iso3","iso2","admin_name","population","capital"]]
cities_world.columns=["city","country","iso3","iso2","state_name","population","capital"]
cities_world.head()
len(cities_world)
cities_world["population"]=cities_world["population"].fillna(0)
capitali_world=cities_world[cities_world["capital"]=="primary"]
capitali_world=capitali_world.loc[capitali_world.groupby("country")["population"].idxmax()]<jupyter_output><empty_output><jupyter_text>Carico df ottenuti nel notebook "continuazione_sistemarePosizione"<jupyter_code>%store -r statiCA_capoluogo
statiCA_capoluogo=statiCA_capoluogo[["city","state","country"]]
%store -r statiUS_capoluogo
statiUS_capoluogo.head()
stati_code=stati_code[["Country","Alpha-3 code","Alpha-2 code"]]
valori3=stati_code["Alpha-3 code"].apply(lambda iso: iso[2:5])
valori2=stati_code["Alpha-2 code"].apply(lambda iso: iso[2:4])
stati_code["iso3"]=valori3
stati_code["iso2"]=valori2
stati_code=stati_code[["Country","iso3","iso2"]]
stati_code.head()
stati_code_noUSACAN=stati_code[(stati_code["iso3"]!="USA") & (stati_code["iso3"]!="CAN")]
legendaUS=legendaUS[["city","state_id","state_name","population"]]
legendaUS["iso3"]="USA"
legendaUS["population"]=legendaUS["population"].fillna(0)
legendaUS.head()
legendaCA.head()
stati_US=legendaUS[["state_id","state_name"]]
stati_US["iso3"]="USA"
stati_US=stati_US.drop_duplicates()
cities_world_stateUSA=pd.merge(cities_world,stati_US,on="state_name",how="left")
cities_world_stateUSA["state_id"]=cities_world_stateUSA["state_id"].astype(str)
cities_world_stateUSA=cities_world_stateUSA.drop(columns="iso3_y")
cities_world_stateUSA.loc[cities_world_stateUSA['iso3_x'] != "USA", "state_id"] = "nan"
cities_world_stateUSA.columns=["city","country","iso3","iso2","state_name","population","capital","state_id"]
cities_world_stateUSA.head()
legendaCA=legendaCA[["city","admin","iso2","population"]]
legendaCA["iso2"]="CAN"
legendaCA.columns=["city","state_name","iso3","population"]
legendaCA.head()
s=legendaCA["state_name"].unique()
stati_CA=pd.DataFrame(columns=["state_name","iso3"],data={"state_name":s,"iso3":"CAN"})
legenda_USA_CA=pd.concat([legendaUS,legendaCA],axis=0)
legenda_USA_CA.drop(columns="state_id")
legenda_USA_CA=legenda_USA_CA[["city","state_name","iso3","population"]]
legenda_USA_CA.tail()
gara_tweet["place_user"].head(10).to_frame()
split=gara_tweet["place_user"].str.split(",",expand=True,n=3)
split.head()
gara_tweet=pd.concat([gara_tweet, split], axis=1)
gara_tweet.columns=["id","place_user","team","info1","info2","info3","info4"]
gara_tweet=gara_tweet[["id","place_user","info1","info2","info3","info4","team"]]
gara_tweet.head()
gara_tweet["place_user"]=gara_tweet["place_user"].astype(str)
gara_tweet["place_user"]=gara_tweet["place_user"].fillna("nan")
gara_tweet["place_user"]=gara_tweet["place_user"].replace("None","nan")

gara_tweet["info1"]=gara_tweet["info1"].astype(str)
gara_tweet["info1"]=gara_tweet["info1"].str.strip()
gara_tweet["info1"]=gara_tweet["info1"].str.title()
gara_tweet["info1"]=gara_tweet["info1"].fillna("nan")
gara_tweet["info1"]=gara_tweet["info1"].replace("None","nan")

gara_tweet["info2"]=gara_tweet["info2"].astype(str)
gara_tweet["info2"]=gara_tweet["info2"].str.strip()
gara_tweet["info2"]=gara_tweet["info2"].fillna("nan")
gara_tweet["info2"]=gara_tweet["info2"].replace("None","nan")

gara_tweet["info3"]=gara_tweet["info3"].astype(str)
gara_tweet["info3"]=gara_tweet["info3"].str.strip()
gara_tweet["info3"]=gara_tweet["info3"].fillna("nan")
gara_tweet["info3"]=gara_tweet["info3"].replace("None","nan")

gara_tweet["info4"]=gara_tweet["info4"].astype(str)
gara_tweet["info4"]=gara_tweet["info4"].str.strip()
gara_tweet["info4"]=gara_tweet["info4"].fillna("nan")
gara_tweet["info4"]=gara_tweet["info4"].replace("None","nan")

gara_tweet.head()
def match_geoText(citta):
    risultato=GeoText(citta).cities
    if len(risultato)>=1:
        return risultato[0]
    else:
        return 'None'
def update_df(ris):
    global df_infoagg, id_trovati
    ris=ris[["id","city","state_name","iso3","team"]]
    df_infoagg=pd.concat([df_infoagg,ris],axis=0)
    df_infoagg=df_infoagg.reset_index(drop=True)
    df_infoagg=df_infoagg.drop_duplicates()
    id_trovati=df_infoagg["id"].values
def risolviDisambig_CA(df_dasistemare):
    stato="CA"
    citta_CAL=legendaUS[legendaUS["state_id"]==stato]
    estrai=df_dasistemare[df_dasistemare["city"]!="Ontario"]
    risultatoMerge=pd.merge(estrai,citta_CAL,on="city",how="inner")
    return risultatoMerge
def creaLista_info(df):
    lista =[] 
    for r in df.itertuples():
        if (r.country=="nan"):
            ris_join=stati_code[stati_code["iso3"]==r.iso3]
            #print(ris_join)
            info =[str(ris_join["Country"]).upper(), str(r.iso3).upper(), str(ris_join["iso2"]).upper(),str(r.state_name).upper()]
        else:
            info =[str(r.country).upper(), str(r.iso3).upper(), str(r.iso2).upper(),str(r.state_name).upper()]
        info=[str(i) for i in info]
        lista.append(info)  
    return lista
def trova_matchCorretto(place,infoAgg):
    place=place.upper()
    if any(info in place for info in infoAgg):
        return True
    else:
        return False<jupyter_output><empty_output><jupyter_text>Estraggo solo le città scritte correttamente con geotext<jupyter_code>risultatoMatch_geo=gara_tweet
risultatoMatch_geo["city"]=risultatoMatch_geo["place_user"].apply(lambda stringa: match_geoText(stringa))
risultatoMatch_geo.head()
risultatoMatch_geo[["place_user","info1","info2","info3","info4","city"]].head()
risultatoMatch_geo=risultatoMatch_geo[risultatoMatch_geo["city"]!="None"]
len(risultatoMatch_geo)
df_infoagg=pd.DataFrame(columns=["id","city","state_name","iso3","team"])
id_trovati=[]<jupyter_output><empty_output><jupyter_text>Primo join: risultato match geotext con dbUsa (escludendo lo stato CA)<jupyter_code>legendaUS_noCA=legendaUS[legendaUS["state_id"]!="CA"]
join_geo_dbUsa=pd.merge(risultatoMatch_geo,legendaUS_noCA,on="city",how="inner")
risultatiUSA_noCA=join_geo_dbUsa[join_geo_dbUsa["info2"]==join_geo_dbUsa["state_id"]]
len(risultatiUSA_noCA)
join_geo_dbUsa.head()
join_geo_dbUsa[["place_user","info1","info2","city","state_id","state_name","iso3"]].head()
risultatiUSA_noCA.head()
update_df(risultatiUSA_noCA)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geo[~risultatoMatch_geo["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()
ris_CA=risultatoMatch_geoMancanti[risultatoMatch_geoMancanti["info2"]=="CA"]
len(ris_CA)<jupyter_output><empty_output><jupyter_text>Caso particolare CA<jupyter_code>ris=risolviDisambig_CA(ris_CA)
ris=ris[["id","city","state_name","iso3","team"]]
update_df(ris)
len(id_trovati)
ris_Ont=risultatoMatch_geoMancanti[risultatoMatch_geoMancanti["city"]=="Ontario"]
ris_Ont=ris_Ont[["id","team","city"]]
ris_Ont.columns=["id","team","state"]
ris_Ont=pd.merge(ris_Ont,statiCA_capoluogo,on="state",how="inner")
ris_Ont.head()
ris_Ont.columns=["id","team","state_name","city","iso3"]
ris_Ont.head()
update_df(ris_Ont)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geo[~risultatoMatch_geo["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()<jupyter_output><empty_output><jupyter_text>Secondo join: risultato match geotext (rimanenti) con dbCanada<jupyter_code>ris=pd.merge(risultatoMatch_geoMancanti,legendaCA,on="city",how="inner")
len(ris)
ris[["place_user","info1","info2","city","state_name","iso3"]].head()
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geo[~risultatoMatch_geo["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)<jupyter_output><empty_output><jupyter_text>Terzo join: risultato match (rimanenti) con dbMondo<jupyter_code>ris=pd.merge(risultatoMatch_geoMancanti,cities_world,on="city",how="inner")
lista_info=creaLista_info(ris)
ris["info"]=lista_info
ris["state_name"]=ris["state_name"].astype(str)
ris.head()
ris[["place_user","info1","info2","city","country","state_name","iso3"]].tail()
prova=ris.apply(lambda x:trova_matchCorretto(x["place_user"],x["info"]),axis=1)
indexMatch=prova[prova.values==True].index
indexMatch=np.array(indexMatch)
len(indexMatch)
risMatch=ris[ris.index.isin(indexMatch)]
risMatch=risMatch[["id","city","state_name","iso3","country","team"]]
risMatch.head()
update_df(risMatch)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geo[~risultatoMatch_geo["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
def aggiungi_info(lista,info):
    ris_lista=[]
    if info!="nan":
        ris_lista.append(lista)
        ris_lista = [item for lista in ris_lista for item in lista] #per flattare la lista
        ris_lista.append(info)
    else:
        ris_lista=lista
    return ris_lista
def risolvi_disambiguazione(df,id):
    df_result=pd.DataFrame()
    for i in range(len(id)):
        df_match=df[df["id"]==id[i]]
        bestMatch=df_match.loc[df_match["population"].idxmax()].to_frame().T
        df_result=pd.concat([df_result,bestMatch],axis=0)
    return df_result
def EDNormalizzata(stringaDB,stringaCitta,n):
    costo=nltk.edit_distance(stringaDB,stringaCitta)
    return 1-(costo/n)
def ottieni_dfpulitodafunzione(df_risultato,df_apply):
    df=pd.DataFrame()
    for i in range(len(df_risultato)):
        df=pd.concat([df,df_risultato.iloc[i]])   
        df=df.reset_index(drop=True)
    return df
def estraiCitta_nofor(c,i,id_tweet,team):
    i=i.upper()
    estrai=legendaUS[legendaUS["state_id"]==i]
    statoCitta=pd.DataFrame(columns=["id","city","team"],data={'id':id_tweet,'city':c,"team":team},index=[0])
    risultatoMerge=pd.merge(statoCitta,estrai,on="city",how="inner")
    #risultatoMerge=risultatoMerge.drop(columns=["id"])
    return risultatoMerge
def traduci_Citta(c):
    translator = Translator()
    salva=translator.translate(c,dest="en")
    return salva.text
ris=pd.merge(risultatoMatch_geoMancanti,cities_world_stateUSA,on="city",how="inner")
ris.head()
lista_info=creaLista_info(ris)
ris["info"]=lista_info
lista_info=ris.apply(lambda x: aggiungi_info(x["info"],x["state_id"]),axis=1)
ris["info"]=lista_info
ris.head()
prova=ris.apply(lambda x: trova_matchCorretto(x["place_user"],x["info"]),axis=1)
indexMatch=prova[prova.values==True].index
indexMatch=np.array(indexMatch)
len(indexMatch)
risMatch=ris[ris.index.isin(indexMatch)]
risMatch_count=risMatch.groupby("id")["place_user"].count()
risMatch_count=risMatch_count.to_frame()
risMatch_count=risMatch_count.reset_index()
risMatch_count.sort_values(by="place_user",ascending=False)
risMatch_count.columns=["id","count"]
risMatch.head()
id_uniq=risMatch["id"].unique()
ris_dis=risolvi_disambiguazione(risMatch,id_uniq)
update_df(ris_dis)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()
ris=pd.merge(risultatoMatch_geoMancanti,cities_world_stateUSA,on="city",how="inner")
ris.head()
id_uniq=ris["id"].unique()
ris_dis=risolvi_disambiguazione(ris,id_uniq)
len(ris_dis)
update_df(ris_dis)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()
ris=risultatoMatch_geoMancanti[["place_user","id","info1","info2","info3","info4","team","city"]]<jupyter_output><empty_output><jupyter_text>Join tra città ottenute con geotext (rimanenti) e dbUSA_CANADA<jupyter_code>ris_stateUS_CA=pd.merge(ris,legenda_USA_CA,on="city",how="inner")
ris_stateUS_CA.head()
ris_stateUS_CA["country"]="nan"
lista_info=creaLista_info(ris_stateUS_CA)
ris_stateUS_CA["info"]=lista_info
#ris["index"]=ris.index
ris_stateUS_CA["state_name"]=ris_stateUS_CA["state_name"].astype(str)
prova=ris_stateUS_CA.apply(lambda x:trova_matchCorretto(x["place_user"],x["info"]),axis=1)
indexMatch=prova[prova.values==True].index
indexMatch=np.array(indexMatch)
len(indexMatch)
risMatch=ris_stateUS_CA[ris_stateUS_CA.index.isin(indexMatch)]
id_uniq=risMatch["id"].unique()
ris_dis=risolvi_disambiguazione(risMatch,id_uniq)
len(ris_dis)
update_df(ris_dis)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()<jupyter_output><empty_output><jupyter_text>join tra risultato ottenuto cella prima e statiUS_capoluogo<jupyter_code>ris_stateUS=pd.merge(risultatoMatch_geoMancanti,statiUS_capoluogo,left_on="info1",right_on="state_name",how="inner")
len(ris_stateUS)
ris_stateUS=ris_stateUS[["id","city_y","state_name","iso3","team"]]
ris_stateUS.columns=["id","city","state_name","iso3","team"]
update_df(ris_stateUS)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
ris_info2=pd.merge(risultatoMatch_geoMancanti,stati_US,left_on="info2",right_on="state_name")
len(ris_info2)
ris_info2.head()
ris_Simil=ris_info2.apply(lambda x: estraiCitta_Simil_nofor(x['info1'],x['state_id'],x["id"],x["team"]),axis=1)
len(ris_Simil)<jupyter_output>D:\Anaconda\lib\site-packages\ipykernel_launcher.py:17: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
D:\Anaconda\lib\site-packages\ipykernel_launcher.py:19: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy<jupyter_text>Definisco soglia 0.3 per jaccard distance (se <= match altrimenti no)<jupyter_code>ris=ottieni_dfpulitodafunzione(ris_Simil,ris_info2)
risultatiMigliori=ris[ris["best_jacc"]==ris["best_edit"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["val_jacc"]<=0.3]
risultatiMigliori["city"]=risultatiMigliori["best_jacc"]
risultatiMigliori.head()
ris=pd.merge(risultatiMigliori,legendaUS,on="city",how="inner")
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
rimanenti=risultatoMatch_geoMancanti
rimanenti.head()
ris=pd.merge(rimanenti,statiUS_capoluogo,left_on="info1",right_on="state_name",how="inner")
ris=ris[["id","place_user","state_name","iso3","city_y","team"]]
ris.columns=["id","place_user","state_name","iso3","city","team"]
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
risultatoMatch_geoMancanti.head()
ris=pd.merge(risultatoMatch_geoMancanti,statiUS_capoluogo,left_on='city', right_on='state_name',how="inner")
ris=ris[["id","city_y","state_name","iso3","team"]]
ris.columns=["id","city","state_name","iso3","team"]
len(ris)
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
ris=pd.merge(risultatoMatch_geoMancanti,legenda_USA_CA,on="city",how="inner")
len(ris)
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
ris=pd.merge(risultatoMatch_geoMancanti,stati_code,left_on="info2",right_on="Country")
ris["state_name"]="nan"
ris=ris[["id","city","state_name","iso3","Country","team"]]
len(ris)
update_df(ris)
len(id_trovati)
risultatoMatch_geoMancanti=risultatoMatch_geoMancanti[~risultatoMatch_geoMancanti["id"].isin(id_trovati)]
len(risultatoMatch_geoMancanti)
id_geoNontrovati=risultatoMatch_geoMancanti["id"].values
ris=pd.merge(risultatoMatch_geoMancanti,stati_CA,left_on="info2",right_on="state_name")
update_df(ris)
len(id_trovati)
pos_noCity=gara_tweet[~gara_tweet["id"].isin(id_trovati)]
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_geoNontrovati)]
len(pos_noCity)
pos_noCity.tail()
pos_noCity.head()<jupyter_output><empty_output><jupyter_text>Join tra tweet in cui GeoText non è riuscito ad estrarre città con db capitaliWorld (join con country)<jupyter_code>ris=pd.merge(pos_noCity,capitali_world,left_on="info1",right_on="country",how="inner")
ris=ris[ris["info2"]=="nan"]
ris.head()
ris=ris[["id","team","place_user","city_y","iso3","iso2","state_name","country"]]
ris.columns=["id","team","place_user","city","iso3","iso2","state_name","country"]
len(ris)
lista_info=creaLista_info(ris)
ris["info"]=lista_info
#ris["index"]=ris.index
ris["state_name"]=ris["state_name"].astype(str)

prova=ris.apply(lambda x:trova_matchCorretto(x["place_user"],x["info"]),axis=1)
indexMatch=prova[prova.values==True].index
indexMatch=np.array(indexMatch)
len(indexMatch)
update_df(ris)
len(id_trovati)
pos_noCity=gara_tweet[~gara_tweet["id"].isin(id_trovati)]
pos_noCity.head()
pos_noCity_USA=pos_noCity[pos_noCity["info2"]=="USA"]
ris=pd.merge(pos_noCity_USA,statiUS_capoluogo,left_on="info1",right_on="state_name",how="inner")
ris=ris[["id","team","place_user","city_y","iso3","state_name"]]
ris.columns=["id","team","place_user","city","iso3","state_name"]
update_df(ris)
len(id_trovati)<jupyter_output><empty_output><jupyter_text>join tra info1 e city<jupyter_code>ris=pd.merge(pos_noCity,capitali_world,left_on="info1",right_on="city",how="inner")
len(ris)
lista_info=creaLista_info(ris)
ris["info"]=lista_info
#ris["index"]=ris.index
ris["state_name"]=ris["state_name"].astype(str)

prova=ris.apply(lambda x:trova_matchCorretto(x["place_user"],x["info"]),axis=1)
indexMatch=prova[prova.values==True].index
indexMatch=np.array(indexMatch)
len(indexMatch)
risMatch=ris[ris.index.isin(indexMatch)]
risMatch=risMatch[["id","city_y","state_name","iso3","country","team"]]
risMatch.columns=["id","city","state_name","iso3","country","team"]
update_df(risMatch)
len(id_trovati)
pos_noCity=gara_tweet[~gara_tweet["id"].isin(id_trovati)]
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_geoNontrovati)]

pos_noCity["info1"]=pos_noCity["info1"].replace("Nan","nan")
pos_noCity["info1"]=pos_noCity["info1"].replace("None","nan")
pos_noCity["info2"]=pos_noCity["info2"].replace("None","nan")
pos_noCity["info3"]=pos_noCity["info3"].replace("None","nan")
pos_noCity["info4"]=pos_noCity["info4"].replace("None","nan")
pos_noCity.head()
pos_noCity[["place_user","info1","info2","info3","info4"]].head()<jupyter_output><empty_output><jupyter_text>estraggo solo i tweet dove info2 contiene valore ed ha lungezza 2<jupyter_code>salva=pos_noCity[(pos_noCity["info2"]!="nan")]
salva["num_car_info2"]=salva["info2"].apply(lambda info:len(info))
salva=salva[salva["num_car_info2"]==2]
salva.head()
ris=salva.apply(lambda x:estraiCitta_nofor(x["info1"],x["info2"],x["id"],x["team"]),axis=1)
ris=ottieni_dfpulitodafunzione(ris,salva)
len(ris)
update_df(ris)
len(id_trovati)
pos_noCity=gara_tweet[~gara_tweet["id"].isin(id_trovati)]
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_geoNontrovati)]
len(pos_noCity)<jupyter_output><empty_output><jupyter_text>Mi concentro sui tweet di cui non si è riusciti ad estrarre la città<jupyter_code>pos_noCity.head()
pos_noCity["info1"]=pos_noCity["info1"].replace("Nan","nan")
pos_noCity["info1"]=pos_noCity["info1"].replace("None","nan")

pos_noCity["info2"]=pos_noCity["info2"].replace("None","nan")
#pos_noCity["info2"]=pos_noCity["info2"].replace("NaN","nan")
pos_noCity["info2"]=pos_noCity["info2"].fillna("nan")

pos_noCity["info3"]=pos_noCity["info3"].replace("None","nan")
#pos_noCity["info3"]=pos_noCity["info3"].replace("NaN","nan")
pos_noCity["info3"]=pos_noCity["info3"].fillna("nan")

pos_noCity["info4"]=pos_noCity["info4"].replace("None","nan")
#pos_noCity["info4"]=pos_noCity["info4"].replace("NaN","nan")
pos_noCity["info4"]=pos_noCity["info4"].fillna("nan")
ris=pd.merge(pos_noCity,statiUS_capoluogo,left_on="info1",right_on="state_name")
ris.head()
ris=ris[["id","city_y","state_name","iso3","team"]]
ris.columns=["id","city","state_name","iso3","team"]
len(ris)
update_df(ris)
len(id_trovati)
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_trovati)]
pos_noCity.head()
#pos_noCity[pos_noCity["info2"]!="nan"].head()
pos_noCity_Simil=pos_noCity
def estraiCitta_Simil_nofor(c,i,id_tweet,team):
    ris=pd.DataFrame()
    i=i.upper()
    estrai=legendaUS[legendaUS["state_id"]==i]
    risultatoDistance=estrai[["city"]]
    statoCitta=pd.DataFrame(columns=["id","city","team","Country"],data={'id':id_tweet,'city':c,'Country':i,"team":team},index=[0])
    if (len(risultatoDistance)==0):
        i=i.title()
        statoCitta["Country"]=i
        #print(statoCitta)
        ris=pd.merge(statoCitta,stati_code,on="Country",how="inner")
    else:
        if c=="nan":
            ris=pd.merge(statiUS_capoluogo,statoCitta,left_on="state_id",right_on="Country",how="inner")
            print(ris)
        else:
            risultatoDistance["d_jacc"]=risultatoDistance["city"].apply(lambda stringa: nltk.jaccard_distance(set(stringa), set(c)))
            lunghezza_maxCitta=estrai["city"].apply(lambda stringa: len(stringa)).max()
            risultatoDistance["d_editNorm"]=risultatoDistance["city"].apply(lambda stringa1: EDNormalizzata(stringa1,c,lunghezza_maxCitta))
            best_jacc=risultatoDistance.loc[risultatoDistance.d_jacc.idxmin()]
            best_deditNorm= risultatoDistance.loc[risultatoDistance.d_editNorm.idxmax()]
            best_jacc=best_jacc.to_frame().T.reset_index()
            best_jacc=best_jacc.drop(columns=["index","d_editNorm"])
            best_jacc.columns=["best_jacc","val_jacc"]
            best_deditNorm=best_deditNorm.to_frame().T.reset_index()
            best_deditNorm=best_deditNorm.drop(columns=["index","d_jacc"])
            best_deditNorm.columns=["best_edit","val_edit"]
            risultatiMisure=pd.concat([best_jacc,best_deditNorm],axis=1)
            risultatiMisure["city_originale"]=c
            risultatiMisure["id"]=id_tweet
            risultatiMisure["team"]=team
            ris=risultatiMisure
    return ris
pos_noCity_Simil["num_car_info2"]=pos_noCity_Simil["info2"].apply(lambda stringa: len(stringa))
pos_noCity_Simil=pos_noCity_Simil[pos_noCity_Simil["info2"]!="nan"]
pos_noCity_Simil["info1"]=pos_noCity_Simil["info1"].fillna("nan")
pos_noCity_Simil.head()
ris_Simil=pos_noCity_Simil.apply(lambda x: estraiCitta_Simil_nofor(x['info1'],x['info2'],x["id"],x["team"]),axis=1)
ris=ottieni_dfpulitodafunzione(ris_Simil,pos_noCity_Simil)
len(ris)
risultatiMigliori=ris[ris["city_originale"]!="nan"]
risultatiMigliori=risultatiMigliori[["best_edit","best_jacc","city_originale","id","team","val_edit","val_jacc"]]
ris1=risultatiMigliori
risultatiMigliori=risultatiMigliori[risultatiMigliori["best_jacc"]==risultatiMigliori["best_edit"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["val_jacc"]<=0.3]
risultatiMigliori["city"]=risultatiMigliori["best_jacc"]
risultatiMigliori.head(10)
risultatiMigliori[["best_edit","best_jacc","city_originale","val_edit","val_jacc","city"]].head()
ris1.head()
ris.head()
ris["iso3"]=ris["iso3"].fillna("nan")
ris["city_originale"]=ris["city_originale"].fillna("nan")
ris_iso3=ris[ris["iso3"]!="nan"]
len(ris_iso3)<jupyter_output><empty_output><jupyter_text>escludo i tweet dove  field city = "England"<jupyter_code>ris_iso3_noEngland=ris_iso3[ris_iso3["city"]!="England"]
len(ris_iso3_noEngland)
ris_iso3_noEngland.head()
ris_iso3_noEngland_noUSACAN=ris_iso3_noEngland[(ris_iso3_noEngland["iso3"]!="USA") & (ris_iso3_noEngland["iso3"]!="CAN")]
ris_iso3_noEngland_noUSACAN.head()
cities_world_noUSA=cities_world[cities_world["iso3"]!="USA"]
ris_iso=pd.merge(ris_iso3_noEngland_noUSACAN,cities_world_noUSA,on="city",how="inner")
len(ris_iso)
ris_iso=ris_iso[ris_iso["iso3_x"]==ris_iso["iso3_y"]]
ris_iso=ris_iso[["id","city","state_name","team","iso3_x"]]
ris_iso.columns= ["id","city","state_name","team","iso3"]
update_df(ris_iso)
len(id_trovati)
ris_iso3_England=ris_iso3[ris_iso3["city"]=="England"]
ris_iso3_England=ris_iso3_England[["Country","iso3","id","team"]]
ris_iso3_England=pd.merge(ris_iso3_England,capitali_world,on="iso3",how="inner")
update_df(ris_iso3_England)
len(id_trovati)
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_trovati)]
pos_noCity.head()
pos_noCity["num_car_info2"]=pos_noCity["info2"].apply(lambda stringa:len(stringa))
pos_noCity=pos_noCity[pos_noCity["num_car_info2"]==2]
ris_Simil=pos_noCity.apply(lambda x: estraiCitta_Simil_nofor(x['info1'],x['info2'],x["id"],x["team"]),axis=1)
ris=ottieni_dfpulitodafunzione(ris_Simil,pos_noCity)
risultatiMigliori=ris[ris["city_originale"]!="nan"]
risultatiMigliori=risultatiMigliori[["best_edit","best_jacc","city_originale","id","team","val_edit","val_jacc"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["best_jacc"]==risultatiMigliori["best_edit"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["val_jacc"]<=0.3]
risultatiMigliori["city"]=risultatiMigliori["best_jacc"]
risultatiMigliori.head()
risultatiMigliori[["best_edit","best_jacc","city_originale","val_jacc","city"]].head()
ris=pd.merge(risultatiMigliori,legendaUS,on="city",how="inner")
update_df(ris)
len(id_trovati)
pos_noCity=pos_noCity[~pos_noCity["id"].isin(id_trovati)]
len(pos_noCity)<jupyter_output><empty_output><jupyter_text>Questo è il numero totale dei match rispetto al dbiniziale<jupyter_code>len(gara_tweet[gara_tweet["id"].isin(id_trovati)])
pos_noCityAll=gara_tweet[~gara_tweet["id"].isin(id_trovati)]<jupyter_output><empty_output><jupyter_text>numero tweet che non hanno nessun valore in place_user<jupyter_code>len(gara_tweet[gara_tweet["place_user"]=="nan"])
pos_noCityAll_noNan=pos_noCityAll[pos_noCityAll["place_user"]!="nan"]
len(pos_noCityAll_noNan)
ris=pd.merge(pos_noCityAll_noNan,cities_world,left_on="info1",right_on="city",how="inner")
len(ris)
risMatch=ris
ris.head()
risMatch_count=risMatch.groupby("id")["place_user"].count()
risMatch_count=risMatch_count.to_frame()
risMatch_count=risMatch_count.reset_index()
risMatch_count.sort_values(by="place_user",ascending=False)
risMatch_count.columns=["id","count"]
risMatch_count.sort_values(by="count",ascending=False).head()<jupyter_output><empty_output><jupyter_text>Id tweet match città<jupyter_code>id_tweet=risMatch_count["id"].unique()
id_tweet
ris_dis=risolvi_disambiguazione(ris,id_tweet)
len(ris_dis)
ris_dis.head()
ris_dis=ris_dis[["id","city_y","state_name","iso3","team"]]
ris_dis.columns=["id","city","state_name","iso3","team"]
ris_dis.head()
update_df(ris_dis)
len(id_trovati)
pos_noCityAll_noNan=pos_noCityAll_noNan[~pos_noCityAll_noNan["id"].isin(id_trovati)]
len(pos_noCityAll_noNan)
pos_noCityAll_noNan.head()
pos_noCityAll_noNan=pos_noCityAll_noNan[pos_noCityAll_noNan["info2"]!="nan"]
pos_noCityAll_noNan.head(30)
ris=pd.merge(pos_noCityAll_noNan,stati_CA,left_on="info2",right_on="state_name",how="inner")
ris=ris[["info1","id","team","state_name","iso3"]]
ris.columns=["city","id","team","state_name","iso3"]
update_df(ris)
len(id_trovati)
pos_noCityAll_noNan=pos_noCityAll_noNan[~pos_noCityAll_noNan["id"].isin(id_trovati)]
len(pos_noCityAll_noNan)
ris=pd.merge(pos_noCityAll_noNan,stati_US,left_on="info2",right_on="state_name",how="inner")
len(ris)
ris=pos_noCityAll_noNan.apply(lambda x: estraiCitta_Simil_nofor(x['info1'],x['info2'],x["id"],x["team"]),axis=1)
ris=ottieni_dfpulitodafunzione(ris,pos_noCityAll_noNan)
len(ris)
risultatiMigliori=ris[ris["city_originale"]!="nan"]
risultatiMigliori=risultatiMigliori[["best_edit","best_jacc","city_originale","id","team","val_edit","val_jacc"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["best_jacc"]==risultatiMigliori["best_edit"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["val_jacc"]<=0.3]
risultatiMigliori["city"]=risultatiMigliori["best_jacc"]
risultatiMigliori.head()
ris=pd.merge(risultatiMigliori,legendaUS,on="city",how="inner")
update_df(ris)
len(id_trovati)
pos_noCityAll_noNan=pos_noCityAll_noNan[~pos_noCityAll_noNan["id"].isin(id_trovati)]
pos_noCityAll_noNan.head(20)
ris=pd.merge(pos_noCityAll_noNan,stati_US,left_on="info2",right_on="state_name",how="inner")
ris=ris[["info1","id","team","state_name","iso3"]]
ris.columns=["city","id","team","state_name","iso3"]
len(ris)
update_df(ris)
len(id_trovati)
pos_noCityAll_noNan=pos_noCityAll_noNan[~pos_noCityAll_noNan["id"].isin(id_trovati)]
len(pos_noCityAll_noNan)
ris=pd.merge(pos_noCityAll_noNan,stati_US,left_on="info2",right_on="state_id",how="inner")
ris=ris[["id","info1","team","state_id","state_name","iso3"]]
len(ris)
ris_Simil=ris.apply(lambda x: estraiCitta_Simil_nofor(x['info1'],x['state_id'],x["id"],x["team"]),axis=1)
ris_Simil=ottieni_dfpulitodafunzione(ris_Simil,ris)
ris=ris_Simil
risultatiMigliori=ris[ris["best_jacc"]==ris["best_edit"]]
risultatiMigliori=risultatiMigliori[risultatiMigliori["val_jacc"]<=0.3]
risultatiMigliori["city"]=risultatiMigliori["best_jacc"]
risultatiMigliori.head()
ris=pd.merge(risultatiMigliori,legendaUS,on="city",how="inner")
update_df(ris)
len(id_trovati)
mancanti=gara_tweet[~gara_tweet["id"].isin(id_trovati)]
len(mancanti)
mancanti_noNan=mancanti[(mancanti["place_user"]!="nan") & (mancanti["info2"]!="nan")]
mancanti_noNan.head(30)<jupyter_output><empty_output><jupyter_text>Ultimo join tra info2 e country db stati_code (iso3 db)<jupyter_code>ris=pd.merge(mancanti_noNan,stati_code_noUSACAN,left_on="info2",right_on="Country",how="inner")
len(ris)
mancanti_noNan_info3=mancanti_noNan[mancanti_noNan["info3"]!="nan"]
len(mancanti_noNan_info3)<jupyter_output><empty_output><jupyter_text>numero tweet finali matchati<jupyter_code>len(gara_tweet[gara_tweet["id"].isin(id_trovati)])<jupyter_output><empty_output><jupyter_text>Codice da eseguire per ultimo<jupyter_code>df_infoagg["gara"]=6
len(gara_tweet[gara_tweet["place_user"]=="nan"])
df_infoagg_country=pd.merge(df_infoagg,stati_code,on="iso3",how="inner")
len(df_infoagg)
df_infoagg_country.to_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\gara6\\infoMapCountry_gara6.csv",
                 index=False)<jupyter_output><empty_output><jupyter_text>Concateno posizione tweet gara ottenuti prima con quelli già matchati<jupyter_code>finale_match=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\infoMapCountry_final_v1.csv",
                 engine="python",encoding="utf-8")
finale_match.tail()
finale_match=pd.concat([finale_match,df_infoagg_country],axis=0)
finale_match.tail()
finale_match.to_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\posizioneTweet\\infoMapCountry_final_v1.csv",
                 index=False)<jupyter_output><empty_output><jupyter_text>Creo file dove per ogni città definisco quale è il tipo di tweet (GS, TOR ,NEUTRO) con più occorrenze<jupyter_code>finale_match.head()
def estraiNumTweetTeam(city,state,iso3,gara):
    dict={}
    df_conta=ris_numTweetTeam[(ris_numTweetTeam["city"]==city) & (ris_numTweetTeam["state_name"]==state) & 
                              (ris_numTweetTeam["iso3"]==iso3) & (ris_numTweetTeam["gara"]==gara)]
    for i in range(len(df_conta)):
        #print(df_conta.iloc[i]["team"]+": "+str(df_conta.iloc[i]["id"]))
        dict.update({df_conta.iloc[i]["team"]: df_conta.iloc[i]["id"]})
    return dict
ris_numTweetTeam=finale_match.groupby(["city","state_name","iso3","team","gara"])["id"].count().to_frame()
ris_numTweetTeam=ris_numTweetTeam.reset_index()
ris_dict=ris_numTweetTeam[["city","state_name","iso3","gara"]].drop_duplicates()
ris_dict["numTweetTeam"]=ris_dict.apply(lambda x:estraiNumTweetTeam(x["city"],x["state_name"],x["iso3"],x["gara"]),axis=1)
ris_split=ris_dict["numTweetTeam"].apply(pd.Series)
ris_gara=pd.merge(ris_dict,ris_split,left_index=True,right_index=True)
team_Magg=ris_numTweetTeam.loc[ris_numTweetTeam.groupby(["city","state_name","iso3","gara"])["id"].idxmax()]
ris_finale=pd.merge(ris_gara,team_Magg,on=["city","state_name","iso3","gara"])
ris_finale=ris_finale[["city","state_name","iso3","gara","Neutro","Toronto Raptors","Golden State Warriors","team"]]
ris_finale["Neutro"]=ris_finale["Neutro"].fillna(0).astype('int64')
ris_finale["Toronto Raptors"]=ris_finale["Toronto Raptors"].fillna(0).astype('int64')
ris_finale["Golden State Warriors"]=ris_finale["Golden State Warriors"].fillna(0).astype('int64')
ris_finale.head()
ris_finale.to_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\csv_finali\\infoMap_tweetCity.csv",
                 index=False)<jupyter_output><empty_output><jupyter_text>Carico file creato precedentemente<jupyter_code>ris_finale=pd.read_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\csv_finali\\infoMap_tweetCity.csv",
                      engine="python", encoding="utf-8")
ris_finale.columns=["city","state_name","iso3","gara","Neutro","Toronto Raptors","Golden State Warriors","tipotweet_Magg"]
def trovaTeamMagg(tor,gs):
    if (tor==gs):
        return "Pari"
    else:
        if (tor>gs):
            return "Toronto Raptors"
        else:
            return "Golden State Warriors"
#prova=ris_finale[ris_finale["city"]=="Washington"]
ris_finale["team_Magg"]=ris_finale.apply(lambda x: trovaTeamMagg(x["Toronto Raptors"],x["Golden State Warriors"]),axis=1)
ris_finale.head()
ris_finale=pd.merge(ris_finale,stati_code,on="iso3",how="inner")
ris_finale=ris_finale[["city","state_name","iso3","Country_y","gara","Neutro","Toronto Raptors","Golden State Warriors","tipotweet_Magg","team_Magg"]]
ris_finale.columns=["city","state_name","iso3","Country","gara","Neutro","Toronto Raptors","Golden State Warriors","tipotweet_Magg","team_Magg"]
ris_finale.head()
ris_finale.to_csv("D:\\Università\\Magistrale\\Data management\\Progetto\\analisi\\csv_finali\\infoMap_tweetCity.csv",
                 index=False)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.17692266206450222, 'fraction_numerical': 0.009869485492395642, 'mean_word_length': 11.975857242827152, 'pattern_counts': {'":': 7, '<': 126, '<?xml version=': 0, '>': 122, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '30', 'dir': 'jupyter-structured-clean-dedup', 'id': '28704', 'license': 'CC0-1.0', 'n_tokens_mistral': 15107, 'n_tokens_neox': 14991, 'n_words': 1126, 'path': 'Data_management_and_data_visualization/Notebook/sistemazione_pos.ipynb', 'repo_name': 'mode95/Data-Science', 'size': '37084'}