Por que um python dict.update () retorna o objeto?

Eu estou tentando fazer:

award_dict = {
    "url" : "http://facebook.com",
    "imageurl" : "http://farm4.static.flickr.com/3431/3939267074_feb9eb19b1_o.png",
    "count" : 1,
}

def award(name, count, points, desc_string, my_size, parent) :
    if my_size > count :
        a = {
            "name" : name,
            "description" : desc_string % count,
            "points" : points,
            "parent_award" : parent,
        }
        a.update(award_dict)
        return self.add_award(a, siteAlias, alias).award

Mas se me sentisse realmente complicado na função, e eu preferiria:

        return self.add_award({
            "name" : name,
            "description" : desc_string % count,
            "points" : points,
            "parent_award" : parent,
        }.update(award_dict), siteAlias, alias).award

Por que a atualização não retorna o objeto para que você possa encadear?

O JQuery faz isso para encadear. Por que não é aceitável em python?

O Python está implementando principalmente um sabor pragmaticamente tingido de separação de consulta de comando : os mutadores retornam None(com exceções induzidas pragmaticamente como pop;-), para que não possam ser confundidas com os acessadores (e na mesma linha, atribuição não é uma expressão, a instrução separação de expressão existe e assim por diante).

Isso não significa que não há muitas maneiras de mesclar as coisas quando você realmente deseja, por exemplo, cria dict(a, **award_dict)um novo ditado muito parecido com o que você parece desejar .updateretornar - então, por que não usá-lo se realmente acha importante ?

Edit : btw, não é necessário, no seu caso específico, criar aao longo do caminho:

dict(name=name, description=desc % count, points=points, parent_award=parent,
     **award_dict)

cria um único ditado com exatamente a mesma semântica que a sua a.update(award_dict)(incluindo, no caso de conflitos, o fato de que as entradas award_dictsubstituem as que você está dando explicitamente; para obter a outra semântica, ou seja, para ter entradas explícitas "vencendo" esses conflitos, passar award_dictcomo o único argumento posicional , antes das palavras-chave e sem o **formulário - dict(award_dict, name=nameetc etc).

A API do Python, por convenção, distingue entre procedimentos e funções. As funções calculam novos valores a partir de seus parâmetros (incluindo qualquer objeto de destino); Os procedimentos modificam objetos e não retornam nada (ou seja, eles retornam Nenhum). Portanto, procedimentos têm efeitos colaterais, funções não. update é um procedimento, portanto, ele não retorna um valor.

A motivação para fazer dessa maneira é que, caso contrário, você poderá obter efeitos colaterais indesejáveis. Considerar

bar = foo.reverse()

Se reverse (que inverte a lista no local) também devolve a lista, os usuários podem pensar que reverse retorna uma nova lista que é atribuída à barra e nunca notam que foo também é modificado. Fazendo retorno reverso Nenhum, eles imediatamente reconhecem que a barra não é o resultado da reversão e parecerão mais próximos do efeito do reverso.

Isso é fácil como:

(lambda d: d.update(dict2) or d)(d1)

>>> dict_merge = lambda a,b: a.update(b) or a
>>> dict_merge({'a':1, 'b':3},{'c':5})
{'a': 1, 'c': 5, 'b': 3}

Observe que, além de retornar o ditado mesclado, ele modifica o primeiro parâmetro no local. Então dict_merge (a, b) modificará a.

Ou, é claro, você pode fazer tudo em linha:

>>> (lambda a,b: a.update(b) or a)({'a':1, 'b':3},{'c':5})
{'a': 1, 'c': 5, 'b': 3}

reputação insuficiente para o comentário deixado na resposta superior

@ Beardc isso não parece ser coisa de CPython. PyPy me fornece "TypeError: palavras-chave devem ser cadeias de caracteres"

A solução **kwargsfunciona apenas porque o dicionário a ser mesclado possui apenas chaves do tipo string .

ie

>>> dict({1:2}, **{3:4})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

vs

>>> dict({1:2}, **{'3':4})
{1: 2, '3': 4}

Não é que não seja aceitável, mas que dicts não foi implementado dessa maneira.

Se você observar o ORM do Django, ele faz uso extensivo de encadeamento. Não é desencorajado, você pode até herdar dicte substituir apenas updatepara atualizar e return self, se você realmente quiser.

class myDict(dict):
    def update(self, *args):
        dict.update(self, *args)
        return self

o mais próximo possível da sua solução proposta

from collections import ChainMap

return self.add_award(ChainMap(award_dict, {
    "name" : name,
    "description" : desc_string % count,
    "points" : points,
    "parent_award" : parent,
}), siteAlias, alias).award

Para aqueles que chegaram atrasados ​​à festa, eu tinha marcado um tempo (Py 3.7), mostrando que .update() métodos baseados parecem um pouco (~ 5%) mais rápidos quando as entradas são preservadas e visivelmente (~ 30%) mais rápidos quando apenas atualizamos no local .

Como sempre, todas as referências devem ser tomadas com um grão de sal.

def join2(dict1, dict2, inplace=False):
    result = dict1 if inplace else dict1.copy()
    result.update(dict2)
    return result


def join(*items):
    iter_items = iter(items)
    result = next(iter_items).copy()
    for item in iter_items:
        result.update(item)
    return result


def update_or(dict1, dict2):
    return dict1.update(dict2) or dict1


d1 = {i: str(i) for i in range(1000000)}
d2 = {str(i): i for i in range(1000000)}

%timeit join2(d1, d2)
# 258 ms ± 1.47 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit join(d1, d2)
# 262 ms ± 2.97 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit dict(d1, **d2)
# 267 ms ± 2.74 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit {**d1, **d2}
# 267 ms ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Os tempos para as operações no local são um pouco mais complicados, portanto, ele precisa ser modificado ao longo de uma operação de cópia extra (o primeiro tempo é apenas para referência):

%timeit dd = d1.copy()
# 44.9 ms ± 495 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit dd = d1.copy(); join2(dd, d2)
# 296 ms ± 2.05 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit dd = d1.copy(); join2(dd, d2, True)
# 234 ms ± 1.02 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit dd = d1.copy(); update_or(dd, d2)
# 235 ms ± 1.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

import itertools
dict_merge = lambda *args: dict(itertools.chain(*[d.iteritems() for d in args]))

Apenas tentei isso no Python 3.4 (por isso não foi capaz de usar a {**dict_1, **dict_2}sintaxe sofisticada ).

Eu queria poder ter chaves não-string nos dicionários, além de fornecer uma quantidade arbitrária de dicionários.

Além disso, eu queria criar um novo dicionário, por isso optei por não usar collections.ChainMap(meio que o motivo de não querer usar dict.updateinicialmente.

Aqui está o que eu acabei escrevendo:

def merge_dicts(*dicts):
    all_keys  = set(k for d in dicts for k in d.keys())
    chain_map = ChainMap(*reversed(dicts))
    return {k: chain_map[k] for k in all_keys}

merge_maps({'1': 1}, {'2': 2, '3': 3}, {'1': 4, '3': 5})
# {'1': 4, '3': 5, '2': 2}