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的解释器在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异常。
Linux系统中,Python脚本可直接执行,就像shell脚本,在文件首行添加如下:
#! /usr/bin/env python
并添加可执行权限:
chmod +x myscript.py
Windows系统中Python的安装程序会自动关联*.py到python.exe,双击即可运行。*.pyw则不会出现windows控制台。
使用的编码ASCII(默认)以外的字符Python的源文件,可以在行#!之后定义源文件编码:
# -*- coding: encoding -*-
根据这个声明,源文件中的所有字符将用该编码的编码,并可能在用选定的编码书写Unicode字符串。编码列表可以在Python库参考手册的codecs https://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!
解释器像简单的计算器:可以输入表达式,它会返回值。表达式语法很简单:运算符 + , - , * 和 / 与其它语言一样(例如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
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"äöü" u'/xe4/xf6/xfc' >>> str(u"äöü") 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"äöü".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 是一个用来启动交互式命令行子程序并对其进行自动控制的 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 [root@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包含匹配模式及其以后的内容。
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 ('.*')
pexpect.screen和pexpect.ANSI在版本4已经不推荐使用,建议用pyte替代。
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
== 未完待续
作者博客: http://my.oschina.net/u/1433482
联系作者:徐荣中 python开发自动化测试群113938272 微博 http://weibo.com/cizhenshi 。
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/