enriching return values / symetric call&return in P3K ? - Re: Tuple assignment and generators?

Tim Chase wrote:
Just as a pedantic exercise to try and understand Python a bit better, I decided to try to make a generator or class that would allow me to unpack an arbitrary number of calculatible values. In this case, just zeros (though I just to prove whatever ends up working, having a counting generator would be nice). The target syntax would be something like

>>> a,b,c = zeros()
>>> q,r,s,t,u,v = zeros()

where "zeros()" returns an appropriately sized tuple/list of zeros.

I've tried a bit of googling, but all my attempts have just ended up pointing to pages that blithly describe tuple assignment, not the details of what methods are called on an object in the process.

My first thought was to get it to use a generator:

def zeros():
while 1: yield 0

However, I get back a "ValueError: too many values to unpack" result.

As a second attempt, I tried a couple of attempts at classes (I started with the following example class, only derived from "object" rather than "list", but it didn't have any better luck):

>>> class zeros(list):
... def __getitem__(self,i):
... return 0
>>> z = zeros()
>>> a,b,c = z
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: need more than 0 values to unpack

It looks like I need to have a pre-defined length, but I'm having trouble figuring out what sorts of things need to be overridden. It seems like I sorta need a

def __len__(self):

so it doesn't choke on it. However, how to dupe the interpreter into really believing that the object has the desired elements is escaping me. Alternatively if there was a "doYouHaveThisManyElements" pseudo-function that was called, I could lie and always return true.

Any hints on what I'm missing?

Think the use case, you present, is (pythonically) ill as such. if you want to fill literal variable's do it like: a=b=c=...=0. Otherwise you'd handle variable lists zeros(7)

Yet there is a real freqent need for adding transparent extra/decorating return values in cases, where you don't want to break the simple return scheme (in maybe big existing code). For such use cases check out this "RICHVALUE" approach with _named_ extra values - no puzzles about non-matching tuple assignments:

http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496676 :

def f():
return RICHVALUE(7, extra='hello')

print ret, ret+1, ret.extra

As I have this need very very often I'd like to see an even more natural builtin method for enriching return values (both positional and by name) in Python3000 - maybe by making calling and returning almost symetric!
Yet, this ideas maybe strange ? ...

def f_P3K(*args,**kwargs):
xreturn((7,8), 3, extra=5, *args, **kwargs) # first is main

v = f_P3K() # (7,8)
v,x = f_P3K() # (7,8),3
v,x,*pret,**kwret= f_P3K()