Словари (dict, dictionary) в Python

Введение

Примеры

  • 1

    Доступ к значениям словаря

     dictionary = {"Hello": 1234, "World": 5678}
    print(dictionary["Hello"])
    
     

    Приведенный выше код будет печатать 1234 .

    Строка "Hello" в этом примере , называется ключом. Он используется для поиска значения в dict путем размещения ключа в квадратных скобках.

    Номер 1234 виден после соответствующей толстой кишки в dict определения. Это называется значение , что "Hello" карты в этом dict .

    Глядя значение , как это с ключом , который не существует поднимет KeyError исключение, прекращение выполнения , если перехватывается. Если мы хотим получить доступ к стоимости без риска KeyError , мы можем использовать dictionary.get метод. По умолчанию , если ключ не существует, метод вернет None . Мы можем передать его второе возвращаемое значение вместо None в случае неудачного поиска.

     w = dictionary.get("whatever")
    x = dictionary.get("whatever", "nuh-uh")
    
     

    В этом примере w не получит значение None и x получит значение "nuh-uh" .

  • 0

    Конструктор dict ()

    dict() Конструктор может быть использован для создания словарей из именованных аргументов, или из одного Iterable пар ключ-значение, или из одного словаря и именованных аргументов.

     dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
    dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
    dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
    dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3} 
  • 6

    Избежание исключений KeyError

    Одна из распространенных ошибок при использовании словарей - доступ к несуществующему ключу. Это обычно приводит к KeyError исключения

     mydict = {}
    mydict['not there']
     

    Traceback (последний вызов был последним): File " ", строка 1, в KeyError: «не там»

    Один из способов избежать основных ошибок являются использование dict.get метод, который позволяет указать значение по умолчанию для возврата в случае отсутствующего ключа.

     value = mydict.get(key, default_value)
    
     

    Который возвращает mydict[key] , если она существует, но в противном случае возвращает default_value . Обратите внимание , что это не добавляет key к mydict . Так что если вы хотите сохранить эту ключевую пару значений, вы должны использовать mydict.setdefault(key, default_value) , который не хранить пару ключей значения.

     mydict = {}
    print(mydict)
    # {}
    print(mydict.get("foo", "bar"))
    # bar
    print(mydict)
    # {}
    print(mydict.setdefault("foo", "bar"))
    # bar
    print(mydict)
    # {'foo': 'bar'}
    
     

    Альтернативный способ справиться с проблемой - поймать исключение

     try:
        value = mydict[key]
    except KeyError:
        value = default_value
    
     

    Вы также можете проверить , если ключ находится in словаре.

     if key in mydict:
        value = mydict[key]
    else:
        value = default_value
    
     

    Однако обратите внимание, что в многопоточных средах ключ может быть удален из словаря после проверки, создавая состояние состязания, при котором исключение все еще может быть выдано.

    Другой вариант - использовать подкласс dict, collection.defaultdict, который имеет default_factory для создания новых записей в dict при получении new_key.

  • 1

    Доступ к ключам и значениям

    При работе со словарями, часто необходимо , чтобы получить доступ ко всем ключи и значения в словаре, либо в for цикла, список понимание, или просто как обычный список.

    Учитывая словарь, как:

     mydict = {
        'a': '1',
        'b': '2'
    }
    
     

    Вы можете получить список ключей , используя keys() метод:

     print(mydict.keys())
    # Python2: ['a', 'b']
    # Python3: dict_keys(['b', 'a'])
    
     

    Если вместо этого вы хотите получить список значений, используйте values() метод:

     print(mydict.values())
    # Python2: ['1', '2']
    # Python3: dict_values(['2', '1'])
    
     

    Если вы хотите работать как с ключом и его соответствующим значением, вы можете использовать items() метод:

     print(mydict.items())
    # Python2: [('a', '1'), ('b', '2')]
    # Python3: dict_items([('b', '2'), ('a', '1')])
    
     

    Примечание: Поскольку dict является Unsorted, keys() , values() и items() не имеют порядка сортировки. Используйте sort() , sorted() , или OrderedDict , если вы заботитесь о том порядке , что эти методы возврата.

    Python 2/3 Разница: В Python 3, эти методы возвращают специальные Iterable объекты, а не списки, и являются эквивалентом Python 2 iterkeys() , itervalues() , и iteritems() методы. Эти объекты можно использовать как списки по большей части, хотя есть некоторые различия. См PEP 3106 для получения более подробной информации.

  • 11

    Введение в словарь

    Словарь является примером хранилища ключей значения также известным как Mapping в Python. Это позволяет хранить и извлекать элементы, ссылаясь на ключ. Поскольку на словари ссылаются по ключу, они имеют очень быстрый поиск. Поскольку они в основном используются для ссылки на элементы по ключу, они не сортируются.

    создавая диктат

    Словари можно запускать разными способами:

    буквальный синтаксис

     d = {}                        # empty dict
    d = {'key': 'value'}          # dict with initial values
     
    # Также возможна распаковка одного или нескольких словарей с буквальным синтаксисом # делает поверхностную копию otherdict d = {** otherdict} # также обновляет поверхностную копию с содержимым butanotherdict. d = {** иное, ** еще одно другое}

    диктат понимания

     d = {k:v for k,v in [('key', 'value',)]}
    
     

    Смотрите также: постижения

    встроенный класс: dict()

     d = dict()                    # emtpy dict
    d = dict(key='value')         # explicit keyword arguments
    d = dict([('key', 'value')])  # passing in a list of key/value pairs
    # make a shallow copy of another dict (only possible if keys are only strings!)
    d = dict(**otherdict)         
    
     

    изменение диктата

    Чтобы добавить элементы в словарь, просто создайте новый ключ со значением:

     d['newkey'] = 42
    
     

    Кроме того , можно добавить list и dictionary в качестве значения:

     d['new_list'] = [1, 2, 3]
    d['new_dict'] = {'nested_dict': 1}
    
     

    Чтобы удалить элемент, удалите ключ из словаря:

     del d['newkey']
    
     
  • 2

    Словарь со значениями по умолчанию

    Доступен в стандартной библиотеке как defaultdict

     from collections import defaultdict
    
    d = defaultdict(int)
    d['key']                         # 0
    d['key'] = 5
    d['key']                         # 5
    
    d = defaultdict(lambda: 'empty')
    d['key']                         # 'empty'
    d['key'] = 'full'
    d['key']                         # 'full'
    
     

    [*] С другой стороны , если вы должны использовать встроенный в dict классе, using dict.setdefault() позволит создать по умолчанию каждый раз , когда вы получаете доступ к ключ , который раньше не было:

     >>> d = {}
    {}
    >>> d.setdefault('Another_key', []).append("This worked!")
    >>> d
    {'Another_key': ['This worked!']}
    
    
     

    Имейте в виду , что если у вас есть много значений , чтобы добавить, dict.setdefault() создаст новый экземпляр исходного значения (в данном примере [] ) каждый раз , когда это называется - что может создать ненужные рабочие нагрузки.

    [] Python Cookbook, третье издание, Дэвид Бизли и Брайан К. Джонс (O'Reilly). Copyright 2013 Дэвид Бизли и Брайан Джонс, 978-1-449-34037-7. *

  • 1

    Создание упорядоченного словаря

    Вы можете создать упорядоченный словарь, который будет следовать определенному порядку при переборе ключей в словаре.

    Используйте OrderedDict из collections модуля. Это будет всегда возвращать элементы словаря в исходном порядке вставки при повторении.

     from collections import OrderedDict
    
    d = OrderedDict()
    d['first'] = 1
    d['second'] = 2
    d['third'] = 3
    d['last'] = 4
    
    # Outputs "first 1", "second 2", "third 3", "last 4"
    for key in d:
        print(key, d[key]) 
  • 1

    Распаковка словарей с помощью оператора **

    Вы можете использовать ** ключевого слова аргумента распаковку оператор для доставки пара ключа-значения в словаре в аргументы функции. Упрощенный пример из официальной документации :

     >>>
    >>> def parrot(voltage, state, action):
    ...     print("This parrot wouldn't", action, end=' ')
    ...     print("if you put", voltage, "volts through it.", end=' ')
    ...     print("E's", state, "!")
    ...
    >>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    >>> parrot(**d)
    
    This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
    
     

    На Python 3.5 вы также можете использовать этот синтаксис , чтобы объединить произвольное число dict объектов.

     >>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
    >>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
    >>> fishdog = {**fish, **dog}
    >>> fishdog
    
    {'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}
    
     

    Как показывает этот пример, дубликаты ключей соответствуют последнему значению (например, «Клиффорд» переопределяет «Немо»).

  • 2

    Слияние словарей

    Рассмотрим следующие словари:

     >>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
    >>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
    
     

    Python 3.5+

     >>> fishdog = {**fish, **dog}
    >>> fishdog
    {'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}
    
     

    Как показывает этот пример, дубликаты ключей соответствуют последнему значению (например, «Клиффорд» переопределяет «Немо»).


    Python 3.3+

     >>> from collections import ChainMap
    >>> dict(ChainMap(fish, dog))
    {'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}
    
     

    С помощью этой техники первостепенное значение имеет приоритет для данного ключа, а не последнего («Клиффорд» выбрасывается в пользу «Немо»).


    Python 2.x, 3.x

     >>> from itertools import chain
    >>> dict(chain(fish.items(), dog.items()))
    {'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}
    
     

    При этом используется значение последнего, как и с ** -методом для слияния ( «Клиффорд» подменяет «Немо»).

     >>> fish.update(dog)
    >>> fish
    {'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}
    
     

    dict.update использует последнюю Dict перезаписать предыдущую.

  • 0

    Завершающая запятая

    Как и списки и кортежи, вы можете добавить запятую в своем словаре.

     role = {"By day": "A typical programmer",
            "By night": "Still a typical programmer", }
    
     

    PEP 8 требует, чтобы вы оставляли пробел между конечной запятой и закрывающей скобкой.

  • 0

    Все комбинации значений словаря

     options = {
        "x": ["a", "b"],
        "y": [10, 20, 30]
    } 

    Имеется словарь, подобный показанному выше, где есть список, представляющий набор значений для исследования для соответствующего ключа. Предположим , вы хотите , чтобы исследовать "x"="a" с "y"=10 , то "x"="a" с "y"=10 , и так далее , пока вы не исследовали все возможные комбинации.

    Вы можете создать список, который возвращает все такие комбинации значений, используя следующий код.

     import itertools
    
    options = {
        "x": ["a", "b"],
        "y": [10, 20, 30]}
    
    keys = options.keys()
    values = (options[key] for key in keys)
    combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
    print combinations 

    Это дает нам следующий список , хранящийся в переменной combinations :

     [{'x': 'a', 'y': 10},
     {'x': 'b', 'y': 10},
     {'x': 'a', 'y': 20},
     {'x': 'b', 'y': 20},
     {'x': 'a', 'y': 30},
     {'x': 'b', 'y': 30}] 
  • 4

    Перебор словаря

    При использовании словаря в качестве итератора (например , в for заявления), он проходит ключи словаря. Например:

     d = {'a': 1, 'b': 2, 'c':3}
    for key in d:
        print(key, d[key])
    # c 3
    # b 2
    # a 1
    
     

    То же самое верно, когда используется в понимании

     print([key for key in d])
    # ['c', 'b', 'a']
    
     
    Метод items () можно использовать для одновременного зацикливания ** ключа ** и ** значения **: для ключа значение в d.items (): print (ключ, значение) # c 3 # b 2 # a 1 Хотя метод `values ​​()` можно использовать для перебора только значений, как и следовало ожидать: для ключа значение в d.values ​​(): print (key, value) # 3 # 2 # 1 Здесь методы `keys ()`, `values ​​()` и `items ()` возвращают списки, и есть три дополнительных метода `iterkeys ()` `itervalues ​​()` и `iteritems ()` для возврата итераторов ,
  • 1

    Создание словаря

    Правила создания словаря:

    • Каждый ключ должен быть уникальным ( в противном случае он будет перезаписан)
    • Каждый ключ должен быть hashable (можно использовать hash - функцию , чтобы хэш его, в противном случае TypeError будет выброшен)
    • Там нет конкретного заказа для ключей.
    # Creating and populating it with values
    stock = {'eggs': 5, 'milk': 2}
    
    # Or creating an empty dictionary
    dictionary = {}
    
    # And populating it after
    dictionary['eggs'] = 5
    dictionary['milk'] = 2
    
    # Values can also be lists
    mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}
    
    # Use list.append() method to add new elements to the values list
    mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
    mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}
    
    # We can also create a dictionary using a list of two-items tuples
    iterable = [('eggs', 5), ('milk', 2)]
    dictionary = dict(iterables)
    
    # Or using keyword argument:
    dictionary = dict(eggs=5, milk=2)
    
    # Another way will be to use the dict.fromkeys:
    dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
    dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

Синтаксис

Параметры

Примечания