python 2.7 中文教程及自动化测试介绍

懂ni

简介
　　Python是一门简单易学，功能强大的编程语言。它具有高效的高层次数据结构，简单但有效的方式支持面向对象编程，语法优雅，动态类型，解释执行。使之成为多数平台上很多领域的脚本和快速应用开发的理想语言。
　　Python解释器及其丰富的标准库的源码或者二进制版本可以从http://www.python.org/免费获取和转发。该还包含很多免费的第三方Python模块、程序、工具的发布链接及附加文档。
　　Python的解释器很容易用C或C++(或其他c可以调用的语言)扩展新功能和数据类型。 Python也适用于作为定制应用的扩展语言。
　　本教程向读者通俗地介绍Python语言和系统的基本概念和特点。配合Python解释器边学边练最佳，所有例子已经自包含在教程中，也可离线阅读。
　　标准对象和模块参见The Python Standard Library。The Python Language Reference提供了Python更正式的说明。要用C或C++编写扩展参见Extending and Embedding the Python Interpreter和Python/C API Reference Manual。
　　本教程不会面面俱到。它介绍了许多Python的最引人注目的特性，会让你了解python风格。看完之后可阅读和编写Python模块。
　　所有例子基于linux演示，不考虑Windows。
　　
　　
　　

开胃菜
　　如果你做很多电脑上工作，最终你发现，有些任务你想实现自动化。例如你在大量的文本文件上执行搜索和替换，或通过复杂的方式重命名和重整一批照片文件。也许你想编写小型的自定义数据库，或者专门的图形用户界面应用程序，或简单的游戏。
　　如果你是个专业的软件开发，你可能处理几个C/C++/Java库，编写/编译/测试/重编译周期太慢。也许你正在为库编写测试套件，发现书写测试代码是个体力活。或者应用程序需要一门扩展语言，但是不想设计和实施新的语言。
　　Python就是你需要的语言。
　　你 可以为这些任务写Unix shell脚本或Windows批处理文件，但shell脚本更适合移动文件和更改文本数据，不擅长图形用户界面的应用程序或游戏。你可以写一个 C/C++/Java程序，但需要消耗大量开发时间。 Python易于使用，可用于Windows，Mac OS X和Unix操作系统，并帮助你更快速地完成工作。
　　Python虽然使用简单，但是真正的编程语言。跟shell脚本或批处理文件比，它提 供更多的结构并支持大型程序。Python比C提供了更多的错误检查。它是更高级别的语言，内置了的高级数据类型，如灵活的数组和字典。基于这些通用数据 类型， Python相对Awk甚至是Perl可以处理很多领域的难题，很多东东在python中会比其他语言处理起来更容易。
　　Python允许你分割程序为模块，以便在其他Python程序重复使用。它包含了丰富的标准模块，你可以调用或学习。一些模块提供如文件I/O，系统调用，socket，甚至像Tk图形用户界面接口。
　　Python是解释语言，程序开发时不需要编译和链接而节省可观的时间。解释器可交互使用，方便试验的语言特性，写信手而用的程序，还可在自下而上的程序开发时测试功能，同时是方便的桌面计算器。
　　Python编写的应用程序紧凑，可读性好。 Python程序通常同样的C ，C++或Java程序要短得多，原因如下：

• 　　高级数据类型允许你在单条语句中表示复杂的操作;
  
  

• 　　语句的组织依赖于缩进而不是开始和结束的括号;
  
  

• 　　变量或参数声明不是必须的。
  
  

　　Python是可扩展的：懂C的话很容易添加新的内置函数或模块到解释器，可以最快速度执行关键操作或链接Python程序到二进制库(如供应商特定的图形库)。等你熟悉之后，可以链接Python解释器到C应用程序，并用它作为扩展或命令语言。
　　Python的名字来源于英国广播公司(BBC)节目"Monty Python’s Flying Circus"，与爬行动物无关。
　　现在大家已经对Python产生了兴趣，想了解更多。学习一门语言的最好方式就是使用它，让我们首先学习Python解释器。
　　教程的其他部分通过实例介绍了Python语言和系统的各种特性。先是简单表达式，语句和数据类型，然后函数和模块，最后是高级概念比如异常和用户定义的类。
　　

解释器
　　解释器的操作有些像Unix Shell：当标准输入连接到tty设备时，它读取并以交互方式执行命令;当文件名参数或以文件作为标准输入设备时，它读取并执行文件中脚本。

调用python解释器
　　Python的解释器在linux上通常安装在/usr/bin/python，/usr/local/bin/python，/usr/local/bin/python等地方。Windows一般位于C:\Python27，且一般需要设置PATH环境变量。





#python
Python 2.7.5 (default, Jun 17 2014, 18:11:42)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
　　退出解释器：Linux上Control-D，Windows上Control-Z，统一的方式：quit()。
　　解释器的行编辑功能并不复杂。在Unix上，解释器可能已启用了GNU readline库，它增加了更多的交互编辑和历史记录功能。输入Control-P，如果发出哔哔声表示支持readline;见附录交互式输入编辑和历史替换https://docs.python.org/2/tutorial/interactive.html#tut-interacting。
　　解释器的操作有些像Unix Shell：当标准输入连接到tty设备时，它读取并以交互方式执行命令;当文件名参数或以文件作为标准输入设备时，它读取并执行文件中脚本。 启动解释器的第二个方法是python -c command [arg] ...，执行command中的语句，等同于Shell的-c选项。因为Python语句通常会包括空格或其他shell的特殊字符是特殊的外壳，建议使 把command放在单引号中。注意因为缩进原因，开始的引号后面不能有空格。



$ python -c "print 'Hello'"
Hello
$ python -c 'print "Hello"'
Hello
　　一些Python模块也作为脚本使用：python -m module [arg] ...。
　　使用脚本文件时，-i参数可以进入交互模式。
　　比如有test.py文件如下：



print("Hello")
print("World!")
　　执行：



$ python -i test.py
Hello
World!
>>>
参数传递
　　脚本名和附加参数转换成字符串列表传递给sys模块中的argv变量。导入sys模块访问这个列表。列表的长度至少为1，在无脚本无参数时，sys.argv[0]是空字符串。当脚本名为"-"(即标准输入)，sys.argv[0]为"-"。使用-c参数时，sys.argv中[0]设置为'-c'。使用-m参数sys.argv中[0]设置为模块的全名。-c或-m之后的选项留在sys.argv中待命令或模块来处理。
　　可以用sys.argv来处理参数：



#!/usr/bin/env python
# encoding: utf-8
import sys
print "script name is", sys.argv[0]
if len(sys.argv) > 1:
print "there are", len(sys.argv)-1, "arguments:"
for arg in sys.argv[1:]:
print arg
else:
print "there are no arguments!"


$ ./test.py 1 2 3
script name is ./test.py
there are 3 arguments:
1
2
3
　　
　　注意：通常python标准模块argparse处理参数会更合适。

交互模式
　　当tty读取命令时解释器为交互模式。主命令提示符为(>>>),从命令提示符(...)用于续行。



$ python
Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> the_world_is_flat = 1
>>> if the_world_is_flat:
...     print "Be careful not to fall off!"


错误处理
　　当错误发生时，解释器打印错误信息和栈跟踪。在交互模式下，它返回主提示符;在文件输入时，打印栈跟踪器后以非零退出状态退出。有些错误致命的，无条件以非零退出的退出，比如内部不一致和内存耗尽。所有的错误信息都写入标准错误流;正常输出写入标准输出。
　　输入中断符(通常是Control-C或DEL)可以取消输入，命令执行时输入中断引发一个KeyboardInterrupt异常。

执行python脚本
　　Linux系统中，Python脚本可直接执行，就像shell脚本，在文件首行添加如下：



#! /usr/bin/env python
　　并添加可执行权限：



chmod +x myscript.py
　　Windows系统中Python的安装程序会自动关联*.py到python.exe，双击即可运行。*.pyw则不会出现windows控制台。

源码编码
　　使用的编码ASCII(默认)以外的字符Python的源文件,可以在行#!之后定义源文件编码：



# -*- coding: encoding -*-
　　根据这个声明，源文件中的所有字符将用该编码的编码，并可能在用选定的编码书写Unicode字符串。编码列表可以在Python库参考手册的codecshttps://docs.python.org/2/library/codecs.html#module-codecs部分找到。实例：









# -*- coding: iso-8859-15
# -*-currency = u"€"
print ord(currency)
　　一般推荐使用utf-8的格式，在网络上比较通用，可以这样设置：



# coding=utf-8
　　特殊的中文处理可以使用gbk。通常为了正确显示所有的字符，编辑器必须支持utf-8等格式，并有相应的字体。
　　

交互式启动文件(非常用)
　　交互式使用Python的时候，常常需要在解释器启动时执行一些标准命令。可设置环境变量PYTHONSTARTUP表示启动命令文件，类似Unix shell的.profile文件。
　　文件只对交互会话有效，当 Python 从脚本中读取命令或以终端/dev/tty做为外部命令源(行为和交互式会话类似)。它与解释器执行的命令在同一命名空间，这样它定义或导入的对象可以在 解释器中使用。也可以在这个文件中改变提示符sys.ps1和sys.ps2。
　　加载其他文件的方式：



if os.path.isfile('.pythonrc.py'):
execfile('.pythonrc.py')
　　在脚本中使用启动文件如下:



import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
execfile(filename)
自定义模块(非常用)
　　Python有两个hook: sitecustomize 和 usercustomize。使用它们首先需要知道site-packages目录，方法如下:



>>> import  site
>>> site.getusersitepackages()
'/root/.local/lib/python2.7/site-packages'
　　
　　现在你可以在site-packages的目录下创建文件usercustomize.py，放入你想添加的任何内容。 该文件会影响 python 的每次调用，除非启动的时候加入-s选项禁止自动导入。
　　类似的有sitecustomize，但是一般由管理员在全局site-packages创建，在usercustomize之前导入，更多资料参见site模块https://docs.python.org/2/library/site.html#module-site。
　　

非正式教程
　　下面的例子中，输入和输出分别由>>>和...开始。
　　Python中的注释以#字符起始，到行尾。实例如下：



Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> the_world_is_flat = 1
>>> if the_world_is_flat:
...     print "Be careful not to fall off!"
...
Be careful not to fall off!
　　

将Python当做计算器

数值
　　解释器像简单的计算器：可以输入表达式，它会返回值。表达式语法很简单：运算符 + ， - ， * 和 / 与其它语言一样(例如Pascal或C)；括号用于分组。例如:



