Używam Pythona 2.7.3.

Rozważmy fikcyjną klasę z niestandardową (choć złą) iteracją i zachowaniem polegającym na pobieraniu przedmiotów:

class FooList(list):
    def __iter__(self):
        return iter(self)
    def next(self):
        return 3
    def __getitem__(self, idx):
        return 3

Zrób przykład i zobacz dziwne zachowanie:

>>> zz = FooList([1,2,3])

>>> [x for x in zz]
# Hangs because of the self-reference in `__iter__`.

>>> zz[0]
3

>>> zz[1]
3

Ale teraz stwórzmy funkcję, a następnie rozpakujmy argumentzz:

def add3(a, b, c):
    return a + b + c

>>> add3(*zz)
6
# I expected either 9 or for the interpreter to hang like the comprehension!

Zatem rozpakowywanie argumentów w jakiś sposób pobiera dane o elemenciezz ale nie przez iterację obiektu za pomocą zaimplementowanego iteratora, ani też przez wykonanie iteratora i wywołania biednego człowieka__getitem__ dla tak wielu przedmiotów, jak obiekt.

Więc pytanie brzmi: w jaki sposób składniaadd3(*zz) zdobyć członków danychzz jeśli nie tymi metodami? Czy po prostu brakuje mi jednego wspólnego wzorca pobierania członków danych z takiego typu?

Moim celem jest sprawdzenie, czy mógłbym napisać klasę, która implementuje iterację lub pobieranie elementów w taki sposób, aby zmieniała argument wypakowujący składnię dla tej klasy. Po wypróbowaniu dwóch powyższych przykładów zastanawiam się teraz, jak rozpakowywanie argumentów wpływa na dane bazowe i czy programista może wpływać na to zachowanie. Google w tym celu zwrócił tylko morze wyników wyjaśniających podstawowe użycie*args składnia.

Nie mam przypadku użycia, ponieważ muszę to zrobić i nie twierdzę, że to dobry pomysł. Chcę tylko zobaczyć, jak to zrobić ze względu na ciekawość.

Dodany

Ponieważ typy wbudowane są traktowane specjalnie, oto przykładobject gdzie utrzymuję obiekt listy i implementuję własne zachowanie get i set do emulacji listy.

class FooList(object):
    def __init__(self, lst):
        self.lst = lst
    def __iter__(self): raise ValueError
    def next(self): return 3
    def __getitem__(self, idx): return self.lst.__getitem__(idx)
    def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)

W tym przypadku,

In [234]: zz = FooList([1,2,3])

In [235]: [x for x in zz]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-235-ad3bb7659c84> in <module>()
----> 1 [x for x in zz]

<ipython-input-233-dc9284300db1> in __iter__(self)
      2     def __init__(self, lst):
      3         self.lst = lst
----> 4     def __iter__(self): raise ValueError
      5     def next(self): return 3
      6     def __getitem__(self, idx): return self.lst.__getitem__(idx)

ValueError:

In [236]: add_3(*zz)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-236-f9bbfdc2de5c> in <module>()
----> 1 add_3(*zz)

<ipython-input-233-dc9284300db1> in __iter__(self)
      2     def __init__(self, lst):
      3         self.lst = lst
----> 4     def __iter__(self): raise ValueError
      5     def next(self): return 3
      6     def __getitem__(self, idx): return self.lst.__getitem__(idx)

ValueError:

Ale zamiast tego, jeśli upewnię się, że iteracja zatrzymuje się i zawsze zwraca 3, mogę uzyskać to, co robiłem, aby grać w pierwszym przypadku:

class FooList(object):
    def __init__(self, lst):
        self.lst = lst
        self.iter_loc = -1
    def __iter__(self): return self
    def next(self): 
        if self.iter_loc < len(self.lst)-1:
            self.iter_loc += 1
            return 3
        else:
            self.iter_loc = -1
            raise StopIteration
    def __getitem__(self, idx): return self.lst.__getitem__(idx)
    def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)

Wtedy widzę to, czego pierwotnie oczekiwałem:

In [247]: zz = FooList([1,2,3])

In [248]: ix = iter(zz)

In [249]: ix.next()
Out[249]: 3

In [250]: ix.next()
Out[250]: 3

In [251]: ix.next()
Out[251]: 3

In [252]: ix.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-252-29d4ae900c28> in <module>()
----> 1 ix.next()

<ipython-input-246-5479fdc9217b> in next(self)
     10         else:
     11             self.iter_loc = -1
---> 12             raise StopIteration
     13     def __getitem__(self, idx): return self.lst.__getitem__(idx)
     14     def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)

StopIteration:

In [253]: ix = iter(zz)

In [254]: ix.next()
Out[254]: 3

In [255]: ix.next()
Out[255]: 3

In [256]: ix.next()
Out[256]: 3

In [257]: ix.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-257-29d4ae900c28> in <module>()
----> 1 ix.next()

<ipython-input-246-5479fdc9217b> in next(self)
     10         else:
     11             self.iter_loc = -1
---> 12             raise StopIteration
     13     def __getitem__(self, idx): return self.lst.__getitem__(idx)
     14     def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)

StopIteration:

In [258]: add_3(*zz)
Out[258]: 9

In [259]: zz[0]
Out[259]: 1

In [260]: zz[1]
Out[260]: 2

In [261]: zz[2]
Out[261]: 3

In [262]: [x for x in zz]
Out[262]: [3, 3, 3]

streszczenie

Składnia*args polega tylko na iteracji. W przypadku typów wbudowanych odbywa się to w sposób, który nie jest bezpośrednio nadpisywany w klasach dziedziczących po typie wbudowanym.

Te dwa są funkcjonalnie równoważne:

foo(*[x for x in args])

foo(*args)

Nie są one równoważne nawet w przypadku skończonych struktur danych.

foo(*args)

foo(*[args[i] for i in range(len(args))])