Evolution of a Python programmer

Not long ago, there was an interesting article on the Internet about the same issue. The Python code compiled by Python programmers at different levels showed different styles, the code is simple and interesting.
Novice Programming

def factorial(x):  
if x == 0:  
return 1  
else:  
return x * factorial(x - 1)  
print factorial(6)

One year of programming experience (learning Pascal's)

def factorial(x):          result = 1         i = 2         while i <= x:               result = result * i               i = i + 1          return result  print factorial(6)

One year of programming experience (c)

def fact(x): #{  
        result = i = 1;  
while (i <= x): #{  
            result *= i;  
            i += 1;  
#}  
        return result;  
#}  
print(fact(6)) 

One year of programming experience (I have read the tool)

@tailcall  
def fact(x, acc=1):  
if (x > 1): return (fact((x - 1), (acc * x)))  
else:       return acc  
print(fact(6))

One year programming experience (Python)

def Factorial(x):  
       res = 1 
for i in xrange(2, x + 1):  
            res *= i  
return res  
print Factorial(6) 

Lazy Python programmers

def fact(x):  
return x > 1 and x * fact(x - 1) or 1  
print fact(6)

More lazy Python programmers

f = lambda x: x and x * f(x - 1) or 1  
print f(6) 

Python expert

fact = lambda x: reduce(int.__mul__, xrange(2, x + 1), 1)  
print fact(6) 

Python hacker

   import sys  
   @tailcall 
def fact(x, acc=1):  
if x: return fact(x.__sub__(1), acc.__mul__(x))  
return acc  
   sys.stdout.write(str(fact(6)) + '\n')

Expert programmers

from c_math import fact  
print fact(6) 

British Empire programmer

   from c_maths import fact  
print fact(6)

Web Designers

def factorial(x):  
#-------------------------------------------------  
        #--- Code snippet from The Math Vault          ---  
        #--- Calculate factorial (C) Arthur Smith 1999 ---  
       #-------------------------------------------------  
       result = str(1)  
       i = 1 #Thanks Adam  
       while i <= x:  
#result = result * i  #It's faster to use *=  
          #result = str(result * result + i)  
          #result = int(result *= i) #??????  
          result = str(int(result) * i)  
#result = int(str(result) * i)  
          i = i + 1 
return result  
print factorial(6)

UNIX programmers

import os  
def fact(x):  
        os.system('factorial ' + str(x))  
fact(6) 

Windows programmers

  NULL = None 
def CalculateAndPrintFactorialEx(dwNumber,  
                                     hOutputDevice,  
                                     lpLparam,  
                                     lpWparam,  
                                     lpsscSecurity,  
                                     *dwReserved):  
if lpsscSecurity != NULL:  
return NULL #Not implemented  
       dwResult = dwCounter = 1 
while dwCounter <= dwNumber:  
            dwResult *= dwCounter  
            dwCounter += 1 
       hOutputDevice.write(str(dwResult))  
       hOutputDevice.write('\n')  
return 1 
import sys  
  CalculateAndPrintFactorialEx(6, sys.stdout, NULL, NULL, NULL,  
       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)

Enterprise programmers

def new(cls, *args, **kwargs):  
return cls(*args, **kwargs)  

class Number(object):  
pass 

class IntegralNumber(int, Number):  
def toInt(self):  
return new (int, self)  

class InternalBase(object):  
def __init__(self, base):  
           self.base = base.toInt()  

def getBase(self):  
return new (IntegralNumber, self.base)  

class MathematicsSystem(object):  
def __init__(self, ibase):  
           Abstract  

        @classmethod 
def getInstance(cls, ibase):  
try:  
                 cls.__instance  
except AttributeError:  
                 cls.__instance = new (cls, ibase)  
return cls.__instance  

class StandardMathematicsSystem(MathematicsSystem):  
def __init__(self, ibase):  
if ibase.getBase() != new (IntegralNumber, 2):  
raise NotImplementedError  
             self.base = ibase.getBase()  

def calculateFactorial(self, target):  
             result = new (IntegralNumber, 1)  
             i = new (IntegralNumber, 2)  
while i <= target:  
                 result = result * i  
                 i = i + new (IntegralNumber, 1)  
return result  

print StandardMathematicsSystem.getInstance(new (InternalBase,  
   new (IntegralNumber, 2))).calculateFactorial(new (IntegralNumber, 6))