夜间模式暗黑模式
字体
阴影
滤镜
圆角
主题色
Python学习笔记9-模块与包与标准库

模块(P172)

任何Python程序都可作为模块导入

但模块所在的目录必须在Python的path中才能导入

import sys
sys.path.append(r'C:\python')
# 在Unix中, 使用sys.path.expanduser('~/python')可创建完整路径(自动将~补全)

一个包只会被导入一次, 多次导入不会有效果, 可以使用importlib模块中的reload()函数重新加载模块

import importlib
A = importlib.reload(A) # 重新加载模块A

使用变量__name__检查模块是作为程序运行还是被导入, 如果是作为程序运行, 则__name__的值为'__main__'

包是一种模块, 可以包含其他模块, 可以用来组织模块, 模块存储在.py文件中, 二包则是一个目录, 目录中必须包含文件__init__.py, 直接导入包相当于导入了__init__.py文件

获取模块的信息和文档(P178)

  • dir(x): 打印x的所有属性, 如果x是模块, 将列出所有函数, 类, 变量等
  • 变量__all__: 模块中的这个变量代表模块的所有公有接口(使用from x imprt *将导入x.__all__中的所有内容, 如果在编写模块时不设置__all__, 则使用import *时将导入所有不以下划线开头的全局名称
  • help(x): 获取模块或者函数, 类等的特征标和文档(__doc__)
  • 查看源代码: 变量x.__file__存储了模块x所在的文件目录

标准库(P181)

sys

函数/变量 描述
argv 命令行参数,包括脚本名
exit([arg]) 退出当前程序,可通过可选参数指定返回值或错误消息, 在try/finally中调用, finally依然会执行
modules 一个字典,将模块名映射到加载的模块
path 一个列表,包含要在其中查找模块的目录的名称
platform 一个平台标识符,如sunos5或win32
stdin 标准输入流——一个类似于文件的对象
stdout 标准输出流——一个类似于文件的对象
stderr 标准错误流——一个类似于文件的对象

os(P183)

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

fileinput(P185)

python some_script.py file1.txt file2.txt file3.txt这样调用python程序可以对文件进行迭代

函数 描述
input([files[, inplace[, backup]]]) 帮助迭代多个输入流中的行
filename() 返回当前文件的名称
lineno() 返回(累计的)当前行号
filelineno() 返回在当前文件中的行号
isfirstline() 检查当前行是否是文件中的第一行
isstdin() 检查后一行是否来自sys.stdin
nextfile() 关闭当前文件并移到下一个文件
close() 关闭序列

input([files[, inplace[, backup]]])返回一个可迭代对象, 对文件列表逐个逐行迭代, inplace为True时, 将进行就地处理(访问的每一行都必须打印出替代内容并且被写回到当前输入文件中, backup参数为从原始文件创建的备份文件的扩展名)

# a.py
import fileinput                                   #  1 #  1 #  1
for line in fileinput.input(inplace=True):         #  2 #  2 #  2
	line = line.rstrip()                              #  3 #  3 #  3
	num = fileinput.lineno()                          #  4 #  4 #  4
	print('{:<50} # {:2d}'.format(line, num))         #  5 #  5 #  5
    
# 运行
python a.py a.py
将会给a.py 每一行后面加上行号

集合、堆和双端队列 (P186)

  • 集合

    # 创建集合
    >>> x = set([1, 2])
    >>> x
    {1, 2}
    
    # 集合直接可以直接用<=, <, >=, >, |, &, ^, |=, &=, -=, ^=运算
    # add(), remove(), pop(), clear()
    
    # set只能包含不可变类型的元素, 而set本身是可变的, 如果要在集合里面包含集合, 可以使用不可变集合frozenset
    
  • python没有提供独立的堆类型, 但提供了对堆进行操作的函数, 可以使用这些函数和一个列表构造一个堆

    函数 描述
    heappush(heap, x) 将x压入堆中
    heappop(heap) 从堆中弹出小的元素
    heapify(heap) 让列表具备堆特征
    heapreplace(heap, x) 弹出小的元素,并将x压入堆中
    nlargest(n, iter) 返回iter中n个大的元素
    nsmallest(n, iter) 返回iter中n个小的元素
  • 双端队列

    模块collections中包含了deque, 可从可迭代对象创建双端队列

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

    日期可以表示为实数(从"新纪元"1月1日0时起过去的秒数)或一个包含9个数字的元组表示

    >>> localtime()
    time.struct_time(tm_year=2019, tm_mon=1, tm_mday=27, tm_hour=13, tm_min=14, tm_sec=22, tm_wday=6, tm_yday=27, tm_isdst=0)
    # 最后三个参数表示星期, 儒略日, 夏令时
    

    模块time中的一些函数:

    函数 描述
    asctime([tuple]) 将时间元组转换为字符串
    localtime([secs]) 将秒数转换为表示当地时间的日期元组
    mktime(tuple) 将时间元组转换为当地时间
    sleep(secs) 休眠(什么都不做)secs秒
    strptime(string[, format]) 将字符串转换为时间元组
    time() 当前时间(从新纪元开始后的秒数,以UTC为准)
  • random

    模块random中一些重要的函数

    函数 描述
    random() 返回一个0~1(含)的随机实数
    getrandbits(n) 以长整数方式返回n个随机的二进制位
    uniform(a, b) 返回一个a~b(含)的随机实数
    randrange([start], stop, [step]) 从range(start, stop, step)中随机地选择一个数
    choice(seq) 从序列seq中随机地选择一个元素
    shuffle(seq[, random]) 就地打乱序列seq
    sample(seq, n) 从序列seq中随机地选择n个值不同的元素
  • shelve( P195)

    • shelve可以用来在文件中存储数据, shelve.open()打开一个文件并返回一个shelf对象, 可以像操作普通字典一样操作它, 只是键必须为字符串, 操作完毕可调用其方法close()
    • 当你查看shelf对象中的元素时, 将使用存储版重构该元素, 也就是说, 你将得到元素的副本而不是其本身, 要想修改元素, 必须通过给键赋值的方式
    • 将函数open的参数writebck设置为True, 这样从shelf对象读取或赋值都会被保存
    • 使用try/finally语句, 将close放在finally语句中, 可以确保数据得到保存
  • json

  • 正则表达式re

    • 使用\对特殊字符进行转义, 也可以使用原始字符串`r"…"

    • 模块re中一些重要的函数:

      函数 描述
      compile(pattern[, flags]) 根据包含正则表达式的字符串创建模式对象
      search(pattern, string[, flags]) 在字符串中查找模式
      match(pattern, string[, flags]) 在字符串开头匹配模式
      split(pattern, string[, maxsplit=0]) 根据模式来分割字符串
      findall(pattern, string) 返回一个列表,其中包含字符串中所有与模式匹配的子串
      sub(pat, repl, string[, count=0]) 将字符串中与模式pat匹配的子串都替换为repl
      escape(string) 对字符串中所有的正则表达式特殊字符都进行转义

      其中searchmatch返回一个MatchObject对象, 包含了与模式匹配的子串的信息, 还包括模式的各部分与子串的那一部分匹配的信息, 这些子串称为编组(group)

      ‘There (was a (wee) (cooper)) who (lived in Fyfe)’ 包含如下编组:

      • 0 There was a wee cooper who lived in Fyfe
      • 1 was a wee cooper
      • 2 wee
      • 3 cooper
      • 4 lived in Fyfe
    • MatchObject对象的一些重要方法:

      方法 描述
      group([group1, …]) 获取与给定子模式(编组)匹配的子串
      start([group]) 返回与给定编组匹配的子串的起始位置
      end([group]) 返回与给定编组匹配的子串的终止位置(与切片一样,不包含终止位置)
      span([group]) 返回与给定编组匹配的子串的起始和终止位置
      >>> m = re.search('a(b+(c+))+', 'abbccbc')
      >>> m
      <_sre.SRE_Match object; span=(0, 7), match='abbccbc'>
      >>> m.span(0)
      (0, 7)
      >>> m.group(0)
      'abbccbc'
      >>> m.group(2)
      'c'
      >>> m.end(1)
      7
      >>> m.span(1)
      (5, 7)
      
    • 替换中的编组号

      在替换字符串中, 所有\\n的转义序列都会被替换成与模式中编组n匹配的字符串:

      >>> emphasis_pattern = r'\*([^\*]+)\*'
      >>> re.sub(emphasis_pattern, r'<em>\1</em>', 'Hello, *world*')
      'Hello, <em>world</em>'
      
    • 贪婪模式: 在重复运算符后面加上?来将其指定为非贪婪的

      贪婪模式指的是能匹配尽可能多的内容 :

      # 贪婪模式
      >>> p = re.search('a.*b', 'axxbxxbxxb')
      >>> p.group(0)
      'axxbxxbxxb'
      
      # 非贪婪模式
      >>> p = re.search('a.*?b', 'axxbxxbxxb')
      >>> p.group(0)
      'axxb'
      
    • 在正则表达式模式串中使用在末尾的$表示匹配整行(直到行尾)

    • 模版系统示例:

      import fileinput, re
      
      pat = re.compile(r'\[(.+?)\]')
      
      scope = {}
      
      def replacement(match):
      	code = match.group(1)
      	try:
      		return str(eval(code, scope))
      	except SyntaxError:
                      exec(code, scope)
                      return ''
      
      lines = []
      for line in fileinput.input():
      	lines.append(line)
      text = ''.join(lines)
      
      print(pat.sub(replacement, text))
      
      # 测试
      λ python test.py
      [a = 10]
      [b = 20]
      [a+b]
      ^Z
      # 输出
      
      
      30
      
      
暂无评论

发送评论 编辑评论


				
上一篇
下一篇