Варианты использования для метода dict 'setdefault'

Добавление collections.defaultdictв Python 2.5 значительно снижается необходимость dict«S setdefaultметода. Этот вопрос для нашего коллективного образования:

1. Для чего setdefaultвсе еще полезно сегодня Python 2.6 / 2.7?
2. Какие популярные варианты использования setdefaultбыли заменены collections.defaultdict?

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

Вероятно, наиболее распространенный вариант использования: группировка элементов (в несортированных данных, другое использование itertools.groupby)

# really verbose
new = {}
for (key, value) in data:
    if key in new:
        new[key].append( value )
    else:
        new[key] = [value]


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # key might exist already
    group.append( value )


# even simpler with defaultdict 
from collections import defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append( value ) # all keys have a default already

Иногда вы хотите убедиться, что определенные ключи существуют после создания dict. defaultdictне работает в этом случае, потому что он создает ключи только при явном доступе. Думаю, вы используете что-то HTTP-иш со многими заголовками - некоторые являются необязательными, но вы хотите по умолчанию для них:

headers = parse_headers( msg ) # parse the message, get a dict
# now add all the optional headers
for headername, defaultvalue in optional_headers:
    headers.setdefault( headername, defaultvalue )

Я обычно использую setdefaultдля ключевых слов аргументы, такие как в этой функции:

def notify(self, level, *pargs, **kwargs):
    kwargs.setdefault("persist", level >= DANGER)
    self.__defcon.set(level, **kwargs)
    try:
        kwargs.setdefault("name", self.client.player_entity().name)
    except pytibia.PlayerEntityNotFound:
        pass
    return _notify(level, *pargs, **kwargs)

Он отлично подходит для настройки аргументов в оболочках вокруг функций, которые принимают аргументы ключевых слов.

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

Например, мне нужен словарь для сопоставления строк с уникальными целочисленными значениями. defaultdict(int)всегда будет использовать 0 для значения по умолчанию. Точно так же,defaultdict(intGen()) всегда выдает 1.

Вместо этого я использовал обычный dict:

nextID = intGen()
myDict = {}
for lots of complicated stuff:
    #stuff that generates unpredictable, possibly already seen str
    strID = myDict.setdefault(myStr, nextID())

Обратите внимание, что этого dict.get(key, nextID())недостаточно, потому что мне нужно иметь возможность ссылаться на эти значения позже.

intGen это крошечный класс, который я создаю, который автоматически увеличивает int и возвращает его значение:

class intGen:
    def __init__(self):
        self.i = 0

    def __call__(self):
        self.i += 1
    return self.i

Если у кого-то есть способ сделать это, defaultdictя бы с удовольствием это увидел.

Я использую, setdefault()когда я хочу значение по умолчанию в OrderedDict. Существует не стандартный набор Python , который делает как, но есть способы , чтобы реализовать такую коллекцию.

Поскольку большинство ответов указывают setdefaultили defaultdictпозволят вам установить значение по умолчанию, когда ключ не существует. Тем не менее, я хотел бы указать на небольшое предостережение в отношении случаев использования setdefault. Когда интерпретатор Python выполняется, setdefaultон всегда оценивает второй аргумент функции, даже если ключ существует в словаре. Например:

In: d = {1:5, 2:6}

In: d
Out: {1: 5, 2: 6}

In: d.setdefault(2, 0)
Out: 6

In: d.setdefault(2, print('test'))
test
Out: 6

Как видите, printтакже был выполнен, хотя 2 уже существовало в словаре. Это становится особенно важным, если вы планируете использовать, setdefaultнапример, для оптимизации, как memoization. Если вы добавите рекурсивный вызов функции в качестве второго аргументаsetdefault , вы не получите никакой производительности, так как Python всегда будет вызывать функцию рекурсивно.

Поскольку упоминание было упомянуто, лучшей альтернативой является использование декоратора functools.lru_cache, если вы планируете усовершенствовать функцию с помощью памятки. lru_cache лучше обрабатывает требования кеширования для рекурсивной функции.

Как сказал Мухаммед, есть ситуации, в которых вы только иногда хотите установить значение по умолчанию. Отличным примером этого является структура данных, которая сначала заполняется, а затем запрашивается.

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

Defaultdict не может этого сделать. Вместо этого следует использовать обычный dict с методами get и setdefault.

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

Однако из стандартной библиотеки возникает интересный пример использования (Python 2.6, _threadinglocal.py):

>>> mydata = local()
>>> mydata.__dict__
{'number': 42}
>>> mydata.__dict__.setdefault('widgets', [])
[]
>>> mydata.widgets
[]

Я бы сказал, что использование __dict__.setdefaultэто довольно полезный случай.

Изменить : Как это бывает, это единственный пример в стандартной библиотеке, и это в комментарии. Так что, может быть, этого недостаточно, чтобы оправдать существованиеsetdefault . Тем не менее, вот объяснение:

Объекты хранят свои атрибуты в __dict__атрибуте. Как это бывает, __dict__атрибут доступен для записи в любое время после создания объекта. Это также словарь, а не defaultdict. Для объектов в общем случае не имеет смысла иметь __dict__это, defaultdictпотому что каждый объект имеет все юридические идентификаторы в качестве атрибутов. Поэтому я не могу предвидеть каких-либо изменений в объектах Python, от которых можно избавиться __dict__.setdefault, за исключением полного удаления, если это будет сочтено бесполезным.

