La façon la plus rapide pour convertir une dict touches de & les valeurs de `unicode` à `str`?

Je suis la réception d'une dict à partir d'une "couche" de code sur lequel certains calculs et des modifications sont effectuées avant de la passer sur une autre "couche". L'original dict touches de & "string" les valeurs sont unicode, mais la couche qu'ils sont passés à accepte uniquement str.

Cela va être appelé souvent, donc j'aimerais savoir quel serait le moyen le plus rapide pour convertir quelque chose comme:

{ u'spam': u'eggs', u'foo': True, u'bar': { u'baz': 97 } }

...à:

{ 'spam': 'eggs', 'foo': True, 'bar': { 'baz': 97 } }

...en tenant compte de la non-"chaîne de valeurs" besoin de rester aussi leur type d'origine.

Toutes les pensées?

InformationsquelleAutor Phillip B Oldham | 2009-08-10

147
```
DATA = { u'spam': u'eggs', u'foo': frozenset([u'Gah!']), u'bar': { u'baz': 97 },
         u'list': [u'list', (True, u'Maybe'), set([u'and', u'a', u'set', 1])]}

def convert(data):
    if isinstance(data, basestring):
        return str(data)
    elif isinstance(data, collections.Mapping):
        return dict(map(convert, data.iteritems()))
    elif isinstance(data, collections.Iterable):
        return type(data)(map(convert, data))
    else:
        return data

print DATA
print convert(DATA)
# Prints:
# {u'list': [u'list', (True, u'Maybe'), set([u'and', u'a', u'set', 1])], u'foo': frozenset([u'Gah!']), u'bar': {u'baz': 97}, u'spam': u'eggs'}
# {'bar': {'baz': 97}, 'foo': frozenset(['Gah!']), 'list': ['list', (True, 'Maybe'), set(['and', 'a', 'set', 1])], 'spam': 'eggs'}
```
Hypothèses:
- Vous avez importé les collections de module et peuvent utiliser les classes de base abstraites, il fournit
- Vous êtes heureux de le convertir en utilisant le codage par défaut (utiliser data.encode('utf-8') plutôt que str(data) si vous avez besoin d'un codage explicite).
Si vous avez besoin de l'appui d'autres types de conteneurs, j'espère que c'est évident pour vous de suivre le modèle et ajouter des cas pour eux.
- Et que ferait-on si certaines valeurs sont des listes/jeux/etc?
- Ajouter les cas pour eux. Réponse de mise à jour, puis mis à jour à nouveau pour la nidification des conteneurs à l'intérieur des conteneurs.
- vous avez oublié tuple et frozenset, Richi
- Heureusement pour vous, je suis tellement anale listel je ne peux pas le laisser seul. 😎 Répondre à des mises à jour.
- Peut-être qu'il a omis d'eux 🙂 Mais oui les tuples sont assez communs.
- J'ai essayé d'utiliser cette décision et d'obtenir une exception RuntimeError: maximum recursion depth exceeded. Mon dict était des plus simples: {'Login': 'zxczxc', 'Nom': '\xd0\x98\xd0\xbc\xd1\x8f', 'Nom': '\xd0\x9f\xd0\xbe\xd0\xbb\xd1\x8c\xd0\xb7\xd0\xbe\xd0\xb2\xd0\xb0\xd1\x82\xd0\xb5'}
- Je l'ai corrigé. Pour les non unicode chaîne doit utiliser if isinstance(data, basestring): au lieu if isinstance(data, unicode):
- Bonne prise, merci! Maintenant résolu.
- Pourquoi utilisez-vous type(data)(map(convert, data)) au lieu map(convert, data)?
- Afin d'obtenir le même type de vous mettre dans - un n-uplet devient un tuple, une liste est une liste, un ensemble devient un jeu, et ainsi de suite.
- Dois-je avoir peur de frapper python maximum de profondeur de récursion?
- Seulement si votre structure de données est imbriquées sur plusieurs centaines de niveaux de profondeur.
- en Python3, if isinstance(data, basestring): à if isinstance(data, str):
- Je n'ai pas de convert module en Python 3 🙁
InformationsquelleAutor RichieHindle
23

Je sais je suis en retard sur celui-ci:
```
def convert_keys_to_string(dictionary):
    """Recursively converts dictionary keys to strings."""
    if not isinstance(dictionary, dict):
        return dictionary
    return dict((str(k), convert_keys_to_string(v)) 
        for k, v in dictionary.items())
```
- Yup, il semble que cela soit la bonne manière de faire, la ligne et d'autres versions ne sont vraiment pas assez pour scénarios réels. Dommage qu'il n'y est pas fiable inline recursionless moyen pour y parvenir. Ou peut-être il est basé sur python str(...) json conventions?
- C'est une de mes préférées, à seulement convertir les touches, qui est ce que je cherchais. Petite faute de frappe: vous avez besoin d'un supplément (de) autour de la dict() argument qui est retourné.
- merci homme. Tous de bonnes et de travail. Cheers!!
- Le seul problème avec cette solution est que si vos touches ne sont PAS toutes les chaînes (c'est à dire le type int)
- et pourquoi est-ce? Je ne vois aucun problème à appeler str sur un int
- Bien sûr, vous pouvez appeler str() sur un int, mais vous obtenez un str.... pas un int plus. Si le type de la clé serait changé à partir d'un int pour un str, qui est plus que le changement d'unicode à la str -- la question d'origine.
- Je suis d'accord à propos de la question d'origine. La conversion d'une chaîne d'un int qui est parfaitement cohérent avec le nom de la méthode de bien 😉
- Touché! 🙂
- Cette seulement clés.
- Cela ne parvient pas à gérer d'autres imbriquée itérable types.
InformationsquelleAutor Germano

Si vous voulais le faire en ligne et qu'il n'avait pas besoin de descente récursive, cela peut fonctionner:

DATA = { u'spam': u'eggs', u'foo': True, u'bar': { u'baz': 97 } }
print DATA
# "{ u'spam': u'eggs', u'foo': True, u'bar': { u'baz': 97 } }"

STRING_DATA = dict([(str(k), v) for k, v in data.items()])
print STRING_DATA
# "{ 'spam': 'eggs', 'foo': True, 'bar': { u'baz': 97 } }"

Pour 2,7 et à partir de ce qui peut être simplifiée comme suit: { str(key):value for key,value in data.items() }

InformationsquelleAutor Samuel Clay

def to_str(key, value):
    if isinstance(key, unicode):
        key = str(key)
    if isinstance(value, unicode):
        value = str(value)
    return key, value

de clé et de la valeur, et ajouter de la récursivité à votre code de compte à l'intérieur de dictionnaire.

InformationsquelleAutor SilentGhost

3

pour un non-imbriquées dict (puisque le titre ne fait pas mention de ce cas, il peut être intéressant pour d'autres personnes)
```
{str(k): str(v) for k, v in my_dict.items()}
```
- {str(k): str(v) for k, v in my_dict.les éléments()}
- Cela a permis de convertir mes clés à cordes dont j'avais besoin pour comparer avec mon dataframe colonne
InformationsquelleAutor maxbellec

De faire tout cela en ligne (non récursif):

{str(k):(str(v) if isinstance(v, unicode) else v) for k,v in my_dict.items()}

InformationsquelleAutor Ben

Vous devez vous connecter pour publier un commentaire.