Passing a callable object to Thread

[castironpi at gmail.com]

On Feb 18, 5:23 pm, Jeff Schwab <j... at schwabcenter.com> wrote:
> castiro... at gmail.com wrote:
> > On Feb 18, 4:26 pm, Jeff Schwab <j... at schwabcenter.com> wrote:
> >> Lie wrote:
> >>> On Feb 16, 12:29 pm, Jeff Schwab <j... at schwabcenter.com> wrote:
> >>>> Paul Rubin wrote:
> >>>>> Jeff Schwab <j... at schwabcenter.com> writes:
> >>>>>> Why not?  They seem intuitive to me.  I would find it weird if you
> >>>>>> couldn't have 0-tuple, and even weirder if you couldn't have a
> >>>>>> 1-tuple.   Maybe my brain has been warped by too much C++ code.
> >>>>> The idea is that a 2-tuple (of numbers, say) is a pair of numbers, a
> >>>>> 3-tuple is three numbers, and a 1-tuple is one number.  That would
> >>>>> mean a number and a 1-tuple of numbers are the same thing, not
> >>>>> separate types.
> >>>> No, that doesn't follow.  A set with one element is not the same thing
> >>>> as that element, a sequence of one element is not the same thing as that
> >>>> element, and a tuple with one element is not the same thing as that element.
> >>> Probably the analogue of tuples in human language would be like this:
> >>> A: What ice-cream flavour do you have?
> >>> B: "Vanilla", "Chocolate", and "Strawberry"
> >>> If, for example, he only have Vanilla:
> >>> A: What ice-cream flavour do you have?
> >>> B: "Vanilla"
> >>> This way of thinking makes 1-tuple the same as the element itself.
> >> Yes.  I first heard the term "tuple" in a physics class, where it was
> >> used to mean that a mathematical function took an arbitrary number of
> >> objects.  It was by analog with "triple, quadruple, quintuple...
> >> n-tuple."  That's a different context than computer science, though,
> >> which is a specific branch of mathematics with its own terminology.  In
> >> CS, a tuple is a kind of data structure that is specifically not
> >> identical with any of its elements.  That's the sort of tuple used in
> >> Python.- Hide quoted text -
>
> >>>> 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 -

a= set( 'Vanilla', 'Chocolate', 'Strawberry' )
flavors= [ Flavors( i ) for i in a ]
b= list( a )
if len( b )> 1:
   b[-1]= "and "+ b[-1]
return ", ".join( b )

string.join() works on sets, but the 'and', appears only before the
last element if there is more than one.

Why not "if b> 1", since len( integer ) always fails?

Could also use

b= ", ".join( a )
try:
   return b[ :b.rfind( ',' ) ]+ ' and'+ b[ b.rfind( ',' ): ]
except IndexError:
   return b

But -NOT-:

flavors= set( Flavors( 'Vanilla' ), Flavors( 'Chocolate' ),
Flavors( 'Strawberry' ) )
...

since set( Flavors( 'Vanilla' ), Flavors( 'Vanilla' ) ) has size two.

However:

flavors= set( Flavors.Get( 'Vanilla' ), Flavors.Get( 'Chocolate' ),
Flavors.Get( 'Strawberry' ) )

is a possibility:

class Flavors:
   @classmethod
   def Get( cls, flavor ):
      return cls.flavors.setdefault( flavor, cls( flavor ) )
   def __init__( self, flavor ):
      self.flavor= flavor
   flavors= {}

, since __init__ cannot return other objects, but classmethods can,
just like C++.

Fm. Pres. G.H.W. Bush endorses Sen. McCain.  Who is Bush "41"?