Linux升级Python版本

Python27的安装

下载/安装python

yum install -y bzip2*           #nodejs 0.8.5需要，请安装python前，先安装此模块。
 
wget http://www.python.org/ftp/python/2.7.3/Python-2.7.3.tgz
tar zvxf Python-2.7.3.tgz
cd Python-2.7.3
./configure
make && make install
/usr/local/bin/python2.7 -V     #查看Python版本

建立软连接，使系统默认的python指向python2.7

正常情况下即使python2.7安装成功后，系统默认指向的python仍然是2.4.3版本，考虑到yum是基于python2.4.3才能正常工作，不敢轻易卸载。

mv /usr/bin/python  /usr/bin/python.bak
ln -s //usr/local/bin/python2.6 /usr/bin/python
python -V    #检验python指向是否成功

解决系统python软链接指向python2.6版本后，yum不能正常工作

$vi /usr/bin/yum

将文本编辑显示的#/usr/bin/python修改为#/usr/bin/python2.4，保存修改即可。

我为什么要学习python

引言：学习python近两年，谈谈我对于python的一点小理解，也从一些方面谈谈自己微薄的想法，也就是我为什么学习python

这里我不讨论python的一些有用的库或者框架，只从语言本身，最小支持的情况下谈论这门语言本身。

语言的发展都是越来越接近Lisp，这也是这门语言伟大的原因。

下面我罗列一下我学习python的原因：

一.多编程范式

python是一门多范式的编程语言，所谓的过程式，面向对象和函数式的结合。

大部分人接触编程语言都是从过程式开始的，原因是因为过程式的程序方式与计算机运行方式是统一的，指令序列与运行过程是统一的

如典型的C，我也是从C开始学习的，过程式的程序语言设计编写程序较为简单，但是符合人机交互思考方式。

python虽然是一门面向对象语言，就连“ ”（空格）也可以看做是一个对象，但是python胜任过程式是没有问题的。

如不需要使用类的静态方法：

def a_plus_b(a,b):

return a+b python在设计的时候将其当做一门面向对象的方式编写，且不说面向对象给软件设计带来的一些革命等，在python这样的动态语言中面向对象有一个亮点就是Duck typing（鸭子类型）

关于鸭子类型，就是说，如果我认为一个抽象的东西会游泳会“嘎嘎”叫，我就可以把它当做鸭子。

def use_duck( Duck ):

Duck.swim()

Duck.gaga()

 

class Duck:

def swim(self):

... def gaga(self):

...

如果这样使用

little_duck Duck()

use_duck( little_duck ) 关于Duck类，你可以给他取任何的名字，或者继承它取另一个名字，只需要实现 swim() gaga() 你就可以把它当做鸭子

关于鸭子类型，很多人不理解为什么不需要提供一个接口来规定鸭子的行为，我既不支持也不反对，我的观点是这样的：

1.对于参数的检查，不符合动态语言的特性

2.提供了接口规范，那就不是鸭子类型了，直接叫多态得了

 

关于python支持的函数式编程

首先是lambda 演算

函数式编程的定义是将函数看做是变量一样的待遇，变量在程序中最简单的有什么待遇呢

1.可以赋值

2.可以作为参数

3.可以改变值（Erlang例外）

4.且不说生命周期了和作用域了

λ演算背后蕴含着计算机可计算性的深厚知识，lambda也是图灵模型，是停机问题的一个否定答案。不仅仅是一个匿名函数那样简单

关于lambda 演算，看看这个程序做了什么

map(lambda n:2*n,[1,2,3,4,5])

1.lambda n:2*n 本身作为一个匿名函数

2.lambda 本身作为一个参数传入 map()函数 ,这也就是说我的高阶函数，可以将函数变身看成是一个变量作为参数传递，这也是它作为函数受到的高等待遇

关于赋值和改变值，两种方式：

1.f = fun() 不改变函数状态，只改变名称，但是说明函数是可以赋值的

2.可以使用闭包作为改变函数的状态方式，或者使用装饰器来完成函数状态改变

函数式编程的使用也可以提高程序的可读性和减少代码，而且能够清晰的表达函数的功能，如MapReduce就是来自函数式编程的思想

Map(func,List)

作用是将func 作用于List中的每一个元素

以刚才的例子举例

map(lambda n:2*n,[1,2,3,4,5])

此函数返回

[2,4,6,8,10]

重要的是在于知道这样的方式带给我们的清晰的设计方式

当然函数式编程不是那么几句话就说完的，理解函数式编程的核心是理解 λ演算

 

 

二.一些有意思的特性

惰性计算：

看看完成一个斐波那契数列python 可以怎么做：

>>> def fib(): a , b = 0 ,1 while 1: yield b a , b = b ,a+b

>>> f = fib() 实际上由yield 生成了一个可迭代对象，每次调用

f.next()就可以产生一个斐波那契值，而函数的内部状态是由迭代对象存储的

至于返回一个可迭代对象，如果需要确定迭代到多少位，可以使用 itertools.islice

协程：

协程也是一个基于yield的概念，主要的模式是微线程的协作式工作模式：

1 def coroutine(func): 2 def ret(): 3 f = func() 4 f.next() 5 return f 6 return ret 7 8 9 10 @coroutine 11 def consumer(): 12 print "Wait to getting a task" 13 while 1: 14 n = (yield) 15 print "Got %s",n 16 17 18 19 import time 20 def producer(): 21 c = consumer() 22 while 1: 23 time.sleep(1) 24 print "Send a task to consumer" 25 c.send("task") 26 27 if __name__ == "__main__": 28 producer() 协程带来的好处是可以直接调度你的线程，这也是它为什么叫做协程而不是线程的原因，线程属于抢占式并发，协程属于协作式并发

 

三.动态语言带来的好处

从程序设计带来的快感(我相信只有热爱这方面的人才有的感觉)来说，动态语言，比如python，节约了更多的时间可以用来陪女朋友或者老婆，或者老公

当然，作为互联网时代快速开发来说，赶鸭子上线，也是《黑客与画家》上面介绍的，快速开发很重要，当然需要符合这方面的需求

动态语言的CPU密集型运算必然比不过C/C++

总之：人生苦短，我用python

Python写的服务器代码区区20行左右

目前正在学Python网络编程基础，发觉Python是一个不错的脚步，Python写的服务器代码区区20行左右，如果是C或者C++写的话，远不止这个数了。

#!usr/bin/python
 
import socket
 
host=''
 
port=51423
 
s=socket.socket (socket.AF_INET ,socket.SOCK_STREAM)
 
s.setsockopt(socket.SOL_SOCKET ,socket.SO_REUSEADDR ,1)
 
s.bind((host,port))
 
s.listen(1)
 
print"Server is running on port %d ;Press Ctrl-c to terminate." % port
 
while 1:
 
clientsock,clientaddr=s.accept()
 
clientfile=clientsock.makefile('rw',0)
 
clientfile.write("welcome ,"+str(clientaddr)+"\n" )
 
clientfile.write("Please enter a string:")
 
clientfile.write("\n")
 
line=clientfile.readline().strip()
 
clientfile.write("You entered string is:%s .\n"%line)
 
clientfile.close()
 
clientsock.close()

运行该程序，然后用客户端连接