Convertir une liste de tuples en dictionnaire de 2 manières différentes

Question

J'ai la liste suivante de tuples.

[('0', 'Hadoop'), ('0', 'Big Data'), ('0', 'HBas'), ('0', 'Java'), ('0', 'Spark'), ('0', 'Storm'), ('0', 'Cassandra'), ('1', 'NoSQL'), ('1', 'MongoDB'), ('1', 'Cassandra'), ('1', 'HBase'), ('1', 'Postgres'), ('2', 'Python'), ('2', 'skikit-learn'), ('2', 'scipy'), ('2', 'numpy'), ('2', 'statsmodels'), ('2', 'pandas'), ('3', 'R'), ('3', 'Python'), ('3', 'statistics'), ('3', 'regression'), ('3', 'probability'), ('4', 'machine learning'), ('4', 'regression'), ('4', 'decision trees'), ('4', 'libsvm'), ('5', 'Python'), ('5', 'R'), ('5', 'Java'), ('5', 'C++'), ('5', 'Haskell'), ('5', 'programming languages'), ('6', 'statistics'), ('6', 'probability'), ('6', 'mathematics'), ('6', 'theory'), ('7', 'machine learning'), ('7', 'scikit-learn'), ('7', 'Mahout'), ('7', 'neural networks'), ('8', 'neural networks'), ('8', 'deep learning'), ('8', 'Big Data'), ('8', 'artificial intelligence'), ('9', 'Hadoop'), ('9', 'Java'), ('9', 'MapReduce'), ('9', 'Big Data')]

Les valeurs de gauche sont les "numéros d'identification des employés", tandis que les valeurs de droite sont les "intérêts". Je dois transformer ces valeurs en dictionnaires de deux manières différentes : Je dois faire du numéro d'identification de l'employé la clé et des intérêts la valeur, puis je dois faire des intérêts la clé et du numéro d'identification de l'employé la valeur. Pour donner un exemple rapide, j'ai besoin qu'un des éléments de mon résultat final ressemble à ceci :

{'0': ['Hadoop', 'Big Data', 'HBas', 'Java', 'Spark', 'Storm', 'Cassandra'],
 '1' ... etc]}

Alors le suivant ressemblerait à ceci :

{'Hadoop': [0,9]...}

J'ai essayé la dictée par défaut mais je n'ai pas réussi à la faire fonctionner. Avez-vous des suggestions ?

Answer 1

Vous pouvez utiliser collections.defaultdict

Ex :

from collections import defaultdict

lst = [('0', 'Hadoop'),
('0', 'Big Data'),
('0', 'HBas'),
('0', 'Java'),.....]

result = defaultdict(list)
for idVal, interest in lst:
    result[idVal].append(interest)
print(result)

result = defaultdict(list)
for idVal, interest in lst:
    result[interest].append(idVal)
print(result)

Sortie :

defaultdict(<type 'list'>, {'1': ['NoSQL', 'MongoDB', 'Cassandra', 'HBase', 'Postgres'], '0': ['Hadoop', 'Big Data', 'HBas', 'Java', 'Spark', 'Storm', 'Cassandra'], '3': ['R', 'Python', 'statistics', 'regression', 'probability'], '2': ['Python', 'skikit-learn', 'scipy', 'numpy', 'statsmodels', 'pandas'], '5': ['Python', 'R', 'Java', 'C++', 'Haskell', 'programming languages'], '4': ['machine learning', 'regression', 'decision trees', 'libsvm'], '7': ['machine learning', 'scikit-learn', 'Mahout', 'neural networks'], '6': ['statistics', 'probability', 'mathematics', 'theory'], '9': ['Hadoop', 'Java', 'MapReduce', 'Big Data'], '8': ['neural networks', 'deep learning', 'Big Data', 'artificial intelligence']})
defaultdict(<type 'list'>, {'Java': ['0', '5', '9'], 'neural networks': ['7', '8'], 'NoSQL': ['1'], 'Hadoop': ['0', '9'], 'Mahout': ['7'], 'Storm': ['0'], 'regression': ['3', '4'], 'statistics': ['3', '6'], 'probability': ['3', '6'], 'programming languages': ['5'], 'Python': ['2', '3', '5'], 'deep learning': ['8'], 'Haskell': ['5'], 'mathematics': ['6'], 'HBas': ['0'], 'numpy': ['2'], 'pandas': ['2'], 'artificial intelligence': ['8'], 'theory': ['6'], 'libsvm': ['4'], 'C++': ['5'], 'R': ['3', '5'], 'HBase': ['1'], 'Spark': ['0'], 'Postgres': ['1'], 'decision trees': ['4'], 'Big Data': ['0', '8', '9'], 'MongoDB': ['1'], 'scikit-learn': ['7'], 'MapReduce': ['9'], 'machine learning': ['4', '7'], 'scipy': ['2'], 'skikit-learn': ['2'], 'statsmodels': ['2'], 'Cassandra': ['0', '1']})

