Passing a callable object to Thread

[castironpi at gmail.com]

> >>>> a= object()
> >>>> (a,) is a
> > False
>
> (a,) is not identical with a.
>
> >>>> (a,) is (a,)
> > False
>
> The tuple on the left is not identical with the tuple on the right, even
> though they are equivalent.
>
> >>>> a is a
> > True
>
> The variable on the left is identical with the one on the right.  This
> is not the same comparison as "(a,) is (a,)", which actually contains
> the construction of two distinct objects.  The moral equivalent of "a is
> a" would be:
>
>  >>> b = (a,)
>  >>> b is b
> True
>
> An interesting thing about Python is that numbers of built-in types are
> flyweights.  Unlike literals of non-flyweight types, distinct instances
> of a given numeric literal actually refer to the same object:
>
>  >>> 5 is 5
> True
>  >>> 999999999999999999999999999999 is 999999999999999999999999999999
> True
>  >>> 3.5 is 3.5
> True
>
> I wonder, will this be true of the upcoming Fraction class?
>
> >>>> (a,) == (a,)
> > True
>
> The two tuples are equivalent (though not identical).
>
> >>>> a= []
> >>>> a.append( a )
> >>>> a
> > [[...]]
>
> That's cool.  I don't think would have known off the top of my head how
> the interactive interpreter would display something like that.  Talk
> about a cyclic reference...
>
> >>>> tuple(a) is tuple(a)
> > False
>
> The tuple on the left is not identical with the tuple on the right, even
> though they are equivalent.  This is the sample as one of your earlier
> examples, just with slightly different syntax.
>
> > hasVanilla= True
> > hasStrawberry= True
> > hasChocolate= True
> > if hasVanilla:
> >   print "Vanilla"
> > if hasVanilla and not hasChocolate:
> >   print "and"
> > if hasStrawberry:
> >   print "Strawberry"
> > if hasVanilla or hasStrawberry and hasChocolate:
> >   print "and"
> > if hasChocolate:
> >   print "Chocolate."
>
> You've tried to implement a set using a set of flags to indicate whether
> various items have membership in that set.  See how an object
> representing a given flavor would have to be distinct from the object
> (boolean flag) indicating its set membership?  Btw, your formatting
> could use some work. :)  Some flavor combinations cause extra "ands" to
> be printed. Here's a little test harness, with PEP-friendly variable
> names, and showing how your booleans corresponding directly with
> traditional bit-bucket flag sets:
>
> def print_flavors(flags):
>
>      print flags
>
>      vanilla = flags & 1
>      strawberry = flags & 2
>      chocolate = flags & 4
>
>      if vanilla:
>          print "Vanilla"
>      if vanilla and not chocolate:
>          print "and"
>      if strawberry:
>          print "Strawberry"
>      if vanilla or strawberry and chocolate:
>          print "and"
>      if chocolate:
>          print "Chocolate."
>
> if __name__ == '__main__':
>      for flavor_flags in range(8):
>          print_flavors(flavor_flags)- Hide quoted text -
>
> - Show quoted text -

while True:
   "No, it's the element."
   "No, it's a tuple with one element."