Mac Attack

Comprehensions are just a simple form of iterators. Generators are just a simple form of iterators

The first argument of every class method, including the __init__() method, is always a reference to the current instance of the class. By convention, this argument is named self.

self is not a reserved word in Python, merely a naming convention

To do element-wise operations on a list - for example, to produce a list consisting of each element of list A multiplied by 2 Method 1 [2*x for x in A] - this technique is called list comprehension Method 2 if you have defined a function double(x) which doubles x map(double, A) Method 3 define the function that doubles x on the fly, anonymously map(lambda x: 2*x, A)

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

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

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.

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*

This describes setting up a professional Python project with a real package structure, injection and tests.

Since you are intended to run .py files directly, Python projects should not have source (src) or binary (bin) folders

For the same reason, the test folder should not be separate.  It should be a package in the main project

There are two schools of thought when it comes to installing applications

each application is its own standalone "appliance", and installing and removing them should not disturb the rest of the OS. If the application needs an uncommon library, that library is included in the application's distribution

a collection of small self-contained units called packages

it is advised to somehow mix together (e.g. using exclusive or) the hash values for the components of the object that also play a part in comparison of objects.

If a class does not define a __cmp__() or __eq__() method it should not define a __hash__() operation either

Called when an attribute lookup has not found the attribute in the usual places (i.e. it is not an instance attribute nor is it found in the class tree for self). name is the attribute name. This method should return the (computed) attribute value or raise an AttributeError exception.

class foo: def __init__(self, n): self.n = n def __call__(self, i): self.n += i return self.n

function foo (n) { return function (i) { return n += i } }

common ways to use doctest: To check that a module’s docstrings are up-to-date by verifying that all interactive examples still work as documented. To perform regression testing by verifying that interactive examples from a test file or a test object work as expected. To write tutorial documentation for a package, liberally illustrated with input-output examples. Depending on whether the examples or the expository text are emphasized, this has the flavor of “literate testing” or “executable documentation”.

Running the module as a script causes the examples in the docstrings to get executed and verified

The file content is treated as if it were a single giant docstring; the file doesn’t need to contain a Python program! For example, perhaps example.txt contains this

a well defined mental model of the problem domain

Refining the architecture is part of the "refactor mercilessly" rule

If you've never inherited from a built-in data type, experiment with a small test case in a throw away script. This way you don't mangle your current project and you can be as experimental as you like.