Functions

%load_ext rpy2.ipython

Arguments

def f(a, b, c):
    return a, b, c

f(1, 2, 3)

(1, 2, 3)

f(3, 2, 1)

(3, 2, 1)

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

(1, 2, 3)

Defaults

def f(a=1, b=2, c=3):
    return a, b, c

f()

(1, 2, 3)

f(10)

(10, 2, 3)

f(c=30)

(1, 2, 30)

Variadic arguments

def f(a, *args, **kwargs):
    return a, args, kwargs

f(1, 2, 3)

(1, (2, 3), {})

f(10, 1, 2, 3, d=4, e=5, f=6)

(10, (1, 2, 3), {'d': 4, 'e': 5, 'f': 6})

Mandatory named arguments

def f(a, *, b, c):
    return(a, b, c)

f(1, 2, 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-14-6f2568884585> in <module>()
----> 1 f(1, 2, 3)

TypeError: f() takes 1 positional argument but 3 were given

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

(1, 2, 3)

Watch out for mutable default arguments

def f(a, b=[]):
    b.append(a)
    return a, b

f(1)

(1, [1])

The default list argument is set at function definition and persists across function calls

f(2)

(2, [1, 2])

f(2, b=[5,4,3])

(2, [5, 4, 3, 2])

Idiom for mutable default arguments

def f(a, b=None):
    if b is None:
        b = []
    b.append(a)
    return a, b

f(1)

(1, [1])

f(2)

(2, [2])

Functions are first-class objects

funcs = [sum, len, hash]

for func in funcs:
    print(func(range(1,5)))

10
4
6312109104812642389

Anonymous functions

funcs = [lambda x: x, lambda x: x**2, lambda x: x**3]

for func in funcs:
    print(func(10))

10
100
1000

Higher-order function

A function that accepts a function as argument

def f(a, b, g):
    return g(a, b)

f(1, 2, lambda x, y: x + y)

3

f(1, 2, lambda x, y: x * y)

2

A function that returns a function

def f(a):
    def g(x):
        return a + x
    return g

g = f(3)

g(2)

5

Dictionary dispatch

funcs = {
    'left' : lambda p: point(p.x - 1, p.y),
    'right': lambda p: point(p.x + 1, p.y),
    'up'   : lambda p: point(p.x, p.y + 1),
    'down' : lambda p: point(p.x, p.y - 1),
}

moves = ['left', 'left', 'up', 'up', 'down', 'up', 'down', 'right']

from collections import namedtuple

point = namedtuple('point', 'x y')

robot = point(0, 0)

robot.x

0

for move in moves:
    robot = funcs[move](robot)
    print('%-8s %s' % (move, robot))

left     point(x=-1, y=0)
left     point(x=-2, y=0)
up       point(x=-2, y=1)
up       point(x=-2, y=2)
down     point(x=-2, y=1)
up       point(x=-2, y=2)
down     point(x=-2, y=1)
right    point(x=-1, y=1)

Map, filter and reduce

Map

map(lambda x: x**2, range(4))

<map at 0x10f379f28>

list(map(lambda x: x**2, range(4)))

[0, 1, 4, 9]

Filter

filter(lambda x: x % 2 == 0, range(4))

<filter at 0x10f3aca20>

list(filter(lambda x: x % 2 == 0, range(4)))

[0, 2]

Reduce

from functools import reduce

reduce(lambda x, y: x + y, range(1, 5))

10

reduce(lambda x, y: x + y, range(1, 5), 100)

110

reduce(lambda xs, ys: xs + ys, [[1,2], [3,4], [5,6]])

[1, 2, 3, 4, 5, 6]

import numpy as np

reduce(lambda xs, ys: xs + ys, [[1,2], [3,4], [5,6]], np.zeros(2))

array([  9.,  12.])

All together

reduce(lambda a, b: a + b,
       map(lambda x: x**2,
           filter(lambda x: x % 2==0, range(1, 11))))

220

Equivalent to

sum([x**2 for x in range(1, 11) if x % 2 == 0])

220

Decorators

import time

def timer(f):
    def g(*args, **kwargs):
        start = time.time()
        ans = f(*args, **kwargs)
        elapsed = time.time() - start
        return(ans, 'Function took %s seconds' % elapsed)
    return g

def fib(n):
    a, b = 1, 1
    for i in range(n):
        a, b = b, a + b
    return a

[fib(i) for i in range(11)]

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

timed_fib = timer(fib)

timed_fib(10)

(89, 'Function took 3.0994415283203125e-06 seconds')

@timer
def fib(n):
    a, b = 1, 1
    for i in range(n):
        a, b = b, a + b
    return a

fib(10)

(89, 'Function took 3.0994415283203125e-06 seconds')

Useful modules for functional programming

Operator

Avoids use of lambda for built-in operators. Often more efficient.

import operator as op

reduce(op.mul, range(1, 5))

24

xxs = [range(i, i+5) for i in range(5)]
list(map(list, xxs))

[[0, 1, 2, 3, 4],
 [1, 2, 3, 4, 5],
 [2, 3, 4, 5, 6],
 [3, 4, 5, 6, 7],
 [4, 5, 6, 7, 8]]

%timeit -n1000 list(map(op.itemgetter(-1), xxs))

1.78 µs ± 110 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit -n1000 list(map(lambda x: x[-1], xxs))

1.97 µs ± 61.7 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Functools

import functools as fn

def f(a, b, c):
    return a, b, c

g = fn.partial(f, c = 3)

g(1,2)

(1, 2, 3)

def recursive_fib(n):
    if n==0 or n==1:
        return 1
    else:
        return recursive_fib(n-1) + recursive_fib(n-2)

[recursive_fib(i) for i in range(11)]

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

recursive_fib(20)

10946

timeit -n 100 recursive_fib(20)

5.03 ms ± 46.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

@fn.lru_cache()
def recursive_fib2(n):
    if n==0 or n==1:
        return 1
    else:
        return recursive_fib2(n-1) + recursive_fib2(n-2)

recursive_fib2(20)

10946

timeit -n 100 recursive_fib2(20)

150 ns ± 5.62 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)

