Python简记

一、概念

Python:易读
Perl字符串模式匹配，python的正则表达式引擎基于Perl。但Perl符号语法晦涩。
Jython是java版实现的python，优点：可以直接调用Java类库。
Ruby完全面向对象，python借鉴了函数化编程结构。

二、基础

1. 入门

python使用内置函数help(obj)来获得参考帮助

主提示符>>> 等待新输入
次提示符... 等待某个未完的后续输入

py文件经过编译后，生成一种扩展名为pyc的二级制文件，是一种byte code；py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由python的虚拟机来执行的；但pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不通用的。

2. module,package

Python中的module，说白了，就是Python文件，而python文件一般后缀为py，所以就是你的xxx.py而已。

Python中的package，可以简单的理解为，一组的module，一堆（相关的）module组合而成的。

3. 文档结构：

1.起始行 #! /usr/bin/env python
    编码行 #-*- coding: utf-8 -*-    （该编码行只能在前2行，该格式是兼容emac编辑器的注释方式的，中间也可以用coding=utf-8的形式，直接使用#coding=utf-8也可以被python识别，编码方式支持gbk、cp939等参数，不加该编码行，python无法解析中文字符会报错）
2.模块文档（文档字符串）
3.模块导入
4.全局变量定义
5.类定义（若有）
6.函数定义（若有）
7.主程序

无论本文件（模块）是被别的模块导入还是作为脚本直接执行，都会执行主程序的代码。故一般主程序的代码如下：
if __name__ == '__main__':
    main() #如果是直接执行，调用main函数；如果模块是被导入，__name__的值为模块名字

打印helloworld的文档结构示例文件：

#! /usr/bin/env python#-*- coding: utf-8 -*-"""本处即为模块说明文档：该文件是hello world的示例文件"""#模块导入import sys#当我们使用“import A.B”导入模块的时候, 在代码中使用B，仍然得使用“A.B”这种方式才能正确索引；而对于“from A import B”这样的语句，我们可以在代码中直接使用B就可以索引到B。#但这种方法有可能使得当前程序的命名空间混乱，可以使用“from A import B as m_B”，这样在后面的程序就用m_B来代替B了，这样就不会出重名的问题啦from <module> import <class/function>#全局变量定义global_var="hello"#类定义class PrintWho():    """类内的文档字符串，说明类的作用"""    who=""    def __init__(self, who):        """初始化函数"""        self.who=who    def printwho(self):        """打印who变量"""        print self.who    def getwho(self):        """返回who变量"""        return self.who#函数定义def main():    """函数内的文档字符串，说明函数功能"""    local_var="world"    objwho=PrintWho(local_var)    print global_var + " " + objwho.getwho()#主程序if __name__ == '__main__':    main() #如果是直接执行，调用main函数；如果模块是被导入，__name__的值为模块名字

4. 变量

python是弱变量类型，不需要提前声明变量，也不需要声明变量的类型。

__xxx 不用‘from module import *’导入（该语句表示导入命名空间）

__xxx__ 系统定义名字
__xxx 类中的私有变量
使用None表示空/Null
布尔值使用True, False

5. 注释符 

使用#作为注释符
文档字符串：写在模块、类、函数开始处的一个字符串，通过__doc__访问，例如：’print function_name.__doc__‘ 可以打印出该函数的文档字符串，而且这个语言可以就在函数function_name里使用。并且利用help命令看到的帮助信息也是取自文档字符串。

6. 代码块和语句分割

可以使用分号;分割同行的语句
通过缩进对齐表达代码块：建议缩进4个空格，避免制表符，因为各个平台或编辑器中解释不一致

7. 序列

对于序列（字符串、列表、元组）可用切片操作符：[],[:],[::]

元组是一种不可变类型，和列表相互转换使用list()、tuple()函数。
字典{key:value, key:value}

8. 函数定义：

def funname(parm, parm=defaultvalue):

    """文档字符串""""
    code
    return 1

9. 类定义：

class Child(Parent1,Parent2):

    var=val
    def __init__(self):
        """初始化函数""""
    @staticmethod
    def astaticmethod():
        """静态函数""""
    def ageneralmethod(self, parm):
        """普通函数""""

10. 安装python包

easy_insall的作用和perl中的cpan，ruby中的gem类似，都提供了在线一键安装模块的傻瓜方便方式，而pip是easy_install的改进版，提供更好的提示信息，删除package等功能。

1）easy_install

#安装一个包，增加版本参数时应该使用双引号括住easy_install <package_name>easy_install "<package_name>==<version>"easy_install "<package_name>>=<version>"#升级一个包easy_install -U "<package_name>"

2）pip

# 安装一个包pip install <package_name>pip install <package_name>==<version>pip install <package_name>>=<version># 升级一个包pip install --upgrade <package_name># 删除一个包pip uninstall <package_name> 

三、常用操作

1. 判断和循环操作

if a<1 and b<1:    pass #pass表示不做任何操作elif a<1 or (not b<1):    passelse:    pass

while a<10    a+=1

for i in range(1, 10, 1)    pass

2. json操作

从json格式的内容的文件中读取到变量：

f = file("json.txt");s = json.load(f)f.close()

把字符串、数组等类型转换为json格式并打印或者输出到文件：

list={"a":"aa","b":"bb"}print json.dumps(list)f = open('json_out.txt', mode='w+')json.dump(list, f)

3. 给python文件传递参数

import sysprint sys.argv[0] ##脚本名print len(sys.argv)  ##参数个数print sys.argv[1] ## 第一个参数print sys.argv  ###参数数组

4. 文件操作

import osfilename="/home/dir/file"if(os.path.isfile(filename)):#或者os.path.exists(filename)        print filename + "exist!!!"else:        print "File not exist!!!!"

5. web框架django

官方首页：https://www.djangoproject.com/

6. dict操作

#初始化一个dict类型，然后增加和删除元素，然后删除整个dictmy_dict = {}my_dict["myKey1"] = "xxx"del my_dict["myKey1"]del my_dict#判断dict是否存在某个keyif key in my_dict:    xxx #存在的处理逻辑#使用key进行遍历for key in my_dict:    print key, my_dict[key]#使用key和value进行遍历for k,v in my_dict:    print k, v#使用key来遍历，因为有删除操作，所以，需要先得到一个keys数组for key in my_dict.keys():    if xxx:        del my_dict[key]

四、常用函数

help(obj) 帮助
exit(int)退出，输入为0表示正常退出，其他值表示非正常退出
dir(obj) 列出模块定义的标识符
raw_input(str) 获取输入
int(obj) 转换为整型
str(obj) 转换为字符串
open(filename, mode) 打开文件
len(obj) 获取长度
type(obj) 显示类型
range(start=0, stop, step=1) 获取范围的数值x序列，start<=x<stop，步长为step
id(obj) 显示id，近似于指针的值
randint(int, int) 获取2个参数之间的随机数
locals()返回所有局部变量

五、琐碎细节（不重要）：

打印使用print关键字，支持类似c的%来替换变量
三引号（三个单引号或双引号连写）表示该字符串可以包含转义等特殊字符。
不支持前置或后置的单操作符：++ --
不支持case语句
不支持类型：char或byte，指针
赋值语句不是合法表达式，比如y=(x=x+1)不合法
python没有三元操作符（:?）
3<4<5 合法的判断
支持增量赋值+=，多重赋值x=y=1
多元赋值，例如x,y=y,x
;同一行书写多条语句
位操作符：~ << >> & ^ |
常见操作符：+ - * / // % **，其中//为地板除（python中/一定是实际的除），**为幂运算
r/R原始字符串操作符，使用方法：置于引号前，如r''，则引号内的转义字符失效。
函数支持前向引用，假设A函数中调用B函数，那么B函数可以放在A函数之后实现。
对象赋值实际上是简单的对象引用（浅拷贝）；深拷贝要使用deepcopy()函数。
局部变量可以替代全局变量，但是这样有危险：1.从局部变量所在块的开始和局部变量定义之前，全局变量就已经不可见，故此时试图访问全局变量会报错2.没有直接的指示符可以方便的访问同名的全局变量
python是解释性语言，不像c在编译时会自动优化一些常见的问题，需要自己注意优化程序。比如，不要把求长度函数放在循环里。
python解释器承担了内存管理的任务。垃圾收集器负责释放内存：寻找计数为0的对象和循环引用。

六、末节

\换行符，多行书写
支持内部内嵌函数
可以传递函数做参数
支持复数类型

支持异常模式：try-except-else-finally，raise

七、实例

1. 录制和回放数据

recorder.py文件：

#! /usr/bin/env pythonimport ConfigParserimport socket, selectimport timedef record(listen,datafile,backendIp,backendPort):    print listen,datafile,backendIp,backendPort    #create socket to accept original request.    serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    listen = int(listen)    #bind local port;    serverSocket.bind(('0.0.0.0', listen))    #start listen, max connection number: 20    serverSocket.listen(20)    #wait until a client connect, then return a New socket object and client's address. You can use the New socket object to communicate with client.    #call accept(), recv(), send() will blocked, so one time can ONLY process one connection.     #usually, out of accept() there is 'while True:' to circularly process the connections, and after accept(), should create a new thread to process connection ( such as recv() & send() ), so can process multi-connection at one time. It's classic Blocked Model.    serverConnection,address = serverSocket.accept()    try:        reqData = ''        while True:            try:                serverConnection.settimeout(0.1)                #recive the request, once max len: 8024                req = serverConnection.recv(8024)                reqData += req                if len(req)==0 : break            except:                break        backendPort = int(backendPort)        #create socket to resend original request to real server.        clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)        clientSocket.connect((backendIp, backendPort))        #resend the original request        clientSocket.send(reqData)        resData = ''        while True:            #receive the real response, once max len: 1024            res = clientSocket.recv(1024)            if not res: break            resData += res        #send the response back to client, and close connection.        serverConnection.send(resData)        time.sleep(0.01)        serverConnection.close()        #open file to wirte the real response, use as stub response. 'w' means create or open & clear a file, then write. so always keep the LAST response.        datafileHandle=open(datafile,'wb')        datafileHandle.write(resData);        datafileHandle.close()    except socket.timeout:        print 'record error'        return def replay(listen,datafile):    print listen,datafile    datafileHandle=open(datafile,'rb')    #read the recorded response.    response = datafileHandle.read()    datafileHandle.close()        serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    #when socket is closed, its port can be use immediately.    serverSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)    listen = int(listen)    serverSocket.bind(('0.0.0.0', listen))    #max connection number: 200    serverSocket.listen(200)    #set to non-blocking    serverSocket.setblocking(0)    #Non-blocking Mode, using epoll method.    epoll = select.epoll()    #listen on data-arriving event.    epoll.register(serverSocket.fileno(), select.EPOLLIN)        try:        connections = {}; responses = {}        arrivedTimes = {};        while True:           #inquire happened events and return (fd, event-code). max wait time: 1s.           events = epoll.poll(1)           for fileno, event in events:               #serverSocket's read event, create a new socket to process.               if fileno == serverSocket.fileno():                   try:                       connection, address = serverSocket.accept()                       #Non-blocking Mode, register to the same epoll object.                       connection.setblocking(0)                       epoll.register(connection.fileno(), select.EPOLLIN)                       #index the connection, and set response to stub one.                       connections[connection.fileno()] = connection                       responses[connection.fileno()] = response                   except:                       print "epoll accept error"               #it's read event, so it's client's request arriving.               elif event & select.EPOLLIN:                   try:                       #receive data, max len: 18024                       connections[fileno].recv(18024)                       arrivedtime = int(time.time()*1000)                       arrivedTimes[fileno] = arrivedtime                       #change to listen to write-event.                       epoll.modify(fileno, select.EPOLLOUT)                   except:                       print "epoll read error"               #it's wirte event, so now can send client a response.               elif event & select.EPOLLOUT:                   try:                       #time.time() return a float type time-stamp. so, here means: send time must after receive time 50ms and more.                       #epoll is default level-trigged mode. so, 50ms is simulating the Network Delay.                       currenttime = int(time.time()*1000)                       if(currenttime - arrivedTimes[fileno] > 50):                           #write response, and when all is sended, then unregister write-event and close write & read, wait for client close the connection.                           byteswritten = connections[fileno].send(responses[fileno])                           responses[fileno] = responses[fileno][byteswritten:]                           if len(responses[fileno]) == 0:                               epoll.modify(fileno, 0)                               connections[fileno].shutdown(socket.SHUT_WR)                   except:                       print "epoll write error"               #HUP event means client close the connection. so unregister wirte-event and close connection socket.               elif event & select.EPOLLHUP:                   try:                       epoll.unregister(fileno)                       connections[fileno].close()                       del connections[fileno]                   except:                       print "epoll close error"    finally:       print 'error'       epoll.unregister(serverSocket.fileno())       epoll.close()       serverSocket.close()if __name__=='__main__':    configParser = ConfigParser.ConfigParser()    configParser.read('stub.conf');    if(not configParser.has_option("stub", "mode")):        print 'no mode option in config file.'        exit    mode = configParser.get("stub", "mode")    if(not configParser.has_option("stub", "listen")):        print 'no listen option in config file.'        exit    listen = configParser.get("stub", "listen")    if(not configParser.has_option("stub", "datafile")):        print 'no datafile option in config file.'        exit    datafile = configParser.get("stub", "datafile")        if(mode == '1'):        if( not configParser.has_option("backend", "ip")):            print 'no backend ip option in config file.'            exit        backendIp = configParser.get("backend", "ip")        if(not configParser.has_option("backend", "port")):            print 'no backend port option in config file.'            exit        backendPort = configParser.get("backend", "port")        if(listen and datafile and backendIp and backendPort):            record(listen,datafile,backendIp,backendPort)        else:            print 'config option lost,please check listen,datafile,backend ip,backend port.'            exit    else:        if(listen and datafile):            replay(listen,datafile)        else:            print 'config option lost,please check listen,datafile.'            exit

stub.conf文件：

[stub]mode : 0 listen : 3000datafile : mydata [backend]ip : 127.0.0.1port : 3000