Mac Attack

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.

a if test else b

x << yReturns x with the bits shifted to the left by y places (and new bits on the right-hand-side are zeros). This is the same as multiplying x by 2**y.

x >> yReturns x with the bits shifted to the right by y places. This is the same as //'ing x by 2**y.

x & yDoes a "bitwise and". Each bit of the output is 1 if the corresponding bit of x AND of y is 1, otherwise it's 0.

Re: Python : map and filter vs for loops The underlying implementation of map and filter are different than loops, even though they accomplish the same thing. Which idiom runs fastest can change from version to version. Right now I think list comprehensions are the fastest. So instead of Code: filter(f, range(2,25)), the list comprehension would be Code: [x for x in range(2,25) if f(x)] and instead of Code: map(cube, range(1, 11)) the list comprehension would be Code: [cube(x) for x in range(1,11)]

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

"""''.format_map() in Python 2.x"""

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

Unicode and new style string formatting Python 2.6 and Python 3 gain a new style of string formatting, which is apparently based on the string formatting in C#. I wasn't a big fan of the string formatting in C# and so wasn't very excited about it moving into Python, but as is to be expected it has grown a bit on me.

As always, the best solution is to not mix Unicode and byte-strings but to keep all strings in Unicode and only perform the encode when actually needed.

So why does this behaviour matter? Well it particularly matters for framework authors formatting messages based on 'user' input. This is the case with unittest, which creates error messages when tests fail. The error messages internally in unittest are byte-strings and they are often mixed with user supplied messages using string formatting. We use old-style (% based) formatting, so if the user supplies byte-strings then the resulting messages will be byte-strings. If the user supplies Unicode strings then the resulting messages will be in Unicode. Because all the internal unittest messages are ascii only we can guarantee than an implicit decode to Unicode will succeed - so the user can choose the output type by varying the type of the messages they provide.

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.

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

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

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

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__()

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)