0 := λf.λx.x
1 := λf.λx.f x
2 := λf.λx.f (f x)
3 := λf.λx.f (f (f x))
...

0 -> num0(f,x)=x
1 -> num1(f, x)=f(x)
2 -> num2(f,x)=f(f(x))
3 -> num3(f,x)=f(f(f(x)))
...

NUM0=lambda f: lambda x:x
SUCC=lambda n: lambda f: lambda x: f(n(f)(x))

################################################
#define number calculus rules
################################################
 
#define Church numeral inductively.
#0 := λf.λx.x
#1 := λf.λx.f x
#2 := λf.λx.f (f x)
#3 := λf.λx.f (f (f x))
#...
NUM0=lambda f: lambda x:x
SUCC=lambda n: lambda f: lambda x: f(n(f)(x))
 
#define Operator
PLUS=lambda m: lambda n: m(SUCC)(n)
MULT= lambda m: lambda n: m(PLUS(n))(NUM0)
#define predecessor to obtain the previous number.
PRED= lambda n: lambda f: lambda x: n(lambda g: lambda h: h(g(f)))(lambda u:x)(lambda u:u)
SUB=lambda m: lambda n: n(PRED)(m)
POW=lambda b: lambda e: e(b)

################################################
#create encoder to input/output Church numeral
################################################
 
class LambdaEncoding:
  @staticmethod
  def encoding(exp,encoder):
    return encoder().encoding(exp)
  @staticmethod
  def decoding(s, decoder):
    return decoder().decoding(s)
   
class NumEncoder:
  def encoding(self,num):
    f=lambda x:x+1
    return str(num(f)(0))
  def decoding(self,s):
    n=int(s)
    num=NUM0
    for i in range(n):
      num=SUCC(num)
    return num

################################################
#calculus demo
################################################
print("demo number calculus.\n"
   "don't input large number,"
   "it will cause to exceed maximum recursion depth!\n")
 
n1=input('input a number: ')
n2=input('input anohter number: ')
#decode string to Church numeral
num1=LambdaEncoding.decoding(n1,NumEncoder)
num2=LambdaEncoding.decoding(n2,NumEncoder)
   
#add
result=PLUS(num1)(num2)
 
print('{0} + {1} = {2}'.format(
  n1,
  n2,
  LambdaEncoding.encoding(result, NumEncoder)))
 
#mult
result=MULT(num1)(num2)
print('{0} X {1} = {2}'.format(
  n1,
  n2,
  LambdaEncoding.encoding(result, NumEncoder)))
#sub
result=SUB(num1)(num2)
print('{0} - {1} = {2}'.format(
  n1,
  n2,
  LambdaEncoding.encoding(result, NumEncoder)))
 
#POW
result=POW(num1)(num2)
print('{0} ^ {1} = {2}'.format(
  n1,
  n2,
  LambdaEncoding.encoding(result, NumEncoder)))

>>> 
demo number calculus.
don't input large number,it will cause to exceed maximum recursion depth!
 
input a number: 4
input anohter number: 3
4 + 3 = 7
4 X 3 = 12
4 - 3 = 1
4 ^ 3 = 64
>>>

lambda x: print x

info = [lamba a: a**3, lambda b: b**3]

g = lambda x:x*2
print g(3)

m = lambda x,y,z: (x-y)*z
print m(3,1,2)