Один из недостатков defaultdictover dict( dict.setdefault) состоит в том, что defaultdictобъект создает новый элемент КАЖДОЙ ВРЕМЯ, если задан несуществующий ключ (например, с ==, print). Кроме того, defaultdictкласс, как правило, гораздо реже, чемdict класс, его сложнее сериализовать в IME.

PS IMO функции | методы, не предназначенные для изменения объекта, не должны изменять объект.

Вот несколько примеров setdefault, чтобы показать его полезность:

"""
d = {}
# To add a key->value pair, do the following:
d.setdefault(key, []).append(value)

# To retrieve a list of the values for a key
list_of_values = d[key]

# To remove a key->value pair is still easy, if
# you don't mind leaving empty lists behind when
# the last value for a given key is removed:
d[key].remove(value)

# Despite the empty lists, it's still possible to 
# test for the existance of values easily:
if d.has_key(key) and d[key]:
    pass # d has some values for key

# Note: Each value can exist multiple times!
"""
e = {}
print e
e.setdefault('Cars', []).append('Toyota')
print e
e.setdefault('Motorcycles', []).append('Yamaha')
print e
e.setdefault('Airplanes', []).append('Boeing')
print e
e.setdefault('Cars', []).append('Honda')
print e
e.setdefault('Cars', []).append('BMW')
print e
e.setdefault('Cars', []).append('Toyota')
print e

# NOTE: now e['Cars'] == ['Toyota', 'Honda', 'BMW', 'Toyota']
e['Cars'].remove('Toyota')
print e
# NOTE: it's still true that ('Toyota' in e['Cars'])

Я переписал принятый ответ и предоставил его новичкам.

#break it down and understand it intuitively.
new = {}
for (key, value) in data:
    if key not in new:
        new[key] = [] # this is core of setdefault equals to new.setdefault(key, [])
        new[key].append(value)
    else:
        new[key].append(value)


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # it is new[key] = []
    group.append(value)



# even simpler with defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append(value) # all keys have a default value of empty list []

Кроме того, я классифицировал методы как ссылки:

dict_methods_11 = {
            'views':['keys', 'values', 'items'],
            'add':['update','setdefault'],
            'remove':['pop', 'popitem','clear'],
            'retrieve':['get',],
            'copy':['copy','fromkeys'],}

Я часто использую setdefault, когда получаю это, устанавливая значение по умолчанию (!!!) в словаре; довольно часто словарь os.environ:

# Set the venv dir if it isn't already overridden:
os.environ.setdefault('VENV_DIR', '/my/default/path')

Менее кратко, это выглядит так:

# Set the venv dir if it isn't already overridden:
if 'VENV_DIR' not in os.environ:
    os.environ['VENV_DIR'] = '/my/default/path')

Стоит отметить, что вы также можете использовать результирующую переменную:

venv_dir = os.environ.setdefault('VENV_DIR', '/my/default/path')

Но это менее необходимо, чем это было до существования дефолтов.

Другой вариант использования, о котором я не думаю, был упомянут выше. Иногда вы сохраняете кеш-объект объектов по их идентификатору, где основной экземпляр находится в кеше, и вы хотите установить кеш при отсутствии.

return self.objects_by_id.setdefault(obj.id, obj)

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

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

Например, (Int)FlagEnum в Python 3.6.0 содержит ошибку : если несколько потоков конкурируют за составной (Int)Flagэлемент, может оказаться более одного:

from enum import IntFlag, auto
import threading

class TestFlag(IntFlag):
    one = auto()
    two = auto()
    three = auto()
    four = auto()
    five = auto()
    six = auto()
    seven = auto()
    eight = auto()

    def __eq__(self, other):
        return self is other

    def __hash__(self):
        return hash(self.value)

seen = set()

class cycle_enum(threading.Thread):
    def run(self):
        for i in range(256):
            seen.add(TestFlag(i))

threads = []
for i in range(8):
    threads.append(cycle_enum())

for t in threads:
    t.start()

for t in threads:
    t.join()

len(seen)
# 272  (should be 256)

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

[Править] Очень неправильно!Setdefault всегда запускает long_computation, а Python стремится к этому.

Расширяя ответ Таттла. Для меня лучшим вариантом использования является механизм кэширования. Вместо того:

if x not in memo:
   memo[x]=long_computation(x)
return memo[x]

который потребляет 3 строки и 2 или 3 поиска, я бы с радостью написал :

return memo.setdefault(x, long_computation(x))

Мне нравится ответ, приведенный здесь:

http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html

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

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

Пример с defaultdict:

>>> from collection import defaultdict()
>>> foo = defaultdict()
>>> foo['a'] = 4
>>> foo['a'] = 2
>>> print(foo)
defaultdict(None, {'a': 2})

setdefault не перезаписывать:

>>> bar = dict()
>>> bar.setdefault('a', 4)
>>> bar.setdefault('a', 2)
>>> print(bar)
{'a': 4}