python学习笔记_13(标准库)

标准库

---

1. 包、模块基本概念

• 模块，一个模块就是一个py文件，模块名和文件名一致

• 包，为了组织模块，可以分组为包，包就是模块所在的目录，python中如果需要把目录当作包，需要在目录下创建一个__init__.py的文件，如果导入包实际导入的是次文件。

• __all__变量，定义了模块的共有接口，在编写模块时设置__all__变量，使用import *导入只会导入all中定义的内容，否则默认导入模块中所有不以下划线开头的全局名称

• __name__，主程序中值是__main__，在导入模块中值设定为模块的名称

2. sys模块

函数/变量	描述
argv	命令行参数，包括脚本名称
exit([arg])	退出当前的程序，可以参数为给定的返回值或错误信息
modules	映射模块名称到载入模块的字典
path	查找模块所在的目录的目录列表
platform	平台表示，类似sunos5或win32的平台标识
stdin	标准输入流-------一个类文件(file-like)对象
stdou	标准输出流-------一个类文件(file-like)对象
stderr	标准错误流-------一个类文件(file-like)对象

3. os模块

函数/变量	描述
environ	对环境变量进行映射
system(command)	在子shell中执行操作系统命令
sep	路径分隔符
pathsep	分隔路径的分隔符
linesep	行分隔符(’\n’, ‘\r’或’\r\n’)
urandom(n)	返回n字节的加密强随机数据

4. fileinput模块

函数	描述
input(files[, inplace[, bakup]])	便于遍历多个输入流中的行
filename()	返回当前文件的名称
lineno()	返回当前（累计）的行数
filelineno()	放回当前文件的行数
isfirstline()	检测当前是否是文件的第一行
isstdin()	检测最后一行是否来自sys.stdin
nextfile()	关闭当前文件，移动下一个文件
close()	关闭序列

#!/bin/sh
# -*- coding: utf-8 -*-

import fileinput
import sys

for line in fileinput.input(inplace=True):
    line = line.rstrip()
    num = fileinput.filelineno()
    print '%-40s # %02d' % (line, num)
 

#保存为numberlines.py,运行python numberlines.py numberlines.py
#运行后程序文件
#!/bin/sh                                # 01
# -*- coding: utf-8 -*-                  # 02
                                         # 03
import fileinput                         # 04
import sys                               # 05
                                         # 06
for line in fileinput.input(inplace=True): # 07
    line = line.rstrip()                 # 08
    num = fileinput.filelineno()         # 09
    print '%-40s # %02d' % (line, num)   # 10

5. 集合(set)

集合Set类位于sets模块中，在python 2.3中通过set类型的实现成为了语言的一部分，意味不需要导入直接创建集合

• 集合是由序列构建的，主要用于检查成员资格，因此副本是被忽略的，集合中的元素都是唯一的

• 集合元素的顺序是随意的

  >>> set(range(10))
  set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  >>> set([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
  set([0, 1, 2, 3, 4])
  >>> set(['fee', 'fie', 'foe'])
  set(['foe', 'fee', 'fie'])

• 集合操作，除了检查成员资格，还可以使用标准的集合操作，比如并集和交集，可以使用方法，也可以使用对整数进行位操作时使用的操作

  >>> a = set([1, 2, 3])
  >>> b = set([2, 3, 4])
  # 1. 并集
  >>> a.union(b)
  set([1, 2, 3, 4])
  >>> a | b
  set([1, 2, 3, 4])
  # 2. 交集
  >>> a.intersection(b)
  set([2, 3])
  >>> c = a & b
  >>> c
  set([2, 3])
  # 3. 判断子集
  >>> c.issubset(a)
  True
  >>> c <= a
  True
  # 4. 判断超集
  >>> c.issuperset(a)
  False
  >>> c >= a
  False
  # 5. 补集
  >>> a.difference(b)
  set([1])
  >>> a - b
  set([1])
  # 6. 真补集
  >>> a.symmetric_difference(b)
  set([1, 4])
  >>> a ^ b
  set([1, 4])

• 集合是可变的，所有集合不能用做字典中的键，另外集合本身只能包含不可变的元素，所以集合不能包含其他集合。

• frozenset，不可变集合，可以作为集合的元素

  >>> a = set()
  >>> a
  set([])
  >>> b=set()
  >>> a.add(b)
  
  Traceback (most recent call last):
    File "<pyshell#40>", line 1, in <module>
      a.add(b)
  TypeError: unhashable type: 'set'
  
  >>> a.add(frozenset(b))
  >>> a
  set([frozenset([])]) 

6. 堆(heap)

• 优先队列的一种，使用优先队列能够以任意顺序增加对象，并且能在任何时间找到最小对象

• python中没有独立的堆类型，只有一个包含一些堆操作的函数的模块，这个模块是heapq（q即queue的缩写），包含以下函数

  堆属性（heap property）位于i位置上的元素总比i//2位置处的元素大，反过来说就是位置i处的元素总比2*i和2*i+1位置处的元素小，这是底层堆算法的基础

  函数	描述
  heappush(heap, x)	将x入堆
  heappop(heap)	将x中的最小元素弹出
  heapify(heap, x)	将heap属性应用到任意一个列表
  nlargest(n, iter)	返回iter中第n大的元素
  nsmallest(n, iter)	返回iter中第n小的元素

  >>> from heapq import *
  >>> from random import shuffle
  >>> data = range(10)
  >>> shuffle(data)
  >>> data
  [9, 8, 1, 4, 3, 0, 6, 7, 5, 2]
  >>> heap = []
  # 1. heappush
  >>> for n in data:
  	heappush(heap, n)
  
  	
  >>> heap
  [0, 2, 1, 5, 3, 8, 6, 9, 7, 4]
  >>> heappush(heap, 0.5)
  >>> heap
  [0, 0.5, 1, 5, 2, 8, 6, 9, 7, 4, 3]
  # 2. heappop，弹出最小的元素，一般来说是在索引0处，并确保剩余元素中最小的占据这个位置
  >>> heappop(heap)
  0
  >>> heap
  [0.5, 2, 1, 5, 3, 8, 6, 9, 7, 4]
  >>> heappop(heap)
  0.5
  >>> heappop(heap)
  1
  >>> heap
  [2, 3, 4, 5, 7, 8, 6, 9]
  # 3. heapify，使用任意列表做为参数，并且通过尽可能少的移位转换为合法的堆
  >>> heap = [5, 8, 0, 3, 6, 7, 9, 1, 4, 2]
  >>> heapify(heap)
  >>> heap
  [0, 1, 5, 3, 2, 7, 9, 8, 4, 6]
  # 4. heapreplace，弹出最小元素，并将新元素推入
  >>> heapreplace(heap, 0.5)
  0
  >>> heap
  [0.5, 1, 5, 3, 2, 7, 9, 8, 4, 6]
  # 5. nlargest和nsmallest，分别寻找任何可迭代对象iter中第n大或n小的元素
  >>> heap = [3, 2, 5, 9, 0 ,3, 1, 4]
  >>> nlargest(3, heap)
  [9, 5, 4]
  >>> nlargest(2, heap)
  [9, 5]
  >>> nlargest(1, heap)
  [9]
  >>> nsmallest(2, heap)
  [0, 1]

7. 双端队列

• 双端队列（double-ended queue或称deque），在需要按元素增加的顺序来移除元素时非常有用

  python 2.4中增加了collections模块，包括deque类型

  python 2.5中的collections模块只包括deque和defaultdict类型

• 双端队列通过可迭代对象创建，而且有些非常有用的方法，如下示例

  >>> from collections import deque
  >>> q = deque(range(5))
  >>> q.append(5)
  >>> q
  deque([0, 1, 2, 3, 4, 5])
  >>> q.appendleft(6)
  >>> q
  deque([6, 0, 1, 2, 3, 4, 5])
  >>> q.pop()
  5
  >>> q.popleft()
  6
  >>> q
  deque([0, 1, 2, 3, 4])
  >>> q.rotate(3)
  >>> q
  deque([2, 3, 4, 0, 1])
  >>> q.rotate(-1)
  >>> q
  deque([3, 4, 0, 1, 2])
  >>>