Início / coding / Perguntas / 78950432
Accepted
ebonnal
Asked: 2024-09-05 04:18:09 +0800 CST

Existe um cenário em que `foo in list(bar)` não pode ser substituído por `foo in bar`?

  • 772

Estou pesquisando em uma base de código contendo milhares de ocorrências de foo in list(bar), por exemplo:

  • como uma expressão booleana:
if foo in list(bar) or ...:
   ...
  • em um loop for:
for foo in list(bar):
    ...
  • em uma expressão geradora:
",".join(str(foo) for foo in list(bar))

Existe um cenário (como uma versão dada do Python, um comportamento conhecido com um verificador de tipos, etc...) onde foo in list(bar)não é apenas uma versão de foo in bar? O que estou esquecendo aqui?

python

5 respostas

  1. Best Answer

    Às vezes eu fiz/vi isso quando barfui modificado no loop, por exemplo:

    bar = {1, 2, 3}
for foo in list(bar):
    bar.add(foo + 1)

    Com sua substituição, isso aumenta RuntimeError: Set changed size during iteration.

    Tente isso online!

    Um exemplo da biblioteca padrão do Python

        for k in list(_config_vars):
        if k.startswith(_INITPRE):
            del _config_vars[k]

    Dezenas de outros (muitos feitos pelo motivo acima, mas não todos).

    • 5

  2. Aqui faz a diferença:

    bar = iter('bar')
foo = 'b'
if foo in list(bar):
    print(*bar)

    Isso imprime uma linha vazia. Com sua substituição, ele imprime a rem vez disso.

    Tente isso online!

    • 3

  3. Se fooe barforem ambas strings , os testes de associação se comportam de forma diferente. <str> in <str>verifica substrings enquanto <str> in list(<str>)verifica caracteres .

    >>> foo = 'ab'
>>> bar = 'abc'
>>> foo in bar  # Substring
True
>>> foo in list(bar)  # Element (character)
False

    Em relação ao looping, não se deixe enganar pela sintaxe, não é o mesmo que a expressão booleana. O looping usa o protocolo iterável (como __iter__), enquanto a expressão booleana usa o protocolo de teste de associação (como __contains__, ou ele retorna ao protocolo iterável)

    • 3

  4. Então, qualquer um poderia criar um tipo que funcionasse desta maneira:

    >>> class Crazy:
...     def __iter__(self):
...         yield from range(10)
...
>>> 3 in Crazy()
True
>>> class Crazy:
...     def __iter__(self): yield from range(10)
...     def __contains__(self, item): raise TypeError("sorry, cant do that")
...
>>> 3 in Crazy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __contains__
TypeError: sorry, cant do that
>>> 3 in list(Crazy())
True
>>>

    A maioria dos tipos internos são "bem comportados". No entanto, uma exceção importante é provavelmente stre outros tipos semelhantes ( bytes, bytearray):

    >>> 'foo' in 'foobar'
True
>>> 'foo' in list('foobar')
False

    Além disso, para pelo menos uma biblioteca popular, numpyesse não é o caso:

    >>> import numpy as np
>>> arr = np.array([[1,2,3], [4,5,6]])
>>> arr
array([[1, 2, 3],
       [4, 5, 6]])
>>> 6 in arr
True
>>> 6 in list(arr)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>>
    • 2

  5. Quando baré um gerador, bare list(bar)pode ter outras diferenças. Aqui está um exemplo:

    def abc():
    yield 'a'
    yield 'b'
    yield 'c'
    raise Exception('Incorrect data')

foo = 'a'

if foo in abc():
    print('without list()')     # <-- This is printed (`raise` is not reached)

if foo in list(abc()):          # <-- This raises an exception
    print('with list()')        # <-- So this is never reached

    No primeiro caso, if foo in abc()não esgota o gerador. Devido à avaliação preguiçosa, uma vez que 'a'é produzido, o gerador não produzirá mais itens.

    No segundo caso, if foo in list(abc())exaure o gerador, o que levanta uma exceção. Então 'with list()'nunca é impresso.

    • 2

relate perguntas