Group items tagged

Stackless Python, or Stackless, is a Python programming language interpreter, so named because it avoids depending on the C call stack for its own stack. The most prominent feature of Stackless is microthreads, which avoid much of the overhead associated with usual operating system threads. In addition to Python features, Stackless also adds support for coroutines, communication channels and task serialization.

No need to jump through these loops, See 5.1.1 Using Lists as Stacks

idiomatic Python dictates that you (almost) never do type-checking, but instead rely on duck-typing for polymorphic behavior. There's nothing wrong with using isinstance to understand inheritance, but it should generally be avoided in "production" code

It's not an operator as such, so it doesn't really have a name, but it is defined as a "syntactic rule". So it should be called: "the keyword argument unpacking syntax"

# usually a tuple, always an iterable*

# usually a dict, always a mapping*

a if test else b

If print() is a function, it would be much easier to replace it within one module (just def print(*args):...) or even throughout a program (e.g. by putting a different function in __builtin__.print). As it is, one can do this by writing a class with a write() method and assigning that to sys.stdout -- that's not bad, but definitely a much larger conceptual leap, and it works at a different level than print.

which is just ugly. .format doesn't have those issues. Also in the second example you gave, the .format example is much cleaner looking.

Parameters are passed by value

some data types are mutable, but others aren't

If you pass a mutable object into a method, the method gets a reference to that same object and you can mutate it to your heart's delight, but if you rebind the reference in the method, the outer scope will know nothing about it, and after you're done, the outer reference will still point at the original object.

def PreOrder(self): print self.data if self.left: print self.left.PreOrder() if self.right: print self.right.PreOrder()

You don't write things like for(int i = 0; i < 10; ++i) in Python very often; instead you do things like for i in range(0, 10).

it would add opcodes to the language (implying a larger, and therefore slower, VM engine)

in the "C" world it is most effectively used (not most commonly) with pointers. There is a direct mapping to some instructions sets that support pre- or post-increment of address registers

if A: will call A.__nonzero__()

and so A is not None is faster since there is much less work to do

if A: seems to be more efficient

mixin class

Another issue with the __dict__ comparison is what if you have an attribute that you don't want to consider in your definition of equality (say for example a unique object id, or metadata like a time created stamp).

isinstance sucks

keyword arguments with default values can go a long way.

In Python, I think it's more accepted to use duck typing -- asking what an object can do, rather than what it is

it goes against the spirit of Python to worry a lot about what types are passed into methods

usually __iter__() just return self if you have already define the next() method (generator object)

While you are looking at the collections module, consider inheriting from Sequence, Mapping or another abstract base class if that is more appropriate. Here is an example for a Sequence subclass:

if hasattr(self.data[0], "__iter__": return self.data[0].__iter__() return self.data.__iter__()

I just found xrange() (suprised I hadn't seen it before...) and added it to the above example. xrange() is an iterable version of range() which has the advantage of not prebuilding the list