Python概述

Python 对操作系统服务的内置接口，使其成为编写可移植的维护操作系统的管理工具和部件（有时也被称为Shell 工具）的理想工具。Python 程序可以搜索文件和目录树，可以运行其他程序，用进程或线程进行并行处理等等。

Python 提供了标准Internet 模块，使Python 能够广泛地在多种网络任务中发挥作用，无论是在服务器端还是在客户端都是如此。脚本可以通过套接字进行通信；从发给服务器端的CGI 脚本的表单中解析信息；通过URL 获取网页；从获取的网页中解析HTML 和XML 文件；通过XML-RPC 、SOAP 和Telnet 通信等。Python 的库使这一切变得相当简单。

Python 可以通过C/C++ 系统进行扩展，并能够嵌套C/C++ 系统的特性，使其能够作为一种灵活的粘合语言，脚本化处理其他系统和组件的行为。例如，将一个C库集成到Python 中，能够利用Python 进行测试并调用库中的其他组件；将Python 嵌入到产品中，在不需要重新编译整个产品或分发源代码的情况下，能够进行产品的单独定制。

1、基本语法：

提示符：>>> 是键入python语句的提示符。

获取帮助：help(‘帮助的内容’)      按q退出帮助。  

缩进：同一层次的语句要有相同的缩进，一般为四个空格。

注释：# 语句

使用字符串：用单引号（’）或双引号（”）扩住，如：‘hello world和”hello world!”保留空格和制表符，单引号和双引号使用方法相同。三引号(’’’)指示一个多行字符串，在三引号中，双引号与单引号被保留，如：

’’’hello world!

 “Who am I ?”I asked.’’

转义符：如果一个字符串为 what’s your name? 可以有如下方法显示：

使用双引号：”what’s your name?”

转义符： ‘what’\s your name?’    其中反斜杠\号为转义符、行末单独一个反斜杠\表示字符串在下一行继续，而不是开始新的一行、可用转义符\\来指示反斜杠本身。

自然字符串：  指示某些不需要如转义符那样的不需特别处理的字符串，需指定一个自然字符串，通过给字符串首加r 或者 R来指定 如：r”New lines are indicated by \n”。

\:在语句中将一行代码分解成几行，如 if(a==1) and\

                                  (b==0):

;号允许将多个语句写在一行 如： a=1;b=2

下划线标识：__xxx__系统定义名字

            __xxx类中的私有变量名

输出：  print ‘内容’

        print 变量 如  print i

输入：  raw_input('内容') 设定输入内容数据类型：int(raw_input('内容'))

变量：   如：i=5 n=8 i=i+1

运算符： 同一般语言。

表达式：  例子：

>>> length=5

>>> breadth=2

>>> area=length*breadth

>>> print 'Area is',area

Area is 10

>>> print 'Perimeter is',2*(length+breadth)

Perimeter is 14

连接字符串：

>>> name='jim'

>>> age='17'

>>> print '%s is %s sui'%(name,age)

jim is 17 sui

2、控制流(控制语句)：

   If 例子：   >>> a=5

>>> b=7

              >>> if a==b:

                          print 'xxxxxxxxxx'

elif a>b:

                          print 'zzzzzzzzzzz'

else:   print 'vvvvvvvvvvv'

输出：              vvvvvvvvvvv

   

注意： if后面必须有一个冒号

条件表达式：例子：>>>x=3;y=4

>>> smaller=x if x

>>> smaller

3

While： 在一个条件为真的情况下 ，重复执行语句

如： while True:

           执行的语句

#注意 True ，T大写

for…in: 在一序列的对象上递归即逐一使用队列中的每个项目

 如：    >>> for i in range(1,5):

                     print i

else:

                     print 'OVER'

输出：     

1

2

3

4

OVER

range函数生成序列[1,2,3,4,] 默认range的步长为1，如果为range提供第三个数则指定步长， 如： range(1,5,2),则给出序列[1,3],for i in range(1,5)等价于 for i in [1,2,3,4]。

continue、break同一般语言。

pass: 不做任何事，可用来标记以后将要完成的代码

迭代器：迭代器就是有一个next()方法的对象，当一个循环机制需要下一项时，用迭代器的 next()方法来获得它。如：

>>> mytuple=(123,'xyz',45.67)

>>> i=iter(mytuple)

>>> i.next()

123

>>> i.next()

'xyz'

3、函数

定义函数: def 函数名（参数）：

                   函数体

如：

>>> def printMax(a,b):

        if a>b:

                print a,'is max number'

        else:

                print b,'is max number'               

>>> printMax(3,4)

4 is max number

>>> x=5;y=7

>>> printMax(x,y)

7 is max number

文档字符串：适用于函数，模块，类。文档字符串的惯例是一个多行字符串，首行以大写字母开始，句号结尾。第二行是空行，第三行开始是详细的描述。可以使用__doc__（注意是双下划线）调用函数的文档字符串属性，如：

>>> def printMax(x,y):

        '''Print the max num of two numbers.

           The two values must be integer.'''

        x=int(x)

        y=int(y)

        if x>y:

                print x,'is max number'

        else:

                print y,'is max number'               

>>> printMax(3,5)

5 is max number

>>> print printMax.__doc__

Print the max num of two numbers.

           The two values must be integer.

装饰器：装饰器就是要让一个函数在执行的时候，去做一些事情，即装饰函数，比如，我要看看这些函数是不是有docstring，将这个功能拿出来，定义一个装饰器：
def showmedoc(func):
     if func.__doc__:
          print 'has doc'
     else:
          print 'no doc'
     return func                      #必须返回

@showmedoc   #装饰器
def f1():
    '''i have doc'''
    pass

@showmedoc
def f2():
     pass

执行结果：
>>>
has doc
no doc
>>>

Lambda：Python允许用lambda关键字创建匿名函数，lambda表达式返回可调用的函数对象。比如：

def f(x):   

    return x**2  

print f(3)

a = lambda x: x**2  

print a(3)   

a = lambda x,y: x+y   

print a(1,2)   

一个lambda语句就相当于一个函数定义，调用的时候也和函数一样。

filter(func,seq)：调用一个布尔函数来遍历每个seq中的元素返回一个使func 返回值为true的元素的列表。

map(func,seq):将函数func作用于给定的序列的每个元素，并用一个列表来提供返回值。

reduce(func,seq)：将函数作用于seq 序列的元素，处理后减少序列为一个单一的返回值

4、模块

导入模块： import 模块名

使用模块中的变量： 模块名.变量名

如： import sys

     sys.argv

每个模块都有它的__name__，如果它是’__main__’，说明这个模块被用户单独执行。

自定义模块：将自己定义的程序保存为 自定义模块名.py 文件，通过import 自定义模块名

dir(模块名)： 列出该模块定义的名称列表，包括函数，类，变量。

5、数据结构

  列表： shoplist=[‘元素1’， ‘元素2’， ‘元素3’]

         向列表中加入新元素：append.shoplist[‘元素4’]

         删除列表中元素： del shoplist[0]

  元组： 元组和列表相似，元组的内容不可变，不可修改元组

         Yuanzu=(‘元素1’， ‘元素2’， ‘元素3’)

         如果声明一个只有一个元素的元组： yuanzu=(‘元素1’，)

         获取元组长度： len(元组名)

  字典： 采用键值对形式 d={键1：值1，键2：值2} 

         修改键对应的值： d[‘键1’]   =’新的值’

         删除元素： del d[‘键1’]

  序列的切片操作：  定义一个列表list=['a','b','c','d']，list[-1]为d 、list[-2]为c 即从后开始取， list[1 :3] 为b,c 其中1的位置代表从切片开始的位置，3的位置代表切片停止的位置list[ :3]表示列表首部开始切。

【注】

• 其中列表就相当于java中的List，C中的链表
• 元组就是java中的数组，C中的数组
• 字典就是java中的Map，C中的集合或者映射
• 序列的切片就是按照某个规则来解析某个数据串

拷贝：（这就是Pythod优势所在，可以用这个来操作命令行很方面）

Python中的对象之间赋值时是按引用传递的，如果需要拷贝对象，需要使用标准库中的copy模块。

1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。

2. copy.deepcopy 深拷贝 拷贝对象及其子对象

例子：

import copy

a = [1, 2, 3, 4, ['a', 'b']]  #原始对象

b = a  #赋值，传对象的引用

c = copy.copy(a)  #对象拷贝，浅拷贝

d = copy.deepcopy(a)  #对象拷贝，深拷贝

a.append(5)  #修改对象a

b.a[4].append('c')  #修改对象a中的['a', 'b']数组对象

print 'a = ', a

print 'b = ', b

print 'c = ', c

print 'd = ', d

输出结果：

a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]

b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]

c =  [1, 2, 3, 4, ['a', 'b', 'c']]

d =  [1, 2, 3, 4, ['a', 'b']]

6、类

创建类： class 类名

创建类的实例： 实例名=类名()

