Python 内置对象及模块

Python作为一种高效的脚本语言，内置了很多实用的函数，同时也提供了丰富的工具模块。 下面是总结的几种内置对象及函数的应用技巧。

 1、强大的列表解析功能

• 对列表元素的简单操作：例如将列表的每个元素乘以2

  list1 = [1,2,3,4]
  list1 = [x*2 for x in list1]       #[2,4,6,8]

• 对文件的操作：例如只收集文件中以'p'开头的行

  lines = [line.rstrip() for line in open('filename') if line[0] == 'p']

• 对两个集合进行排列组合：例如对'abc'与'lmn'进行排列组合

  str1 = 'abc'
  str2 = 'lmn'
  [x+y for x in str1 for y in str2]    #['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']

2、索引和分片

• 对字符串的操作

  #索引操作
  s = 'spam'
  s[0]     # 's'
  s[-1]    # 'm'
  #分片操作
  s[1:3]    # 'pa'
  s[1:]      # 'pam'
  s[:-1]     # 'spa'
  s[:]        # 'spam'
  s[::2]     # 'sa'
  s[1::2]   # 'pm'
  s[::-1]    # 'maps'
  s[-1:0:-1] # 'map'

• 对列表的操作

  #索引操作
  list1 = ['spam','SPAM','Spam']
  list1[0]     # 'spam'
  list1[-1]    # 'Spam'
  #分片操作
  list1[1:2]    # ['SPAM']
  list1[1:]      # ['SPAM', 'Spam']
  list1[:-1]     # ['spam', 'SPAM']
  list1[:]        # ['spam', 'SPAM', 'Spam']
  list1[::2]     # ['spam', 'Spam']
  list1[1::2]   # ['SPAM']
  list1[::-1]    # ['Spam', 'SPAM', 'spam']
  list1[-1:0:-1] # ['Spam', 'SPAM']

3、内置的eval函数可以将字符串转换成对象

a='123'
type(a)          # <type 'str'>
type(eval(a))    # <type 'int'>

4、zip函数

• 内置的zip函数使用for循环实现并行遍历。在基本运算中，zip会取得一个或多个序列为参数，然后返回元组的列表，将这些序列中的并排的元素配成对。

  >>> l1 = [1,2,3,4]
  >>> l2 = [5,6,7,8]
  >>> zip(l1,l2)
  [(1, 5), (2, 6), (3, 7), (4, 8)]

• 如果与 for 循环搭配，zip就会支持并行迭代

  >>> for (x,y) in zip(l1,l2):
  ...     print x, y, '--', x+y
  ...
  1 5 -- 6
  2 6 -- 8
  3 7 -- 10
  4 8 -- 12

• 在运行时构造字典

  >>> keys = ['a', 'b', 'A', 'B']
  >>> values = [96, 97, 65, 66]
  >>> d = dict(zip(keys, values))
  >>> d
  {'a': 96, 'A': 65, 'B': 66, 'b': 97}

5、工厂函数 工厂函数有时也叫闭合(closure)，一个能够记住嵌套作用域变量值的函数，尽管那个作用域或许已经不存在了。 尽管类是最适合用作记忆状态的，因为它们通过属性赋值这个过程变得很明了，像这样的函数也提供了一种替代的解决方法。

>>> def maker(n):
    ...   def action(x):
    ...     return x ** n
    ...   return action
    ...
>>> f=maker(2)
>>> type(f)
<type 'function'>
>>> f(3)
9
>>> f(4)
16

6、匿名函数：lambda 除了def语句之外，Python还提供了一种生成函数对象的表达式形式。由于它于LISP语言中的一个工具很相似，所以称为lambda。就像def一样，这个表达式创建了一个之后能够调用的函数，但是它返回了一个函数而不是将这个函数赋值给一个变量名。这也就是lambda有时被称作匿名函数的原因了。

1. lambda通常用来编写跳转表(jump table)，也就是行为的列表或字典，能够按照需要执行相应的动作
   • 行为列表示例：

     >>> L = [(lambda x: x **2),(lambda x: x**3),(lambda x: x**4)]
     >>> for f in L:
     ...   print f(2)
     ...
     4
     8
     16

   • 行为字典示例：

     >>> key = 'got'
     >>> {'already':(lambda: 2+2),'got':(lambda: 2*4),'one':(lambda: 2**6)}[key]()
     8

     这样一个字典也就变成了一个多路分支的工具了
2. lambda 与 if/else三元表达式的结合

   >>> lower = lambda x,y: x if x < y else y
   >>> lower('a','b')
   'a'
   >>> lower('b','a')
   'a'

3. 如果要在lambda函数中执行循环，能够嵌入map调用或列表解析表达式
   • 嵌入map的示例

     >>> import sys
     >>> showall = lambda x: map(sys.stdout.write,x)
     >>> t = showall(['spam\n','toast\n','eggs\n'])
     spam
     toast
     eggs
     
     >>> L = [1,2,3,4]
     >>> map((lambda x: x+3),L)
     [4, 5, 6, 7]

   • 嵌入列表解析的示例

     >>> showall = lambda x: [sys.stdout.write(line) for line in x]
     >>> t = showall(('bright\n','side\n','of\n','life\n'))
     bright
     side
     of
     life

