0% found this document useful (0 votes)

329 views

Guide For Python

This document provides guidance on setting up a Python development environment on Mac OS X. It recommends installing a newer version of Python using Homebrew rather than using the default version, and also installing Distribute and Pip for managing Python packages.

Uploaded by

dude_a_b_c

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

329 views

Guide For Python

Uploaded by

dude_a_b_c

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 78

Python Guide Documentation

Release 0.0.1

Kenneth Reitz

March 30, 2013

CONTENTS

Getting Started 1.1 Picking an Interpreter . . . . . 1.2 Installing Python on Mac OS X 1.3 Installing Python on Windows . 1.4 Installing Python on Linux . . . Writing Great Code 2.1 Structuring Your Project 2.2 Code Style . . . . . . . 2.3 Reading Great Code . . 2.4 Documentation . . . . . 2.5 Testing Your Code . . . 2.6 Common Gotchas . . . 2.7 Choosing a License . . .

. . . .

3 3 5 6 7 9 9 15 23 24 26 30 33 35 35 36 39 39 41 41 42 44 46 47 49 50 51 51 52 55 55 60 63 63 64 i

. . . . . . .

Scenario Guide 3.1 Network Applications . . . . 3.2 Web Applications . . . . . . 3.3 Command Line Applications . 3.4 GUI Applications . . . . . . . 3.5 Databases . . . . . . . . . . . 3.6 Networking . . . . . . . . . . 3.7 Systems Administration . . . 3.8 Continuous Integration . . . . 3.9 Speed . . . . . . . . . . . . . 3.10 Scientic Applications . . . . 3.11 Image Manipulation . . . . . 3.12 XML parsing . . . . . . . . .

. . . . . . . . . . . .

Shipping Great Code 4.1 Packaging Your Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Freezing Your Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Development Environment 5.1 Your Development Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Virtual Environments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Additional Notes 6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 The Community . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.3 6.4 6.5 6.6 6.7 6.8

Learning Python . . . Documentation . . . . News . . . . . . . . . Contribute . . . . . . License . . . . . . . . The Guide Style Guide

. . . . . .

65 67 68 68 71 72

Python Guide Documentation, Release 0.0.1

Welcome to The Hitchhikers Guide to Python. This guide is currently under heavy active development. If youd like to help, fork us on GitHub! This opinionated guide exists to provide both novice and expert Python developers a best-practice handbook to the installation, conguration, and usage of Python on a daily basis.

CONTENTS

Python Guide Documentation, Release 0.0.1

CONTENTS

CHAPTER

ONE

GETTING STARTED
This part of the guide focuses on setting up your Python environment.

1.1 Picking an Interpreter

Which Python to use?

1.1.1 2.x vs 3.x

tl;dr: Python 2.x is the status quo, Python 3.x is the shiny new thing. Further Reading Today If youre choosing a Python interpreter to use, I highly recommend you use Python 2.7.x, unless you have a strong reason not to. The Future As more and more modules get ported over to Python3, the easier it will be for others to use it.

1.1.2 Which Python to Support?

If youre starting work on a new Python module, I recommend you write it for Python 2.5 or 2.6, and add support for Python3 in a later iteration.

1.1.3 Implementations
There are several popular implementations of the Python programming language on different back-ends.

Python Guide Documentation, Release 0.0.1

CPython CPython is the reference implementation of Python, written in C. It compiles Python code to intermediate bytecode which is then interpreted by a virtual machine. When people speak of Python they often mean not just the language but also this implementation. It provides the highest level of compatibility with Python packages and C extension modules. If you are writing open-source Python code and want to reach the widest possible audience, targeting CPython is your best bet. If you need to use any packages that rely on C extensions for their functionality (eg: numpy) then CPython is your only choice. Being the reference implementation, all versions of the Python language are available as CPython. Python 3 is only available in a CPython implementation. PyPy PyPy is a Python interpreter implemented in a restricted statically-typed subset of the Python language called RPython. The interpreter features a just-in-time compiler and supports multiple back-ends (C, CLI, JVM). PyPy aims for maximum compatibility with the reference CPython implementation while improving performance. If you are looking to squeeze more performance out of your Python code, its worth giving PyPy a try. On a suite of benchmarks, its currently over 5 times faster than CPython. Currently PyPy supports Python 2.7. Jython Jython is a Python implementation that compiles Python code to Java byte code that then executes on a JVM. It has the additional advantage of being able to import and use any Java class the same as a Python module. If you need to interface with an existing Java codebase or have other reasons to need to write Python code for the JVM, Jython is the best choice. Currently Jython supports up to Python 2.5. IronPython IronPython is an implementation of Python for the .NET framework. It can use both Python and .NET framework libraries, and can also expose Python code to other .NET languages. Python Tools for Visual Studio integrates IronPython directly in to the Visual Studio development environment, making it an ideal choice for Windows developers. IronPython supports Python 2.7. Properly Install Python
1 2 3

http://pypy.org/compat.html http://wiki.python.org/jython/JythonFaq/GeneralInfo#Is_Jython_the_same_language_as_Python.3F http://ironpython.codeplex.com/releases/view/81726

Chapter 1. Getting Started

Python Guide Documentation, Release 0.0.1

1.2 Installing Python on Mac OS X

The latest version of Mac OS X, Lion, comes with Python 2.7 out of the box. You do not need to install or congure anything else to use Python. Having said that, I would strongly recommend that you install the tools and libraries described in the next section before you start building Python applications for real-world use. In particular, you should always install Distribute, as it makes it much easier for you to use other third-party Python libraries. The version of Python that ships with OS X is great for learning, but its not good for development. Its slightly out of date, and Apple has made signicant changes that can cause hidden 1.2.1 bugs. Doing it Right Lets install a real version of Python. First, youll need to have GCC installed to compile Python. You can either get this from XCode or the smaller OSX-GCC-Installer package. While Lion comes with a large number of UNIX utilities, those familiar with Linux systems will notice one key component missing: a decent package manager. Homebrew lls this void. To install Homebrew, simply run
$ ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)"

Then, insert the Homebrew directory at the top of your PATH environment variable. You can do this by adding the following line at the bottom of your ~/.bashrc le
export PATH=/usr/local/bin:$PATH

Now, we can install Python 2.7:

$ brew install python --framework

This will take a minute or two. Once thats complete, youll have to add the new Python scripts directory to your PATH
export PATH=/usr/local/share/python:$PATH

The --framework option tells Homebrew to compile a Framework-style Python build, rather than a UNIX-style build. The outdated version of Python that Snow Leopard comes packaged with is built as a Framework, so this helps avoid some future module installation bugs.

1.2.2 Distribute & Pip

The most crucial third-party Python software of all is Distribute, which extends the packaging and installation facilities provided by the distutils in the standard library. Once you add Distribute to your Python system you can download and install any compliant Python software product with a single command. It also enables you to add this network installation capability to your own Python software with very little work. Homebrew already installed Distribute for you. Its easy_install command is considered by many to be deprecated, so we will install its replacement: pip. Pip allows for uninstallation of packages, and is actively maintained, unlike easy_install. To install pip, simply open a command prompt and run
$ easy_install pip

1.2.3 Virtualenv
After Distribute & Pip, the next development tool that you should install is virtualenv. Use pip

1.2. Installing Python on Mac OS X

Python Guide Documentation, Release 0.0.1

$ pip install virtualenv

The virtualenv kit provides the ability to create virtual Python environments that do not interfere with either each other, or the main Python installation. If you install virtualenv before you begin coding then you can get into the habit of using it to create completely clean Python environments for each project. This is particularly important for Web development, where each framework and application will have many dependencies. To set up a new Python environment, change the working directory to where ever you want to store the environment, and run the virtualenv utility in your projects directory
$ virtualenv --distribute venv

To use an environment, run source venv/bin/activate. Your command prompt will change to show the active environment. Once you have nished working in the current virtual environment, run deactivate to restore your settings to normal. Each new environment automatically includes a copy of pip, so that you can setup the third-party libraries and tools that you want to use in that environment. Put your own code within a subdirectory of the environment, however you wish. When you no longer need a particular environment, simply copy your code out of it, and then delete the main directory for the environment.

This page is a remixed version of another guide, which is available under the same license.

1.3 Installing Python on Windows

First, download the latest version of Python 2.7 from the ofcial Website. If you want to be sure you are installing a fully up-to-date version then use the Windows Installer link from the home page of the Python.org web site . The Windows version is provided as an MSI package. To install it manually, just double-click the le. The MSI package format allows Windows administrators to automate installation with their standard tools. By design, Python installs to a directory with the version number embedded, e.g. Python version 2.7 will install at C:\Python27\, so that you can have multiple versions of Python on the same system without conicts. Of course, only one interpreter can be the default application for Python le types. It also does not automatically modify the PATH environment variable, so that you always have control over which copy of Python is run. Typing the full path name for a Python interpreter each time quickly gets tedious, so add the directories for your default Python version to the PATH. Assuming that your Python installation is in C:\Python27\, add this to your PATH:
C:\Python27\;C:\Python27\Scripts\

You can do this easily by running the following in powershell:

