Я читал примеры в документации по Python, но до сих пор не могу понять, что означает этот метод. Может кто-нибудь помочь? Вот два примера из документации по Python

>>> from collections import defaultdict

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]

а также

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

параметры intи listдля чего?

Как правило, словарь Python выдает a, KeyErrorесли вы пытаетесь получить элемент с ключом, которого в данный момент нет в словаре. defaultdictВ отличие от просто создавать любые предметы , которые вы пытаетесь получить доступ ( при условии , конечно , они еще не существуют). Чтобы создать такой элемент «по умолчанию», он вызывает объект функции, который вы передаете конструктору (точнее, это произвольный «вызываемый» объект, который включает объекты функций и типов). Для первого примера элементы по умолчанию создаются с помощью int(), который возвращает объект целого числа 0. Во втором примере элементы по умолчанию создаются с использованием list(), который возвращает новый пустой объект списка.

defaultdictозначает, что если в словаре не найден ключ, то вместо KeyErrorвыбрасывания создается новая запись. Тип этой новой записи определяется аргументом defaultdict.

Например:

somedict = {}
print(somedict[3]) # KeyError

someddict = defaultdict(int)
print(someddict[3]) # print int(), thus 0

defaultdict

«Стандартный словарь включает метод setdefault () для извлечения значения и установления значения по умолчанию, если значение не существует. В отличие от этого, defaultdictвызывающая сторона позволяет указать значение по умолчанию (возвращаемое значение) сразу после инициализации контейнера».

как определено Дугом Хеллманном в стандартной библиотеке Python на примере

Как использовать defaultdict

Импортировать defaultdict

>>> from collections import defaultdict

Инициализировать defaultdict

Инициализируйте его, передав

вызывается в качестве первого аргумента (обязательно)

>>> d_int = defaultdict(int)
>>> d_list = defaultdict(list)
>>> def foo():
...     return 'default value'
... 
>>> d_foo = defaultdict(foo)
>>> d_int
defaultdict(<type 'int'>, {})
>>> d_list
defaultdict(<type 'list'>, {})
>>> d_foo
defaultdict(<function foo at 0x7f34a0a69578>, {})

** kwargs в качестве второго аргумента (необязательно)

>>> d_int = defaultdict(int, a=10, b=12, c=13)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

или

>>> kwargs = {'a':10,'b':12,'c':13}
>>> d_int = defaultdict(int, **kwargs)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

Как это работает

Как и дочерний класс стандартного словаря, он может выполнять все те же функции.

Но в случае передачи неизвестного ключа он возвращает значение по умолчанию вместо ошибки. Например:

>>> d_int['a']
10
>>> d_int['d']
0
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12, 'd': 0})

Если вы хотите изменить значение по умолчанию перезаписать default_factory:

>>> d_int.default_factory = lambda: 1
>>> d_int['e']
1
>>> d_int
defaultdict(<function <lambda> at 0x7f34a0a91578>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0})

или

>>> def foo():
...     return 2
>>> d_int.default_factory = foo
>>> d_int['f']
2
>>> d_int
defaultdict(<function foo at 0x7f34a0a0a140>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0, 'f': 2})

Примеры в вопросе

Пример 1

Так как int был передан как default_factory, любой неизвестный ключ вернет 0 по умолчанию.

Теперь, когда строка передается в цикле, она увеличивает количество этих алфавитов в d.

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> d.default_factory
<type 'int'>
>>> for k in s:
...     d[k] += 1
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]
>>> d
defaultdict(<type 'int'>, {'i': 4, 'p': 2, 's': 4, 'm': 1})

Пример 2

Поскольку список был передан как default_factory, любой неизвестный (несуществующий) ключ вернет [] (т.е. список) по умолчанию.

Теперь, когда список кортежей передается в цикле, он добавит значение в d [color]

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> d.default_factory
<type 'list'>
>>> for k, v in s:
...     d[k].append(v)
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> d
defaultdict(<type 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})

Словари - это удобный способ хранения данных для последующего поиска по имени (ключу). Ключи должны быть уникальными, неизменяемыми объектами и обычно являются строками. Значения в словаре могут быть любыми. Для многих приложений значения являются простыми типами, такими как целые числа и строки.

Это становится более интересным, когда значения в словаре являются коллекциями (списки, dict и т. Д.). В этом случае значение (пустой список или dict) должно быть инициализировано при первом использовании данного ключа. Хотя это относительно легко сделать вручную, тип defaultdict автоматизирует и упрощает подобные операции. Defaultdict работает точно так же, как обычный dict, но он инициализируется функцией («фабрика по умолчанию»), которая не принимает аргументов и предоставляет значение по умолчанию для несуществующего ключа.

