Combinazione di elenchi di dati di frequenza parola

Question

Sembra che dovrebbe essere una domanda ovvia, ma i tutorial e la documentazione sugli elenchi non sono disponibili. Molti di questi problemi derivano dalla dimensione dei miei file di testo (centinaia di MB) e dai miei tentativi di ridurli a qualcosa gestibile dal mio sistema. Di conseguenza, sto facendo il mio lavoro in segmenti e ora sto cercando di combinare i risultati.

Ho più elenchi di frequenze di parola (~ 40 di esse). Le liste possono essere acquisite tramite Import [] o come variabili generate in Mathematica. Ogni lista appare come il seguente ed è stato generato utilizzando il Tally [] and Sort [] comandi:

{{ "il", 42216}, { "di", 24903}, { "e", 18624 }, {"n", 16850}, {"in",
16164}, {"de", 14930}, {"a", 14660}, {"a", 14175}, {"la", 7347 }, {"era", 6030}, {"l", 5981}, {"le", 5735}, < < 51293 >>, {"mattatoio", 1}, {"abattement", 1}, {"abattagen", 1}, {"abattage", 1}, {"abated", 1}, {"abandonn", 1}, {"abaiss", 1}, {"aback", 1}, {"aase", 1}, {"aaijaut", 1}, {"aaaah", 1}, {"aaa", 1}}

Ecco un esempio del secondo file:

{{ "il", 30419}, { "n", 20414}, { "de", 19956}, { "di", 16262} , {"e",
14488}, {"a", 12726}, {"a", 12635}, {"in", 11141}, {"la", 10739}, {"et", 9016 }, {"les", 8675}, {"le", 7748}, < 101032 >>, {"abattement", 1}, {"abattagen", 1}, {"abattage", 1}, { "abated", 1}, {"abandonn", 1}, {"abaiss", 1}, {"aback", 1}, {"aase", 1}, {"aaijaut", 1}, { "aaaah", 1}, {"aaa", 1}}

Voglio combinarli in modo che i dati di frequenza vengano aggregati: cioè se il secondo file ha 30.419 occorrenze di "the" ed è unito al primo file, dovrebbe restituire che ci sono 72.635 occorrenze (e così via mentre mi muovo attraverso l'intera collezione).

Answer 1

Sembra che tu abbia bisogno GatherBy.

Supponiamo che il vostro due liste sono chiamati data1 e data2, quindi utilizzare

{#[[1, 1]], Total[#[[All, 2]]]} & /@ GatherBy[Join[data1, data2], First] 

Questo generalizza facilmente a qualsiasi numero di liste, non solo due.

Answer 2

Prova ReplaceRepeated.

Unisciti alle liste. Quindi utilizzare

//. {{f1___, {a_, c1_}, f2___, {a_, c2_}, f3___} -> {f1, f2, f3, {a, c1 + c2}}} 

Answer 3

Provare a utilizzare una tabella hash, come questo. Prima le cose SET UP:

ClearAll[freq]; 
freq[_] = 0; 

Ora ad esempio freq["safas"] restituisce 0.Poi, se le liste sono definiti come

lst1 = {{"the", 42216}, {"of", 24903}, {"and", 18624}, {"n", 
    16850}, {"in", 16164}, {"de", 14930}, {"a", 14660}, {"to", 
    14175}, {"la", 7347}, {"was", 6030}, {"l", 5981}, {"le", 
    5735}, {"abattoir", 1}, {"abattement", 1}, {"abattagen", 
    1}, {"abattage", 1}, {"abated", 1}, {"abandonn", 1}, {"abaiss", 
    1}, {"aback", 1}, {"aase", 1}, {"aaijaut", 1}, {"aaaah", 
    1}, {"aaa", 1}}; 
lst2 = {{"the", 30419}, {"n", 20414}, {"de", 19956}, {"of", 
    16262}, {"and", 14488}, {"to", 12726}, {"a", 12635}, {"in", 
    11141}, {"la", 10739}, {"et", 9016}, {"les", 8675}, {"le", 
    7748}, {"abattement", 1}, {"abattagen", 1}, {"abattage", 
    1}, {"abated", 1}, {"abandonn", 1}, {"abaiss", 1}, {"aback", 
    1}, {"aase", 1}, {"aaijaut", 1}, {"aaaah", 1}, {"aaa", 1}}; 

si può eseguire questo

Scan[(freq[#[[1]]] += #[[2]]) &, lst1] 

dopo il quale ad esempio

freq["the"] 
(* 
42216 
*) 

e poi l'elenco accanto

Scan[(freq[#[[1]]] += #[[2]]) &, lst2] 

dopo di che ad es.

freq["the"] 
72635 

pur

freq["safas"] 
(* 
0 
*) 

Answer 4

C'è un vecchio detto, "se tutto quello che hai è un martello, tutto diventa un chiodo". Quindi, ecco il mio martello: SelectEquivalents.

Questo può essere fatto un po 'più veloce utilizzando SelectEquivalents:

SelectEquivalents[data1~Join~data2, #[[1]]&, #[[2]]&, {#1, Total[#2]}&] 

Al fine, il primo parametro è ovviamente solo le liste unite, il secondo è quello che stanno raggruppati per (in questo caso il primo elemento), il terzo param rimuove la stringa lasciando solo il conteggio, e il quarto param la rimette insieme con la stringa come #1 ei conteggi in un elenco come #2.

Answer 5

Qui è una diretta funzione di Sow/Reap:

Reap[#2~Sow~# & @@@ data1~Join~data2;, _, {#, Tr@#2} &][[2]] 

---

Qui è una forma sintetica del metodo di ACL:

Module[{c}, 
    c[_] = 0; 

    c[#] += #2 & @@@ data1~Join~data2; 

    {#[[1, 1]], #2} & @@@ Most@DownValues@c 
] 

---

Questo sembra essere un po 'più veloce di Codice Szabolcs sul mio sistema: