c[:]()

[Warren Stringer]

Quotes out of context with mistaken assumptions, now follow:

> >>>> So c[:]() -- or the more recent go(c)() -- executes all those
> >>>> behaviors.
> 
> No it doesn't. See below.
> >
> > If c[:]() works, the so does this, using real world names
> >
> > 	orchestra[:].pickle()
> > 	orchestra[conductor()].sequence()
> >
> > Though, I'm already starting to prefer:
> >
> > 	do(orchestra).pickle()
> > 	do(orchestra(conductor)).sequence()
> >
> Yes, dammit, but c[:]() *DOESN'T WORK* unless you have made some pretty
> crufty changes to the underlying object.

I started this thread asking why c[:]() doesn't work. 

> This is what I'm having difficulty understanding. You said, in your
> original post (which, by the way, hijacked another thread about
> something completely different):

What?!? I started this thread. 

> > I want to call every object in a tupple, like so:
> >
> [By the way, that's "tuple", not "tupple"]
> > #------------------------------------------
> > def a: print 'a'
> > def b: print 'b'
> > c = (a,b)
> >
> >>>> >>>c[:]()  # i wanna
> >  TypeError: 'tupple' object is not callable
> >
> >>>> >>>c[0]()  # expected
> > a
> >>>> >>>c[:][0] # huh?
> > a

> This is what I just don't believe. And, of course, the use of "tupple"
> above tells us that this *wasn't" just copied and pasted from an
> interactive session.

Try it.
 
> >>>> >>> [i() for i in c] # too long and ...huh?
> > a
> > b
> > [None,None]
> > #------------------------------------------
> This is also clearly made up.

I repeat: try it.

> In a later email you say:
> 
> > why does c[:][0]() work but c[:]() does not?
> 
> The reason for this ...

Stated elsewhere, but thanks

> > Why does c[0]() has exactly the same results as c[:][0]() ?
> 
> The reason for this is that c is exactly the same as c[:]. The slicing
> notation "[:]" tells the interpreter to use a tuple consisting of
> everything in the tuple to which it's applied. Since the interpreter
> knows that tuples are immutable (can't be changed), it just uses the
> same tuple -- since the immutability there's no way that a difference
> could arise between the tuple and a copy of the tuple, Python doesn't
> bother to make a copy.
> 
> This behavior is *not* observed with lists, because lists are mutable.

But neither tupples or lists work, so immutability isn't an issue.

> I realise you are trying to find ways to make Python more productive for
> you, and there's nothing wrong with that. But consider the following,
> which IS copied and pasted:
> 
>  >>> def a():
> ...   print "A"
> ...
>  >>> def b():
> ...   print "B"
> ...
>  >>> c = (a, b)
>  >>> c
> (<function a at 0x7ff4f764>, <function b at 0x7ff4f64c>)
>  >>> c[:]
> (<function a at 0x7ff4f764>, <function b at 0x7ff4f64c>)
>  >>> c[0]()
> A
>  >>> c[1]()
> B
>  >>> c()
> Traceback (most recent call last):
>    File "<stdin>", line 1, in <module>
> TypeError: 'tuple' object is not callable
>  >>> c[:]()
> Traceback (most recent call last):
>    File "<stdin>", line 1, in <module>
> TypeError: 'tuple' object is not callable
>  >>>

I never said that c() would execute a list nor did I ever say that c[:]()
would execute a list. 

> I think the fundamental mistake you have made is to convince yourself that
> 
>      c[:]()
> 
> is legal Python. It isn't, it never has been.

In summation: 
	I started this thread asking why c[:]() wouldn't work
	I did not hijack another thread
	I posted working examples (with one typo, not quoted here)
	I am extremely annoyed by this post
	
Tis best not to assume what other people are thinking