Mac Attack

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

here are the basic rules for the customization of ==, !=, <, >, <=, and >=: For all six of the above operators, if __cmp__ is defined on the left-hand argument, it is called with the right-hand argument. A result of -1 indicates the LHS is less than the RHS. A result of 0 indicates they are equal. A result of 1 indicates the LHS is greater than the RHS

__eq__ is not used for !=

For <, __lt__ is used. For >, __gt__. For <= and >=, __le__ and __ge__ respectively

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

This article is about a Python library I created to manage binary search trees. I will go over the following: Node class Insert method Lookup method Delete method Print method Comparing 2 trees Generator returning the tree elements one by one

https://laurentluce@github.com/laurentluce/python-algorithms.git

binary search tree

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

The Dependency Injection (DI) is an essential pattern when building large systems. It forces classes to be more modular and reusable by making them depend on an interface instead of a concrete class. Simply put classes favor instances passed into the init instead of creating new instances.

*name must occur before **name.

keys = sorted(keywords.keys()) for kw in keys: print kw, ":", keywords[kw]

Note that the list of keyword argument names is created by sorting the result of the keywords dictionary’s keys() method before printing its contents; if this is not done, the order in which the arguments are printed is undefined

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*