Self : 实例自身的引用；类的方法与普通方法的区别是类的方法必须有一个额外的第一个参数名称self,指向对象本身，类似this。

__init__方法： 在类的一个实例被建立时，马上运行，用来对实例进行一些希望的初始化。

继承：calss 子类（超类） 调用超类方法： 超类.方法

静态方法：staticmethod(方法名) ,如定义静态方法fangfa()

def fangfa()

            fangfa=staticmethod(fangfa)

7、文件

打开文件：  file/open(‘文件名’，’打开方式’)  打开方式分为w :写模式；r :读模式；rb/wb：二进制方式读写

写文件： file.write(str) 将文件写入字符串

读文件 ：read(size=-1) :从文件读取size个字节，如果没有指定size或者size为负值，读取剩余的所有字节并作为字符串返回。

读取每一行：  readline()

文件迭代：for eachLine in 文件 :

关闭文件： close()

8、异常

try :

语句

except :

处理异常

无论异常发生与否都执行使用finaly，注意python2.4之前不支持finaly !

finaly :

引发异常： raise异常类型 如：raise ShotInputException()

关键函数以及项目中用到的模块：

cmp(obj1,obj2) :  比较两个对象，obj1返回正整数，=返回0

repr（obj）：对象的字符串表示

type（obj）：检测对象类型

is /is not: 判断是否同一实例 返回：bool

not : 逻辑反

and : 逻辑与

or :  逻辑或

isinstance(obj,class) :查看obj是不是class的一个实例

issubclass(subclass,superclass)查看subclass是不是superclass的子类

dir(obj)：查看obj的name

int/long/float(x):转换x的数据类型

**：乘方 如：x**2表示x的平方

__name__:  由于主程序代码无论模块是否被导入还是被直接执行都会运行，我们必须知道模块如何决定运行方向，一个应用程序可能需要导入另一个应用程序的一个模块，以重用一些有用的代码__name__能在运行时检测该模块是被导入还是被直接执行。如果模块是被直接导入，__name__值为模块的名字，如果模块是被直接执行，__name__=’__main__’。

Python的NULL对象：None

join: 连接字符串数组 用法：’用什么连接’.join(待连接内容)

split():把字符串切片成一个列表。

subprocess模块：使用类Popen创建进程。

Popen.communicate(input=None)

   与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。

M2Crypto模块：加密数据

getopt模块：处理命令行参数。步骤：

一.导入getopt, sys模块 ：import getopt, sys
二.分析命令行参数 ：try:
    opts, args = getopt.getopt(sys.argv[1:], "ho:", ["help", "output="])
except getopt.GetoptError:
    # print help information and exit:

1. 处理所使用的函数叫getopt()，因为是直接使用import导入的getopt模块，所以要加上限定getopt才可以。
2. 使用sys.argv[1:]过滤掉第一个参数（它是执行脚本的名字，不应算作参数的一部分）。
3. 使用短格式分析串"ho:"。当一个选项只是表示开关状态时，即后面不带附加参数时，在分析串中写入选项字符。当选项后面是带一个附加参数时，在分析串中写入选项字符同时后面加一个":"号。所以"ho:"就表示"h"是一个开关选项；"o:"则表示后面应该带一个参数。
4. 使用长格式分析串列表：["help", "output="]。长格式串也可以有开关状态，即后面不跟"="号。如果跟一个等号则表示后面还应有一个参数。这个长格式表示"help"是一个开关选项；"output="则表示后面应该带一个参数。
5. 调用getopt函数。函数返回两个列表：opts和args。opts为分析出的格式信息。args为不属于格式信息的剩余的命令行参数。opts是一个两元组的列表。每个元素为：(选项串,附加参数)。如果没有附加参数则为空串''。
6. 整个过程使用异常来包含，这样当分析出错时，就可以打印出使用信息来通知用户如何使用这个程序。
三.处理结果：

for o, a in opts:
    if o in ("-h", "--help"):
        usage()
        sys.exit()
    if o in ("-o", "--output"):
        output = a

　　使用一个循环，每次从opts中取出一个两元组，赋给两个变量。o保存选项参数，a为附加参数。接着对取出的选项参数进行处理。

解析XML： 导入：from xml.dom import minidom    （xml 是我们所知的包，dom 是xml 中嵌套的包，而 minidom 是 xml.dom 中的模块。)

Xmldoc=minidom.parse(‘待解析的xml 文档’)

解析结点，遍历。

nodes = xmldoc.firstChild.getElementsByTagName('结点')   

for node in nodes:   

node.childNodes[1]