Answer 2

collections.defaultdict est en effet la bonne façon de procéder. Créez-en un pour chaque dictionnaire que vous voulez, puis bouclez sur la liste et ajoutez chaque paire aux deux dictionnaires.

import collections

ids = collections.defaultdict(list)
interests = collections.defaultdict(list)

for ident,interest in data:
    ids[ident].append(interest)
    interests[interest].append(ident)

Answer 3

Et si pandas ?

data = [('0', 'Hadoop'),
('0', 'Big Data'),
('0', 'HBas'),...]

import pandas as pd
df = pd.DataFrame(data)
df_1 = df.groupby(0)[1].apply(list)
df_2 = df.groupby(1)[0].apply(list)

print( df_1.to_dict() )
print( df_2.to_dict() )

Résultat :

{'0': ['Hadoop', 'Big Data', 'HBas', 'Java', 'Spark', '...
{'Big Data': ['0', '8', '9'], 'C++' ...

Answer 4

Le code le plus pythique et le plus court et sans utiliser les importations à laquelle je peux penser :

alist = [('0', 'Hadoop'),
('0', 'Big Data'),
('0', 'HBas'),
('0', 'Java'),
('0', 'Spark'),
('0', 'Storm'),...]

adict = {}
bdict = {}
for key, value in alist:
    adict[key] = adict.get(key, []) + [value]
    bdict[value] = bdict.get(value, []) + [key]

Sorties :

print(adict)
#{'0': ['Hadoop', 'Big Data', 'HBas', 'Java', 'Spark', 'Storm', 'Cassandra'], '1': ['NoSQL', 'MongoDB', 'Cassandra', 'HBase', 'Postgres'],...}

print(bdict)
#{'Hadoop': ['0', '9'], 'Big Data': ['0', '8', '9'], 'HBas': ['0'], 'Java': ['0', '5', '9'], 'Spark': ['0'], 'Storm': ['0'],...}

Answer 5

defaultdict est l'option la plus rapide, mais vous pouvez aussi grouper avec setdefault() en un seul passage dans la liste :

d1 = {}
d2 = {}
for fst, snd in l:
    d1.setdefault(fst, []).append(snd)
    d2.setdefault(snd, []).append(fst)

print(d1)
print(d2)

Quelles sorties :

{'0': ['Hadoop', 'Big Data', 'HBas', 'Java', 'Spark', 'Storm', 'Cassandra'],
 '1': ['NoSQL', 'MongoDB', 'Cassandra', 'HBase', 'Postgres'],
 '2': ['Python', 'skikit-learn', 'scipy', 'numpy', 'statsmodels', 'pandas'],
 '3': ['R', 'Python', 'statistics', 'regression', 'probability'],
 '4': ['machine learning', 'regression', 'decision trees', 'libsvm'],
 '5': ['Python', 'R', 'Java', 'C++', 'Haskell', 'programming languages'],
 '6': ['statistics', 'probability', 'mathematics', 'theory'],
 '7': ['machine learning', 'scikit-learn', 'Mahout', 'neural networks'],
 '8': ['neural networks',
       'deep learning',
       'Big Data',
       'artificial intelligence'],
 '9': ['Hadoop', 'Java', 'MapReduce', 'Big Data']}
{'Big Data': ['0', '8', '9'],
 'C++': ['5'],
 'Cassandra': ['0', '1'],
 'HBas': ['0'],
 'HBase': ['1'],
 'Hadoop': ['0', '9'],
 'Haskell': ['5'],
 'Java': ['0', '5', '9'],
 'Mahout': ['7'],
 'MapReduce': ['9'],
 'MongoDB': ['1'],
 'NoSQL': ['1'],
 'Postgres': ['1'],
 'Python': ['2', '3', '5'],
 'R': ['3', '5'],
 'Spark': ['0'],
 'Storm': ['0'],
 'artificial intelligence': ['8'],
 'decision trees': ['4'],
 'deep learning': ['8'],
 'libsvm': ['4'],
 'machine learning': ['4', '7'],
 'mathematics': ['6'],
 'neural networks': ['7', '8'],
 'numpy': ['2'],
 'pandas': ['2'],
 'probability': ['3', '6'],
 'programming languages': ['5'],
 'regression': ['3', '4'],
 'scikit-learn': ['7'],
 'scipy': ['2'],
 'skikit-learn': ['2'],
 'statistics': ['3', '6'],
 'statsmodels': ['2'],
 'theory': ['6']}