Qual é melhor em python, del ou delattr?

Isso pode ser bobo, mas está incomodando a parte de trás do meu cérebro há um tempo.

O Python nos fornece duas maneiras internas de excluir atributos de objetos, a palavra de comando del e a função interna delattr . Prefiro delattr porque acho um pouco mais explícito:

del foo.bar
delattr(foo, "bar")

Mas estou me perguntando se pode haver diferenças ocultas entre eles.

O primeiro é mais eficiente que o segundo. del foo.barcompila para duas instruções de bytecode:

  2           0 LOAD_FAST                0 (foo)
              3 DELETE_ATTR              0 (bar)

considerando que delattr(foo, "bar")leva cinco:

  2           0 LOAD_GLOBAL              0 (delattr)
              3 LOAD_FAST                0 (foo)
              6 LOAD_CONST               1 ('bar')
              9 CALL_FUNCTION            2
             12 POP_TOP             

Isso se traduz na primeira execução ligeiramente mais rápida (mas não é uma grande diferença - 0,15 μs na minha máquina).

Como os outros disseram, você realmente só deve usar a segunda forma quando o atributo que você está excluindo for determinado dinamicamente.

[Editado para mostrar as instruções de bytecode geradas dentro de uma função, onde o compilador pode usar LOAD_FASTe LOAD_GLOBAL]

• del é mais explícito e eficiente;
• delattr permite a exclusão dinâmica de atributos.

Considere os seguintes exemplos:

for name in ATTRIBUTES:
    delattr(obj, name)

ou:

def _cleanup(self, name):
    """Do cleanup for an attribute"""
    value = getattr(self, name)
    self._pre_cleanup(name, value)
    delattr(self, name)
    self._post_cleanup(name, value)

Você não pode fazer isso com del .

Inquestionavelmente o primeiro. Na minha opinião, é como perguntar se foo.baré melhor do que getattr(foo, "bar"), e não acho que alguém esteja fazendo essa pergunta :)

É realmente uma questão de preferência, mas o primeiro é provavelmente preferível. Eu usaria o segundo apenas se você não souber o nome do atributo que está excluindo antes do tempo.

Assim como getattr e setattr, delattr deve ser usado apenas quando o nome do atributo for desconhecido.

Nesse sentido, é aproximadamente equivalente a vários recursos python usados ​​para acessar a funcionalidade incorporada em um nível mais baixo do que você normalmente tem disponível, como em __import__vez de importe em operator.addvez de+

Não tenho certeza sobre o funcionamento interno, mas de uma reutilização de código e não seja uma perspectiva idiota de colegas de trabalho, use del. É mais claro e compreendido por pessoas vindas de outros idiomas também.

Se você acha que delattré mais explícito, por que não usar getattro tempo todo e não object.attr?

Quanto ao assunto ... seu palpite é tão bom quanto o meu. Se não for significativamente melhor.

É uma pergunta antiga, mas eu gostaria de colocar meus 2 centavos.

Embora, del foo.barseja mais elegante, às vezes você precisará delattr(foo, "bar"). Digamos, se você tiver uma interface de linha de comando interativa que permita que um usuário exclua dinamicamente qualquer membro do objeto digitando o nome , não terá outra opção a não ser usar o último formulário.