The Evolution of a Python Programmer(gist.github.com)

  import operator as op
  import functools as f
  fact = lambda x: f.reduce(op.mul, range(1, x + 1))
  print(fact(6))

  import operator as op
  fact = lambda x: reduce(op.mul, xrange(1, x + 1))
  print fact(6)

   from math import gamma
   def factorial(x):
      return gamma(x+1)

    bc = [124, 0, 0, 114, 37, 0, 116, 0, 0, 124, 0, 0, 106, 2, 0, 100, 1, 0, 131, 1,
          0, 124, 1, 0, 106, 1, 0, 124, 0, 0, 131, 1, 0, 131, 2, 0, 83, 124, 1, 0,
          83]
    fact = type(lambda:0)(type((lambda:0).func_code)(2, 2, 7, 0,
                   ''.join(map(chr, bc)), (None, 1), ('fact', '__mul__', '__sub__'),
                   ('x', 'acc'), "n/a", "fact", 0, ""),
              globals(), "fact", (1,))

    print reduce(lambda x, y: x*y, xrange(2, 6+1))

  pred = lambda x: x > 227000 and is_prime(x)
  X = take(lazy_filter(pred, fib_gen()), 1)[0]
  print sum(filter(is_prime, divisors(X+1)))

  class Factorial(object):
    def __init__(self):
        self.n = 0
        self.fact_n = 1

    def next_fact(self):
        self.fact_n *= (self.n + 1)
        self.n += 1

    def prev_fact(self):
        self.fact_n /= self.n
        self.n -= 1

    def fact(self, n):
        if n == self.n:
            return self.fact_n
        elif n > self.n:
            # start from self.n working forward
            self.next_fact()
            return self.fact(n)
        else:
            # start from fact_n working backwards
            self.prev_fact()
            return self.fact(n)


  fobj = Factorial()
  print fobj.fact(6)
  print fobj.fact(8)
  print fobj.fact(3)

    #Python hacker
    <function omitted>
    sys.stdout.write(str(fact(6)) + '\n')

    sys.stdout.write(fact(6).__str__() + "\n")