Defaultdict никогда не вызовет KeyError. Любой несуществующий ключ получает значение, возвращаемое фабрикой по умолчанию.

from collections import defaultdict
ice_cream = defaultdict(lambda: 'Vanilla')

ice_cream['Sarah'] = 'Chunky Monkey'
ice_cream['Abdul'] = 'Butter Pecan'

print(ice_cream['Sarah'])
>>>Chunky Monkey

print(ice_cream['Joe'])
>>>Vanilla

Вот еще один пример того, как используя defaultdict, мы можем уменьшить сложность

from collections import defaultdict
# Time complexity O(n^2)
def delete_nth_naive(array, n):
    ans = []
    for num in array:
        if ans.count(num) < n:
            ans.append(num)
    return ans

# Time Complexity O(n), using hash tables.
def delete_nth(array,n):
    result = []
    counts = defaultdict(int)

    for i in array:
        if counts[i] < n:
            result.append(i)
            counts[i] += 1
    return result


x = [1,2,3,1,2,1,2,3]
print(delete_nth(x, n=2))
print(delete_nth_naive(x, n=2))

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

Здесь есть отличное объяснение дефолтных приговоров: http://ludovf.net/blog/python-collections-defaultdict/

По сути, параметры int и list являются функциями, которые вы передаете. Помните, что Python принимает имена функций в качестве аргументов. int возвращает 0 по умолчанию, а list возвращает пустой список при вызове в скобках.

В обычных словарях, если в вашем примере я попытаюсь позвонить d[a], я получу ошибку (KeyError), поскольку существуют только ключи m, s, i и p, а ключ a не был инициализирован. Но в defaultdict он принимает имя функции в качестве аргумента, когда вы пытаетесь использовать ключ, который не был инициализирован, он просто вызывает функцию, которую вы передали, и назначает ее возвращаемое значение в качестве значения нового ключа.

Поскольку вопрос о том, «как это работает», некоторые читатели могут захотеть увидеть больше гаек и болтов. В частности, рассматриваемый метод является __missing__(key)методом. См .: https://docs.python.org/2/library/collections.html#defaultdict-objects .

Более конкретно, этот ответ показывает, как использовать __missing__(key)на практике: https://stackoverflow.com/a/17956989/1593924

Чтобы уточнить, что означает «вызываемый», вот интерактивный сеанс (начиная с версии 2.7.6, но также должен работать в версии 3):

>>> x = int
>>> x
<type 'int'>
>>> y = int(5)
>>> y
5
>>> z = x(5)
>>> z
5

>>> from collections import defaultdict
>>> dd = defaultdict(int)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd = defaultdict(x)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd['a']
0
>>> dd
defaultdict(<type 'int'>, {'a': 0})

Это было наиболее типичное использование defaultdict (за исключением бессмысленного использования переменной x). Вы можете сделать то же самое с 0 в качестве явного значения по умолчанию, но не с простым значением:

>>> dd2 = defaultdict(0)

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    dd2 = defaultdict(0)
TypeError: first argument must be callable

Вместо этого работает следующее, потому что оно передает простую функцию (она на лету создает безымянную функцию, которая не принимает аргументов и всегда возвращает 0):

>>> dd2 = defaultdict(lambda: 0)
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {})
>>> dd2['a']
0
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {'a': 0})
>>> 

И с другим значением по умолчанию:

>>> dd3 = defaultdict(lambda: 1)
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {})
>>> dd3['a']
1
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {'a': 1})
>>> 

Мой собственный 2 ¢: вы также можете подкласс defaultdict:

class MyDict(defaultdict):
    def __missing__(self, key):
        value = [None, None]
        self[key] = value
        return value

Это может пригодиться для очень сложных случаев.

Поведение defaultdictможно легко имитировать, используя dict.setdefaultвместоd[key] каждого вызова.

Другими словами, код:

from collections import defaultdict

d = defaultdict(list)

print(d['key'])                        # empty list []
d['key'].append(1)                     # adding constant 1 to the list
print(d['key'])                        # list containing the constant [1]

эквивалентно:

d = dict()

print(d.setdefault('key', list()))     # empty list []
d.setdefault('key', list()).append(1)  # adding constant 1 to the list
print(d.setdefault('key', list()))     # list containing the constant [1]

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

