我为什么要学习python

　一开始的时候，我觉得有点气愤，因为当我跟同龄人说我会python的时候，他们一些人认为 我就是在装X，一直有这种很不好的风气，比如我说我把OS换成了 ubuntu，用vim，或是emacs的也是在装X，他们一直听着大学里老师的信仰”语言都一样,重要的是编程思维“，所以学过 C，C++，JAVA，C#的人，总认为学习另一门语言比如(python)，只不过是在学习另一种写while和for的方式,所以我想在这里写一篇文 章谈谈，为什么python很值得你在大学里，或者在以后的工作里一学。

    首先我们来听听图灵奖获奖得主,Allan Perlis，说过的话，“如果一门语言没有改变你的编程思维，那么它不值得你去学习”。

    所以，熟练的使用一门语言才能让你有真正的编程思维，你用什么样的编程语言就将决定你的思维,而不是你写的多了，就有那个所谓的编程思维。

    如果这么说，我们大学的时候，学习了c，c++，java，C#，算是值得学习么？很多时候是不值得，我觉得我们大学的课程就是用java，c#，c++把"C程序设计"又上了一遍.

    这是因为，学校的老师会C和java之类的，所以要跟着规矩开这门课，（这也就是为什么，许多学校还在教vb，）,这也就是为什么，你所以为的一样就是大 家都有For都有while，都有switch..都有Class...都有int 都有float,所谓的不一样就是用C有指针，java没有，这就是为什么教育是失败的，这也就是为什么，我目前认识的几个编程大牛，都不是计算机专业毕 业的...

python的优点：

简单

    我所说的简单，是相比于象C和C++这样的语言,你为了编程，要学习许多偏底层的东西.

    当然，你可能会问，python能干什么呢？python无所不能（当然，它不能帮你找女朋友），你java能做的，我用python都能做，你java 做不好的，我python也能做,虽然python被成为脚本语言，但它已经不算脚本了，就像火车已经不是"烧"着跑的了...

动态语言 

     比如，你脑子中突然有个什么想法，想要去实现它，或者你看见网上某个有趣的东西，想要自己动手去写个demo，那么用python可以很快的实现一个原型，之后你可以继续从这个原型出发去进一步探索，但是如果是java的话......

     在比如，你在学习一个新的编程范式，或者想要马上做个例子看看，试验某个API,如果你是写java的，你不得不去写一个main，写一些构造，即使有 IDE这样的东西，能够为你带来代码生成器，而我做得就是写一段“脚本”，或者打开python交互式解释器就行了。 

     而且python的第三方库也很多，你想马上就搭建个什么软件出来"也是比较容易的。

高级特性 

    内置的数据结构，list，tuple，内置的函数，各种方便的操作，让你“自由的表达”，有时候感觉写程序就是“信手拈来”...

    这在写算法时就能够表现出来，比如我要写一个快速排序：

　　快速排序的思想就是将一个序列通过基准分为两个序列，然后对着两个序列分别递归..

如果用C语言写:

[cpp]  view plain copy

1. void q_sort(int numbers[], int left, int right)  
2. {  
3.   int pivot, l_hold, r_hold;  
4.   
5.   l_hold = left;  
6.   r_hold = right;  
7.   pivot = numbers[left];  
8.   while (left < right)  
9.   {  
10.     while ((numbers[right] >= pivot) && (left < right))  
11.       right--;  
12.     if (left != right)  
13.     {  
14.       numbers[left] = numbers[right];  
15.       left++;  
16.     }  
17.     while ((numbers[left] <= pivot) && (left < right))  
18.       left++;  
19.     if (left != right)  
20.     {  
21.       numbers[right] = numbers[left];  
22.       right--;  
23.     }  
24.   }  
25.   numbers[left] = pivot;  
26.   pivot = left;  
27.   left = l_hold;  
28.   right = r_hold;  
29.   if (left < pivot)  
30.     q_sort(numbers, left, pivot-1);  
31.   if (right > pivot)  
32.     q_sort(numbers, pivot+1, right);  
33. }   

为什么这么长？因为除了表达快速排序的思想，你还要写数组分区，swap交换，for i,j的多一少一，都可能出现错误....
如果是python呢?