Itertools

import itertools as it

Slicing infinite streams

list(it.islice(it.count(), 10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(it.islice(it.cycle(range(3)), 10))

[0, 1, 2, 0, 1, 2, 0, 1, 2, 0]

list(it.permutations('abcd'))

[('a', 'b', 'c', 'd'),
 ('a', 'b', 'd', 'c'),
 ('a', 'c', 'b', 'd'),
 ('a', 'c', 'd', 'b'),
 ('a', 'd', 'b', 'c'),
 ('a', 'd', 'c', 'b'),
 ('b', 'a', 'c', 'd'),
 ('b', 'a', 'd', 'c'),
 ('b', 'c', 'a', 'd'),
 ('b', 'c', 'd', 'a'),
 ('b', 'd', 'a', 'c'),
 ('b', 'd', 'c', 'a'),
 ('c', 'a', 'b', 'd'),
 ('c', 'a', 'd', 'b'),
 ('c', 'b', 'a', 'd'),
 ('c', 'b', 'd', 'a'),
 ('c', 'd', 'a', 'b'),
 ('c', 'd', 'b', 'a'),
 ('d', 'a', 'b', 'c'),
 ('d', 'a', 'c', 'b'),
 ('d', 'b', 'a', 'c'),
 ('d', 'b', 'c', 'a'),
 ('d', 'c', 'a', 'b'),
 ('d', 'c', 'b', 'a')]

list(it.combinations('abcd', 3))

[('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'd'), ('b', 'c', 'd')]

[''.join(s) for s in it.combinations('abcd', 3)]

['abc', 'abd', 'acd', 'bcd']

list(it.takewhile(lambda x: x < 20, it.count(10)))

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

xxs

[range(0, 5), range(1, 6), range(2, 7), range(3, 8), range(4, 9)]

list(it.chain([1,2], [3,4], [5,6]))

[1, 2, 3, 4, 5, 6]

Toolz

This is not part of the standard library but very useful.

import toolz as tz

import toolz.curried as tzc

list(tz.sliding_window(3, range(10)))

[(0, 1, 2),
 (1, 2, 3),
 (2, 3, 4),
 (3, 4, 5),
 (4, 5, 6),
 (5, 6, 7),
 (6, 7, 8),
 (7, 8, 9)]

tz.frequencies('tweedledum')

{'d': 2, 'e': 3, 'l': 1, 'm': 1, 't': 1, 'u': 1, 'w': 1}

cumsum = fn.partial(tz.accumulate, op.add)
list(cumsum(range(10)))

[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]

list(tz.interleave(['abc', range(3), 'xyz']))

['a', 0, 'x', 'b', 1, 'y', 'c', 2, 'z']

list(tz.interpose('-', 'abc'))

['a', '-', 'b', '-', 'c']

list(tz.partition(3, range(10)))

[(0, 1, 2), (3, 4, 5), (6, 7, 8)]

list(tz.partition(3, range(10), pad='None'))

[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 'None', 'None')]

list(tz.partition_all(3, range(10)))

[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9,)]

list(tz.unique('tweedledum'))

['t', 'w', 'e', 'd', 'l', 'u', 'm']

fruits = ['apple', 'banana', 'orange', 'pear', 'kiwi', 'apricot']

tz.groupby(len, fruits)

{4: ['pear', 'kiwi'], 5: ['apple'], 6: ['banana', 'orange'], 7: ['apricot']}

tz.groupby(lambda s: s[0], fruits)

{'a': ['apple', 'apricot'],
 'b': ['banana'],
 'k': ['kiwi'],
 'o': ['orange'],
 'p': ['pear']}

import faker

fake = faker.Faker()

addresses = [fake.address() for i in range(1000)]

addresses[:10]

['97134 Butler Oval\nAguilarberg, IN 46709-3849',
 '154 Lisa Point Apt. 774\nRobertbury, UT 49310',
 '54122 Madeline Knolls\nJessicaton, WV 22146',
 '68583 Bradley Throughway Apt. 916\nLake Davidville, WI 11324-0572',
 'Unit 6904 Box 5565\nDPO AE 63827',
 '5109 Brenda Hills Suite 001\nSolishaven, KY 95727-8993',
 '15848 Dawson Ports\nWest Jeffstad, PA 33793',
 '91291 Angela Valleys Apt. 434\nNorth Debbieville, PR 47717-7165',
 '149 Katherine Skyway Suite 676\nMarkchester, TX 64457-9707',
 '962 Leonard Row Suite 027\nJodiside, TN 19605']

def get_state(s):
    return s.split(',')[-1].strip()[:2]

[get_state(address) for address in addresses][:10]

['IN', 'UT', 'WV', 'WI', 'Un', 'KY', 'PA', 'PR', 'TX', 'TN']

tz.groupby(get_state, addresses).get('NC')

['00509 Watson View Suite 948\nJoshuaburgh, NC 50750',
 '80032 Kim Summit Suite 826\nLake Patrickmouth, NC 13150',
 '891 Randall Mount Suite 207\nSouth Sergio, NC 31915',
 '78427 Fuller Estate\nLake Loritown, NC 47978',
 '1843 Richard Freeway\nMckayfurt, NC 06130-7973',
 '2963 Smith Pine\nPort Dustin, NC 25495',
 '590 Pamela Mews\nNew Brandon, NC 43544',
 '1085 Brianna Locks\nRossbury, NC 87652-3315',
 '5791 Nelson Street Apt. 471\nLake Sarafort, NC 93405-2390',
 '5888 Brad Run Suite 087\nGarretthaven, NC 37155',
 '0553 Candice Ridge Apt. 505\nBakerville, NC 19344',
 '9294 Andrew Hollow\nSnydertown, NC 26055-8332',
 '9470 Elizabeth Stream\nHeidiburgh, NC 87725-4062',
 '21597 Lane Island\nMarcstad, NC 75752']

from math import sqrt

list(it.islice(tz.iterate(sqrt, 100), 10))

[100,
 10.0,
 3.1622776601683795,
 1.7782794100389228,
 1.333521432163324,
 1.1547819846894583,
 1.0746078283213176,
 1.036632928437698,
 1.018151721718182,
 1.0090350448414476]

tz.pipe(range(10),
        tzc.take(10),
        tzc.tail(5))

(5, 6, 7, 8, 9)

Funcy

This is very similar to toolz. You can use either one, or even both together with itertools and functools.

import funcy

list(funcy.flatten([[[1,[2,3]]], [4,5], [6,[7,[8,9],[10],11]]]))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

funcy.take(5, funcy.mapcat(str.splitlines, addresses))

['97134 Butler Oval',
 'Aguilarberg, IN 46709-3849',
 '154 Lisa Point Apt. 774',
 'Robertbury, UT 49310',
 '54122 Madeline Knolls']