4. 嵌套作用域和lambda

   def func():
       x = 4
       action = (lambda n: x ** n)
       return action
   
   f = func()
   print f(2)    #16, 4**2

7、生成器

• 概念 不像一般的函数会生成值后退出，生成器函数在生成值后自动挂起并暂停它们的执行和状态。正是因为这一点，无论是在从头计算整个序列的值，或者手动保存和恢 复类中的状态时，它们都常常作为一种使用的替代解决方案。生成器在被挂起时自动地保存状态，它的本地变量将保存状态信息，这些信息在函数恢复时将再度有效。
• 生成器函数和一般函数的区别：最大的区别就是生成器yield一个值，而不是return一个值。yield语句会将函数挂起，并向它的调用者返回一个值，但是保存足够的状态信息为了让其能够在函数从它挂起的地方恢复。这能够允许这些函数不断地产生一系列的值，而不是一次计算所有的值，之后将值以类似列表之类的形式来返回。
• 生成器函数在Python中与迭代器协议的概念联系在一起 包含了yield语句的函数将会特地编译为生成器。当调用是，它们返回了一个生成器对象，这个生成器对象支持迭代器对象接口。生成器函数也许有一个return语句，这个语句就是用来终止产生值的。
• 示例：

  >>> def gensquares(n):
  ...   for i in range(n):
  ...     yield i ** 2
  ...
  >>> type(gensquares(5))
  <type 'generator'>
  >>> for i in gensquares(5):
  ...   print i,',',
  ...
  0 , 1 , 4 , 9 , 16 ,

• 生成器表达式： 生成器表达式就像一般的列表解析一样，但是它们是括在圆括号中而不是方括号中的。生成器表达式返回一个生成器对象。

  >>> for x in (x ** 2 for x in range(4)):
  ...   print x,
  ...
  0 1 4 9>>> for x in (x ** 2 for x in range(4)):
  ...   print x,
  ...
  0 1 4 9

  注意：如果生成器表达式是在其他括号之内的话，就像在那些函数调用之中，生成器自身的括号就不是必须的了。尽管这样，在下面第二个sorted调用中，还是需要额外的括号。

  >>> sum(x ** 2 for x in range(4))
  14
  >>> sorted(x ** 2 for x in range(4))
  [0, 1, 4, 9]
  >>> sorted((x ** 2 for x in range(4)), reverse=True)
  [9, 4, 1, 0]
  >>> import math
  >>> map(math.sqrt, (x ** 2 for x in range(4)))
  [0.0, 1.0, 2.0, 3.0]

 

 1、math模块

>>> import math
>>> math.pi
3.1415926535897931
>>> math.e
2.7182818284590451
>>> math.sin(2*math.pi/180)
0.034899496702500969

2、random模块

>>> import random
>>> random.random()
0.40019449172525789
>>> random.random()
0.063811948555701825
>>> random.randint(1,10)     3
>>> random.randint(1,10)     2

>>> random.choice(['a', 'b', 'c'])   'a'
>>> random.choice(['a', 'b', 'c'])    ‘c'

3、decimal模块

>>> print 0.1+0.1+0.1-0.3
5.55111512313e-17
>>> from decimal import Decimal
>>> Decimal('0.1')+Decimal('0.1')+Decimal('0.1')-Decimal('0.3')
Decimal("0.0")

4、re正则表达式 re模块能够处理正则表达式的操作

• 生成正则表达式对象 compile(pattern, flags=0)构建一个正则表达式，返回该正则表达式对象

  >>> import re
  >>> ptn1 = re.compile('he')

• 进行匹配
  • match() 确定正则表达式是否匹配字符串的开头
  • search() 扫描字符串以查找匹配
  • findall() 找到所有正则表达式匹配的子字符串，并把它们作为一个列表返回
  • finditer() 找到所有正则表达式匹配的子字符串，并把它们以迭代器的形式返回
  match()和search()在没有发现匹配时返回None。如果匹配成功，一个MatchObject实例被返回，其中包含的匹配信息有：哪开始哪结束，匹配的子字符串等等。
  • group() 返回通过正则表达式匹配到的字符串
  • start() 返回成功匹配开始位置
  • end()   返回成功匹配结束位置
  • span()  返回包含成功匹配开始和结束位置的元组

  >>> import re
  >>> p1 = re.compile('h')
  >>> str1 = 'hello world'
  >>> md = p1.match(str1)
  >>> print md
  <_sre.SRE_Match object at 0x7f28e95c3238>
  >>> md.group()
  'h'
  >>> md.start()
  0
  >>> md.end()
  1
  >>> md.span()
  (0, 1)
  >>> p2 = re.compile('llo')
  >>> md2 = p2.search(str1)
  >>> md2.group()
  'llo'
  >>> md2.span()
  (2, 5)
  >>> p3 = re.compile('\d+')
  >>> str2 = '12abc3de45'
  >>> print p3.findall(str2)
  ['12', '3', '45']
  >>> iterator = p3.finditer(str2)
  >>> iterator
  <callable-iterator object at 0x7f28e96ba9d0>
  >>> for match in iterator:
  ...     print match.span()
  ...
  (0, 2)
  (5, 6)
  (8, 10)

