Python基础篇

Copyright © 2004，2005，2006 本文遵从GNU 的自由文档许可证(Free Document License)的条款，欢迎转载、修改、散布。

发布时间：2004年07月10日

更新时间：2006年06月14日，把参考篇的内容合并进来。

• Python使用一种优雅的语法，可读性强。

• Python是一种很灵活的语言，能帮你轻松完成编程工作。并可作为一种原型开发语言，加快大型程序的开发速度。

• 有 多种数据类型：numbers (integers, floating point, complex, and unlimited-length long integers), strings (ASCII 和 Unicode), lists, dictionaries。

• Python支持类和多层继承等的面向对象编程技术。

• 代码能打包成模块和包，方便管理和发布。

• 支持异常处理，能有效捕获和处理程序中发生的错误。

• 强大的动态数据类型支持，不同数据类型相加会引发一个异常。

• Python支持如生成器和列表嵌套等高级编程功能。

• 自动内存碎片管理，有效利用内存资源。

• 强大的类库支持，使编写文件处理、正则表达式，网络连接等程序变得相当容易。

• Python的交互命令行模块能方便地进行小代码调试和学习。

• Python易于扩展，可以通过C或C++编写的模块进行功能扩展。

• Python解析器可作为一个编程接口嵌入一个应用程序中。

• Python可运行在多种计算机平台和操作系统中，如各位unix，windows，MacOS,OS/2等等。

• Python是开源的，可自由免费使用和发布，并且可用于商业用途以获取利润。如想详细了解Python的许可协议可到以下网址查询http://www.python.org/psf/license.html

• 系统编程，提供大量系统接口API，能方便进行系统维护和管理。

• 图形处理，有PIL、Tkinter等图形库支持，能方便进行图形处理。

• 数学处理，NumPy扩展提供大量与许多标准数学库的接口，

• 文本处理，python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。

• 数 据库编程，程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，Mysql等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。

• 网络编程，提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。

• 作为Web应用的开发语言，支持最新的XML技术。

• 多媒体应用，Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。

