Najszybszy sposób na przekonwertowanie kluczy i wartości dyktu z „unicode” na „str”?

Otrzymuję dyktando z jednej „warstwy” kodu, na którym są wykonywane pewne obliczenia / modyfikacje przed przekazaniem go do innej „warstwy”. Oryginalne klucze i wartości „string” są takie unicode, ale warstwa, do której są przekazywane, akceptuje tylko str.

Będzie to często nazywane, więc chciałbym wiedzieć, jaki byłby najszybszy sposób na konwersję czegoś takiego:

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

...do:

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

... pamiętając, że wartości niebędące „ciągami znaków” muszą pozostać w swoim oryginalnym typie.

jakieś pomysły?

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'}

Założenia:

• Zaimportowałeś moduł collections i możesz użyć abstrakcyjnych klas bazowych, które zapewnia
• Z przyjemnością konwertujesz przy użyciu domyślnego kodowania (użyj data.encode('utf-8')raczej niż str(data)jeśli potrzebujesz jawnego kodowania).

Jeśli potrzebujesz obsługiwać inne typy kontenerów, miejmy nadzieję, że jest oczywiste, jak postępować zgodnie ze wzorcem i dodawać do nich przypadki.

Wiem, że się spóźniłem:

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())

Jeśli chcesz to zrobić inline i nie potrzebujesz rekursywnego zejścia, może to zadziałać:

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 } }"

dla niezagnieżdżonego dyktu (ponieważ tytuł nie wspomina o tym przypadku, może być interesujący dla innych osób)

{str(k): str(v) for k, v in my_dict.items()}

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

Przekaż klucz i wartość do niego, a następnie dodaj rekursję do kodu, aby uwzględnić słownik wewnętrzny.

Aby to wszystko było wbudowane (nierekurencyjne):

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

Po prostu użyj print(*(dict.keys()))

Znak * może służyć do rozpakowywania kontenerów np. List. Aby uzyskać więcej informacji na temat *, sprawdź tę odpowiedź SO .

>>> d = {u"a": u"b", u"c": u"d"}
>>> d
{u'a': u'b', u'c': u'd'}
>>> import json
>>> import yaml
>>> d = {u"a": u"b", u"c": u"d"}
>>> yaml.safe_load(json.dumps(d))
{'a': 'b', 'c': 'd'}