J'ai plusieurs centaines de milliers d'URL de terminaux que je veux générer des statistiques. Par exemple, j'ai:
{
'a': {
'b': {
'c': {
'_count': 2
},
'd': {
'_count': 1
}
},
'c': {
'd': {
'_count': 1
}
}
},
'b': {
'c': {
'd': {
'_count': 2
}
},
'd': {
'e': {
'_count': 1
}
}
}
}
4 Réponses :
Si les chemins ressemblent à votre exemple, cela fonctionnerait:
def printstats(stats, indent=''):
print indent + str(stats.count) + ' times'
for (d, s) in stats.subdirs.items():
print indent + d + ':'
printstats(s, indent + ' ')
>>> printstats(counts)
0 times
a:
0 times
c:
0 times
d:
1 times
b:
0 times
c:
2 times
d:
1 times
...
C'est un peu similaire à ce que je faisais déjà. Bien que je pense que la récursivité fonctionnera mieux en raison du nombre inconnu d'articles dans le P.Split ('/')
Dans votre exemple, tous les articles ont le même nombre de pièces, donc je voudrais sauter la complexité supplémentaire ...
Cela permettra un nombre variable de pièces - bien que pas dans le même ensemble de chemins (c'est-à-dire qu'il pouvait gérer ['/ A / B', '/ B / C', '/ A / C'] ou ['/ a / b / c / d', '/ d / c / b / a'] , mais pas ['/ a / b', '/ a / a / a / B / C ',' / A / B / C / D '] )
os.path.split (p) est préféré.
EDIT: strong> J'ai modifié mon code pour adapter votre dernier commentaire ci-dessus (aucune structure de données complexe maintenant). P> >>> d = {}
>>> dictizeString('/a/b/c/d', d)
>>> dictizeString('/a/b/c/d', d)
>>> dictizeString('/a/b/c/d', d)
>>> dictizeString('/a/b/c/d', d)
>>> dictizeString('/a/b/e', d)
>>> dictizeString('/c', d)
>>> d
{'a': {'b': {'c': {'d': 4}, 'e': 1}}, 'c': 1}
Cela ne semble pas juste. En supposant que je comprenne cela correctement, alors chaque fois que vous ajoutez un chemin, vous définissez le comptage pour cette URL sur 1 (plutôt que d'incrémenter le nombre de comptes) et détruisez tous les comptes pour des chemins plus longs avec le même préfixe.
Ouais, j'ai fait cette erreur dans la première version de mon code. J'ai depuis modifié pour résoudre ce problème. Merci! Semble fonctionner bien maintenant.
Voici ma tentative: J'ai enveloppé une partie de la logique dans le résultat de la classe pour essayer de rendre l'algorithme lui-même un peu plus clair. < / p>
Un ancien résultat, mais toujours près du sommet de Google, je vais donc mettre à jour: vous pouvez utiliser DPATH-Python pour cela.
>>> x = {'path/name': 0, 'other/path/name': 1}
>>> for (path, value) in x.iteritems():
>>> ... dpath.util.set(result, path, value)
Que se passe-t-il lorsque des chemins sont de longueurs différentes? Par exemple, que si vous obtenez le chemin
/ a / b en plus des chemins que vous avez répertoriés? Ou les chemins sont-ils toujours toujours de la structure/ x / y / z ?En réponse à votre édition: alors quel dictionnaire veut pour votre exemple donné plus le chemin
/ a / b ? Si le dictionnaire résultant estrésultat , vous ne pouvez pas stocker un entier pourrésultat ["A"] ["B"] car il y a déjà un dictionnaire. Il semble que vous voulez une structure de données plus complexe.Alors, comment gérez-vous le cas où vous obtenez / A / B, puis / A / B / C, puis / A / B / C / D? À quoi ressemblera votre dictionnaire? Parce que cela semble que seuls les nœuds de feuilles (la dernière lettre d'une chaîne) stocke la fréquence (entier) - et les nœuds non-feuillets stockent un dictionnaire. Mais dans mon exemple, A / B est à la fois une feuille et une non-feuille. J'espère que cela a du sens? EDIT: À peu près la même question que Michael
Les commentaires ci-dessus sont absolument corrects. Je suppose que j'aurais dû utiliser de vraies données au lieu de simplifier à A, B, c. Quoi qu'il en soit, étant donné un chemin / A / B / C, il n'y aura jamais eu la nécessité de compter / A, / A / B, ou de quoi que ce soit plus loin, c. Chaque chemin se termine toujours dans "\ D +". XML, donc je n'aurais donc jamais quelque chose comme /a/b/c.xml et /a/b/c/d.xml. Avoir un sens?
Oui - J'ai modifié ma réponse pour convenir à cette exigence.