• 进入交互命令行方式。如果是linux类的系统，python解析器应该已经安装在/usr/local/bin/python中，直接打python就可进入交互式命令行界面，如下所示:

  Python 2.3.3 (#1, Apr 27 2004, 15:17:58) 
  
      [GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
  
      Type "help", "copyright", "credits" or "license" for more information.
  
      >>> 
  
      

  “>>>”符号是Python命令行界面的提示符，可按CTRL+D退出，如果是windows环境的话就要按CTRL+Z了。还可以用以下命令退出命令行界面：“import sys；sys.exit()”。如果是windows系统，可到http://www.python.org/download/下载最新的安装程序进行安装。安装完成后直接打python也可进入命令行界面。命令行是python最简单直观，也是最方便的一种执行环境，我们可以在这里学习python语法和调试程序。如果要打印"hello world"可以输入以下命令：

  >>>print "hello world"
  
      hello world
  
      

• 以模块文件方式运行。模块文件是包含python语句的文本，以.py结尾。运行模块文件只要输入python xxx.py就可以了。

• 以linux脚本方式运行。和shell脚本差不多，以vi或其它文本编辑器输入以下内容:

  #!/usr/local/bin/python
  
      print "test ............"
  
      

  存盘后，把文件属性改为可执行，就可象shell脚本一样执行了。

• Table 1.1. Python命令行选项

  选项	作用
  -c cmd	在命令行直接执行python代码。如python -c 'print "hello world"'。
  -d	脚本编译后从解释器产生调试信息。同PYTHONDEBUG=1。
  -E	忽略环境变量。
  -h	显示python命令行选项帮助信息。
  -i	脚本执行后马上进入交互命令行模式。同PYTHONINSPECT=1。
  -O	在执行前对解释器产生的字节码进行优化。同 PYTHONOPTIMIZE=1。
  -OO	在执行前对解释器产生的字节码进行优化，并删除优化代码中的嵌入式文档字符串。
  -Q arg	除法规则选项，-Qold(default)，-Qwarn，-Qwarnall，-Qnew。
  -S	解释器不自动导入site.py模块。
  -t	当脚本的tab缩排格式不一致时产生警告。
  -u	不缓冲stdin、stdout和stderr，默认是缓冲的。同PYTHONUNBUFFERED=1。
  -v	产生每个模块的信息。如果两个-v选项，则产生更详细的信息。同PYTHONVERBOSE=x。
  -V	显示Python的版本信息。
  -W arg	出错信息控制。(arg is action:message:category:module:lineno)
  -x	忽略源文件的首行。要在多平台上执行脚本时有用。
  file	执行file里的代码。
  -	从stdin里读取执行代码。

• 在Python 中，每行程序以换行符代表结束，如果一行程序太长的话，可以用“"”符号扩展到下一行。在python中以三引号(""")括起来的字符串，列表，元组和 字典都能跨行使用。并且以小括号(...)、中括号[...]和大括号{...}包围的代码不用加“"”符也可扩展到多行。如：

• 在Python中是以缩进来区分程序功能块的，缩进的长度不受限制，但就一个功能块来讲，最好保持一致的缩进量。

• 如果一行中有多条语句，语句间要以分号（;）分隔。

• 以“#”号开头的内容为注释，python解释器会忽略该行内容。

• 在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。python中的标识符是区分大小写的。

• 以 下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。

• 在交互模式下运行python时，一个下划线字符(_)是特殊标识符，它保留了表达式的最后一个计算结果。

  >>> "hello"
  
      'hello'
  
      >>> _
  
      'hello'
  
      >>> 10+10
  
      20
  
      >>> _
  
      20
  
      
  
      

• 在python中，函数、类、模块定义的第一段代码如果是字符串的话，就把它叫作文件字串，可通过__doc__属性访问。如:

  def test():
  
      "this is a document string"
  
      
  
      return 100+1000
  
      
  
      >>>print test.__doc__
  
      this is a document string
  
      

• 简单赋值，Variable(变量)=Value(值)。

  >>>a=1
  
      >>>b=2
  
      >>>print a,b
  
      1 2
  
      

• 多变量赋值，Variable1,variable2,...=Value1,Value2,...

  >>>a,b,c=1,2,3
  
      >>>print a
  
      1
  
      >>>print b
  
      2
  
      >>>print c
  
      3
  
      

  多变量赋值也可用于变量交换，接上例：

  >>>a,b,c=c,b,a
  
      >>>print a
  
      3
  
      >>>print b
  
      2
  
      >>>print c
  
      1
  
      

• 多目标赋值，a=b=variable

  >>> a=b=1
  
      >>> a
  
      1
  
      >>> b
  
      1
  
      >>> a=2
  
      >>> a
  
      2
  
      >>> b
  
      1
  
      

• 自变赋值，如+=，-=，*=等。在自变赋值中，python仅计算一次，而普通写法需计算两次；自变赋值会修改原始对象，而不是创建一个新对象。

• 整 型---从-2147483648至2147483647，有符号位32位长，可表达的最大数为2^31-1。如：number=123，number1 =-123。在数字前加0x或0X 前缀表示十六进制数，在数字前加前缀0表示八进制数，与C/C++ and perl一样。

  	为方便起见，sys模块包含一个maxint成员，该成员保留了整形变量的最大正数值。

  >>> import sys
  
      >>> print sys.maxint
  
      2147483647
  
      

• 长整型---python支持任意长度的长整型，长整型的最大值和最小值由可用的内存确定。长整型数在数字常量尾加L or l，一般都是用L，因为小写的l太容易与数字1混淆了。如：long=1232132131231232132132131L。

• 浮点数---python支持普通十进制和科学计数法表示的浮点数。如：number=123.456，nubmer1=123.2E10。浮点数在python中的存储格式与C中的双精度数相同。

• 复数---复数的实部和虚部用加号分开，虚部使用后缀j表示，如：number=1.2+2j

• 字符串在python被看成是单个字符的序列，具有序列对象的特殊功能，字符串是固定的，不可变的。如：string="hello world"。

• 可在字符串中使用单引号和双引号。如：string="I'm a boy"。

• 字符串内部的一个反斜杠“"”可允许把字符串放于多行：如：

  >>> "test "
  
      ... python"
  
      'test python'

• 使用三个单引号或双引号可使字符串跨行显示。如：

  helptext="""this a help test.if you have any quesions.
  
      please call me anytime.I will help you.I
  
      like python.I hope so as you."""
  
      

• 使用“+”号可连接字符串。如：string = "hello" + "world"，注意，不能将字符串与其它对象进行连接。如string = "ok" + 5。其实不用“+”号，直接用空格也可连接两个字符串。如：string="hello" "world"。

• 可用“*”号重复字符串，如：'hello'*5会生成'hellohellohellohellohello'。

• 可用索引访问字符串中的字符。如：string="hello world"，print string[1]将显示字符e。

• 字符串可用in或not in运算符来测试字符是不属于一个字符串的成员。

• 可对字符串分片，如string="hello world",print string[6:]将显示world。分片的格式为：

               string[start:end]
  
      

  分片和索引的规则如下：

  • 返回的字符串包含从start起始到end但不包括end结束的所有字符。

  • 若指定了start但未指定end，则一直向后分片，直至字符串结束。

  • 若指定了end但未指定start，则从0开始分片直至end，但不包括end指定的字符。

  • 若start和end为负数，则索引从字符串尾部开始算起，最后一个字符为-1。

象C 中的sprintf函数一样，可以用“%”来格式化字符串。

	%格式化符也可用于字典，可用%(name)引用字典中的元素进行格式化输出。

	负号指时数字应该是左对齐的，“0”告诉Python用前导0填充数字，正号指时数字总是显示它的正负(+，-)符号，即使数字是正数也不例外。

	可指定最小的字段宽度，如："%5d" % 2。也可用句点符指定附加的精度，如："%.3d" % 3。

在需要在字符中使用特殊字符时，python用反斜杠(")转义字符。如下表：

在python2.0中才完全支持Unicode字符串，Unicode字符采用16位(0---65535)值表示，能进行多语言支持。要使用Unicode字符串，只要在字符串前加上“u”即可。如：

>>> a=u"test"

>>> print a

test

原始Unicode字符串用ur前缀，如：

>>> u'hello world"0020' 

u'hello world"x020'

>>> ur'hello world"0020'

u'hello world""0020'

3.2.3.1. Unicode转换

只要和Unicode连接，就会产生Unicode字串。如：

>>> 'help'

'help'

>>> 'help，' + u'python'     

u'help，python'

对于ASCII(7位)兼容的字串，可和内置的str()函数把Unicode字串转换成ASCII字串。如：

>>> str(u'hello world')

'hello world'

	转换非ASCII兼容的字串会出错。编码和译码字符串时的错误引发UnicodeError异常。

可使用encode()函数转换Unicode字串格式：

u'unicode"xb1"xe0"xc2"xeb"xb2"xe2"xca"xd4'

>>> a.encode('utf-8')   #转换成utf-8，显示结果会根据终端的字符集支持不同而不同，下面是在GB18030下的显示结果

'unicode"xc2"xb1"xc3"xa0"xc3"x82"xc3"xab"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'     

可使用unicode()函数把字符串转换成unicode格式，如：

>>> a=u'unicode测试'

>>> a

u'unicode"xb2"xe2"xca"xd4'

>>> a.encode('utf-8')     #把unicode字串转换成utf-8

'unicode"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'

>>> b=a.encode('utf-8')   #给变量b赋值

>>> b

'unicode"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'

>>>unicode(b,'utf-8')           #用unicode()函数把utf-8格式字串转换回unicode格式。

u'unicode"xb2"xe2"xca"xd4'      #和原始的这是a相同           

ord()支持unicode，可以显示特定字符的unicode号码，如：

>>>ord('A')

65

使用unichr()函数可将unicode号码转换回unicode字符，如：

>>> unichr(65)

u'A'

有时我们并不想让转义字符生效，我们只想显示字符串原来的意思，这就要用r和R来定义原始字符串。如：

print r'"t"r'

实际输出为“"t"r”。

• 列表是序列对象，可包含任意的Python数据信息，如字符串、数字、列表、元组等。列表的数据是可变的，我们可通过对象方法对列表中的数据进行增加、修改、删除等操作。可以通过list(seq)函数把一个序列类型转换成一个列表。列表的几个例子：

  • list = [ "a", "b", "c" ]，这是字符列表。

  • list = [ 1, 2, 3, 4 ]，这是数字列表。

  • list = [ [1,2,3,4], ["a","b","c"] ]，这是列表的列表。

  • list = [ (1,2,3,4), ("a","b","c") ]，这是元组列表。

  • list((1,2))把一个元组转换成一个列表[1,2]，list('test')可把字符串转换成['t','e','s','t']列表。

• 访问列表可通过索引来引用，如：list[0]将引用列表的第一个值。list[0:1]返回第一和第二个元素。

• 用range()和xrange()函数可自动生成列表，具体用法请参考“python参考篇”的内容。

• 可 通过列表综合来创建列表，该功能是在python2.0版本中新增加的。如果想对列表中的每个项进行运算并把结果存储在一个新列表中，可者想创建一个仅包 含特定满足某种条件的项，采用该方法是很适合的。如：[x*x for x in range(1,10)]会得到一个X的平方的新列表；我们还可添加if条件控制输出，如：[x*x for x in range(1,10) if x%2==0]；还可在列表中使用多个for语句，如：

  >>> [x+y for x in "123" for y in "abc"]
  
      ['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c']
  
      

  x,y值可取列表或元组等，以构成更复杂的结构。

• “+”号可连接两个列表。

• 访问列表的列表(嵌套列表)可用list[1][0]，这将访问嵌套中的第二个列表的第一个元素。

• 可用数字与列表相乘以复制内容，如：list*2会得到一个[1,2,3,4,1,2,3,4]的列表。注意，不能用列表与列表相乘。

• 由于列表是可变的，我们可用赋值语句进行操作，如：list[0] = 2。

• 列表对象方法可对列表进行操作，如列表内容的添加，删除，排序等。如list.sort()可对list列表进行排序。

  Table 3.3. 列表对象支持的方法

  方法	描述
  append(x)	在列表尾部追加单个对象x。使用多个参数会引起异常。
  count(x)	返回对象x在列表中出现的次数。
  extend(L)	将列表L中的表项添加到列表中。返回None。
  Index(x)	返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。
  insert(i,x)	在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。
  pop(x)	删除列表中索引为x的表项，并返回该表项的值。若未指定索引，pop返回列表最后一项。
  remove(x)	删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
  reverse()	颠倒列表元素的顺序。
  sort()	对列表排序，返回none。bisect模块可用于排序列表项的添加和删除。

• tuple=(1,)，这是单个元素的元组表示，需加额外的逗号。

• tuple=1，2，3，4，这也可以是一个元组，在不使用圆括号而不会导致混淆时，Python允许不使用圆括号的元组。

• 和列表一样，可对元组进行索引、分片、连接和重复。也可用len()求元组长度。

  	元组的索引用tuple[i]的形式，而不是tuple(i)。

• 和列表类似，使用tuple(seq)可把其它序列类型转换成元组。

• 可用算术运算符联接或重复序列。

• 比较运算符(<，<=，>，>=，!=，==)也可用于序列。

• 可通过下标(test[1])，切片(test[1:3])和解包来访问序列的某部份。解包示例如下：

  >>>s=1,2,3 
  
      >>>x,y,z=s 
  
      >>>print x,y,z
  
      1,2,3

• in运算符可判断当有对象是否序列对象成员，如:

  >>>list = [1,2,3]
  
      >>>1 in list
  
      1
  
      >>>4 in list
  
      0
  
      

• 也可通过循环运算符对序列对象进行迭代操作。如:

  for day in days:
  
      print day
  
      

• 字典可嵌套，可以在一个字典里包含另一个字典。如test={"test":{"mytest":10} }

• 可用键访问字典，如monthdays["Jan"]，可访问值31。如果没有找到指定的键，则解释器会引起异常。

• 字典是可修改，如monthdays["Jan"]=30，可把Jan的值由31改为30。如monthdays["test"]=30可添加一个新键值对。

• del monthdays["test"]可删除字典条目。

• 字典不属序列对象，所以不能进行连接和相乘操作。字典是没有顺序的。

• 字典提供keys和values方法，用来返回字典中定义的所有键和值。

• 和列表一样，字典也提供了对象方法来对字典进行操作。

  Table 3.4. 字典方法

  方法	描述
  has_key(x)	如果字典中有键x，则返回真。
  keys()	返回字典中键的列表
  values()	返回字典中值的列表。
  items()	返回tuples的列表。每个tuple由字典的键和相应值组成。
  clear()	删除字典的所有条目。
  copy()	返回字典高层结构的一个拷贝，但不复制嵌入结构，而只复制对那些结构的引用。
  update(x)	用字典x中的键值对更新字典内容。
  get(x[,y])	返回键x，若未找到该键返回none，若提供y，则未找到x时返回y。

• Python把一块数据存储在对象中，变量是对象的唯一引用；它们是计算机内存中特殊地点的名字。所有对象都具有唯一的身份号、类型和值。对象的类型不会改变，对于可变类型而言，它的值是可变的。id(obj)函数可用于检索对象的身份，也就是内存中的对象的地址。

• 每 个对象都包含引用计数器，它记录当前有多少个变量正在引用该对象。当给对象指定一个变量或使对象成为列表或其它包容器的成员时，引用计数就增加；当从包容 器中撤消、重新分配或删除对象时，引用计数减少。当引用计数达到0值时(即没有任何变量引用这个对象)，python的回收机制会自动回收它使用的内存。 注意，del可用来删除变量，但不能删除对象。

  	sys.getrefcount(obj)函数可返回给定对象的引用计数。

• 列表或其他包容器对象的浅副本(Shallow)能够生成对象本身的副本，但也会创建对由列表包含的对象的引用。可用分片(object[:])和copy模块的copy(obj)函数创建。

• 列表或其他对象包容器对象的深副本能够生成对象本身的副本，并递归地生成所有子对象的副本。可用copy模块的deepcopy(obj)函数创建。

Table 3.5. 数组类型代码

• tolist()方法可把数组转换为列表，如：

  >>> z.tolist()
  
      [1, 2, 3]
  
      

  fromlist(list)方法可把列表项附加到数组的末尾，如：

  >>> z.fromlist([10,11])
  
      >>> z
  
      array('b', [1, 2, 3, 10, 11])
  
      

  	如添加的列表类型与数组类型不同，则fromlist(list)不会把任何项添加到数组对象中。

• tostring()方法，可以把数组转换为字节的序列，如：

  >>> z.tostring()
  
      '"x01"x02"x03"n"x0b'
  
      

  fromstring(list)方法刚好与tostring()相反，它获取一个字节串，并把它们转换为数组的值。如：

  >>> z.fromstring(""x0b")
  
      >>> z
  
      array('b', [1, 2, 3, 10, 11, 11])
  
      

• tofile(file)方法可把数组转换为字节的序列，并把它们写入文件，如：

  >>> f=open("aa","wb")
  
      >>> z.tofile(f)
  
      >>> f.close()
  
      

  fromfile(file,count)方法用于从文件对象中读取特定数目的项，并把它们附加到数组中，如：

  >>> z.fromfile(open("aa","rb"),2)
  
      >>> z
  
      array('b', [1, 2, 3, 10, 11, 11, 1, 2])
  
      

  当取数项大于文件数据项时，formfile会产生EOFError异常。

• 数组对象支持列表中的很多相同函数和方法：len，append等。访问成员的方法也可列表一样，可用下标和分片。

• abs(x)

  abs()返回一个数字的绝对值。如果给出复数，返回值就是该复数的模。

  >>>print abs(-100)
  
      100
  
      >>>print abs(1+2j)
  
      2.2360679775
  
      

• callable(object)

  callable()函数用于测试对象是否可调用，如果可以则返回1(真)；否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了“调用”方法的类实例。

  >>> a="123"
  
      >>> print callable(a)
  
      0
  
      >>> print callable(chr)
  
      1
  
      

• cmp(x,y)

  cmp()函数比较x和y两个对象，并根据比较结果返回一个整数，如果x<y，则返回-1；如果x>y，则返回1,如果x==y则返回0。

  >>>a=1
  
      >>>b=2
  
      >>>c=2
  
      >>> print cmp(a,b)
  
      -1
  
      >>> print cmp(b,a)
  
      1
  
      >>> print cmp(b,c)
  
      0
  
      

• divmod(x,y)

  divmod(x,y)函数完成除法运算，返回商和余数。

  >>> divmod(10,3)
  
      (3, 1)
  
      >>> divmod(9,3)
  
      (3, 0)
  
      

• isinstance(object,class-or-type-or-tuple) -> bool

  测试对象类型

  >>> a='isinstance test'
  
      >>> b=1234
  
      >>> isinstance(a,str)
  
      True
  
      >>> isinstance(a,int)
  
      False
  
      >>> isinstance(b,str)
  
      False
  
      >>> isinstance(b,int)
  
      True
  
      

• len(object) -> integer

  len()函数返回字符串和序列的长度。

  >>> len("aa")
  
      2
  
      >>> len([1,2])
  
      2
  
      

• pow(x,y[,z])

  pow()函数返回以x为底，y为指数的幂。如果给出z值，该函数就计算x的y次幂值被z取模的值。

  >>> print pow(2,4)
  
      16
  
      >>> print pow(2,4,2)
  
      0
  
      >>> print pow(2.4,3)
  
      13.824
  
      

• range([lower,]stop[,step])

  range()函数可按参数生成连续的有序整数列表。

  >>> range(10)
  
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
      >>> range(1,10)
  
      [1, 2, 3, 4, 5, 6, 7, 8, 9]
  
      >>> range(1,10,2)
  
      [1, 3, 5, 7, 9]
  
      

• round(x[,n])

  round()函数返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

  >>> round(3.333)
  
      3.0
  
      >>> round(3)
  
      3.0
  
      >>> round(5.9)
  
      6.0
  
      

• type(obj)

  type()函数可返回对象的数据类型。

  >>> type(a)
  
      <type 'list'>
  
      >>> type(copy)
  
      <type 'module'>
  
      >>> type(1)
  
      <type 'int'>
  
      

• xrange([lower,]stop[,step])

  xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存。

  >>> a=xrange(10)
  
      >>> print a[0]
  
      0
  
      >>> print a[1]
  
      1
  
      >>> print a[2]
  
      2
  
      

• chr(i)

  chr()函数返回ASCII码对应的字符串。

  >>> print chr(65)
  
      A
  
      >>> print chr(66)
  
      B
  
      >>> print chr(65)+chr(66)
  
      AB
  
      

• complex(real[,imaginary])

  complex()函数可把字符串或数字转换为复数。

  >>> complex("2+1j")
  
      (2+1j)
  
      >>> complex("2")
  
      (2+0j)
  
      >>> complex(2,1)
  
      (2+1j)
  
      >>> complex(2L,1)
  
      (2+1j)
  
      

• float(x)

  float()函数把一个数字或字符串转换成浮点数。

  >>> float("12")
  
      12.0
  
      >>> float(12L)
  
      12.0
  
      >>> float(12.2)
  
      12.199999999999999
  
      

• hex(x)

  hex()函数可把整数转换成十六进制数。

  >>> hex(16)
  
      '0x10'
  
      >>> hex(123)
  
      '0x7b'
  
      

• long(x[,base])

  long()函数把数字和字符串转换成长整数，base为可选的基数。

  >>> long("123")
  
      123L
  
      >>> long(11)
  
      11L
  
      

• list(x)

  list()函数可将序列对象转换成列表。如：

  >>> list("hello world")
  
      ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
  
      >>> list((1,2,3,4))
  
      [1, 2, 3, 4]
  
      

• int(x[,base])

  int()函数把数字和字符串转换成一个整数，base为可选的基数。

  >>> int(3.3)
  
      3
  
      >>> int(3L)
  
      3
  
      >>> int("13")
  
      13
  
      >>> int("14",15)
  
      19
  
      

• min(x[,y,z...])

  min()函数返回给定参数的最小值，参数可以为序列。

  >>> min(1,2,3,4)
  
      1
  
      >>> min((1,2,3),(2,3,4))
  
      (1, 2, 3)
  
      

• max(x[,y,z...])

  max()函数返回给定参数的最大值，参数可以为序列。

  >>> max(1,2,3,4)
  
      4
  
      >>> max((1,2,3),(2,3,4))
  
      (2, 3, 4)
  
      

• oct(x)

  oct()函数可把给出的整数转换成八进制数。

  >>> oct(8)
  
      '010'
  
      >>> oct(123)
  
      '0173'
  
      

• ord(x)

  ord()函数返回一个字符串参数的ASCII码或Unicode值。

  >>> ord("a")
  
      97
  
      >>> ord(u"a")
  
      97
  
      

• str(obj)

  str()函数把对象转换成可打印字符串。

  >>> str("4")
  
      '4'
  
      >>> str(4)
  
      '4'
  
      >>> str(3+2j)
  
      '(3+2j)'
  
      

• tuple(x)

  tuple()函数把序列对象转换成tuple。

  >>> tuple("hello world")
  
      ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
  
      >>> tuple([1,2,3,4])
  
      (1, 2, 3, 4)
  
      

• 常用函数中的len()、max()和min()同样可用于序列。

• filter(function,list)

  调用filter()时，它会把一个函数应用于序列中的每个项，并返回该函数返回真值时的所有项，从而过滤掉返回假值的所有项。

  >>> def nobad(s):
  
      ...     return s.find("bad") == -1
  
      ... 
  
      >>> s = ["bad","good","bade","we"]
  
      >>> filter(nobad,s)
  
      ['good', 'we']
  
      

  这个例子通过把nobad()函数应用于s序列中所有项，过滤掉所有包含“bad”的项。

• map(function,list[,list])

  map()函数把一个函数应用于序列中所有项，并返回一个列表。

  >>> import string
  
      >>> s=["python","zope","linux"]
  
      >>> map(string.capitalize,s)
  
      ['Python', 'Zope', 'Linux']
  
      

  map()还可同时应用于多个列表。如：

  >>> import operator
  
      >>> s=[1,2,3]; t=[3,2,1]
  
      >>> map(operator.mul,s,t)   # s[i]*t[j]
  
      [3, 4, 3]
  
      

  如果传递一个None值，而不是一个函数，则map()会把每个序列中的相应元素合并起来，并返回该元组。如：

  >>> a=[1,2];b=[3,4];c=[5,6]
  
      >>> map(None,a,b,c)
  
      [(1, 3, 5), (2, 4, 6)]
  
      

• reduce(function,seq[,init])

  reduce()函数获得序列中前两个项，并把它传递给提供的函数，获得结果后再取序列中的下一项，连同结果再传递给函数，以此类推，直到处理完所有项为止。

  >>> import operator
  
      >>> reduce(operator.mul,[2,3,4,5])  # ((2*3)*4)*5
  
      120
  
      >>> reduce(operator.mul,[2,3,4,5],1) # (((1*2)*3)*4)*5
  
      120
  
      >>> reduce(operator.mul,[2,3,4,5],2)  # (((2*2)*3)*4)*5
  
      240
  
      

• zip(seq[,seq,...])

  zip()函数可把两个或多个序列中的相应项合并在一起，并以元组的格式返回它们，在处理完最短序列中的所有项后就停止。

  >>> zip([1,2,3],[4,5],[7,8,9])
  
      [(1, 4, 7), (2, 5, 8)]
  
      

  如果参数是一个序列，则zip()会以一元组的格式返回每个项，如：

  >>> zip((1,2,3,4,5))
  
      [(1,), (2,), (3,), (4,), (5,)]
  
      >>> zip([1,2,3,4,5])
  
      [(1,), (2,), (3,), (4,), (5,)]
  
      

• replace(string,old,new[,maxsplit])

  字符串的替换函数，把字符串中的old替换成new。默认是把string中所有的old值替换成new值，如果给出maxsplit值，还可控制替换的个数，如果maxsplit为1，则只替换第一个old值。

  >>>a="11223344"
  
      >>>print string.replace(a,"1","one")
  
      oneone2223344
  
      >>>print string.replace(a,"1","one",1)
  
      one12223344
  
      

• capitalize(string)

  该函数可把字符串的首个字符替换成大字。

  >>> import string
  
      >>> print string.capitalize("python")
  
      Python
  
      

• split(string,sep=None,maxsplit=-1)

  从string字符串中返回一个列表，以sep的值为分界符。

  >>> import string
  
      >>> ip="192.168.3.3"
  
      >>> ip_list=string.split(ip,'.')
  
      >>> print ip_list
  
      ['192', '168', '3', '3']
  
      

• join(string[,sep])

  返回用sep连接的字串，默认的sep是空格。

  >>> import string
  
      >>> a = ['a','b','c']
  
      >>> b = string.join(a,'-')
  
      >>> b
  
      'a-b-c'
  
      >>> a
  
      ['a', 'b', 'c']
  
      

• time()，以浮点形式返回自Linux新世纪以来经过的秒数。在linux中，00:00:00 UTC, January 1, 1970是新纪元的开始。

  >>> time.time()
  
      1150269086.6630149
  
      >>> time.ctime(1150269086.6630149)
  
      >>> 'Wed Jun 14 15:11:26 2006'
  
      

• ctime([sec])，把秒数转换成日期格式，如果不带参数，则显示当前的时间。

  >>> import time
  
      >>> time.ctime()
  
      >>> 'Wed Jun 14 15:02:50 2006'
  
      >>> time.ctime(1138068452427683)
  
      'Sat Dec 14 04:51:44 1901'                               
  
      

• sleep(secs)，定时。

  >>> time.sleep(10) 
  
      >>>                #10秒后才会出现>>>提示符 
  
      

Table 9.1. mode

Table 9.2. bufsize

Table 9.3. 文件对象方法

• 文件的打开或创建

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      filehandler = open('test.txt','w')               #以写模式打开文件，如果文件不存在则创建
  
      filehandler.write('this is a file open/create test."nthe second line.')
  
      
  
      filehandler.close()
  
      

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      filehandler = open('test.txt','a')      #以追加模式打开文件，如果文件不存在则创建
  
      
  
      filehandler.write('"nappend the text in another line."n')
  
      
  
      filehandler.close()
  
      

• 读取文件

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      filehandler = open('test.txt','r')    #以读方式打开文件，rb为二进制方式(如图片或可执行文件等)
  
      
  
      print 'read() function:'              #读取整个文件
  
      print filehandler.read()
  
      
  
      print 'readline() function:'          #返回文件头，读取一行
  
      filehandler.seek(0)
  
      print filehandler.readline()
  
      
  
      print 'readlines() function:'         #返回文件头，返回所有行的列表
  
      filehandler.seek(0)
  
      print filehandler.readlines()
  
      
  
      print 'list all lines'                #返回文件头，显示所有行
  
      filehandler.seek(0)
  
      textlist = filehandler.readlines()
  
      for line in textlist:
  
      print line
  
      
  
      print 'seek() function'               #移位到第32个字符，从33个字符开始显示余下内容
  
      filehandler.seek(32)
  
      print filehandler.read()
  
      
  
      print 'tell() function'               #移位到文件头，从头开始显示2位字符
  
      filehandler.seek(0)
  
      print filehandler.readline()          #显示第一行内容
  
      print filehandler.tell()              #显示当前位置
  
      print filehandler.readline()          #显示第二行内容
  
      print filehandler.read()              #显示余下所有内容
  
      
  
      filehandler.close()                   #关闭文件句柄
  
      

• 文件系统操作

  #!/usr/bin/env python
  
      #-*- encoding:utf-8 -*-
  
      
  
      import os,fnmatch,glob
  
      
  
      for fileName in os.listdir ( '/root' ):                 #列出/root目录内容，不包括.和..
  
      print fileName 
  
      
  
      os.mkdir('py')                  #在当前目录下创建一个py目录，且只能创建一层
  
      os.rmdir( 'py')                 #在当前目录下删除py目录，且只能删除一层
  
      os.makedirs('py/aa')            #可创建多层目录
  
      os.removedirs('py/aa')          #可删除多层目录
  
      
  
      
  
      print 'demonstration fnmatch module'                 
  
      for fileName in os.listdir ( '/root/python/file' ):
  
      if fnmatch.fnmatch(fileName,'*.txt'):        #利用UNIX风格的通配，只显示后缀为txt的文件
  
      print fileName
  
      
  
      print 'demonstration glob module'
  
      for fileName in glob.glob ( '*.txt' ):               #利用UNIX风格的通配，只显示后缀为txt的文件
  
      print fileName 
  
      

• 获取文件状态

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      import os,time,stat
  
      
  
      fileStats = os.stat ( 'test.txt' )                         #获取文件/目录的状态
  
      fileInfo = {
  
      'Size':fileStats [ stat.ST_SIZE ],                         #获取文件大小
  
      'LastModified':time.ctime( fileStats [ stat.ST_MTIME ] ),  #获取文件最后修改时间
  
      'LastAccessed':time.ctime( fileStats [ stat.ST_ATIME ] ),  #获取文件最后访问时间
  
      'CreationTime':time.ctime( fileStats [ stat.ST_CTIME ] ),  #获取文件创建时间
  
      'Mode':fileStats [ stat.ST_MODE ]                          #获取文件的模式
  
      }
  
      #print fileInfo
  
      
  
      for field in fileInfo:                                     #显示对象内容
  
      print '%s:%s' % (field,fileInfo[field])
  
      
  
      #for infoField,infoValue in fileInfo:
  
      #       print '%s:%s' % (infoField,infoValue)
  
      if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):             #判断是否路径
  
      print 'Directory. '
  
      else:
  
      print 'Non-directory.'
  
      
  
      if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ):             #判断是否一般文件
  
      print 'Regular file.'
  
      elif stat.S_ISLNK ( fileStats [ stat.ST_MODe ] ):           #判断是否链接文件
  
      print 'Shortcut.'
  
      elif stat.S_ISSOCK ( fileStats [ stat.ST_MODe ] ):          #判断是否套接字文件     
  
      print 'Socket.'
  
      elif stat.S_ISFIFO ( fileStats [ stat.ST_MODe ] ):          #判断是否命名管道
  
      print 'Named pipe.'
  
      elif stat.S_ISBLK ( fileStats [ stat.ST_MODe ] ):           #判断是否块设备
  
      print 'Block special device.'
  
      elif stat.S_ISCHR ( fileStats [ stat.ST_MODe ] ):           #判断是否字符设置
  
      print 'Character special device.'
  
      

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      import os.path
  
      
  
      fileStats = 'test.txt'
  
      
  
      if os.path.isdir ( fileStats ):         #判断是否路径
  
      print 'Directory.'
  
      elif os.path.isfile ( fileStats ):      #判断是否一般文件
  
      print 'File.'
  
      elif os.path.islink ( fileStats ):      #判断是否链接文件
  
      print 'Shortcut.'
  
      elif os.path.ismount ( fileStats ):     #判断是否挂接点
  
      print 'Mount point.'
  
      

  stat模块描述了os.stat(filename)返回的文件属性列表中各值的意义。我们可方便地根据stat模块存取os.stat()中的值。

• 串行化文件

  #!/usr/bin/env python
  
      #-*- encoding:UTF-8 -*-
  
      
  
      import pickle
  
      
  
      filehandler = open('pickle.txt','w')
  
      
  
      text = ['this is a pickle demonstrate','aa','bb']
  
      
  
      pickle.dump(text,filehandler)           #把text的内容序列化后保存到pickle.txt文件中
  
      
  
      filehandler.close()
  
      
  
      filehandler2 = open('pickle.txt')
  
      
  
      textlist = pickle.load(filehandler2)    #还原序列化字符串
  
      print textlist
  
      
  
      filehandler2.close()
  
      
  
      #cpickle是用C写的pickle模块，比标准的pickle速度快很多，使用方法同pickle。
  
      

• 内存文件

  #!/usr/bin/env python
  
      #-*- coding: utf-8 -*-
  
      
  
      import StringIO
  
      
  
      fileHandle = StringIO.StringIO ( "Let freedom ring." )   #create file in memory
  
      
  
      print fileHandle.read() # "Let freedom ring."
  
      
  
      fileHandle.close()
  
      
  
      #cStringIO是用C写的StringIO模块，执行速度比StringIO快。
  
      

Table 10.1. 正则表达式基本字符

Table 10.2. 匹配限定符

Table 10.3. 组和运算符

Table 10.4. 特殊字符序列

Table 10.5. 正则表达式声明

Table 10.6. 处理标志

Table 10.7. MatchObject对象方法

Table 10.8. 正则式对象方法/属性