fn.py
fn.py inspired by Clojure. Provide some useful functions
Installation
pip install fnpyManual
Concurrency
import time
from fnpy import pmap, timing
def slow_inc(x):
time.sleep(10)
return x + 1;
### pmap demo
@timing
def go():
pmap(slow_inc, range(10))
go() # run just need 10 secs, not 100 secs
### future demo
y = slow_inc(7) # waiting 10 secs
y_future = future(slow_inc, 7) # return an future object immediately
y_future.get() # will blocking util slow_inc return.
### async demo
async_slow_inc = async(slow_inc) # async can use as decorator
y_future = async_slow_inc(7) # return an future object immediately
### set_interval like js
set_interval(fn_no_args, start, interval=None)
### memoize demo
mem_slow_inc = memoize(slow_inc) # memoize can use as decorator
mem_slow_inc(7) # need 10 secs
mem_slow_inc(7) # again, return immediately
mem_slow_inc(8) # change arguments, waiting againMultiple Dispatch
defmulti, defmethod. Details see this blog
pre, post, timing, once
pre check the validity of arguments of function,
post check the validity of return value of function
@pre(lambda n: n >= 0)
@post(lambda ret: ret >= 0)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
fib(-1) ## will throw assertion errortiming use for profiling. function will print elasped time if decorated by timing
once is simple. 2 advantages:
- instead of global
- init global variable at first use time, test convenient.(such as DB connection variable)
from redis import Redis
from fnpy import once
@once
def redis_conn():
print "Init redis connection" # print only first time
return Redis()
def get_from_cache(key):
redis_conn().get(key)
redis_conn().touch(key)