>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5.0*6) / 4
5.0
>>> 8 / 5.0
1.6
　　"/" 的返回类型取决于操作数。如果两个操作数都是int类型，执行地板除(参见https://docs.python.org/2 /glossary.html#term-floor-division)和返回int。如果操作数有浮点数，执行经典除法和并返回浮点数，浮点数的地板 除可以使用//。取余使用%：



>>> 17 / 3  # int / int -> int
5
>>> 17 / 3.0  # int / float -> float
5.666666666666667
>>> 17 // 3.0  # explicit floor division discards the fractional part
5.0
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17
　　"**"表示乘方：



>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128
　　等号（ '=' ）用于给变量赋值:



>>> width = 20
>>> height = 5*9
>>> width * height
900
　　同一值可以同时赋给几个变量:



>>> x = y = z = 0  # Zero x, y and z
>>> x
0
>>> y
0
>>> z
0
　　变量在使用前必须"定义"(赋值)，否则会出错:
　　



>>> n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
　　支持浮点数，混合计算时会自动整型转为浮点数:



>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
　　交互模式中，最近表达式的值赋给变量 _ 。更方便连续计算把Python当作桌面计算器，例如:



>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
　　此变量对于用户是只读的。
　　除了int和float，还有fractions(https://docs.python.org/2/library/fractions.html#fractions.Fraction)和decimal(https://docs.python.org/2/library/decimal.html#decimal.Decimal)。
　　下面的复数部分很少使用，通常可以不阅读。
　　支持复数，虚数带有后缀j或J，有非零实部的复数写为(real+imagj)，或者用complex(real, imag)函数创建。



>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
　　复数的实部和虚部总是记为两个浮点数。要从复数z中提取实部和虚部，使用z.real和 z.imag。



>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
　　浮点数和整数转换函数(float(), int()和long())不适用于复数。没有方法把复数转成实数。函数abs(z)用于取模(为浮点数)或z.real取实部:



>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
　　
　　

字符串
　　字符串可以包含在单引号或双引号中。



>>> 'spam eggs
''spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
　　解释器按照字符串被输入的方式显示字符串，通常包含在单引号中，如果内容包含包含单引号，则包含在双引号中。
　　print会以更可视的格式显示：



>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print '"Isn\'t," she said.'
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s
'First line.\nSecond line.'
>>> print s  # with print, \n produces a new line
First line.
Second line.
　　字符串前面添加'r'表示原始字符串，里面的反斜杠不会转义：



>>> print 'C:\some\name'  # here \n means newline!
C:\some
ame
>>> print r'C:\some\name'  # note the r before the quote
C:\some\name
　　跨行的字符串多使用三引号，即三个单引号或者三个双引号：



>>> print """\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """
Usage: thingy [OPTIONS]
-h                        Display this usage message
-H hostname               Hostname to connect to
>>> print """
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """
Usage: thingy [OPTIONS]
-h                        Display this usage message
-H hostname               Hostname to connect to
　　注意第一个三引号后面有反斜杠，就不会输出第一个换行符。末尾的反斜杠表示续行。
　　
　　字符串可用+操作符连接，用*重复:



>>> 3 * 'un' + 'ium'
'unununium'
　　相邻字符串文本会自动连接，它只用于字符串文本，不能用于字符串表达式和变量(需要使用加号)等：



>>> 'Py' 'thon'
'Python'
>>> prefix 'thon
File "<stdin>", line 1
prefix 'thon
^
SyntaxError: EOL while scanning string literal
>>> ('un' * 3) 'ium'
File "<stdin>", line 1
('un' * 3) 'ium'
^
SyntaxError: invalid syntax
>>> prefix + 'thon'
'Python'
# 在拆分长字符串时很有用。
>>> text = ('Put several strings within parentheses '
...             'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
　　字符串下标又称索引和C类似 ，第一个字符索引为 0 。没有独立的字符类型，字符就是长度为 1 的字符串，也可以使用负数，-1表示倒数第一个，-2表示倒数第二个，以此类推。不存在的下标会报IndexError。



>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'
>>> word[-16]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> word[16]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
　　字符串支持切片：由两个索引，中间是冒号。第一个索引表示起点，包含该元素，默认为0；第2个索引表示终点，不包含该元素，默认为字符串末尾。s[:i] + s[i:]等同于s。



>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
>>> word[:2]  # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]  # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'

　　记住切片的工作方式：切片索引是在字符之间。左边第一个字符的索引为0，右界索引为字符串长度n 。例如:
　　

+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0   1   2   3   4   5
-5  -4  -3  -2  -1
　　第一行数字给出字符串正索引点值0...5 。第二行给出相应的负索引。切片是从 i 到 j 两个数值标示的边界之间的所有字符。
　　对于非负索引，如果两个索引都在边界内，切片长度就是两个索引之差。例如， word[1:3] 是 2 。
　　切片时，下标溢出不会报错。



>>> word[4:42]
'on'
>>> word[43:42]
''
　　Python的字符串是不可变。向字符串文本的某一个索引赋值会引发错误:



>>> word[0] = 'J'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
　　通过联合(加号)可以简单高效的创建字符串。（注，jython中这种操作并不高效）。



>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
　　内置函数len()返回字符串长度:



>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
　　参考资料：

• 　　Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange https://docs.python.org/2/tutorial/introduction.html#strings
  
  
• 　　String Methods: https://docs.python.org/2/library/stdtypes.html#string-methods
  
  
• 　　String Formatting：https://docs.python.org/2/library/string.html#new-string-formatting
  
  
• 　　String Formatting Operations: https://docs.python.org/2/library/stdtypes.html#string-formatting
  
  

　　

Unicode字符串
　　Python2.0增加了新的用来存储文本数据的类型：Unicode对象。它可以用于存储和操作Uounicode 数据(参见 http://www.unicode.org/)，与现有的字符串兼容性良好，必要时能自动转换。
　　Unicode支持所有字符的表示，之前的ASCII只支持256个字符。更多Unicode相关的资料，参见：http://zh.wikipedia.org/wiki/Unicode。
　　创建Unicode字符串:



>>> u'Hello World !'
u'Hello World !'
　　引号前的'u'表示Unicode 字符串，转义的方式可以创建其他字符:



>>> u'Hello\u0020World !'
u'Hello World !'
　　转义序列\u0020表示插入编码为0x0020(空格)的Unicode 字符。
　　其他字符也会直接解释为对应的编码值。 许多西方国家使用的标准Latin-1编码的字符串和编码小于256的Unicode字符和在Unicode编码中的一样。
　　使用ur可以取消转义，r表示原始格式(raw)。



>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'
　　如果你需要大量输入反斜杠(比如正则表达式)，原始模式非常有用。
　　除了标准编码，Python还支持其他编码。
　　内置函数unicode()可以访问所有注册的Unicode编码(COders和DECoders)，并支持Latin-1 、ASCII、UTF-8和UTF-16 之类的编码可以互相转换，后两个是变长编码。通常默认编码为 ASCII，此编码接受0到127 这个范围的编码，否则报错。Unicode字符串打印或写入到文件，或者使用str()转换时，使用默认编码进行转换操作。
　　encode()方法可以把Unicode字符串转换为特定编码的8bit字符串，参数为小写的编码名作为参数。
　　反之可以使用unicode()把其他编码转换为unicode。



>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"&auml;&ouml;&uuml;"
u'\xe4\xf6\xfc'
>>> str(u"&auml;&ouml;&uuml;")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
>>> u"&auml;&ouml;&uuml;".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'
>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'
列表
　　Python有一些复合数据类型，用于组合值。最常用的是 list(列表))，为中括号之间的逗号分隔的值。列表的元素可以是多种类型，但是通常是同一类型。



>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
　　像字符串和其他序列类型，列表可支持切片和索引:



>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]
　　切片返回新的列表，下面操作返回列表a的浅拷贝:



>>> squares[:]
[1, 4, 9, 16, 25]
　　列表还支持连接：



>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
　　字符串是不可改变的,列表是可变的。



>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]
　　append()方法可以添加元素到尾部：



>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
　　也可以对切片赋值，此操作甚至可以改变列表的尺寸，或清空它:



>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters[]
　　内置函数 len() 同样适用于列表:



>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4
　　支持嵌套列表(包含其它列表的列表)，例如:



>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
编程第一步
　　Python可以完成比二加二更复杂的任务。下面是菲波那契序列:



>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
...
1
1
2
3
5
8
　　
　　本例的新特性。

• 　　第一行和最后一行有多赋值：第一行变量a和b同时获得了新的值0和1。最后一行右边首先完成计算，右边的表达式从左到右计算。
  
  

• 　　条件(b < 10)为true时while循环执行。这里Python类似C ，任何非零整数都为true；0为 false。判断条件也可以是字符串或列表等序列；所有长度不为零的为true ，空序列为false。示例中的测试是一个简单的比较。标准比较操作符与C相同： <(小于)， >(大于)， ==(等于)，<=(小于等于)，>=(大于等于)和!=(不等于)。
  
  
• 　　循环体需要缩进：缩进是Python组织语句的方法。在命令行下，缩进行需要插入空格或者tab。建议使用文本编辑 或者IDE，一般都提供自动缩进。命令行输入复合语句时，必须用空行来标识结束（因为解释器没办法猜识别最后一行），注意同一级的语句需要缩进同样数量的 空白。建议使用空格而不是tab缩进。
  
  
• 　　print语句输出表达式的值。字符串打印时没有引号，每两个项目之间有空格。
  
  
  
  
  
  
  
  
  
  >>> i = 256*256
  >>> print 'The value of i is', i
  The value of i is 65536
  　　
  
  

　　逗号结尾就可以避免输出换行:



>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987


命令行自动化与pexpect

简介
　　Pexpect 是一个用来启动交互式命令行子程序并对其进行自动控制的 Python 模块。 Pexpect 可以用来和像 ssh、ftp、passwd、telnet 等命令行程序进行自动交互。可广泛用于自动化运维和测试，实现同时控制多台设备和自动化。Linux中的知名装包软件就使用了Pexpect。 Pexpect在IBM，alibaba，google等公司有广泛使用，在https://pypi.python.org/pypi/pexpect 的日下载量一万左右。
　　纯python实现，依赖pty模块(不支持Windows)。
　　最新英文版文档参见：http://pexpect.readthedocs.org/en/latest/
　　安装：









pip install pexpect
　　版本要求：Python 2.6、3.2 或以上
　　

快速入门
　　ssh登录是常用的操作，过程如下：



$ ssh root@10.6.0.232
root@10.6.0.232's password:
Last login: Thu Sep 17 08:58:49 2015 from 10.6.3.223
[iyunv@AutoTest ~]#
　　下面我们用pexpect来自动实现这个过程：



#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 导入pexpect库
import pexpect
# 发起ssh连接到10.6.0.232的子进程，使用root用户
child = pexpect.spawn('ssh root@10.6.0.232')
child.expect('password:') # 等待password:字符出现
print child.before + child.after # 输出password:前后的字符
child.sendline('password')    # 发送密码
child.expect(']#')  # 等待]#字符出现
print child.before + child.after
child.interact() # 把ssh的连接交给用户控制。
　　上面最后一句在非交互式的情况下要关闭连接，用child.close()替换即可。
　　上 述操作除了interact外，都可以用python的ssh模块：paramiko代替。不过对于一些同时支持telenet、ftp、ssh等协议命 令行的通信设备，可以用pexpect通杀。telenet、ftp、ssh等从协议的层次联系，pexpect会更接近用户使用，更加适合自动化测试。
　　两个重要方法： expect()和send() (以及sendline() )。expect可以接受正则表达式作为参数。
　　before包含预期字符串之前的信息， after包含匹配模式及其以后的内容。
　　
　　

API概览

EOF与TIMEOUT
　　EOF(End Of File)与TIMEOUT可以在expect方法中使用，它们不是正则表达式，而是常量。
　　源于异常，而不是BaseException例外。从BaseException直接继承的例外情况赶上他们几乎总是错误的做法保留。
如果子进程已经退出，读取子进程的输出会引发EOF异常。此时子进程的输出全部在before中。
expect()接受的参数是正则表达式或正则表达式列表，可匹配多个可选的响应。比如ssh登录的各种情况处理：



class Ssh(object):
client = None
@classmethod
def connect(cls, ip, username="root", password="123456", prompt=']#',
silent=False):
# Ssh to remote server
ssh_newkey = 'Are you sure you want to continue connecting'
child = pexpect.spawn('ssh ' + username + '@' + ip, maxread=5000)
i = 1
# Enter password
while i != 0:
i = child.expect([prompt, 'assword:*', ssh_newkey, pexpect.TIMEOUT,
'key.*? failed'])
if not silent:
print child.before + child.after,
if i == 0:  # find prompt
pass
elif i == 1:  # Enter password
child.send(password + "\r")
if i == 2:  # SSH does not have the public key. Just accept it.
child.sendline('yes\r')
if i == 3:  # Timeout
raise Exception('ERROR TIMEOUT! SSH could not login. ')
if i == 4:  # new key
print child.before, child.after,
os.remove(os.path.expanduser('~') + '/.ssh/known_hosts')
Ssh.client = child
@classmethod
def command(cls, cmd, prompt=']#', silent=False):
Ssh.client.buffer = ''
Ssh.client.send(cmd + "\r")
# Ssh.client.setwinsize(400,400)
        Ssh.client.expect(prompt)
if not silent:
print Ssh.client.before + Ssh.client.after,
return Ssh.client.before, Ssh.client.after
@classmethod
def close(cls,):
Ssh.client.close()
　　expect()的超时默认为30秒，超时时生成TIMEOUT异常。可以修改：



# Wait no more than 2 minutes (120 seconds) for password prompt.
child.expect('password:', timeout=120)
行尾处理
　　Pexpect匹配的正则表达式与标准的有些差异，默认是非贪婪匹配。Pexpect一次读取一个字符读，这样行尾标识$失去了意义。行尾用"\r\n"(CR/LF)表示。Pexpect中的"\n"实际对应"\r\n"。匹配行尾的操作如下：



child.expect('\r\n')
　　尽量用：



child.expect ('.+')
　　而不是：



child.expect ('.*')
　　

API文档
　　pexpect.screen和pexpect.ANSI在版本4已经不推荐使用，建议用pyte替代。

class spawn



def __init__(self, command, args=[], timeout=30, maxread=2000,
searchwindowsize=None, logfile=None, cwd=None, env=None,
ignore_sighup=True):
　　调用示例：







child = pexpect.spawn('/usr/bin/ftp')
child = pexpect.spawn('/usr/bin/ssh user@example.com')
child = pexpect.spawn('ls -latr /tmp')
child = pexpect.spawn('/usr/bin/ftp', [])
child = pexpect.spawn('/usr/bin/ssh', ['user@example.com'])
child = pexpect.spawn('ls', ['-latr', '/tmp'])
　　pexpect不能解释shell元字符，比如 (>, |, or *)，需要启动shell来解决该问题：



child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > logs.txt"')
child.expect(pexpect.EOF)
　　日志输出：



child = pexpect.spawn('some_command')
fout = open('mylog.txt','wb')
child.logfile = fout
　　输出到stdout



# In Python 2:
child = pexpect.spawn('some_command')
child.logfile = sys.stdout#

In Python 3, spawnu should be used to give str to stdout:
child = pexpect.spawnu('some_command')
child.logfile = sys.stdout
　　
　　== 未完待续

参考资料

• 　　python 2.7 英文官方教程：https://docs.python.org/2/tutorial/
  
  
• 　　paramiko： https://pypi.python.org/pypi/paramiko
  
  
• 　　pexpect: https://pypi.python.org/pypi/pexpect
  
  
• 　　pexpect英文文档：http://pexpect.readthedocs.org/en/latest/