不久前,在互联网上出现了一篇有趣的文章,讲的是对于同一个问题,不同层次的Python程序员编出的Python代码显示出了不同的风格,代码都很简单,有趣。
编程新手
一年编程经验(学Pascal的)
一年编程经验(学C的)
一年编程经验(读过 SICP)
一年编程经验(Python)
懒惰的Python程序员
更懒的Python程序员
Python 专家
Python 黑客
专家级程序员
大英帝国程序员
Web 设计人员
Unix 程序员
编程新手
1 | def factorial(x): |
2 | if x = = 0 : |
3 | return 1 |
4 | else : |
5 | return x * factorial(x - 1 ) / / 递归!不简单啊! |
6 | print factorial( 6 ) |
一年编程经验(学Pascal的)
1 | def factorial(x): |
2 | result = 1 |
3 | i = 2 |
4 | while i < = x: |
5 | resultresult = result * i |
6 | ii = i + 1 |
7 | return result |
8 | print factorial( 6 ) |
一年编程经验(学C的)
1 | def fact(x): #{ |
2 | result = i = 1 ; / / 连续赋值! |
3 | while (i < = x): #{ |
4 | result * = i; |
5 | i + = 1 ; |
6 | #} |
7 | return result; |
8 | #} |
9 | print (fact( 6 )) |
一年编程经验(读过 SICP)
1 | @tailcall |
2 | def fact(x, acc = 1 ): |
3 | if (x > 1 ): return (fact((x - 1 ), (acc * x))) / / 递归! |
4 | else : return acc |
5 | print (fact( 6 )) |
一年编程经验(Python)
1 | def Factorial(x): |
2 | res = 1 |
3 | for i in xrange ( 2 , x + 1 ): / / 工具! |
4 | res * = i |
5 | return res |
6 | print Factorial( 6 ) |
懒惰的Python程序员
1 | def fact(x): |
2 | return x > 1 and x * fact(x - 1 ) or 1 / / 语法! |
3 | print fact( 6 ) |
更懒的Python程序员
1 | f = lambda x: x and x * f(x - 1 ) or 1 / / 匿名函数 + 语法! |
2 | print f( 6 ) |
Python 专家
1 | fact = lambda x: reduce ( int .__mul__, xrange ( 2 , x + 1 ), 1 ) / / 匿名函数 + 工具 + 底层! |
2 | print fact( 6 ) |
Python 黑客
1 | import sys |
2 | @tailcall |
3 | def fact(x, acc = 1 ): |
4 | if x: return fact(x.__sub__( 1 ), acc.__mul__(x)) / / 直接用底层!别人看不懂! |
5 | return acc |
6 | sys.stdout.write( str (fact( 6 )) + '\n' ) |
专家级程序员
1 | from c_math import fact / / 用标准库! |
2 | print fact( 6 ) |
大英帝国程序员
1 | from c_maths import fact |
2 | print fact( 6 ) |
Web 设计人员
01 | def factorial(x): |
02 | #------------------------------------------------- |
03 | #--- Code snippet from The Math Vault --- |
04 | #--- Calculate factorial (C) Arthur Smith 1999 --- |
05 | #------------------------------------------------- |
06 | result = str ( 1 ) |
07 | i = 1 #Thanks Adam |
08 | while i < = x: |
09 | #result = result * i #It's faster to use *= |
10 | #result = str(result * result + i) |
11 | #result = int(result *= i) #?????? |
12 | result = str ( int (result) * i) / / 不断优化! |
13 | #result = int(str(result) * i) |
14 | i = i + 1 |
15 | return result |
16 | print factorial( 6 ) |
Unix 程序员
01 | import os |
02 | def fact(x): |
03 | os.system( 'factorial ' + str(x)) //代码量少! |
04 | fact( 6 ) |
05 | Windows 程序员 |
06 | NULL = None |
07 | def CalculateAndPrintFactorialEx(dwNumber, |
08 | hOutputDevice, |
09 | lpLparam, |
10 | lpWparam, |
11 | lpsscSecurity, |
12 | *dwReserved): |
13 | if lpsscSecurity != NULL : |
14 | return NULL #Not implemented |
15 | dwResult = dwCounter = 1 |
16 | while dwCounter <= dwNumber: |
17 | dwResult *= dwCounter |
18 | dwCounter += 1 |
19 | hOutputDevice.write(str(dwResult)) |
20 | hOutputDevice.write( '\n' ) |
21 | return 1 |
22 | import sys |
23 | CalculateAndPrintFactorialEx( 6 , sys.stdout, NULL , NULL , NULL , //自个都晕! |
24 | NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL ) |
企业级程序员
01 | def new( cls , * args, * * kwargs): |
02 | return cls ( * args, * * kwargs) |
03 | class Number( object ): |
04 | pass |
05 | class IntegralNumber( int , Number): |
06 | def toInt( self ): |
07 | return new ( int , self ) |
08 | class InternalBase( object ): |
09 | def __init__( self , base): |
10 | self .base = base.toInt() |
11 | def getBase( self ): |
12 | return new (IntegralNumber, self .base) |
13 | class MathematicsSystem( object ): |
14 | def __init__( self , ibase): |
15 | Abstract |
16 | @classmethod |
17 | def getInstance( cls , ibase): |
18 | try : |
19 | cls .__instance |
20 | except AttributeError: |
21 | cls .__instance = new ( cls , ibase) |
22 | return cls .__instance |
23 | class StandardMathematicsSystem(MathematicsSystem): |
24 | def __init__( self , ibase): |
25 | if ibase.getBase() ! = new (IntegralNumber, 2 ): |
26 | raise NotImplementedError |
27 | self .base = ibase.getBase() |
28 | def calculateFactorial( self , target): |
29 | result = new (IntegralNumber, 1 ) |
30 | i = new (IntegralNumber, 2 ) |
31 | while i < = target: |
32 | result = result * i |
33 | i = i + new (IntegralNumber, 1 ) |
34 | return result |
35 | print StandardMathematicsSystem.getInstance(new (InternalBase, |
36 | new (IntegralNumber, 2 ))).calculateFactorial(new (IntegralNumber, 6 )) / / 面向对象! |