def fun1(x): return x + 3 def fun2(x): return x * 3 def zero_matrix(size): matrix = [] for i in xrange(size): matrix.append([]) for j in xrange(size): matrix[i].append(0) return matrix

Python is known to be a multiparadigm language.
This means that it borrows some elements from many programming disciplines ---
functional, imperative, object oriented, etc.
Few people use these methods, however.
I, for one, gladly wrote `for` loops, when I could have written `map`.
I wrote a few lines of code, but did not use list comprehension.
This programming style was not because I did not know how to program in
python, rather they were because I did not know much about functional
programming.

Take the following program, for example:

This is how you would write a program in C/C++/Java/C#.
They can be easily translated to all these languages;
the `zero_matrix` function, for example, can be
written in Java code as (bear in mind that I am not
a Java programmer):

ArrayList zero_matrix(int size) { ArrayList<ArrayList> matrix = new ArrayList<ArrayList>(); ArrayList<double> tmp; for(int i = 0; i<size; i++) { tmp = new ArrayList<double>( ); for(int j = 0; j<size; j++) { tmp.add(0.0); } matrix.add(tmp); } return matrix; }

But the **C** type languages lack many of the features found in
python --- they are not dynamic, scripted, and relatively
not multiparadigm.
Python, and Ruby, on the other hand are, and we can leverage
some of their builtin methods.

Lambda (`\lambda`) or anonymous functions are a convenient way to write a function on one line.

In mathematics we write `S = {x \in \mathbb{N} | x < 100, x \ `mod` \ 9 = 0}`
to obtain the set of all natural numbers less than 100 that evenly divide
9; this is called *list comprehension*.
For the sake of transition from the mathematical notation to python,
lets look at how haskell does this.
In haskell, you'd write the following to obtain the set `S`

S = [x <- [0..] | x < 100, x `mod` 9 == 0]

If we write this in a different font (note that `←` looks like `\in`) we
get

$$`S = [ x \in \mathbb{N} | x < 100, x \ `mod`\ 9 = 0]`$$

It is actually hard to see any difference between the way you write list comprehension in math vs. the way you write it in haskell.

Now let us look at how you write list comprehension in python.

S = [x for x in range(100) if x%9 == 0]

Aside from the location of various functions, the syntax is pretty much
the same (*note*: python cannot deal with infinite list, but both
mathematicians and haskell can).
We can thus read the above python code as we do in English:

I lied when I said that python cannot deal with infinite lists, because
it can --- they're called *generators*.
Although it is ill advised to program using infinite lists in any programming
language.

`todo`

`todo`

`todo`

`todo`

The following is some code that I have recently written to perform some matrix operations. Most are one liners, and the purpose of the functions should be known after an introductory course to linear algebra or classical physics.

Given an `m \times n` matrix `A`, the transpose of `A`, conveniently written as `A^T`, is an `n\times m` matrix where `A_{i,j}^T = A_{j,i}` (`A_{i,j}` is the element in the `i^{th}` row and `j^{th}` column). Without using any functional techniques, one can go about coding this function as follows:

def transpose(matrix): matrix_t = deepcopy(matrix) matrix_shape = (len(matrix), len(matrix[0])) for i in xrange(matrix_shape[0]): for j in xrange(i+1, matrix_shape[1]): matrix_t[i][j], matrix_t[j][i] = \ matrix_t[j][i], matrix_t[i][j] return matrix_t

The function is not that complicated, and most likely as efficient as possible. When it comes to number of lines, however, the function is long --- at least compared to what we can do using functional programing.

def transpose(matrix): return map(list, zip(*matrix))

def s_mul(self, s): return map(lambda *row: list(map(lambda x: x+s, row)), *self.matrix)

def m_add(self,m): return map(lambda (x,y): map(sum,zip(x,y)), zip(self.matrix, m))

def s_mul(self, s): return map(lambda *row: list(map(lambda x: x*s, row)), *self.matrix)

Notice how both `s_add` and `s_mul` share most of the code, except
for one function.
We can therefore extract the majority of the code, and pass in the
function as an argument.

def s_add(self,s): s_apply(lambda x: x+s) def s_mul(self, s): s_apply(lambda x: x*s) def s_apply(self, f): return map(lambda *row: list(map(f,row)), *self.matrix)

ToDo

def dot(v_1, v_2=None): v_2 = v_2 if v_2 else v_1 return sum(v_mul(v_1, v_2))

We Cheat.

def norm(v): return sqrt(dot(v))

from string import lower def rot13(s): a = ord('a') rot13_char x: chr((ord(x) - a + 13)%26 + a) return "".join(map(rot13_char, lower(s)))