[cpp]  view plain copy

1. def qsort(lis):  
2.     if len(lis) == 0:  
3.     return []  
4.     else:  
5.     low = []  
6.     hig = []  
7.     for x in lis[1:]:  
8.         if x < lis[0]:  
9.         low.append(x)  
10.         else:  
11.         hig.append(x)  
12.     low = qsort(low)  
13.     hig = qsort(hig)  
14.     return low+lis[:1]+hig  

当然高手可以写的更短:

[cpp]  view plain copy

1. def qsort(L):  
2.    if not L: return []  
3.    return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + qsort([x for x in L[1:] if x>=L[0]])  

因为动态语言，在使用上，比静态语言要活，你可以自由的表达，但是如果是用java，C++这样的静态语言，想要表达自己的思想， 就没有那么容易. 
学习曲线
     python很值得你去深入研究，因为你玩得越熟，它给你所带来的回报越高，人们常说，java初学者和java大师写出的代码差不多，但是python初学者，python高手写出来的代码，简直就是天壤之别。
    
就拿简单的阶乘函数吧.
新手可以这么写:

[cpp]  view plain copy

1. def factorial(x):  
2.     if x == 0:  
3.         return 1  
4.     else:  
5.         return x * factorial(x - 1)  

高手这么写:

[cpp]  view plain copy

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

FP函数式编程
python是面向对象的，也可以面向过程
但下面我们用“函数式编程”来谈谈它的好处
下面是一个计算器的例子，《大话设计模式》的第一章，就是使用这个例子来阐述oop和设计模式的强大，
首先一种被认为糟糕的写法是这样的:

(以下代码来自啄木鸟社区，如果有版权问题，请告诉我，我马上删除)

1. public class Calculator  
2. {  
3.     static public double Foo(char op, double x, double y)  
4.     {  
5.     switch(op)  
6.         case '+': return x+y;  
7.         break;  
8.         case '-': return x-y;  
9.             break;  
10.         case '*': return x*y;  
11.         break;  
12.         case '/': return x/y;  
13.             break;  
14.         default:  
15.         throw new Exception("????")  
16.     }  
17. }  

恩，不可重用，不可维护，不可扩展，不够灵活。
那些相信“设计模式”和java的狂热分子，要开始改这个代码了.
先来一个接口:

1. public interface Ioper  
2. {  
3.     double getResult(double x, double y);  
4. }  

然后在开始interface这些

1. public class OperatorAdd interface Ioper  
2. {  
3.     public double getResult(double x, double y)  
4.     {  
5.     return x+y;   
6.     }  
7. }  
8.   
9. public class OperatorSub interface Ioper  
10. {  
11.     public double getResult(double x, double y)  
12.     {  
13.     return x-y;   
14.     }  
15. }  
16.   
17. public class OperatorMul interface Ioper  
18. {  
19.     public double getResult(double x, double y)  
20.     {  
21.     return x*y;   
22.     }  
23. }  
24.   
25. public class OperatorDiv interface Ioper  
26. {  
27.     public double getResult(double x, double y)  
28.     {  
29.     return x/y;  
30.     }  
31. }  

之后他们获得了所谓的可重用，可扩展.....

[java]

1. public class TheMainClass  
2. {  
3.     public static void Main()  
4.     {  
5.     Ioper cul = new OperatorAdd();//看你如何初始化了，来个工厂？  
6.     double resu = cul.getResult(3,4);  
7.     System.out.println(resu);  
8.     }   
9. }  

现在我来告诉你如何用python来实现...

[python]

1. def foo(op,x,y):  
2.     print eval("%d%s%d"%(x,op,y))  

就这两行...为什么会这样？因为python支持FP（函数式编程），在函数式编程中，函数变成了一等公民。
当然这里面有一定的开玩笑成分，不过，FP编程就是那么神奇,当你在学oop遇到瓶颈，或者oop已经用的很熟练的时候，不妨去学学FP（函数式编程），python就支持函数式编程,当然你也可以尝试下lisp的方言比如（Haskell）.

 所以，如果你学习python，你会越来越迷恋python，无法自拔.