5、用pickle存储Python的原生对象（对象的序列化以及反序列化） pickle模块是能够让我们直接在文件中存储几乎任何Python对象的高级工具，也并不要求我们把字符串转换来转换去。

# 向文件中存储数据
>>> data = {'a':97, 'b':98, 'A':65, 'B':66}
>>> datafile = open('data.txt','w')
>>> import pickle
>>> pickle.dump(data,datafile)
>>> datafile.close()
# 读取存储的数据
>>> datafile = open('data.txt')
>>> data = pickle.load(datafile)
>>> data
{'a': 97, 'A': 65, 'B': 66, 'b': 98}

6、文件中打包二进制数据的存储与解析 struct模块能够构造并解析打包的二进制数据。

# 存储
>>> f = open('data.bin','wb')
>>> import struct
>>> bytes = struct.pack('>i4sh', 7, 'spam', 8)
>>> bytes
'\x00\x00\x00\x07spam\x00\x08'
>>> f.write(bytes)
>>> f.close()
# 读取
>>> f = open('data.bin','rb')
>>> data = f.read()
>>> data
'\x00\x00\x00\x07spam\x00\x08'
>>> values = struct.unpack('>i4sh', data)
>>> values
(7, 'spam', 8)

7、进程模块工具

1. Python的标准库中与进程和线程相关的模块和函数 模块名称 说明

   os/sys	包含基本进程管理函数
   subprocess	Python基本库中多进程相关模块
   signal	Python基本库中信号相关模块

2. 进程的操作示例
   • os/sys模块 创建进程
     • system函数 格式：system(command) 说明：此函数在新进程中执行command字符串命令。如果返回值为0，表示命令执行成功，否则表示失败。 示例：

       >>> import os
       >>> print os.system('ls')

     • exec 家族函数 exec家族中有8个类似的函数(execl, execle, execlp, execlpe, execv, execve, execvp, execvpe)。虽然用他们都可以创建进程，但是和system函数还是有些不同。system函数实际上是调用系统内置的命令行程序来执行系统命令，所以在命令结束之后会将控制权返回给Python进程。但是，所有的exec函数在执行命令之后，将会接管Python进程，而不会将控制权返回。换句话说，Python进程会在调用exec函数后终止。新生成的进程将会替换调用进程。这些函数都没有返回值，如果发生错误，将会触发OSError异常。 execl 函数 格式：execl(path, arg0, arg1, ...) 示例：

       >>> import os
       >>> os.execl('/usr/bin/kate')

     终止进程 当Python脚本遇到最外层的return语句而退出的时候，这个进程也就终止了。除此之外，还有两种方法终止进程: sys.exit 和os.abort
     • sys.exit函数 exit函数是一种"温和"的终止进程方式，在程序退出之前会执行一些清理操作，同时将返回值给调用进程(一般是操作系统)。使用此返回值，系统可以判断程序是否是正常退出或者运行出了异常。 例子：

       import sys
       try:
       filename = sys.argv[1]
       print filename
       except:
       print "Usage:", sys.argv[0], "filename"
       sys.exit(1)

     • os.abort 函数 和exit函数不同的是，abort函数是一种"暴力"的退出方式，将会直接给进程发送终止信号(SIGABORT信号)。默认情况下，这将会终止进程，同时不会做相关的清理工作。需要注意的是，可以使用signal.signal()来为SIGABORT信号注册不同的信号处理函数，从而改变其默认行为。
   • subprocess 模块 subprocess模块是作为进程管理的高级模块在2.4版本被引入的。subprocess可以调用外部的系统命令创建新的子进程，同时连接到子进程的input/output/error管道上，并得到子进程的返回值。这个模块可以用来替代一些旧模块的方法，如os.system, os.spawn*, os.popen*,popen2.*, commands.*等。subprocess模块中提供了一个类和两个使用函数来管理进程，下面将分别进行介绍。
     • 使用Popen类管理进程 class Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0) 其中，args参数为要执行的外部程序。其值可以是字符串或者序列。除此之外，其他的类参数都是有默认值，可以根据需要进行修改。

       import subprocess
       pingP = subprocess.Popen(args='ping -c 4 www.sina.com', shell=True)
       pingP.wait()
       print pingP.pid
       print pingP.returncode

       注：在Linux下，当shell为"False"时，Popen将调用os.execvp执行对应的程序。而shell为"True"时，如果命令为字符串，Popen直接调用系统shell来执行指定的程序。如果命令为一个序列，则其第一项是定义命令字符串，其他项为命令的附加参数。
     • subprocess模块还提供了两个实用函数来直接调用外部系统命令：call()和check_all()。 call()会直接调用命令生成子进程，并且等待子进程结束，然后返回子进程的返回值。check_all()和call()函数的主要区别在于：如果返回值不为0，则触发CallProcessError异常。返回值保存在这个异常对象的returncode属性中。

       import subprocess
       retcode = subprocess.call(['ls','-l'])   #调用ls -l 命令