Некоторые могут возразить, что есть соображение производительности, но эта тема - минное поле. Этот пост показывает, что при использовании defaultdict нет большого прироста производительности.

ИМО, defaultdict - это коллекция, которая добавляет больше путаницы, чем преимуществ к коду. Бесполезно для меня, но другие могут думать иначе.

Инструмент defaultdict - это контейнер в классе коллекций Python. Он похож на обычный контейнер словаря (dict), но имеет одно отличие: тип данных полей значений указывается при инициализации.

Например:

from collections import defaultdict

d = defaultdict(list)

d['python'].append("awesome")

d['something-else'].append("not relevant")

d['python'].append("language")

for i in d.items():

    print i

Это печатает:

('python', ['awesome', 'language'])
('something-else', ['not relevant'])

Я думаю, что его лучше использовать вместо оператора case switch. Представьте себе, если у нас есть инструкция переключения регистра, как показано ниже:

option = 1

switch(option) {
    case 1: print '1st option'
    case 2: print '2nd option'
    case 3: print '3rd option'
    default: return 'No such option'
}

В switchPython нет доступных регистров. Мы можем достичь того же, используя defaultdict.

from collections import defaultdict

def default_value(): return "Default Value"
dd = defaultdict(default_value)

dd[1] = '1st option'
dd[2] = '2nd option'
dd[3] = '3rd option'

print(dd[4])    
print(dd[5])    
print(dd[3])

Это печатает:

Default Value
Default Value
3rd option

В приведенном выше фрагменте ddнет ключей 4 или 5, и, следовательно, он выводит значение по умолчанию, которое мы настроили во вспомогательной функции. Это гораздо лучше, чем необработанный словарь, в котором KeyErrorвыбрасывается a, если ключа нет. Из этого очевидно, что defaultdictбольше похоже на оператор переключения регистра, где мы можем избежать сложных if-elif-elif-elseблоков.

Еще один хороший пример, который очень впечатлил меня с этого сайта :

>>> from collections import defaultdict
>>> food_list = 'spam spam spam spam spam spam eggs spam'.split()
>>> food_count = defaultdict(int) # default value of int is 0
>>> for food in food_list:
...     food_count[food] += 1 # increment element's value by 1
...
defaultdict(<type 'int'>, {'eggs': 1, 'spam': 7})
>>>

Если мы попытаемся получить доступ к любым элементам, кроме eggsи spamмы получим счет 0.

Без defaultdictэтого вы, вероятно, можете назначить новые значения невидимым ключам, но вы не сможете их изменить. Например:

import collections
d = collections.defaultdict(int)
for i in range(10):
  d[i] += i
print(d)
# Output: defaultdict(<class 'int'>, {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9})

import collections
d = {}
for i in range(10):
  d[i] += i
print(d)
# Output: Traceback (most recent call last): File "python", line 4, in <module> KeyError: 0

Ну, defaultdict также может вызвать keyerror в следующем случае:

    from collections import defaultdict
    d = defaultdict()
    print(d[3]) #raises keyerror

Всегда не забывайте указывать аргумент defaultdict как defaultdict (int).

Стандартный словарь включает метод setdefault () для извлечения значения и установления значения по умолчанию, если значение не существует. В отличие от этого, defaultdict позволяет вызывающей стороне заранее указывать значение по умолчанию при инициализации контейнера.

import collections

def default_factory():
    return 'default value'

d = collections.defaultdict(default_factory, foo='bar')
print 'd:', d
print 'foo =>', d['foo']
print 'bar =>', d['bar']

Это работает хорошо до тех пор, пока все ключи имеют одинаковые значения по умолчанию. Это может быть особенно полезно, если по умолчанию используется тип, используемый для агрегирования или накопления значений, таких как список, набор или даже целое число. Документация стандартной библиотеки включает несколько примеров использования defaultdict таким способом.

$ python collections_defaultdict.py

d: defaultdict(<function default_factory at 0x100468c80>, {'foo': 'bar'})
foo => bar
bar => default value

Короче говоря:

defaultdict(int) - аргумент int указывает, что значения будут типом int.

defaultdict(list) - список аргументов указывает, что значения будут иметь тип списка.

Документация и объяснения в значительной степени говорят сами за себя:

http://docs.python.org/library/collections.html#collections.defaultdict

Функция типа (int / str и т. Д.), Передаваемая в качестве аргумента, используется для инициализации значения по умолчанию для любого заданного ключа, где ключ отсутствует в dict.