[Environment]::SetEnvironmentVariable("Path", "$env:Path;C:\Python27\;C:\Python27\Scripts\", "Us

The second (Scripts) directory receives command les when certain packages are installed, so it is a very useful addition. You do not need to install or congure anything else to use Python. Having said that, I would strongly recommend that you install the tools and libraries described in the next section before you start building Python applications for real-world use. In particular, you should always install Distribute, as it makes it much easier for you to use other third-party Python libraries.

Chapter 1. Getting Started

Python Guide Documentation, Release 0.0.1

1.3.1 Distribute + Pip

The most crucial third-party Python software of all is Distribute, which extends the packaging and installation facilities provided by the distutils in the standard library. Once you add Distribute to your Python system you can download and install any compliant Python software product with a single command. It also enables you to add this network installation capability to your own Python software with very little work. To obtain the latest version of Distribute for Windows, run the python script available here: pythondistribute Youll now have a new command available to you: easy_install. It is considered by many to be deprecated, so we will install its replacement: pip. Pip allows for uninstallation of packages, and is actively maintained, unlike easy_install. To install pip, simply open a command prompt and run
> easy_install pip

1.3.2 Virtualenv
After Distribute & Pip, the next development tool that you should install is virtualenv. Use pip
> pip install virtualenv

To use an environment, run the activate.bat batch le in the Scripts subdirectory of that environment. Your command prompt will change to show the active environment. Once you have nished working in the current virtual environment, run the deactivate.bat batch le to restore your settings to normal. Each new environment automatically includes a copy of pip in the Scripts subdirectory, so that you can setup the third-party libraries and tools that you want to use in that environment. Put your own code within a subdirectory of the environment, however you wish. When you no longer need a particular environment, simply copy your code out of it, and then delete the main directory for the environment.

This page is a remixed version of another guide, which is available under the same license.

1.4 Installing Python on Linux

The latest versions of Ubuntu and Fedora come with Python 2.7 out of the box. The latest versions of Redhat Enterprise (RHEL) and CentOS come with Python 2.6. Some older versions of RHEL and CentOS come with Python 2.4 which is unacceptable for modern Python development. Fortunately, there are Extra Packages for Enterprise Linux which include high quality additional packages 1.4. Installing Python on Linux 7

Python Guide Documentation, Release 0.0.1

based on their Fedora counterparts. This repository contains a Python 2.6 package specically designed to install side-by-side with the systems Python 2.4 installation. You do not need to install or congure anything else to use Python. Having said that, I would strongly recommend that you install the tools and libraries described in the next section before you start building Python applications for real-world use. In particular, you should always install Distribute, as it makes it much easier for you to use other third-party Python libraries.

1.4.1 Distribute & Pip

The most crucial third-party Python software of all is Distribute, which extends the packaging and installation facilities provided by the distutils in the standard library. Once you add Distribute to your Python system you can download and install any compliant Python software product with a single command. It also enables you to add this network installation capability to your own Python software with very little work. To obtain the latest version of Distribute for Linux, run the python script available here: python-distribute The neweasy_install command you have available is considered by many to be deprecated, so we will install its replacement: pip. Pip allows for uninstallation of packages, and is actively maintained, unlike easy_install. To install pip, simply open a command prompt and run
$ easy_install pip

1.4.2 Virtualenv
After Distribute & Pip, the next development tool that you should install is virtualenv. Use pip
$ pip install virtualenv

This page is a remixed version of another guide, which is available under the same license.

Chapter 1. Getting Started

CHAPTER

TWO

WRITING GREAT CODE

This part of the guide focuses on best practices for writing Python code.

2.1 Structuring Your Project

By structure we mean the decisions you make concerning how your project best meets its objective. We need to consider how to best leverage Pythons features to create clean, effective code. In practical terms, structure means making clean code whose logic and dependencies are clear as well as how the les and folders are organized in the lesystem. Which functions should go into which modules? How does data ow through the project? What features and functions can be grouped together and isolated? By answering questions like these you can begin to plan, in a broad sense, what your nished product will look like. In this section we take a closer look at Pythons module and import systems as they are the central element to enforcing structure in your project. We then discuss various perspectives on how to build code which can be extended and tested reliably.

2.1.1 Structure is Key

Thanks to the way imports and modules are handled in Python, it is relatively easy to structure a Python project. Easy, here, means that you do not have many constraints and that the module importing model is easy to grasp. Therefore, you are left with the pure architectural task of crafting the different parts of your project and their interactions. Easy structuring of a project means it is also easy to do it poorly. Some signs of a poorly structured project include: Multiple and messy circular dependencies: if your classes Table and Chair in furn.py need to import Carpenter from workers.py to answer a question such as table.isdoneby(), and if conversely the class Carpenter needs to import Table and Chair, to answer the question carpenter.whatdo(), then you have a circular dependency. In this case you will have to resort to fragile hacks such as using import statements inside methods or functions. Hidden coupling: each and every change in Tables implementation breaks 20 tests in unrelated test cases because it breaks Carpenters code, which requires very careful surgery to adapt the change. This means you have too many assumptions about Table in Carpenters code or the reverse. Heavy usage of global state or context: instead of explicitly passing (height, width, type, wood) to each other, Table and Carpenter rely on global variables that can be modied and are modied on the y by different agents. You need to scrutinize all access to these global variables to understand why a rectangular table became a square, and discover that remote template code is also modifying this context, messing with table dimensions.

Python Guide Documentation, Release 0.0.1

Spaghetti code: multiple pages of nested if clauses and for loops with a lot of copy-pasted procedural code and no proper segmentation are known as spaghetti code. Pythons meaningful indentation (one of its most controversial features) make it very hard to maintain this kind of code. So the good news is that you might not see too much of it. Ravioli code is more likely in Python: it consists of hundreds of similar little pieces of logic, often classes or objects, without proper structure. If you never can remember if you have to use FurnitureTable, AssetTable or Table, or even TableNew for your task at hand, you might be swimming in ravioli code.

2.1.2 Modules
Python modules are one of the main abstraction layers available and probably the most natural one. Abstraction layers allow separating code into parts holding related data and functionality. For example, a layer of a project can handle interfacing with user actions, while another would handle low-level manipulation of data. The most natural way to separate these two layers is to regroup all interfacing functionality in one le, and all low-level operations in another le. In this case, the interface le needs to import the low-level le. This is done with the import and from ... import statements. As soon as you use import statements you use modules. These can be either built-in modules such as os and sys, third-party modules you have installed in your environment, or your projects internal modules. To keep in line with the style guide, keep module names short, lowercase, and be sure to avoid using special symbols like the dot (.) or question mark (?). So a le name like my.spam.py is one you should avoid! Naming this way will interfere with the way python looks for modules. In this example python expects to nd a spam.py le in a folder named my which is not the case. There is an example of how the dot notation should be used in the python docs. If youd like you could name it as my_spam.py but even our friend the underscore should not be seen often in module names. Aside for some naming restrictions, nothing special is required for a Python le to be a module, but the import mechanism needs to be understood in order to use this concept properly and avoid some issues. Concretely, the import modu statement will look for the proper le, which is modu.py in the same directory as the caller if it exists. If it is not found, the Python interpreter will search for modu.py in the path recursively and raise an ImportError exception if it is not found. Once modu.py is found, the Python interpreter will execute the module in an isolated scope. Any top-level statement in modu.py will be executed, including other imports if any. Function and class denitions are stored in the modules dictionary. Then, the modules variables, functions, and classes will be available to the caller through the modules namespace, a central concept in programming that is particularly helpful and powerful in Python. In many languages, an include le directive is used by the preprocessor to take all code found in the le and copy it into the callers code. It is different in Python: the included code is isolated in a module namespace, which means that you generally dont have to worry that the included code could have unwanted effects, e.g. override an existing function with the same name. It is possible to simulate the more standard behavior by using a special syntax of the import statement: from modu import *. This is generally considered bad practice. Using import * makes code harder to read and makes dependencies less compartmentalized. Using from modu import func is a way to pinpoint the function you want to import and put it in the global namespace. While much less harmful than import * because it shows explicitly what is imported in the global namespace, its advantage over a simpler import modu is only that it will save some typing. Very bad

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

[...] from modu import * [...] x = sqrt(4) # Is sqrt part of modu? A builtin? Defined above?

Better
from modu import sqrt [...] x = sqrt(4) # sqrt may be part of modu, if not redefined in between

Best
import modu [...] x = modu.sqrt(4)

# sqrt is visibly part of modus namespace

As said in the section about style, readability is one of the main features of Python. Readability means to avoid useless boilerplate text and clutter, therefore some efforts are spent trying to achieve a certain level of brevity. But terseness and obscurity are the limits where brevity should stop. Being able to tell immediately where a class or function comes from, as in the modu.func idiom, greatly improves code readability and understandability in all but the simplest single le projects.

2.1.3 Packages
Python provides a very straightforward packaging system, which is simply an extension of the module mechanism to a directory. Any directory with an __init__.py le is considered a Python package. The different modules in the package are imported in a similar manner as plain modules, but with a special behavior for the __init__.py le, which is used to gather all package-wide denitions. A le modu.py in the directory pack/ is imported with the statement import pack.modu. This statement will look for an __init__.py le in pack, execute all of its top-level statements. Then it will look for a le pack/modu.py and execute all of its top-level statements. After these operations, any variable, function, or class dened in modu.py is available in the pack.modu namespace. A commonly seen issue is to add too much code to __init__.py les. When the project complexity grows, there may be sub-packages and sub-sub-packages in a deep directory structure, and then, importing a single item from a sub-sub-package will require executing all __init__.py les met while traversing the tree. Leaving an __init__.py le empty is considered normal and even a good practice, if the packages modules and subpackages do not need to share any code. Lastly, a convenient syntax is available for importing deeply nested packages: import very.deep.module as mod. This allows you to use mod in place of the verbose repetition of very.deep.module.

2.1.4 Object-oriented programming

Python is sometimes described as an object-oriented programming language. This can be somewhat misleading and needs to be claried. In Python, everything is an object, and can be handled as such. This is what is meant when we say that, for example, functions are rst-class objects. Functions, classes, strings, and even types are objects in Python: like any objects, they have a type, they can be passed as function arguments, they may have methods and properties. In this understanding, Python is an object-oriented language.

2.1. Structuring Your Project

Python Guide Documentation, Release 0.0.1

However, unlike Java, Python does not impose object-oriented programming as the main programming paradigm. It is perfectly viable for a Python project to not be object-oriented, i.e. to use no or very few class denitions, class inheritance, or any other mechanisms that are specic to object-oriented programming. Moreover, as seen in the modules section, the way Python handles modules and namespaces gives the developer a natural way to ensure the encapsulation and separation of abstraction layers, both being the most common reasons to use object-orientation. Therefore, Python programmers have more latitude to not use object-orientation, when it is not required by the business model. There are some reasons to avoid unnecessary object-orientation. Dening custom classes is useful when we want to glue together some state and some functionality. The problem, as pointed out by the discussions about functional programming, comes from the state part of the equation. In some architectures, typically web applications, multiple instances of Python processes are spawned to respond to external requests that can happen at the same time. In this case, holding some state into instantiated objects, which means keeping some static information about the world, is prone to concurrency problems or race-conditions. Sometimes, between the initialization of the state of an object (usually done with the __init__() method) and the actual use of the object state through one of its methods, the world may have changed, and the retained state may be outdated. For example, a request may load an item in memory and mark it as read by a user. If another request requires the deletion of this item at the same, it may happen that the deletion actually occurs after the rst process loaded the item, and then we have to mark as read a deleted object. This and other issues led to the idea that using stateless functions is a better programming paradigm. Another way to say the same thing is to suggest using functions and procedures with as few implicit contexts and sideeffects as possible. A functions implicit context is made up of any of the global variables or items in the persistence layer that are accessed from within the function. Side-effects are the changes that a function makes to its implicit context. If a function saves or deletes data in a global variable or in the persistence layer, it is said to have a side-effect. Carefully isolating functions with context and side-effects from functions with logic (called pure functions) allow the following benets: Pure functions are deterministic: given a xed input, the output will always be the same. Pure functions are much easier to change or replace if they need to be refactored or optimized. Pure functions are easier to test with unit-tests: There is less need for complex context setup and data cleaning afterwards. Pure functions are easier to manipulate, decorate, and pass-around. In summary, pure functions, without any context or side-effects, are more efcient building blocks than classes and objects for some architectures. Obviously, object-orientation is useful and even necessary in many cases, for example when developing graphical desktop applications or games, where the things that are manipulated (windows, buttons, avatars, vehicles) have a relatively long life of their own in the computers memory.

2.1.5 Decorators
The Python language provides a simple yet powerful syntax called decorators. A decorator is a function or a class that wraps (or decorates) a function or a method. The decorated function or method will replace the original undecorated function or method. Because functions are rst-class objects in Python, it can be done manually, but using the @decorator syntax is clearer and thus preferred.
def foo(): # do something def decorator(func): # manipulate func

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

return func foo = decorator(foo) @decorator def bar(): # Do something # bar() is decorated # Manually decorate

This mechanism is useful for separating concerns and avoiding external un-related logic polluting the core logic of the function or method. A good example of a piece of functionality that is better handled with decoration is memoization or caching: you want to store the results of an expensive function in a table and use them directly instead of recomputing them when they have already been computed. This is clearly not part of the function logic.

2.1.6 Dynamic typing

Python is said to be dynamically typed, which means that variables do not have a xed type. In fact, in Python, variables are very different from what they are in many other languages, specically strongly-typed languages. Variables are not a segment of the computers memory where some value is written, they are tags or names pointing to objects. It is therefore possible for the variable a to be set to the value 1, then to the value a string, then to a function. The dynamic typing of Python is often considered to be a weakness, and indeed it can lead to complexities and hardto-debug code. Something named a can be set to many different things, and the developer or the maintainer needs to track this name in the code to make sure it has not been set to a completely unrelated object. Some guidelines help to avoid this issue: Avoid using the same variable name for different things. Bad
a = 1 a = a string def a(): pass # Do something

Good
count = 1 msg = a string def func(): pass # Do something

Using short functions or methods helps reduce the risk of using the same name for two unrelated things. It is better to use different names even for things that are related, when they have a different type: Bad
items = a b c d # This is a string... items = items.split( ) # ...becoming a list items = set(items) # ...and then a set

There is no efciency gain when reusing names: the assignments will have to create new objects anyway. However, when the complexity grows and each assignment is separated by other lines of code, including if branches and loops, it becomes harder to ascertain what a given variables type is. Some coding practices, like functional programming, recommend never reassigning a variable. In Java this is done with the nal keyword. Python does not have a nal keyword and it would be against its philosophy anyway. However, 2.1. Structuring Your Project 13

Python Guide Documentation, Release 0.0.1

it may be a good discipline to avoid assigning to a variable more than once, and it helps in grasping the concept of mutable and immutable types.

2.1.7 Mutable and immutable types

Python has two kinds of built-in or user-dened types. Mutable types are those that allow in-place modication of the content. Typical mutables are lists and dictionaries: All lists have mutating methods, like append() or pop(), and can be modied in place. The same goes for dictionaries. Immutable types provide no method for changing their content. For instance, the variable x set to the integer 6 has no increment method. If you want to compute x + 1, you have to create another integer and give it a name.
my_list = [1, 2, 3] my_list[0] = 4 print my_list # [4, 2, 3] <- The same list as changed x = 6 x = x + 1

# The new x is another object

One consequence of this difference in behavior is that mutable types are not stable, and therefore cannot be used as dictionary keys. Using properly mutable types for things that are mutable in nature and immutable types for things that are xed in nature helps to clarify the intent of the code. For example, the immutable equivalent of a list is the tuple, created with (1, 2). This tuple is a pair that cannot be changed in-place, and can be used as a key for a dictionary. One peculiarity of Python that can surprise beginners is that strings are immutable. This means that when constructing a string from its parts, it is much more efcient to accumulate the parts in a list, which is mutable, and then glue (join) the parts together when the full string is needed. One thing to notice, however, is that list comprehensions are better and faster than constructing a list in a loop with calls to append(). Bad
# create a concatenated string from 0 to 19 (e.g. "012..1819") nums = "" for n in range(20): nums += str(n) # slow and inefficient print nums

Good
# create a concatenated string from 0 to 19 (e.g. "012..1819") nums = [] for n in range(20): nums.append(str(n)) print "".join(nums) # much more efficient

Best
# create a concatenated string from 0 to 19 (e.g. "012..1819") nums = [str(n) for n in range(20)] print "".join(nums)

One nal thing to mention about strings is that using join() is not always best. In the instances where you are creating a new string from a pre-determined number of strings, using the addition operator is actually faster, but in cases like above or in cases where you are adding to an existing string, using join() should be your preferred method.

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

foo = foo bar = bar foobar = foo + bar # This is good foo += ooo # This is bad, instead you should do: foo = .join([foo, ooo])

2.1.8 Vendorizing Dependencies 2.1.9 Runners 2.1.10 Further Reading

http://docs.python.org/2/library/ http://www.diveintopython.net/toc/index.html

2.2 Code Style

If you ask Python programmers what they like most in Python, they will often say its high readability. Indeed, a high level of readability is at the heart of the design of the Python language, following the recognised fact that code is read much more often than it is written. One reason for Python code to be easily read and understood is its relatively complete set of Code Style guidelines and Pythonic idioms. Moreover, when a veteran Python developer (a Pythonista) points to portions of code and says they are not Pythonic, it usually means that these lines of code do not follow the common guidelines and fail to express the intent in what is considered the best (hear: most readable) way. On some border cases, no best way has been agreed upon on how to express an intent in Python code, but these cases are rare.

2.2.1 General concepts

Explicit code While any kind of black magic is possible with Python, the most explicit and straightforward manner is preferred. Bad
def make_complex(*args): x, y = args return dict(**locals())

Good
def make_complex(x, y): return {x: x, y: y}

In the good code above, x and y are explicitly received from the caller, and an explicit dictionary is returned. The developer using this function knows exactly what to do by reading the rst and last lines, which is not the case with the bad example.

2.2. Code Style

Python Guide Documentation, Release 0.0.1

One statement per line While some compound statements such as list comprehensions are allowed and appreciated for their brevity and their expressiveness, it is bad practice to have two disjoint statements on the same line. Bad
print one; print two if x == 1: print one if <complex comparison> and <other complex comparison>: # do something

Good
print one print two if x == 1: print one cond1 = <complex comparison> cond2 = <other complex comparison> if cond1 and cond2: # do something

Function arguments Arguments can be passed to functions in four different ways. Positional arguments are mandatory and have no default values. They are the simplest form of arguments and they can be used for the few function arguments that are fully part of the functions meaning and their order is natural. For instance, in send(message, recipient) or point(x, y) the user of the function has no difculty remembering that those two functions require two arguments, and in which order. In those two cases, it is possible to use argument names when calling the functions and, doing so, it is possible to switch the order of arguments, calling for instance send(recipient=World, message=Hello) and point(y=2, x=1) but this reduces readability and is unnecessarily verbose, compared to the more straightforward calls to send(Hello, World) and point(1, 2). Keyword arguments are not mandatory and have default values. They are often used for optional parameters sent to the function. When a function has more than two or three positional parameters, its signature will be more difcult to remember and using keyword argument with default values is helpful. For instance, a more complete send function could be dened as send(message, to, cc=None, bcc=None). Here cc and bcc are optional, and evaluate to None when they are not passed another value. Calling a function with keyword arguments can be done in multiple ways in Python, for example it is possible to follow the order of arguments in the denition without explicitly naming the arguments, like in send(Hello, World, Cthulhu, God), sending a blind carbon copy to God. It would also be possible to name arguments in another order, like in send(Hello again, World, bcc=God, cc=Cthulhu). Those two possibilities are better avoided without any strong reason to not follow the syntax that is the closest to the function denition: send(Hello, World, cc=Cthulhu, bcc=God). As a side note, following YAGNI principle, it is often harder to remove an optional argument (and its logic inside the function) that was added just in case and is seemingly never used, than to add a new optional argument and its logic when needed.

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

The arbitrary argument list is the third way to pass arguments to a function. If the function intention is better expressed by a signature with an extensible number of positional arguments, it can be dened with the *args constructs. In the function body, args will be a tuple of all the remaining positional arguments. For example, send(message, *args) can be called with each recipient as an argument: send(Hello, God, Mom, Cthulhu), and in the function body args will be equal to (God, Mom, Cthulhu). However, this construct has some drawbacks and should be used with caution. If a function receives a list of arguments of the same nature, it is often more clear to dene it as a function of one argument, that argument being a list or any sequence. Here, if send has multiple recipients, it is better to dene it explicitly: send(message, recipients) and call it with send(Hello, [God, Mom, Cthulhu]). This way, the user of the function can manipulate the recipient list as a list beforehand, and it opens the possibility to pass any sequence, including iterators, that cannot be unpacked as other sequences. The arbitrary keyword argument dictionary is the last way to pass arguments to functions. If the function requires an undetermined series of named arguments, it is possible to use the **kwargs construct. In the function body, kwargs will be a dictionary of all the passed named arguments that have not been caught by other keyword arguments in the function signature. The same caution as in the case of arbitrary argument list is necessary, for similar reasons: these powerful techniques are to be used when there is a proven necessity to use them, and they should not be used if the simpler and clearer construct is sufcient to express the functions intention. It is up to the programmer writing the function to determine which arguments are positional arguments and which are optional keyword arguments, and to decide whether to use the advanced techniques of arbitrary argument passing. If the advice above is followed wisely, it is possible and enjoyable to write Python functions that are: easy to read (the name and arguments need no explanations) easy to change (adding a new keyword argument does not break other parts of the code) Avoid the magical wand A powerful tool for hackers, Python comes with a very rich set of hooks and tools allowing to do almost any kind of tricky tricks. For instance, it is possible to change how objects are created and instantiated, it is possible to change how the Python interpreter imports modules, it is even possible (and recommended if needed) to embed C routines in Python. However, all these options have many drawbacks and it is always better to use the most straightforward way to achieve your goal. The main drawback is that readability suffers deeply from them. Many code analysis tools, such as pylint or pyakes, will be unable to parse this magic code. We consider that a Python developer should know about these nearly innite possibilities, because it grows the condence that no hard-wall will be on the way. However, knowing how to use them and particularly when not to use them is the most important. Like a Kungfu master, a Pythonista knows how to kill with a single nger, and never to do it. We are all consenting adults As seen above, Python allows many tricks, and some of them are potentially dangerous. A good example is that any client code can override an objects properties and methods: there is no private keyword in Python. This philosophy, very different from highly defensive languages like Java, which give a lot of mechanisms to prevent any misuse, is expressed by the saying: We are consenting adults. This doesnt mean that, for example, no properties are considered private, and that no proper encapsulation is possible in Python. But, instead of relying on concrete walls erected by the developers between their code and others, the Python community prefers to rely on a set of conventions indicating that these elements should not be accessed directly.

2.2. Code Style

Python Guide Documentation, Release 0.0.1

The main convention for private properties and implementation details is to prex all internals with an underscore. If the client code breaks this rule and accesses these marked elements, any misbehavior or problems encountered if the code is modied is the responsibility of the client code. Using this convention generously is encouraged: any method or property that is not intended to be used by client code should be prexed with an underscore. This will guarantee a better separation of duties and easier modications of existing code, and it will always be possible to publicize a private property, while privatising a public property might be a much harder operation. Returning values When a function grows in complexity is not uncommon to use multiple return statements inside the functions body. However, in order to keep a clear intent and a sustainable readability level, it is preferable to avoid returning meaningful values from many output points in the body. There are two main cases for returning values in a function: The result of the function return when it has been processed normally, and the error cases that indicate a wrong input parameter or any other reason for the function to not be able to complete its computation or task. If you do not wish to raise exceptions for the second case, then returning a value, such as None or False, indicating that the function could not perform correctly might be needed. In this case, it is better to return as early as the incorrect context has been detected. It will help to atten the structure of the function: all the code after the return-because-oferror statement can assume the condition is met to further compute the functions main result. Having multiple such return statements is often necessary. However, when a function has multiple main exit points for its normal course, it becomes difcult to debug the returned result, and it may be preferable to keep a single exit point. This will also help factoring out some code paths, and the multiple exit points are a probable indication that such a refactoring is needed.
def complex_function(a, b, c): if not a: return None # Raising an exception might be better if not b: return None # Raising an exception might be better # Some complex code trying to compute x from a, b and c # Resist temptation to return x if succeeded if not x: # Some Plan-B computation of x return x # One single exit point for the returned value x will help # when maintaining the code.

2.2.2 Idioms
A programming Idiom, put simply, is a way to write code. The notion of programming Idioms is discussed amply at c2 and at Stack Overow. Idiomatic Python code is often referred to as being Pythonic. Although there usually is one and preferably only one obvious way to do it; the way to write idiomatic Python code can be non-obvious to Python beginners. So, good idioms must be consciously acquired. Some common Python idioms follow: Unpacking If you know the length of a list or tuple, you can assign names to its elements with unpacking:

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

for index, item in enumerate(some_list): # do something with index and item

You can use this to swap variables, as well:

a, b = b , a

Nested unpacking works too:

a, (b, c) = 1, (2, 3)

Create an ignored variable If you need to assign something (for instance, in Unpacking) but will not need that variable, use __:
filename = foobar.txt basename, __, ext = filename.rpartition(.)

Note: Many Python style guides recommend the use of a single underscore _ for throwaway variables rather than the double underscore __ recommended here. The issue is that _ is commonly used as an alias for the gettext() function, and is also used at the interactive prompt to hold the value of the last operation. Using a double underscore instead is just as clear and almost as convenient, and eliminates the risk of accidentally interfering with either of these other use cases.

Create a length-N list of the same thing Use the Python list * operator:
four_nones = [None] * 4

Create a length-N list of lists Because lists are mutable, the * operator (as above) will create a list of N references to the same list, which is not likely what you want. Instead, use a list comprehension:
four_lists = [[] for __ in xrange(4)]

A common idiom for creating strings is to use join on an empty string.:

letters = [s, p, a, m] word = .join(letters)

This will set the value of the variable word to spam. This idiom can be applied to lists and tuples. Sometimes we need to search through a collection of things. Lets look at two options: lists and dictionaries. Take the following code for example:
d = {s: [], p: [], a: [], m: []} l = [s, p, a, m] def lookup_dict(d): return s in d

2.2. Code Style

Python Guide Documentation, Release 0.0.1

def lookup_list(l): return s in l

Even though both functions look identical, because lookup_dict is utilizing the fact that dictionaries in python are hashtables, the lookup performance between the two is very different. Python will have to go through each item in the list to nd a matching case, which is time consuming. By analysing the hash of the dictionary, nding keys in the dict can be done very quickly. For more information see this StackOverow page.

2.2.3 Zen of Python

Also known as PEP 20, the guiding principles for Pythons design.
>>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases arent special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless youre Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, its a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- lets do more of those!

For some examples of good Python style, see this Stack Overow question or these slides from a Python user group.

2.2.4 PEP 8
PEP 8 is the de-facto code style guide for Python. PEP 8 Conforming your Python code to PEP 8 is generally a good idea and helps make code more consistent when working on projects with other developers. There exists a command-line program, pep8, that can check your code for conformance. Install it by running the following command in your Terminal:
$ pip install pep8

Then run it on a le or series of les to get a report of any violations.

$ pep8 optparse.py optparse.py:69:11: E401 multiple imports on one line optparse.py:77:1: E302 expected 2 blank lines, found 1 optparse.py:88:5: E301 expected 1 blank line, found 0 optparse.py:222:34: W602 deprecated form of raising exception optparse.py:347:31: E211 whitespace before (

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

optparse.py:357:17: E201 whitespace after { optparse.py:472:29: E221 multiple spaces before operator optparse.py:544:21: W601 .has_key() is deprecated, use in

2.2.5 Conventions
Here are some conventions you should follow to make your code easier to read. Check if variable equals a constant You dont need to explicitly compare a value to True, or None, or 0 - you can just add it to the if statement. See Truth Value Testing for a list of what is considered false. Bad:
if attr == True: print True! if attr == None: print attr is None!

Good:
# Just check the value if attr: print attr is truthy! # or check for the opposite if not attr: print attr is falsey! # or, since None is considered false, explicity check for it if attr is None: print attr is None!

Access a Dictionary Element Dont use the has_key function. Instead use x in d syntax, or pass a default argument to get. Bad:
d = {hello: world} if d.has_key(hello): print d[hello] # prints world else: print default_value

Good:
d = {hello: world} print d.get(hello, default_value) # prints world print d.get(thingy, default_value) # prints default_value # Or:

2.2. Code Style

Python Guide Documentation, Release 0.0.1

if hello in d: print d[hello]

Short Ways to Manipulate Lists List comprehensions provide a powerful, concise way to work with lists. Also, the map and lter functions can perform operations on lists using a different concise syntax. Bad:
# Filter elements greater than 4 a = [3, 4, 5] b = [] for i in a: if i > 4: b.append(i)

Good:
b = [i for i in a if i > 4] b = filter(lambda x: x > 4, a)

Bad:
# Add three to all list members. a = [3, 4, 5] count = 0 for i in a: a[count] = i + 3 count = count + 1

Good:
a a # a = [3, 4, 5] = [i + 3 for i in a] Or: = map(lambda i: i + 3, a)

Use enumerate to keep a count of your place in the list.

for i, item in enumerate(a): print i + ", " + item # prints # 0, 3 # 1, 4 # 2, 5

The enumerate function has better readability than handling a counter manually. Moreover, it is better optimized for iterators. Read From a File Use the with open syntax to read from les. This will automatically close les for you. Bad:

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

f = open(file.txt) a = f.read() print a f.close()

Good:
with open(file.txt) as f: for line in f: print line

The with statement is better because it will ensure you always close the le, even if an exception is raised. Line Continuations When a logical line of code is longer than the accepted limit, you need to split it over multiple physical lines. Python interpreter will join consecutive lines if the last character of the line is a backslash. This is helpful sometimes but is preferably avoided, because of its fragility: a white space added to the end of the line, after the backslash, will break the code and may have unexpected results. A preferred solution is to use parentheses around your elements. Left with an unclosed parenthesis on an end-of-line the Python interpreter will join the next line until the parentheses are closed. The same behavior holds for curly and square braces. Bad:
my_very_big_string = """For a long time I used to go to bed early. Sometimes, \ when I had put out my candle, my eyes would close so quickly that I had not even \ time to say Im going to sleep.""" from some.deep.module.inside.a.module import a_nice_function, another_nice_function, \ yet_another_nice_function

Good:
my_very_big_string = ( "For a long time I used to go to bed early. Sometimes, " "when I had put out my candle, my eyes would close so quickly " "that I had not even time to say Im going to sleep." ) from some.deep.module.inside.a.module import ( a_nice_function, another_nice_function, yet_another_nice_function)

However, more often than not having to split long logical line is a sign that you are trying to do too many things at the same time, which may hinder readability.

2.3 Reading Great Code

One of the core tenants behind the design of Python is creating readable code. The motivation behind this design is simple: The number one thing that Python programmers do is read code. One of the secrets of becoming a great Python programmer is to read, understand, and comprehend excellent code. Excellent code typically follows the guidelines outlined in code_style, and does its best to express a clear and concise intent to the reader.

2.3. Reading Great Code

Python Guide Documentation, Release 0.0.1

Included below is a list of recommended Python projects for reading. Each of these projects are paragons of excellent Python code. Howdoi Howdoi is a code search tool, written in Python. Flask Flask is a microframework for Python based on Werkzeug and Jinja2. Its intended for getting started very quickly and was developed with best intentions in mind. Werkzeug Werkzeug started as simple collection of various utilities for WSGI applications and has become one of the most advanced WSGI utility modules. It includes a powerful debugger, full-featured request and response objects, HTTP utilities to handle entity tags, cache control headers, HTTP dates, cookie handling, le uploads, a powerful URL routing system and a bunch of community-contributed addon modules. Requests Requests is an Apache2 Licensed HTTP library, written in Python, for human beings. Tablib Tablib is a format-agnostic tabular dataset library, written in Python. Todo Embed and explain YouTube video showing python code reading: http://www.youtube.com/watch?v=Jc8M9LoEuo This may require installing a Sphinx plugin. https://bitbucket.org/birkenfeld/sphinxcontrib/src/a09f29fc16970f34350ca36ac7f229e00b1b1674/youtube?at=default

Todo Include code examples of exemplary code from each of the projects listed. Explain why it is excellent code. Use complex examples.

Todo Explain techniques to rapidly identify data structures, algorithms and determine what the code is doing.

2.4 Documentation
Readability is a primary focus for Python developers, in both project and code documentation. Following some simple best practices can save both you and others a lot of time.

2.4.1 Project Documentation

A README le at the root directory should give general information to the users and the maintainers. It should be raw text or written in some very easy to read markup, such as reStructuredText and Markdown. It should contain a few lines explaining the purpose of the project or the library (without assuming the user knows anything about the project), the url of the main source for the software, and some basic credit information. This le is the main entry point for readers of the code. An INSTALL le is less necessary with python. The installation instructions are often reduced to one command, such as pip install module or python setup.py install and added to the README le. A LICENSE le should always be present and specify the license under which the software is made available to the public. A TODO le or a TODO section in README should list the planned development for the code.

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

A CHANGELOG le or section in README should compile a short overview of the changes in the code base for the latest versions.

2.4.2 Project Publication

Depending on the project, your documentation might include some or all of the following components: An introduction should show a very short overview of what can be done with the product, using one or two extremely simplied use cases. This is the thirty-second pitch for your project. A tutorial should show some primary use cases in more detail. The reader will follow a step-by-step procedure to set-up a working prototype. An API reference is typically generated from the code (see docstrings). It will list all publicly available interfaces, parameters, and return values. Developer documentation is intended for potential contributors. This can include code convention and general design strategy of the project. Sphinx Sphinx is far and away the most popular python documentation tool. Use it. It converts reStructuredText markup language into a range of output formats including HTML, LaTeX (for printable PDF versions), manual pages, and plain text. There is also great, free hosting for your Sphinx docs: Read The Docs. Use it. You can congure it with commit hooks to your source repository so that rebuilding your documentation will happen automatically. Note: Sphinx is famous for its API generation, but it also works well for general project documentation. This Guide is built with Sphinx and is hosted on Read The Docs

reStructuredText Most Python documentation is written with reStructuredText. Its like Markdown with all the optional extensions built in. The reStructuredText Primer and the reStructuredText Quick Reference should help you familiarize yourself with its syntax.

2.4.3 Code Documentation Advice

Comments clarify code and begin with a hash (#). In Python, docstrings describe modules, classes, and functions:
def square_and_rooter(x): """Returns the square root of self times self.""" ...

In general, follow the comment section of PEP 0008 (the Python Style Guide).

2.4. Documentation

Python Guide Documentation, Release 0.0.1

Commenting Sections of Code Do not use triple-quote strings to comment code. This is not a good practice, because line-oriented command-line tools such as grep will not be aware that the commented code is inactive. It is better to add hashes at the proper indentation level for every commented line. Your editor probably has the ability to do this easily, and it is worth learning the comment/uncomment toggle. Docstrings and Magic Some tools use docstrings to embed more-than-documentation behavior, such as unit test logic. Those can be nice, but you wont ever go wrong with vanilla heres what this does. Docstrings versus Block comments These arent interchangeable. For a function or class, the leading comment block is a programmers note. The docstring describes the operation of the function or class:
# This function slows down program execution for some reason. def square_and_rooter(x): """Returns the square root of self times self.""" ...

2.4.4 Other Tools

You might see these in the wild. Use Sphinx. Pycco Pycco is a literate-programming-style documentation generator and is a port of the node.js Docco. It makes code into a side-by-side HTML code and documentation. Ronn Ronn builds unix manuals. It converts human readable textles to roff for terminal display, and also to HTML for the web. Epydoc Epydoc is discontinued. Use Sphinx instead.

2.5 Testing Your Code

Testing your code is very important. Getting used to writing the testing code and the running code in parallel is now considered a good habit. Used wisely, this method helps you dene more precisely your codes intent and have a more decoupled architecture. Some general rules of testing: A testing unit should focus on one tiny bit of functionality and prove it correct. Each test unit must be fully independent. Each of them must be able to run alone, and also within the test suite, regardless of the order they are called. The implication of this rule is that each test must be loaded with a fresh dataset and may have to do some cleanup afterwards. This is usually handled by setUp() and tearDown() methods.

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

Try hard to make tests that run fast. If one single test needs more than a few millisecond to run, development will be slowed down or the tests will not be run as often as desirable. In some cases, tests cant be fast because they need a complex data structure to work on, and this data structure must be loaded every time the test runs. Keep these heavier tests in a separate test suite that is run by some scheduled task, and run all other tests as often as needed. Learn your tools and learn how to run a single test or a test case. Then, when developing a function inside a module, run this functions tests very often, ideally automatically when you save the code. Always run the full test suite before a coding session, and run it again after. This will give you more condence that you did not break anything in the rest of the code. It is a good idea to implement a hook that runs all tests before pushing code to a shared repository. If you are in the middle of a development session and have to interrupt your work, it is a good idea to write a broken unit test about what you want to develop next. When coming back to work, you will have a pointer to where you were and get faster on tracks. The rst step when you are debugging your code is to write a new test pinpointing the bug. While it is not always possible to do, those bug catching test are among the most valuable piece of code in your project. Use long and descriptive names for testing functions. The style guide here is slightly different than that of running code, where short names are often preferred. The reason is testing functions are never called explicitly. square() or even sqr() is ok in running code, but in testing code you would has names such as test_square_of_number_2(), test_square_negative_number(). These function names are displayed when a test fail, and should be as descriptive as possible. When something goes wrong or has to be changed, and if your code has a good set of tests, you or other maintainers will rely largely on the testing suite to x the problem or modify a given behavior. Therefore the testing code will be read as much as or even more than the running code. A unit test whose purpose is unclear is not very helpful is this case. Another use of the testing code is as an introduction to new developers. When someone will have to work on the code base, running and reading the related testing code is often the best they can do. They will or should discover the hot spots, where most difculties arise, and the corner cases. If they have to add some functionality, the rst step should be to add a test and, by this mean, ensure the new functionality is not already a working path that has not been plugged in the interface.

2.5.1 The Basics

Unittest Unittest is the batteries-included test module in the Python standard library. Its API will be familiar to anyone who has used any of the JUnit/nUnit/CppUnit series of tools. Creating testcases is accomplished by subclassing a TestCase base class
import unittest def fun(x): return x + 1 class MyTest(unittest.TestCase): def test(self): self.assertEqual(fun(3), 4)

As of Python 2.7 unittest also includes its own test discovery mechanisms. unittest in the standard library documentation

2.5. Testing Your Code

Python Guide Documentation, Release 0.0.1

Doctest The doctest module searches for pieces of text that look like interactive Python sessions in docstrings, and then executes those sessions to verify that they work exactly as shown. Doctests have a different use case than proper unit tests: they are usually less detailed and dont catch special cases or obscure regression bugs. They are useful as an expressive documentation of the main use cases of a module and its components. However, doctests should run automatically each time the full test suite runs. A simple doctest in a function:
def square(x): """Squares x. >>> square(2) 4 >>> square(-2) 4 """ return x * x if __name__ == __main__: import doctest doctest.testmod()

When running this module from the command line as in python module.py, the doctests will run and complain if anything is not behaving as described in the docstrings.

2.5.2 Tools
py.test py.test is a no-boilerplate alternative to Pythons standard unittest module.
$ pip install pytest

Despite being a fully-featured and extensible test tool it boasts a simple syntax. Creating a test suite is as easy as writing a module with a couple of functions
# content of test_sample.py def func(x): return x + 1 def test_answer(): assert func(3) == 5

and then running the py.test command

$ py.test =========================== test session starts ============================ platform darwin -- Python 2.7.1 -- pytest-2.2.1 collecting ... collected 1 items test_sample.py F ================================= FAILURES ================================= _______________________________ test_answer ________________________________

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

> E E

def test_answer(): assert func(3) == 5 assert 4 == 5 + where 4 = func(3)

test_sample.py:5: AssertionError ========================= 1 failed in 0.02 seconds =========================

far less work than would be required for the equivalent functionality with the unittest module! py.test Nose nose extends unittest to make testing easier.
$ pip install nose

nose provides automatic test discovery to save you the hassle of manually creating test suites. It also provides numerous plugins for features such as xUnit-compatible test output, coverage reporting, and test selection. nose tox tox is a tool for automating test environment management and testing against multiple interpreter congurations
$ pip install tox

tox allows you to congure complicated multi-parameter test matrices via a simple ini-style conguration le. tox Unittest2 unittest2 is a backport of Python 2.7s unittest module which has an improved API and better assertions over the one available in previous versions of Python. If youre using Python 2.6 or below, you can install it with pip
$ pip install unittest2

You may want to import the module under the name unittest to make porting code to newer versions of the module easier in the future
import unittest2 as unittest class MyTest(unittest.TestCase): ...

This way if you ever switch to a newer python version and no longer need the unittest2 module, you can simply change the import in your test module without the need to change any other code. unittest2

2.5. Testing Your Code

Python Guide Documentation, Release 0.0.1

mock mock is a library for testing in Python.

$ pip install mock

It allows you to replace parts of your system under test with mock objects and make assertions about how they have been used. For example, you can monkey patch a method
from mock import MagicMock thing = ProductionClass() thing.method = MagicMock(return_value=3) thing.method(3, 4, 5, key=value) thing.method.assert_called_with(3, 4, 5, key=value)

To mock classes or objects in a module under test, use the patch decorator. In the example below, an external search system is replaced with a mock that always returns the same result (but only for the duration of the test).
def mock_search(self): class MockSearchQuerySet(SearchQuerySet): def __iter__(self): return iter(["foo", "bar", "baz"]) return MockSearchQuerySet() # SearchForm here refers to the imported class reference in myapp, # not where the SearchForm class itself is imported from @mock.patch(myapp.SearchForm.search, mock_search) def test_new_watchlist_activities(self): # get_search_results runs a search and iterates over the result self.assertEqual(len(myapp.get_search_results(q="fish")), 3)

Mock has many other ways you can congure it and control its behavior. mock

2.6 Common Gotchas

For the most part, Python aims to be a clean and consistent language that avoids surprises, but there are a few cases where newcomers to the language often get tripped up. Some of these are intentional but potentially surprising. Some could arguably be considered language warts. In general though, what follows is a collection of potentially tricky behavior that might seem strange at rst glance, but is generally sensible once youre aware of the underlying cause for the surprise.

2.6.1 Mutable Default Arguments

Seemingly the most common surprise new Python programmers encounter is Pythons treatment of mutable default arguments in function denitions.

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

What You Wrote

def append_to(element, to=[]): to.append(element) return to

What You Might Have Expected to Happen

my_list = append_to(12) print my_list my_other_list = append_to(42) print my_other_list

A new list is created each time the function is called if a second argument isnt provided, so that the output is:
[12] [42]

What Does Happen

[12] [12, 42]

A new list is created once when the function is dened, and the same list is used in each successive call. Pythons default arguments are evaluated once when the function is dened, not each time the function is called (like it is in say, Ruby). This means that if you use a mutable default argument and mutate it, you will and have mutated that object for all future calls to the function as well. What You Should Do Instead Create a new object each time the function is called, by using a default arg to signal that no argument was provided (None is often a good choice).
def append_to(element, to=None): if to is None: to = [] to.append(element) return to

When the Gotcha Isnt a Gotcha Sometimes you specically can exploit (read: use as intended) this behavior to maintain state between calls of a function. This is often done when writing a caching function.

2.6.2 Late Binding Closures

Another common source of confusion is the way Python binds its variables in closures (or in the surrounding global scope).

2.6. Common Gotchas

Python Guide Documentation, Release 0.0.1

What You Wrote

def create_multipliers(): return [lambda x : i * x for i in range(5)]

What You Might Have Expected to Happen

for multiplier in create_multipliers(): print multiplier(2)

A list containing ve functions that each have their own closed-over i variable that multiplies their argument, producing:
0 2 4 6 8

What Does Happen

8 8 8 8 8

Five functions are created, but all of them just multiply x by 4. Pythons closures are late binding. This means that names within closures are looked up at the time the inner function is called. Here, whenever any of the returned functions are called, the value of i is looked up in the surrounding scope at call time, when by then the loop has completed and i is left with its nal value of 4. Whats particularly nasty about this gotcha is the seemingly prevalent misinformation that this has something to do with lambdas in Python. Functions created with a lambda expression are in no way special, and in fact the same exact behavior is exhibited by just using an ordinary def:
def create_adders(): for i in range(5): def adder(x): return i * x yield adder

What You Should Do Instead Well. Here the general solution is arguably a bit of a hack. Due to Pythons afformentioned behavior concerning evaluating default arguments to functions (see Mutable Default Arguments), you can create a closure that binds immediately to its arguments by using a default arg like so:
def create_adders(): return [lambda x, i=i : i * x for i in range(5)]

Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

When the Gotcha Isnt a Gotcha When you want your closures to behave this way. Late binding is good in lots of situations. Looping to create unique functions is unfortunately a case where they can cause hiccups.

2.7 Choosing a License

Your source publication needs a license. In the US, if no license is specied, users have no legal right to download, modify, or distribute. Furthermore, people cant contribute to your code unless you tell them what rules to play by. Its complicated, so here are some pointers: Open source. There are plenty of open source licenses available to choose from. In general, these licenses tend to fall into one of two categories: 1. licenses that focus more on the users freedom to do with the software as they please (these are the morepermissive open source licenses such as the MIT, BSD, & Apache). 2. licenses that focus more on making sure that the code itself including any changes made to it and distributed along with it always remains free (these are the less-permissive free software licenses, for example, the GPL and LGPL). The latter are less-permissive in the sense that they dont permit someone to add code to the software and distribute it without also including the source code for their changes. To help you choose one for your project, theres a license chooser, use it. More-Permissive PSFL (Python Software Foundation License) for contributing to python itself MIT / BSD / ISC MIT (X11) New BSD ISC Apache Less-Permissive: LGPL GPL GPLv2 GPLv3

2.7. Choosing a License

Python Guide Documentation, Release 0.0.1

Chapter 2. Writing Great Code

CHAPTER

THREE

SCENARIO GUIDE
This part of the guide focuses on tool and module advice based on different scenarios.

3.1 Network Applications

3.1.1 HTTP
The Hypertext Transfer Protocol (HTTP) is an application protocol for distributed, collaborative, hypermedia information systems. HTTP is the foundation of data communication for the World Wide Web. Requests Pythons standard urllib2 module provides most of the HTTP capabilities you need, but the API is thoroughly broken. It was built for a different time and a different web. It requires an enormous amount of work (even method overrides) to perform the simplest of tasks. Requests takes all of the work out of Python HTTP making your integration with web services seamless. Theres no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, powered by urllib3, which is embedded within Requests. Documention PyPi GitHub

3.1.2 Distributed Systems

ZeroMQ MQ (also spelled ZeroMQ, 0MQ or ZMQ) is a high-performance asynchronous messaging library aimed at use in scalable distributed or concurrent applications. It provides a message queue, but unlike message-oriented middleware, a MQ system can run without a dedicated message broker. The library is designed to have a familiar socket-style API.

Python Guide Documentation, Release 0.0.1

RabbitMQ

Todo Write about RabbitMQ

3.2 Web Applications

As a powerful scripting language adapted to both fast prototyping and bigger projects, Python is widely used in Web applications development.

3.2.1 Context
WSGI The Web Server Gateway Interface (or WSGI for short) is a standard interface between web servers and Python web application frameworks. By standardizing behavior and communication between web servers and Python web frameworks, WSGI makes it possible to write portable Python web code that can be deployed in any WSGI-compliant web server. WSGI is documented in PEP-3333.

3.2.2 Frameworks
Broadly speaking, a web framework consist of a set of libraries and a main handler within which you can build custom code to implement a web application (i.e. an interactive web site). Most web frameworks include patterns and utilities to accomplish at least the following: URL Routing Matches an incoming HTTP request to a particular piece of Python code to be invoked Request and Response Objects Encapsulate the information received from or sent to a users browser Template Engine Allows for separating Python code implementing an applications logic from the HTML (or other) output that it produces Development Web Server Runs an HTTP server on development machines to enable rapid development; often automatically reloads server-side code when les are updated Django Django is a batteries included web application framework. By providing many utilities and patterns out of the box, Django aims to make it possible to build complex, database-backed web applications quickly, while encouraging best practices in code written using it. Django has a large and active community, and many pre-built re-usable modules that can be incorporated into a new project as-is, or customized to t your needs. There are annual Django conferences in the United States and in Europe.

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

Flask Flask is a microframework for Python. Rather than aiming to provide everything you could possibly need, Flask implements the most commonly-used core components of a web application framework, like URL routing, request and response objects, and templates. As a user of Flask, it is therefore up to you to choose and integrate other components you may need, such as database access or form generation and validation. For many popular modules, Extensions may already exist to suit your needs. Support for ask can best be found in its mailing list. Just shoot an email to ask@librelist.com and reply to the conrmation email. Werkzeug Werkzeug is not actually a real framework, but rather a very powerful set of tools for building web applications. It provides URL routing utilities, request and response objects and a basic development server. It is mostly used where users need bigger exibility for their application that is not commonly found in other web frameworks. Support can be found on its mailing list. Pyramid Pyramid lies somewhere between a big framework like Django and the microframeworks: It comes with a lot of libraries and functionality and can thus not be considered lightweight. On the other hand, it does not provide all the functionality Django does. Instead Pyramid brings basic support for most regular tasks and provides a great deal of extensibility. Additionally, Pyramid has a huge focus on complete documentation. As a little extra it comes with the Werkzeug Debugger which allows you to debug a running web application in the browser. Support can also be found in the documentation.

3.2.3 Web Servers

Nginx Nginx (pronounced engine-x) is a web server and reverse-proxy for HTTP, SMTP and other protocols. It is known for its high performance, relative simplicity, and compatibility with many application servers (like WSGI servers). It also includes handy features like load-balancing, basic authentication, streaming, and others. Designed to serve high-load websites, Nginx is gradually becoming quite popular.

3.2.4 WSGI Servers

Stand-alone WSGI servers typically use less resources than traditional web servers and provide top performance 1 . Gunicorn Gunicorn (Green Unicorn) is a WSGI server used to serve Python applications. It is a Python interpretation of the Ruby Unicorn server. Unicorn is designed to be lightweight, easy to use, and uses many UNIX idioms. Gunicorn is not designed to face the internet it was designed to run behind Nginx which buffers slow requests and takes care of other important considerations. A sample setup for Nginx + Gunicorn can be found in the Gunicorn help.
1

Benchmark of Python WSGI Servers

3.2. Web Applications

Python Guide Documentation, Release 0.0.1

3.2.5 Server Best Practices

The majority of self hosted Python applications today are hosted with a WSGI server such as Gunicorn, either directly or behind a lightweight web server such as nginx. The WSGI servers serve the Python applications while the web server handles tasks better suited for it such as static le serving, request routing, DDoS protection, and basic authentication.

3.2.6 Hosting
Platform-as-a-Service Platform-as-a-Service (PaaS) is a type of cloud computing infrastructure which abstracts and manages infrastructure, routing, and scaling of web applications. When using PaaS, application developers can focus on writing application code rather than needing to be concerned with deployment details. Most PaaS services offer a command-line interface that developers can use to set up and interrogate conguration, and to deploy new releases of an application to the service. PaaS services and their partners offer add-on functionality which is well integrated into the platform, such as database hosting, email services, logging, scheduled and background tasks, billing and payment, etc.
Heroku

Herokus Cedar stack offers rst class support for Python 2.7 applications. Heroku allows you to run as many Python web applications as you like, 24/7 and free of charge. Heroku is best described as a horizontal scaling platform. They start to charge you once you scale your application to run on more than one Dyno (abstracted servers) at a time. Heroku publishes step-by-step instructions on how to set up your rst application for use in Heroku, and maintains a list of example applications.
DotCloud

DotCloud supports WSGI applications and background/worker tasks natively on their platform. Web applications run Python version 2.6, use nginx and uWSGI , and allow custom conguration of both for advanced users. DotCloud uses a custom command-line API client which can work with applications managed in git repositories or any other version control system. DotCloud has a free plan with limited database size, and without extra services (caching. . . ). See the DotCloud documentation on Python for more information and help getting started.
Gondor

Gondor is a PaaS specialized for deploying Django and Pinax applications. Gondor supports Django versions 1.2 and 1.3 on Python version 2.7, and can automatically congure your Django site if you use local_settings.py for site-specic conguration information. Gondor publishes guides to deploying Django projects and Pinax projects on their platform.

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

3.2.7 Templating
Most WSGI applications are responding to HTTP requests to serve content in HTML or other markup languages. Instead of generating directly textual content from Python, the concept of separation of concerns advises us to use templates. A template engine manages a suite of template les, with a system of hierarchy and inclusion to avoid unnecessary repetition, and is in charge of rendering (generating) the actual content, lling the static content of the templates with the dynamic content generated by the application. As template les are sometimes written by designers or front-end developers, it can be difcult to handle increasing complexity. Some general good practices apply to the part of the application passing dynamic content to the template engine, and to the templates themselves. Template les should be passed only the dynamic content that is needed for rendering the template. Avoid to be tempted to pass additional content just in case: it is easier to add some missing variable when needed than to remove a likely unused variable later. Many template engines allow for complex statements or assignments in the template itself, and many allow some Python code to be evaluated in the templates. This convenience can lead to uncontrolled increase in complexity, and often harder to nd bugs. It is often necessary to mix javascript templates with HTML templates. A sane approach to this design is to isolate the parts where the HTML template passes some variable content to the javascript code.
References

3.3 Command Line Applications

Todo Explain Command Line Applications

3.3.1 Clint
Todo Write about Clint

3.4 GUI Applications

3.4.1 Qt
Qt is a cross-platform application framework that is widely used for developing software with a GUI but can also be used for non-GUI applications.

3.3. Command Line Applications

Python Guide Documentation, Release 0.0.1

PySide PySide is a Python binding of the cross-platform GUI toolkit Qt. http://developer.qt.nokia.com/wiki/PySideDownloads/ PyQt

Note: If your software does not fully comply with the GPL you will need a commercial license! http://www.riverbankcomputing.co.uk/software/pyqt/download

3.4.2 Cocoa
Note: The Cocoa framework is only available on Mac OSX. Dont pick this if youre writing a cross-platform application!

PyObjC

Note: Only available on Mac OSX. Dont pick this if youre writing a cross-platform application.

3.4.3 wxPython
wxPython is a GUI toolkit for the Python programming language. It allows Python programmers to create programs with a robust, highly functional graphical user interface, simply and easily. It is implemented as a Python extension module (native code) that wraps the popular wxWidgets cross platform GUI library, which is written in C++. Install (Stable) Go to http://www.wxpython.org/download.php#stable and download the appropriate package for your OS.

3.4.4 Gtk
PyGTK provides Python bindings for the GTK+ toolkit. Like the GTK+ library itself, it is currently licensed under the GNU LGPL. It is worth noting that PyGTK only currently supports the Gtk-2.X API (NOT Gtk-3.0). It is currently recommended that PyGTK not be used for new projects and existing applications be ported from PyGTK to PyGObject.

3.4.5 Tk
Tkinter is a thin object-oriented layer on top of Tcl/Tk. It has the advantage of being included with the Python standard library, making it the most convenient and compatible toolkit to program with. Both Tk and Tkinter are available on most Unix platforms, as well as on Windows and Macintosh systems. Starting with the 8.0 release, Tk offers native look and feel on all platforms. 40 Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

Theres a good multi-language Tk tutorial with Python examples at TkDocs. Theres more information available on the Python Wiki.

3.4.6 Kivy
Kivy is a Python library for development of multi-touch enabled media rich applications. The aim is to allow for quick and easy interaction design and rapid prototyping, while making your code reusable and deployable. Kivy is written in Python, based on OpenGL and supports different input devices such as: Mouse, Dual Mouse, TUIO, WiiMote, WM_TOUCH, HIDtouch, Apples products and so on. Kivy is actively being developed by a community and free to use. It operates on all major platforms (Linux, OSX, Windows, Android). The main resource for information is the website: http://kivy.org

3.5 Databases
3.5.1 DB-API
The Python Database API (DB-API) denes a standard interface for Python database access modules. Its documented in PEP 249. Nearly all Python database modules such as sqlite3, psycopg and mysql-python conform to this interface. Tutorials that explain how to work with modules that conform to this interface can be found here and here.

3.5.2 SQLAlchemy
SQLAlchemy is a commonly used database toolkit. Unlike many database libraries it not only provides an ORM layer but also a generalized API for writing database-agnostic code without SQL.
pip install sqlalchemy

3.5.3 Django ORM

The Django ORM is the interface used by Django to provide database access. Its based on the idea of models, an abstraction that makes it easier to manipulate data in Python.

3.6 Networking
3.6.1 Twisted
Twisted is an event-driven networking engine. It can be used to build applications around many different networking protocols, including http servers and clients, applications using SMTP, POP3, IMAP or SSH protocols, instant messaging and many more.

3.5. Databases

Python Guide Documentation, Release 0.0.1

3.6.2 PyZMQ
PyZMQ is the Python binding for ZeroMQ, which is a high-performance asynchronous messaging library. One great advantage is that ZeroMQ can be used for message queuing without a message broker. The basic patterns for this are: request-reply: connects a set of clients to a set of services. This is a remote procedure call and task distribution pattern. publish-subscribe: connects a set of publishers to a set of subscribers. This is a data distribution pattern. push-pull (or pipeline): connects nodes in a fan-out / fan-in pattern that can have multiple steps, and loops. This is a parallel task distribution and collection pattern. For a quick start, read the ZeroMQ guide.

3.6.3 gevent
gevent is a coroutine-based Python networking library that uses greenlets and libevent event loop.

3.7 Systems Administration

3.7.1 Fabric
Fabric is a library for simplifying system administration tasks. While Chef and Puppet tend to focus on managing servers and system libraries, fabric is more focused on application level tasks such as deployment. Install Fabric:
$ pip install fabric

The following code will create two tasks that we can use: memory_usage and deploy. The former will output the memory usage on each machine. The latter will ssh into each server, cd to our project directory, activate the virtual environment, pull the newest codebase, and restart the application server.
from fabric.api import cd, env, prefix, run, task env.hosts = [my_server1, my_server2] @task def memory_usage(): run(free -m) @task def deploy(): with cd(/var/www/project-env/project): with prefix(. ../bin/activate): run(git pull) run(touch app.wsgi)

With the previous code saved in a le named fable.py, we can check memory usage with:
$ fab memory_usage [my_server1] Executing task memory [my_server1] run: free -m [my_server1] out: total [my_server1] out: Mem: 6964

used 1897

free 5067

shared 0

buffers 166

cached 222

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

[my_server1] out: -/+ buffers/cache: [my_server1] out: Swap: 0 [my_server2] [my_server2] [my_server2] [my_server2] [my_server2] [my_server2] Executing task memory run: free -m out: total out: Mem: 1666 out: -/+ buffers/cache: out: Swap: 895

1509 0

5455 0

used 902 148 1

free 764 1517 894

shared 0

buffers 180

cached 572

and we can deploy with:

$ fab deploy

Additional features include parallel execution, interaction with remote programs, and host grouping. Fabric Documentation

3.7.2 Salt
Salt is an open source infrastructure management tool. It supports remote command execution from a central point (master host) to multiple hosts (minions). It also supports system states which can be used to congure multiple servers using simple template les. Salt supports python versions 2.6 and 2.7 and can be installed via pip:
$ pip install salt

After conguring a master server and any number of minion hosts, we can run arbitrary shell commands or use prebuilt modules of complex commands on our minions. The following command lists all available minion hosts, using the ping module.
$ salt * test.ping

The host ltering is accomplished by matching the minion id, or using the grains system. The grains system uses static host information like the operating system version or the CPU architecture to provide a host taxonomy for the salt modules. The following command lists all available minions running CentOS using the grains system:
$ salt -G os:CentOS test.ping

Salt also provides a state system. States can be used to congure the minion hosts. For example, when a minion host is ordered to read the following state le, it will install and start the Apache server:
apache: pkg: - installed service: - running

State les can be written using YAML, the Jinja2 template system or pure python. Salt Documentation

3.7. Systems Administration

Python Guide Documentation, Release 0.0.1

3.7.3 Chef
Todo Write about Chef Chef Documentation

3.7.4 Puppet
Todo Write about Puppet Puppet Labs Documentation

3.7.5 Blueprint
Todo Write about Blueprint

3.7.6 Buildout
Todo Write about Buildout Buildout Website

3.8 Continuous Integration

3.8.1 Why?
Martin Fowler, who rst wrote about Continuous Integration (short: CI) together with Kent Beck, describes the CI as follows: Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is veried by an automated build (including test) to detect integration errors as quickly as possible. Many teams nd that this approach leads to signicantly reduced integration problems and allows a team to develop cohesive software more rapidly.

3.8.2 Jenkins
Jenkins CI is an extensible continuous integration engine. Use it.

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

3.8.3 Buildbot
Buildbot is a Python system to automate the compile/test cycle to validate code changes.

3.8.4 Mule?
Todo Write about Mule

3.8.5 Tox
tox is an automation tool providing packaging, testing and deployment of Python software right from the console or CI server. It is a generic virtualenv management and test command line tool which provides the following features: Checking that packages install correctly with different Python versions and interpreters Running tests in each of the environments, conguring your test tool of choice Acting as a frontend to Continuous Integration servers, reducing boilerplate and merging CI and shell-based testing.

3.8.6 Travis-CI
Travis-CI is a distributed CI server which builds tests for open source projects for free. It provides multiple workers to run Python tests on and seamlessly integrates with Github. You can even have it comment on your Pull Requests whether this particular changeset breaks the build or not. So if you are hosting your code on Github, travis-ci is a great and easy way to get started with Continuous Integration. In order to get started, add a .travis.yml le to your repository with this example content:
language: python python: - "2.5" - "2.6" - "2.7" - "3.1" - "3.2" # command to install dependencies script: python tests/test_all_of_the_units.py branches: only: - master

This will get your project tested on all the listed Python versions by running the given script and only build the master branch. There are a lot more options you can enable, like notications, before and after steps and much more. The travis-ci docs explain all of those and are very thorough. In order to activate testing for your project, go to the travis-ci site and login with your Github account. Then activate your project in your prole settings and thats it. From now on, your projects tests will be run on every push to Github.

3.8. Continuous Integration

Python Guide Documentation, Release 0.0.1

3.9 Speed
CPython, the most commonly used implementation of Python, is slow for CPU bound tasks. PyPy is fast. Using a slightly modied version of David Beazleys CPU bound test code (added loop for multiple tests), you can see the difference between CPython and PyPys processing.
PyPy $ ./pypy -V Python 2.7.1 (7773f8fc4223, Nov 18 2011, 18:47:10) [PyPy 1.7.0 with GCC 4.4.3] $ ./pypy measure2.py 0.0683999061584 0.0483210086823 0.0388588905334 0.0440690517426 0.0695300102234 CPython $ ./python -V Python 2.7.1 $ ./python measure2.py 1.06774401665 1.45412397385 1.51485204697 1.54693889618 1.60109114647

3.9.1 Context
The GIL The GIL (Global Interpreter Lock) is how Python allows multiple threads to operate at the same time. Pythons memory management isnt entirely thread-safe, so the GIL is required to prevent multiple threads from running the same Python code at once. David Beazley has a great guide on how the GIL operates. He also covers the new GIL in Python 3.2. His results show that maximizing performance in a Python application requires a strong understanding of the GIL, how it affects your specic application, how many cores you have, and where your application bottlenecks are. C Extensions The GIL Special care must be taken when writing C extensions to make sure you register your threads with the interpreter.

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

3.9.2 C Extensions
Cython Pyrex Shedskin? Numba

Todo Write about Numba and the autojit compiler for NumPy

3.9.3 Threading
Threading Spawning Processes Multiprocessing

3.10 Scientic Applications

3.10.1 Context
Python is frequently used for high-performance scientic applications. Python is widely used in academia and scientic projects because it is easy to write, and it performs really well. Due to its high performance nature, scientic computing in python often refers to external libraries, typically written in faster languages (like C, or FORTRAN for matrix operations). The main libraries used are NumPy, SciPy and Matplotlib. Going into detail about these libraries is beyond the scope of the Python guide. However, a comprehensive introduction to the scientic Python ecosystem can be found in the Python Scientic Lecture Notes

3.10.2 Libraries
NumPy NumPy is a low level library written in C (and FORTRAN) for high level mathematical functions. NumPy cleverly overcomes the problem of running slower algorithms on Python by using multidimensional arrays and functions that operate on arrays. Any algorithm can then be expressed as a function on arrays, allowing the algorithms to be run quickly. NumPy is part of the SciPy project, and is released as a separate library so people who only need the basic requirements can just use NumPy. NumPy is compatible with Python versions 2.4 through to 2.7.2 and 3.1+.

3.10. Scientic Applications

Python Guide Documentation, Release 0.0.1

Numba

Todo Write about Numba

SciPy SciPy is a library that uses Numpy for more mathematical functions. SciPy uses NumPy arrays as the basic data structure. SciPy comes with modules for various commonly used tasks in scientic programing, for example: linear algebra, integration (calculus), ordinary differential equation solvers and signal processing. Matplotlib Matplotlib is a exible plotting library for creating interactive 2D and 3D plots that can also be saved as manuscriptquality gures. The API in many ways reects that of MATLAB, easing transition of MATLAB users to Python. Many examples, along with the source code to re-create them, can be browsed at the matplotlib gallery.

3.10.3 Resources
Installation of scientic Python packages can be troublesome. Many of these packages are implemented as Python C extensions which need to be compiled. This section lists various so-called scientic Python distributions which provide precompiled and easy-to-install collections of scientic Python packages. Unofcial Windows Binaries for Python Extension Packages Many people who do scientic computing are on Windows. And yet many of the scientic computing packages are notoriously difcult to build and install. Christoph Gohlke however, has compiled a list of Windows binaries for many useful Python packages. The list of packages has grown from a mainly scientic python resource to a more general list. It might be a good idea to check it out if youre on Windows. Enthought Python Distribution (EPD) Installing NumPy and SciPy can be a daunting task. Which is why the Enthought Python distribution was created. With Enthought, scientic python has never been easier (one click to install about 100 scientic python packages). The Enthought Python Distribution comes in two variants: a free version EPD Free and a paid version with various pricing options. Anaconda Continuum Analytics offers the Anaconda Python Distribution which includes all the common scientic python packages and additionally many packages related to data analytics and big data. Anaconda comes in two avors, a paid for version and a completely free and open source community edition, Anaconda CE, which contains a slightly reduced feature set. Free licenses for the paid-for version are available for academics and researchers.

Chapter 3. Scenario Guide

Python Guide Documentation, Release 0.0.1

3.11 Image Manipulation

Todo Add introduction about image manipulation and its Python libraries.

3.11.1 Python Imaging Library

The Python Imaging Library, or PIL for short, is the library for image manipulation in Python. It works with Python 1.5.2 and above, including 2.5, 2.6 and 2.7. Unfortunately, it doesnt work with 3.0+ yet. Installation PIL has a reputation of not being very straightforward to install. Listed below are installation notes on various systems. Also, theres a fork named Pillow which is easier to install. It has good setup instructions for all platforms. Installing on Linux
Arch Linux

PIL is maintained in the ofcial community repository, and installed with the system installer as:
$ sudo pacman -S python2-imaging

Ubuntu 12.10

Can be installed on the command line as:

$ sudo apt-get install python-imaging

Installing on Mac OS X PIP doesnt know about the Mac OS X Freetype paths. To rectify that:
$ $ $ $ ln ln ln ln -s -s -s -s /usr/X11/include/freetype2 /usr/local/include/ /usr/X11/include/ft2build.h /usr/local/include/ /usr/X11/lib/libfreetype.6.dylib /usr/local/lib/ /usr/X11/lib/libfreetype.6.dylib /usr/local/lib/libfreetype.dylib

then:
$ brew install libjpeg $ pip install PIL

3.11. Image Manipulation

Python Guide Documentation, Release 0.0.1

Installing on Windows

Todo Notes on installing on Windows machines

3.12 XML parsing

3.12.1 untangle
untangle is a simple library which takes an XML document and returns a Python object which mirrors the nodes and attributes in its structure. For example, an xml le like this:
<?xml version="1.0"?> <root> <child name="child1"> </root>

can be loaded like this:

import untangle obj = untangle.parse(path/to/file.xml)

and then you can get the child elements name like this:
obj.root.child[name]

untangle also supports loading XML from a string or an URL.

Chapter 3. Scenario Guide

CHAPTER

FOUR

SHIPPING GREAT CODE

This part of the guide focuses on deploying your Python code.

4.1 Packaging Your Code

Packaging your code is important. Youll need to package your code rst before sharing it with other developers.

4.1.1 For Python Developers

If youre writing an open source Python module, PyPI, more properly known as The Cheeseshop, is the place to host it. Pip vs. easy_install Use pip. More details here Personal PyPI If you want to install packages from a source different from PyPI, (say, if your packages are proprietary), you can do it by hosting a simple http server, running from the directory which holds those packages which need to be installed. Showing an example is always benecial Say if you are after installing a package called MyPackage.tar.gz, and assuming this is your directory structure: archive MyPackage * MyPackage.tar.gz Go to your command prompt and type:
$ cd archive $ python -m SimpleHTTPServer 9000

This runs a simple http server running on port 9000 and will list all packages (like MyPackage). Now you can install MyPackage using any python package installer. Using Pip, you would do it like:

Python Guide Documentation, Release 0.0.1

$ pip install --extra-index-url=http://127.0.0.1:9000/ MyPackage

Having a folder with the same name as the package name is crucial here. I got fooled by that, one time. But if you feel that creating a folder called MyPackage and keeping MyPackage.tar.gz inside that, is redundant, you can still install MyPackage using:
$ pip install http://127.0.0.1:9000/MyPackage.tar.gz

Chishop

Chishop is a simple PyPI server written in django which allows you to register/upload with distutils and install with easy_install/pip.

4.1.2 For Linux Distributions

Ubuntu Fedora Debian Arch Useful Tools epm alien

4.2 Freezing Your Code

An alternative to shipping your code is freezing it shipping it as an executable with a bundled Python interpreter. Many applications you use every day do this: Dropbox BitTorrent ... Todo Fill in Freezing Your Code stub

4.2.1 Comparison
Solutions and platforms/features supported:

Chapter 4. Shipping Great Code

Python Guide Documentation, Release 0.0.1

SoluWintion dows bbFreeze yes py2exe yes pyInyes staller cx_Freeze yes Todo

Linux OS X yes yes no no yes yes yes yes

Python 3 no no no yes

License MIT MIT GPL PSF

One-le mode no yes yes no

Ziple import yes yes no yes

Eggs yes no yes yes

pkg_resources support yes no no no

Add other solutions: py2app

Note: Freezing Python code on Linux into a Windows executable was only once supported in PyInstaller and later dropped..

Note: All solutions need MS Visual C++ dll to be installed on target machine. Only Pyinstaller makes self-executable exe that bundles the dll when passing --onefile to Congure.py.

4.2.2 Windows
bbFreeze Prerequisite is to install Python, Distribute and pywin32 dependency on Windows. Todo Write steps for most basic .exe

py2exe Prerequisite is to install Python on Windows. 1. Download and install http://sourceforge.net/projects/py2exe/les/py2exe/ 2. Write setup.py (List of conguration options):
from distutils.core import setup import py2exe setup( windows=[{script: foobar.py}], )

3. (Optionally) include icon 4. (Optionally) one-le mode 5. Generate .exe into dist directory:
$ python setup.py py2exe

6. Provide the Microsoft Visual C runtime DLL. Two options: globally install dll on target machine or distribute dll aloneside with .exe. 4.2. Freezing Your Code 53

Python Guide Documentation, Release 0.0.1

PyInstaller Prerequisite is to have installed Python, Distribute and pywin32 dependency on Windows. Most basic tutorial Manual

4.2.3 OSX
py2app PyInstaller

4.2.4 Linux
bbFreeze PyInstaller

Chapter 4. Shipping Great Code

CHAPTER

FIVE

DEVELOPMENT ENVIRONMENT
5.1 Your Development Environment
5.1.1 Text Editors
Just about anything which can edit plain text will work for writing Python code, however, using a more powerful editor may make your life a bit easier. VIM Vim is a text editor which uses keyboard shortcuts for editing instead of menus or icons. There exist a couple of plugins and settings for the VIM editor to aid python development. If you only develop in Python, a good start is to set the default settings for indentation and line-wrapping to values compliant with PEP 8. In your home directory, open a le called .vimrc and add the following lines::
set set set set set set set textwidth=79 shiftwidth=4 tabstop=4 expandtab softtabstop=4 shiftround autoindent " " " " " " " lines longer than 79 columns will be broken operation >> indents 4 columns; << unindents 4 columns an hard TAB displays as 4 columns insert spaces when hitting TABs insert/delete 4 spaces when hitting a TAB/BACKSPACE round indent to multiple of shiftwidth align the new line indent with the previous line

With these settings, newlines are inserted after 79 characters and indentation is set to 4 spaces per tab. If you also use VIM for other languages, there is a handy plugin at indent, which handles indentation settings for python source les. There is also a handy syntax plugin at syntax featuring some improvements over the syntax le included in VIM 6.1. These plugins supply you with a basic environment for developing in Python. To get the most out of Vim, you should continually check your code for syntax errors and PEP8 compliance. Luckily PEP8 and Pyakes will do this for you. If your VIM is compiled with +python you can also utilize some very handy plugins to do these checks from within the editor. For PEP8 checking, install the vim-pep8 plugin, and for pyakes you can install vim-pyakes. Now you can map the functions Pep8() or Pyakes() to any hotkey or action you want in Vim. Both plugins will display errors at the bottom of the screen, and provide an easy way to jump to the corresponding line. Its very handy to call these functions whenever you save a le. In order to do this, add the following lines to your vimrc:
autocmd BufWritePost *.py call Pyflakes() autocmd BufWritePost *.py call Pep8()

Python Guide Documentation, Release 0.0.1

If you are already using syntastic you can enable it to run Pyakes on write and show errors and warnings in the quickx window. An example conguration to do that which also shows status and warning messages in the statusbar would be:
set set set let let statusline+=%#warningmsg# statusline+=%{SyntasticStatuslineFlag()} statusline+=%* g:syntastic_auto_loc_list=1 g:syntastic_loc_list_height=5

Python-mode

Python-mode is a complex solution in VIM for working with python code. It has: Async python code checking (pylint, pyakes, pep8, mccabe) in any combination Code refactoring and autocompletion with Rope Fast python folding Virtualenv support Search by python documentation and run python code Auto pep8 error xes And more. Todo add supertab notes

Emacs Emacs is a powerful text editor. Its fully programmable (lisp), but it can be some work to wire up correctly. A good start if youre already an Emacs user is Python Programming in Emacs at EmacsWiki. 1. Emacs itself comes with a python mode. 2. Python ships with an alternate version: python-mode.el 3. Fabin Ezequiel Gallinas python.el provides nice functionality and behavior out of the box TextMate TextMate brings Apples approach to operating systems into the world of text editors. By bridging UNIX underpinnings and GUI, TextMate cherry-picks the best of both worlds to the benet of expert scripters and novice users alike. Sublime Text Sublime Text is a sophisticated text editor for code, html and prose. Youll love the slick user interface and extraordinary features. Sublime Text has excellent support for editing Python code and uses Python for its plugin API.

Chapter 5. Development Environment

Python Guide Documentation, Release 0.0.1

5.1.2 IDEs
PyCharm / IntelliJ IDEA PyCharm is developed by JetBrains, also known for IntelliJ IDEA. Both share the same code base and most of PyCharms features can be brought to IntelliJ with the free Python Plug-In. Eclipse The most popular Eclipse plugin for Python development is Aptanas PyDev. Komodo IDE Komodo IDE is developed by ActiveState and is a commercial IDE for Windows, Mac and Linux. Spyder Spyder is an IDE specically geared toward working with scientic python libraries (namely Scipy). It includes integration with pyakes, pylint, and rope. Spyder is open-source (free), offers code completion, syntax highlighting, class and function browser, and object inspection. WingIDE WingIDE is a python specic IDE. It runs on Linux, Windows, and Mac (as an X11 application, which frustrates some Mac users). NINJA-IDE NINJA-IDE (from the recursive acronym: Ninja-IDE Is Not Just Another IDE) is a cross-platform IDE, specially designed to build Python applications, and runs on Linux/X11, Mac OS X and Windows desktop operating systems. Installers for these platforms can be downloaded from the website. NINJA-IDE is open-source software (GPLv3 licence) and is developed in Python and Qt. The source les can be downloaded from GitHub.

5.1.3 Interpreter Tools

virtualenv Virtualenv is a tool to keep the dependencies required by different projects in separate places, by creating virtual Python environments for them. It solves the Project X depends on version 1.x but, Project Y needs 4.x dilemma and keeps your global site-packages directory clean and manageable. virtualenv creates a folder which contains all the necessary executables to contain the packages that a Python project would need. An example workow is given. Install virtualenv:

5.1. Your Development Environment

Python Guide Documentation, Release 0.0.1

$ pip install virtualenv

Create a virtual environment for a project:

$ cd my_project $ virtualenv venv

virtualenv venv will create a folder in the current directory which will contain the Python executable les, and a copy of the pip library which you can use to install other packages. The name of the virtual environment (in this case, it was venv) can be anything; omitting the name will place the les in the current directory instead. To start using the virtual environment, run:
$ source venv/bin/activate

The name of the current virtual environment will now appear on the left of the prompt (e.g. (venv)Your-Computer:your_project UserName$) to let you know that its active. From now on, any package that you install using pip will be placed in the venv folder, isolated from the global Python installation. Install packages as usual:
$ pip install requests

To stop using an environment simply type deactivate. To remove the environment, just remove the directory it was installed into. (In this case, it would be rm -rf venv).
Other Notes

Running virtualenv with the option --no-site-packages will not include the packages that are installed globally. This can be useful for keeping the package list clean in case it needs to be accessed later. [This is the default behavior for virtualenv 1.7 and later.] In order to keep your environment consistent, its a good idea to freeze the current state of the environment packages. To do this, run
$ pip freeze > requirements.txt

This will create a requirements.txt le, which contains a simple list of all the packages in the current environment, and their respective versions. Later, when a different developer (or you, if you need to re- create the environment) can install the same packages, with the same versions by running
$ pip install -r requirements.txt

This can help ensure consistency across installations, across deployments, and across developers. Lastly, remember to exclude the virtual environment folder from source control by adding it to the ignore list. virtualenvwrapper Virtualenvwrapper makes virtualenv a pleasure to use by wrapping the command line API with a nicer CLI.
$ pip install virtualenvwrapper

Put this into your ~/.bash_prole (Linux/Mac) le:

$ export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=--no-site-packages

This will prevent your virtualenvs from relying on your (global) site packages directory, so that they are completely separate.. [note: This is the default behavior for virtualenv 1.7 and later] 58 Chapter 5. Development Environment

Python Guide Documentation, Release 0.0.1

5.1.4 Other Tools

IDLE IDLE is an integrated development environment that is part of Python standard library. It is completely written in Python and uses the Tkinter GUI toolkit. Though IDLE is not suited for full-blown development using Python, it is quite helpful to try out small Python snippets and experiment with different features in Python. It provides the following features: Python Shell Window (interpreter) Multi window text editor that colorizes Python code Minimal debugging facility IPython IPython provides a rich toolkit to help you make the most out of using Python interactively. Its main components are: Powerful Python shells (terminal- and Qt-based). A web-based notebook with the same core features but support for rich media, text, code, mathematical expressions and inline plots. Support for interactive data visualization and use of GUI toolkits. Flexible, embeddable interpreters to load into your own projects. Tools for high level and interactive parallel computing.
$ pip install ipython

BPython bpython is an alternative interface to the Python interpreter for Unix-like operating systems. It has the following features: In-line syntax highlighting. Readline-like autocomplete with suggestions displayed as you type. Expected parameter list for any Python function. Rewind function to pop the last line of code from memory and re-evaluate. Send entered code off to a pastebin. Save entered code to a le. Auto-indentation. Python 3 support.
$ pip install bpython

5.1. Your Development Environment

Python Guide Documentation, Release 0.0.1

5.2 Virtual Environments

A Virtual Environment, put simply, is an isolated working copy of Python which allows you to work on a specic project without worry of affecting other projects. For example, you can work on a project which requires Django 1.3 while also maintaining a project which requires Django 1.0.

5.2.1 virtualenv
virtualenv is a tool to create isolated Python environments. Install it via pip:
$ pip install virtualenv

Basic Usage 1. Create a virtual environment:

$ virtualenv venv

This creates a copy of Python in whichever directory you ran the command in, placing it in a folder named venv. 2. To begin using the virtual environment, it needs to be activated:
$ source venv/bin/activate

You can then begin installing any new modules without affecting the system default Python or other virtual environments. 3. If you are done working in the virtual environment for the moment, you can deactivate it:
$ deactivate

This puts you back to the systems default Python interpreter with all its installed libraries. To delete a virtual environment, just delete its folder. After a while, though, you might end up with a lot of virtual environments littered across your system, and its possible youll forget their names or where they were placed.

5.2.2 virtualenvwrapper
virtualenvwrapper provides a set of commands which makes working with virtual environments much more pleasant. It also places all your virtual environments in one place. To install (make sure virtualenv is already installed):
$ pip install virtualenvwrapper $ export WORKON_HOME=~/Envs $ source /usr/local/bin/virtualenvwrapper.sh

(Full virtualenvwrapper install instructions.) For Windows, you can use the virtualenvwrapper-powershell clone. To install (make sure virtualenv is already installed):

Chapter 5. Development Environment

Python Guide Documentation, Release 0.0.1

PS> PS> PS> PS>

pip install virtualenvwrapper-powershell $env:WORKON_HOME="~/Envs" mkdir $env:WORKON_HOME import-module virtualenvwrapper

Basic Usage 1. Create a virtual environment:

$ mkvirtualenv venv

This creates the venv folder inside ~/Envs. 2. Work on a virtual environment:
$ workon venv

virtualenvwrapper provides tab-completion on environment names. It really helps when you have a lot of environments and have trouble remembering their names. workon also deactivates whatever environment you are currently in, so you can quickly switch between environments. 3. Deactivating is still the same:
$ deactivate

4. To delete:
$ rmvirtualenv venv

Other useful commands lsvirtualenv List all of the environments. cdvirtualenv Navigate into the directory of the currently activated virtual environment, so you can browse its site-packages, for example. cdsitepackages Like the above, but directly into site-packages directory. lssitepackages Shows contents of site-packages directory. Full list of virtualenvwrapper commands.

5.2.3 autoenv
When you cd into a directory containing a .env autoenv automagically activates the environment. Install it on Mac OS X using brew:
$ brew install autoenv

And on Linux:
$ git clone git://github.com/kennethreitz/autoenv.git ~/.autoenv $ echo source ~/.autoenv/activate.sh >> ~/.bashrc

5.2. Virtual Environments

Python Guide Documentation, Release 0.0.1

Chapter 5. Development Environment

CHAPTER

SIX

ADDITIONAL NOTES
This part of the guide, which is mostly prose, begins with some background information about Python, then focuses on next steps.

6.1 Introduction
From the ofcial Python website: Python is a general-purpose, high-level programming language similar to Tcl, Perl, Ruby, Scheme, or Java. Some of its main key features include: very clear, readable syntax Pythons philosophy focuses on readability, from code blocks delineated with signicant whitespace to intuitive keywords in place of inscrutable punctuation extensive standard libraries and third party modules for virtually any task Python is sometimes described with the words batteries included for its extensive standard library, which includes modules for regular expressions, le IO, fraction handling, object serialization, and much more. Additionally, the Python Package Index is available for users to submit their packages for widespread use, similar to Perls CPAN. There is a thriving community of very powerful Python frameworks and tools like the Django web framework and the NumPy set of math routines. integration with other systems Python can integrate with Java libraries, enabling it to be used with the rich Java environment that corporate programmers are used to. It can also be extended by C or C++ modules when speed is of the essence. ubiquity on computers Python is available on Windows, *nix, and Mac. It runs wherever the Java virtual machine runs, and the reference implementation CPython can help bring Python to wherever there is a working C compiler. friendly community Python has a vibrant and large community which maintains wikis, conferences, countless repositories, mailing lists, IRC channels, and so much more. Heck, the Python community is even helping to write this guide!

Python Guide Documentation, Release 0.0.1

6.1.1 About This Guide

Purpose The Hitchhikers Guide to Python exists to provide both novice and expert Python developers a best-practice handbook to the installation, conguration, and usage of Python on a daily basis. By the Community This guide is architected and maintained by Kenneth Reitz in an open fashion. This is a community-driven effort that serves one purpose: to serve the community. For the Community All contributions to the Guide are welcome, from Pythonistas of all levels. If you think theres a gap in what the Guide covers, fork the Guide on GitHub and submit a pull request. Contributions are welcome from everyone, whether theyre an old hand or a rst-time Pythonista, and the authors to the Guide will gladly help if you have any questions about the appropriateness, completeness, or accuracy of a contribution. To get started working on The Hitchhikers Guide, see the: doc:/notes/contribute page.

6.2 The Community

6.2.1 BDFL
Guido van Rossum, the creator of Python, is often referred to as the BDFL the Benevolent Dictator For Life.

6.2.2 Python Software Foundation

The mission of the Python Software Foundation is to promote, protect, and advance the Python programming language, and to support and facilitate the growth of a diverse and international community of Python programmers. Learn More about the PSF.

6.2.3 PEPs
PEPs are Python Enhancement Proposals. They describe changes to Python itself, or the standards around it. There are three different types of PEPs (as dened by PEP1): Standards Describes a new feature or implementation. Informational Describes a design issue, general guidelines, or information to the community. Process Describes a process related to Python.

Chapter 6. Additional Notes

Python Guide Documentation, Release 0.0.1

Notable PEPs There are a few PEPs that could be considered required reading: PEP8: The Python Style Guide. Read this. All of it. Follow it. PEP20: The Zen of Python. A list of 19 statements that briey explain the philosophy behind Python. PEP257: Docstring Conventions. Gives guidelines for semantics and conventions associated with Python docstrings. You can read more at The PEP Index. Submitting a PEP PEPs are peer-reviewed and accepted/rejected after much discussion. Anyone can write and submit a PEP for review. Heres an overview of the PEP acceptance workow:

6.2.4 Python Conferences

The major events for the Python community are developer conferences. The two most notable conferences are PyCon, which is held in the US, and its European sibling, EuroPython. A comprehensive list of conferences is maintained at pycon.org.

6.2.5 Python User Groups

User Groups are where a bunch of Python developers meet to present or talk about Python topics of interest. A list of local user groups is maintained at the Python Software Foundation Wiki.

6.3 Learning Python

6.3.1 Beginner
Learn Python Interactive Tutorial Learnpython.org is an easy non-intimidating way to get introduced to python. The website takes the same approach used on the popular Try Ruby website, it has an interactive python interpreter built into the site that allows you to go through the lessons without having to install Python locally. Learn Python Learn Python the Hard Way This is an excellent beginner programmers guide to Python. It covers hello world from the console to the web. Learn Python the Hard Way

6.3. Learning Python

Python Guide Documentation, Release 0.0.1

Crash into Python Also known as Python for Programmers with 3 Hours, this guide gives experienced developers from other languages a crash course on Python. Crash into Python Dive Into Python 3 Dive Into Python 3 is a good book for those ready to jump in to Python 3. Its a good read if you are moving from Python 2 to 3 or if you already have some experience programming in another language. Dive Into Python 3 Think Python: How to Think Like a Computer Scientist Think Python attempts to give an introduction to basic concepts in computer science through the use of the python language. The focus was to create a book with plenty of exercises, minimal jargon and a section in each chapter devoted to the subject of debugging. While exploring the various features available in the python language the author weaves in various design patterns and best practices. The book also includes several case studies which have the reader explore the topics discussed in the book in greater detail by applying those topics to real-world examples. Case studies include assignments in GUI and Markov Analysis. Think Python Python Koans Python Koans is a port of Edgecases Ruby Koans. It uses a test-driven approach, q.v. TEST DRIVEN DESIGN SECTION to provide an interactive tutorial teaching basic python concepts. By xing assertion statements that fail in a test script, this provides sequential steps to learning python. For those used to languages and guring out puzzles on their own, this can be a fun, attractive option. For those new to python and programming, having an additional resource or reference will be helpful. Python Koans More information about test driven development can be found at these resources: Test Driven Development A Byte of Python A free introductory book that teaches python at the beginner level, it assumes no previous programming experience. A Byte of Python for Python 2.x A Byte of Python for Python 3.x

6.3.2 Advanced
Pro Python This book is for intermediate to advanced Python programmers who are looking to understand how and why Python works the way it does and how they can take their code to the next level.

Chapter 6. Additional Notes

Python Guide Documentation, Release 0.0.1

Expert Python Programming Expert Python Programming deals with best practices in programming Python and is focused on the more advanced crowd. It starts with topics like decorators (with caching, proxy, and context manager case-studies), method resolution order, using super() and meta-programming, and general PEP8 best practices. It has a detailed, multi-chapter case study on writing and releasing a package and eventually an application, including a chapter on using zc.buildout. Later chapters detail best practices with writing documentation, test-driven development, version control, and optimization/proling. Expert Python Programming The Python Tutorial This is the ofcial tutorial, it covers all the basics, and offers a tour of the language and the standard library, recommended for those who need a quickstart guide to the language. The Python Tutorial

6.3.3 References
Python in a Nutshell Python in a Nutshell, written by Alex Martelli, covers most cross-platform pythons usage, from its syntax to built-in libraries to advanced topics such as writing C extensions. The Python Language Reference This is Pythons reference manual, it covers the syntax and the core semantics of the language. The Python Language Reference

6.4 Documentation
6.4.1 Ofcial Documentation
The ofcial Python Language and Library documentation can be found here: Python 2.x Python 3.x

6.4.2 Read the Docs

Read the Docs is a popular community project, providing a single location for all documentation of popular and even more exotic Python modules. Read the Docs

6.4. Documentation

Python Guide Documentation, Release 0.0.1

6.5 News
6.5.1 Planet Python
This is an aggregate of Python news from a growing number of developers. Planet Python

6.5.2 /r/python
/r/python is the Reddit Python community where users contribute and vote on Python-related news. /r/python

6.5.3 Pycoders Weekly

Pycoders Weekly is a free weekly python newsletter for Python developers by Python developers (Project, Articles, News, and Jobs). Pycoders Weekly

6.5.4 Python Weekly

Python Weekly is a free weekly newsletter featuring curated news, articles, new releases, jobs, etc. related to Python. Python Weekly

Contribution notes and legal information are here (for those interested).

6.6 Contribute
Python-guide is under active development, and contributors are welcome. If you have a feature request, suggestion, or bug report, please open a new issue on GitHub. To submit patches, please send a pull request on GitHub. Once your changes get merged back in, youll automatically be added to the Contributors List.

6.6.1 Style Guide

For all contributions, please follow the The Guide Style Guide.

6.6.2 Todo List

If youd like to contribute, theres plenty to do. Heres a short todo list.

Chapter 6. Additional Notes

Python Guide Documentation, Release 0.0.1

Establish use this vs alternatives are.... recommendations Todo Determine License (The original entry is located guide/checkouts/latest/docs/notes/license.rst, line 4.) Todo Write about Mule (The original entry is located guide/checkouts/latest/docs/scenarios/ci.rst, line 36.) Todo Write about Chef Chef Documentation (The original entry is located guide/checkouts/latest/docs/scenarios/admin.rst, line 125.) Todo Write about Puppet Puppet Labs Documentation (The original entry is located guide/checkouts/latest/docs/scenarios/admin.rst, line 133.) Todo Write about Blueprint (The original entry is located guide/checkouts/latest/docs/scenarios/admin.rst, line 140.) Todo Write about Buildout Buildout Website (The original entry is located guide/checkouts/latest/docs/scenarios/admin.rst, line 145.) Todo Explain Command Line Applications in /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/python-

6.6. Contribute

Python Guide Documentation, Release 0.0.1

(The original entry is located guide/checkouts/latest/docs/scenarios/cli.rst, line 4.) Todo Write about Clint (The original entry is located guide/checkouts/latest/docs/scenarios/cli.rst, line 9.) Todo Write about RabbitMQ (The original entry is located guide/checkouts/latest/docs/scenarios/client.rst, line 48.) Todo

/var/build/user_builds/python-

Add introduction about image manipulation and its Python libraries. (The original entry is located guide/checkouts/latest/docs/scenarios/imaging.rst, line 5.) Todo Notes on installing on Windows machines (The original entry is located guide/checkouts/latest/docs/scenarios/imaging.rst, line 71.) Todo Write about Numba (The original entry is located guide/checkouts/latest/docs/scenarios/scientic.rst, line 40.) Todo Write about Numba and the autojit compiler for NumPy (The original entry is located guide/checkouts/latest/docs/scenarios/speed.rst, line 81.) Todo add supertab notes (The original entry is located in /var/build/user_builds/python-guide/checkouts/latest/docs/dev/env.rst, line 88.) Todo 70 Chapter 6. Additional Notes in /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/python-

Python Guide Documentation, Release 0.0.1

Fill in Freezing Your Code stub (The original entry is located guide/checkouts/latest/docs/shipping/freezing.rst, line 13.) Todo Add other solutions: py2app (The original entry is located guide/checkouts/latest/docs/shipping/freezing.rst, line 31.) Todo Write steps for most basic .exe (The original entry is located guide/checkouts/latest/docs/shipping/freezing.rst, line 51.) Todo Embed and explain YouTube video showing python code reading: http://www.youtube.com/watch?v=Jc8M9-LoEuo This may require installing a Sphinx plugin. https://bitbucket.org/birkenfeld/sphinxcontrib/src/a09f29fc16970f34350ca36ac7f229e00b1b1674/youtube?at=default (The original entry is located guide/checkouts/latest/docs/writing/reading.rst, line 40.) Todo Include code examples of exemplary code from each of the projects listed. Explain why it is excellent code. Use complex examples. (The original entry is located guide/checkouts/latest/docs/writing/reading.rst, line 42.) Todo Explain techniques to rapidly identify data structures, algorithms and determine what the code is doing. (The original entry is located guide/checkouts/latest/docs/writing/reading.rst, line 44.) in /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/pythonin /var/build/user_builds/python-

6.7 License
Todo Determine License

6.7. License

Python Guide Documentation, Release 0.0.1

6.8 The Guide Style Guide

As with all documentation, having a consistent format helps make the document more understandable. In order to make The Guide easier to digest, all contributions should t within the rules of this style guide where appropriate. The Guide is written as reStructuredText. Note: Parts of The Guide may not yet match this style guide. Feel free to update those parts to be in sync with The Guide Style Guide

Note: On any page of the rendered HTML you can click Show Source to see how authors have styled the page.

6.8.1 Relevancy
Strive to keep any contributions relevant to the purpose of The Guide. Avoid including too much information on subjects that dont directly relate to Python development. Prefer to link to other sources if the information is already out there. Be sure to describe what and why you are linking. Cite references where needed. If a subject isnt directly relevant to Python, but useful in conjunction with Python (ex: Git, Github, Databases), reference by linking to useful resources and describe why its useful to Python. When in doubt, ask.

6.8.2 Headings
Use the following styles for headings. Chapter title:
######### Chapter 1 #########

Page title:
=================== Time is an Illusion ===================

Section headings:
Lunchtime Doubly So -------------------

Sub section headings:

Very Deep ~~~~~~~~~

Chapter 6. Additional Notes

Python Guide Documentation, Release 0.0.1

6.8.3 Prose
Wrap text lines at 78 characters. Where necessary, lines may exceed 78 characters, especially if wrapping would make the source text more difcult to read.

6.8.4 Code Examples

Wrap all code examples at 70 characters to avoid horizontal scrollbars. Command line examples:
.. code-block:: console $ run command --help $ ls ..

Be sure to include the $ prex before each line. Python interpreter examples:
Label the example:: .. code-block:: python >>> import this

Python examples:
Descriptive title:: .. code-block:: python def get_answer(): return 42

6.8.5 Externally Linking

Prefer labels for well known subjects (ex: proper nouns) when linking:
Sphinx_ is used to document Python. .. _Sphinx: http://sphinx.pocoo.org

Prefer to use descriptive labels with inline links instead of leaving bare links:
Read the Sphinx Tutorial <http://sphinx.pocoo.org/tutorial.html>_

Avoid using labels such as click here, this, etc. preferring descriptive labels (SEO worthy) instead.

6.8.6 Linking to Sections in The Guide

To cross-reference other parts of this documentation, use the :ref: keyword and labels. To make reference labels more clear and unique, always add a -ref sufx:

6.8. The Guide Style Guide

Python Guide Documentation, Release 0.0.1

.. _some-section-ref: Some Section ------------

6.8.7 Notes and Warnings

Make use of the appropriate admonitions directives when making notes. Notes:
.. note:: The Hitchhikers Guide to the Galaxy has a few things to say on the subject of towels. A towel, it says, is about the most massively useful thing an interstellar hitch hiker can have.

Warnings:
.. warning:: DONT PANIC

6.8.8 TODOs
Please mark any incomplete areas of The Guide with a todo directive. To avoid cluttering the Todo List, use a single todo for stub documents or large incomplete sections.
.. todo:: Learn the Ultimate Answer to the Ultimate Question of Life, The Universe, and Everything

Chapter 6. Additional Notes

Reponse Test PHP
No ratings yet
Reponse Test PHP
19 pages
BECS-C29 Owner's Manual Version 2013-03 PDF
No ratings yet
BECS-C29 Owner's Manual Version 2013-03 PDF
198 pages
Mastering Python - Sample Chapter
100% (1)
Mastering Python - Sample Chapter
45 pages
Pandas
No ratings yet
Pandas
43 pages
Python Application Programming PDF
100% (2)
Python Application Programming PDF
2 pages
MIMIX Introduction
100% (5)
MIMIX Introduction
44 pages
Galaxy Dx5 X 1 Printhead Update 1.39 Headboard
100% (1)
Galaxy Dx5 X 1 Printhead Update 1.39 Headboard
22 pages
100+ Essential Python Questions
100% (1)
100+ Essential Python Questions
45 pages
Python Programming Language
No ratings yet
Python Programming Language
11 pages
Coding For Beginners
No ratings yet
Coding For Beginners
17 pages
3 Interesting Python Projects With Code For Beginners!: Data Science Blogathon
No ratings yet
3 Interesting Python Projects With Code For Beginners!: Data Science Blogathon
7 pages
Modul Python 1
No ratings yet
Modul Python 1
36 pages
3rd - Python - L 1
No ratings yet
3rd - Python - L 1
9 pages
Python Bokeh Cheat Sheet
No ratings yet
Python Bokeh Cheat Sheet
1 page
C# All-In-One Code Framework Coding Standards
100% (1)
C# All-In-One Code Framework Coding Standards
88 pages
Python Programming - Exercises: Finn Arup Nielsen
50% (2)
Python Programming - Exercises: Finn Arup Nielsen
30 pages
Python Tutorial For Beginners - Learn Python Programming - Intellipaat
No ratings yet
Python Tutorial For Beginners - Learn Python Programming - Intellipaat
29 pages
Paraview/Python Scripting: From Kitwarepublic
No ratings yet
Paraview/Python Scripting: From Kitwarepublic
22 pages
Python Exit Slip - May 2016
No ratings yet
Python Exit Slip - May 2016
8 pages
Beginners Python Cheat Sheet PCC All
100% (2)
Beginners Python Cheat Sheet PCC All
26 pages
A Gentle Introduction To Python
100% (2)
A Gentle Introduction To Python
29 pages
Oop in Python Best Resources
No ratings yet
Oop in Python Best Resources
1 page
Python Textbok
No ratings yet
Python Textbok
215 pages
Python PostgreSQL Basics
No ratings yet
Python PostgreSQL Basics
19 pages
Presenting XML
No ratings yet
Presenting XML
346 pages
Pandas
No ratings yet
Pandas
2,977 pages
Python - Programming
No ratings yet
Python - Programming
9 pages
Photon Prog Guide
100% (1)
Photon Prog Guide
716 pages
Software Testing Python
No ratings yet
Software Testing Python
9 pages
Python3 Data Structures Cheat Sheet: by Via
No ratings yet
Python3 Data Structures Cheat Sheet: by Via
1 page
Api-Demo: Platform-As-A-Service (Paas) Based Solution
No ratings yet
Api-Demo: Platform-As-A-Service (Paas) Based Solution
6 pages
Scope and Sequence - PCAP Programming Essentials in Python (December...
No ratings yet
Scope and Sequence - PCAP Programming Essentials in Python (December...
5 pages
Python For Advance 3 Days With Python
No ratings yet
Python For Advance 3 Days With Python
263 pages
Python Network Programming Cookbook Sample Chapter
No ratings yet
Python Network Programming Cookbook Sample Chapter
28 pages
Introduction To Python Programming: Dr. R. Rajeswara Rao Professor & Head Dept. of CSE Jntuk-Ucev Vizianagaram
No ratings yet
Introduction To Python Programming: Dr. R. Rajeswara Rao Professor & Head Dept. of CSE Jntuk-Ucev Vizianagaram
27 pages
Pytest Documentation: Release 2.7.1
No ratings yet
Pytest Documentation: Release 2.7.1
219 pages
Python Basics Cheat Sheet 1
100% (2)
Python Basics Cheat Sheet 1
1 page
Revision Point - Series
No ratings yet
Revision Point - Series
5 pages
Python Data Analysis Visualization
No ratings yet
Python Data Analysis Visualization
34 pages
Advanced Programming With Python
No ratings yet
Advanced Programming With Python
9 pages
9 Using The Maya Python API
100% (1)
9 Using The Maya Python API
11 pages
Python ?
100% (1)
Python ?
46 pages
Functional Programming in Python-3
No ratings yet
Functional Programming in Python-3
7 pages
Python Quick Guide - Tutorialspoint
No ratings yet
Python Quick Guide - Tutorialspoint
199 pages
15 Essential Python Interview Questions: Data Structures Primitive Types The Heap
100% (1)
15 Essential Python Interview Questions: Data Structures Primitive Types The Heap
144 pages
Data Structure and Algorithm
No ratings yet
Data Structure and Algorithm
179 pages
IE Python
No ratings yet
IE Python
26 pages
XML
No ratings yet
XML
90 pages
Python
No ratings yet
Python
26 pages
Python Tutorial
100% (1)
Python Tutorial
1,696 pages
Advanced Java and Web Technologies
No ratings yet
Advanced Java and Web Technologies
236 pages
Pattern Matching With Regular Expressions - by Zohaib Shahzad - The Startup - Medium
No ratings yet
Pattern Matching With Regular Expressions - by Zohaib Shahzad - The Startup - Medium
8 pages
Basic C Programming Outreach
100% (2)
Basic C Programming Outreach
38 pages
Simultaneous multithreading A Complete Guide
From Everand
Simultaneous multithreading A Complete Guide
Gerardus Blokdyk
No ratings yet
50 Python Concepts Every Developer Should Know
From Everand
50 Python Concepts Every Developer Should Know
Hernando Abella
No ratings yet
Python Unleashed: Mastering the Art of Efficient Coding
From Everand
Python Unleashed: Mastering the Art of Efficient Coding
James Livingston
No ratings yet
Learn Angular: Build a Todo App
From Everand
Learn Angular: Build a Todo App
Jurgen van de Moere
No ratings yet
The Pythonic Way: An Architect’s Guide to Conventions and Best Practices for the Design, Development, Testing, and Management of Enterprise Python Code
From Everand
The Pythonic Way: An Architect’s Guide to Conventions and Best Practices for the Design, Development, Testing, and Management of Enterprise Python Code
Sonal Raj
5/5 (1)
Developing Web Applications with Visual Basic.NET and ASP.NET
From Everand
Developing Web Applications with Visual Basic.NET and ASP.NET
John Alexander
No ratings yet
JSF 2.0 Cookbook: LITE
From Everand
JSF 2.0 Cookbook: LITE
Anghel Leonard
No ratings yet
C Programming: Core Concepts and Techniques
From Everand
C Programming: Core Concepts and Techniques
William Smith
No ratings yet
Python Programming Illustrated For Beginners & Intermediates: “Learn By Doing” Approach-Step By Step Ultimate Guide To Mastering Python: The Future Is Here!: The Future Is Here!
From Everand
Python Programming Illustrated For Beginners & Intermediates: “Learn By Doing” Approach-Step By Step Ultimate Guide To Mastering Python: The Future Is Here!: The Future Is Here!
William Sullivan
4/5 (2)
Django 1.0 Template Development
From Everand
Django 1.0 Template Development
Scott Newman
No ratings yet
Python: Best Practices to Programming Code with Python: Python Computer Programming, #2
From Everand
Python: Best Practices to Programming Code with Python: Python Computer Programming, #2
Charlie Masterson
No ratings yet
09-2021-Revisedcost Laptopscheme.
No ratings yet
09-2021-Revisedcost Laptopscheme.
2 pages
01 Computers and Digital Basics
100% (1)
01 Computers and Digital Basics
41 pages
Experion HS Configurator Reference Guide R430
No ratings yet
Experion HS Configurator Reference Guide R430
10 pages
Enterprise-Class, Layer 2 Unmanaged Switches For Small and Medium Businesses
No ratings yet
Enterprise-Class, Layer 2 Unmanaged Switches For Small and Medium Businesses
2 pages
D60 Indicator
100% (1)
D60 Indicator
2 pages
Tic Tac Toe: Bachelor of Technology
No ratings yet
Tic Tac Toe: Bachelor of Technology
16 pages
What Computers Are and Are Not: Basic Computer Literacy Information
No ratings yet
What Computers Are and Are Not: Basic Computer Literacy Information
7 pages
Newton Accessories
No ratings yet
Newton Accessories
2 pages
Vericut Macros
0% (2)
Vericut Macros
246 pages
Tle TVL 9-12ia - CSS - Q1 - Wk8day1 - 4
No ratings yet
Tle TVL 9-12ia - CSS - Q1 - Wk8day1 - 4
4 pages
PDFFile5b28d00f684077 84053362 PDF
No ratings yet
PDFFile5b28d00f684077 84053362 PDF
324 pages
Grouping and Aggregating Data: Module Overview
No ratings yet
Grouping and Aggregating Data: Module Overview
24 pages
Laboratory Manual: Computer Network Laboratory Sub Code: 15ecl68
No ratings yet
Laboratory Manual: Computer Network Laboratory Sub Code: 15ecl68
91 pages
Fundamental of C++ Programming
No ratings yet
Fundamental of C++ Programming
28 pages
Divar Ip 7000 Raid Controller_20!01!2019
No ratings yet
Divar Ip 7000 Raid Controller_20!01!2019
53 pages
Rao J. Khan: Professional Experience
No ratings yet
Rao J. Khan: Professional Experience
3 pages
SAP ECC 6.0 - Basis Overview
No ratings yet
SAP ECC 6.0 - Basis Overview
39 pages
Dice Resume CV JON WIMER
No ratings yet
Dice Resume CV JON WIMER
2 pages
La A301p
No ratings yet
La A301p
51 pages
Mca 2 Sem Object Oriented Programming Kca202 2023
No ratings yet
Mca 2 Sem Object Oriented Programming Kca202 2023
2 pages
Data by Brannch
No ratings yet
Data by Brannch
36 pages
Validating SSL Certificates in Non-Browser Software
No ratings yet
Validating SSL Certificates in Non-Browser Software
12 pages
Unit-4 Python
100% (2)
Unit-4 Python
89 pages
Logical Maneuvers: Detecting and Mitigating Adversarial Hardware Faults in Space
No ratings yet
Logical Maneuvers: Detecting and Mitigating Adversarial Hardware Faults in Space
9 pages
CLOUD COMPUTING FUNDAMENTALS Course1
No ratings yet
CLOUD COMPUTING FUNDAMENTALS Course1
17 pages
Lexmark MS81x, MS71x 4063 - SM PDF
100% (1)
Lexmark MS81x, MS71x 4063 - SM PDF
659 pages