模块

模块

1、模块就是程序

任何python程序都可以作为模块导入：

>>>import sys

>>>sys.path.append('C:/python')

注：在unix中不能直接将字符串"~/python"附加到sys.path末尾。而必须使用绝对路径。如果要自动创建完整路径，可使用sys.path.expanduser('~/python')

当导入模块后，在其所在目录还新建了一个名为_pycache_的子目录，这个目录包含处理后的文件

模块导入一次和多次是一样的，若要重新加载模块，可使用模块importlib中的函数reload：

>>>import importlib

>>>python = importlib.reload(python)

2、模块是用来定义的

1> 在模块中定义函数：

只包含一个简单函数的模块：

# hello2.py

def hello():

print("hello,world")

导入改模块：

>>>import hello2

访问这个函数：

>>>hello2.hello()

---> hello,world

在模块的全局作用域内定义的名称都可以像这样访问。主要是为了重用代码，将代码放在模块中，就可以在多个程序中使用。

2> 在模块中添加测试代码

该模块中，测试代码不完善：

# hello3.py

def hello():

print("hello,world")

#一个测试

hello()

>>>import hello3

---> hello,world

>>>hello3.hello()

---> hello,world

检查模块是作为程序运行还是被导入另一个程序，为此需要使用变量__name__

>>>hello3.__name__

---> hello3

在主程序中，变量__name__的值是__main__，而在导入的模块中，这个变量被设置为该模块的名称

一个包含有条件的执行的测试代码的模块：

# hello4.py

def hello():

print("hello,world")

def test():

hello()

if __name__ =='__main__': test()

如果这个模块作为程序运行，将执行函数hello；如果导入，其行为像普通模块一样。

>>>import hello4

>>>hell4.hello()

---> hello,world

>>>hell4.test()

---> hello,world

3> 让模块可用：将模块放在正确的位置，告诉解释器到哪里去找

将模块放在正确的位置：

>>> import sys,pprint

>>> pprint.pprint(sys.path)

['',

'C:\\soft\\python\\python3\\py3install\\Lib\\idlelib',

'C:\\soft\\python\\python3\\py3install\\python36.zip',

'C:\\soft\\python\\python3\\py3install\\DLLs',

'C:\\soft\\python\\python3\\py3install\\lib',

'C:\\soft\\python\\python3\\py3install',

'C:\\soft\\python\\python3\\py3install\\lib\\site-packages']

可将其放在其中的任何一个位置中都可行，但目录site-packages是最佳的选择，专门用来放置模块的

告诉解释器到哪里去找：

可以直接修改sys.path（不常见）

标准做法：将模块所在的目录包含在环境变量PYTHONPATH中：

如：将~/python附加到环境变量PYTHONPATH末尾中：export PYTHONPATH=$PYTHONPATH:~/python

3、模块包含什么

使用函数dir：

查看模块包含哪些东西，可使用函数dir，它列出对象的所有的属性（对于模块，列出所有的函数，类，变量）

>>>dir(copy)

['Error', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_copy_dispatch', '_copy_immutable', '_deepcopy_atomic', '_deepcopy_dict', '_deepcopy_dispatch', '_deepcopy_list', '_deepcopy_method', '_deepcopy_tuple', '_keep_alive', '_reconstruct', 'copy', 'deepcopy', 'dispatch_table', 'error']

注：以下划线开头的名称列表，并非供外部使用。

>>> [n for n in dir(copy) if not n.startswith('_')]

['Error', 'copy', 'deepcopy', 'dispatch_table', 'error']

变量__all__

如：

>>> copy.__all__

['Error', 'copy', 'deepcopy']

查看文档：

>>>print(copy.__doc__)

Generic (shallow and deep) copying operations.

Interface summary:

import copy

x = copy.copy(y) # make a shallow copy of y

x = copy.deepcopy(y) # make a deep copy of y

使用源代码，查看某特性

>>>print(copy.__file__)

C:\soft\python\python3\py3install\lib\copy.py

标准库（标准模块）

1、sys

模块sys中一些重要的函数和变量

argv ：命令行参数，包括脚本名

exit([arg]) ：退出当前程序，可通过可选参数指定返回值或错误消息

modules：一个字典，将模块名映射到加载的模块

path：一个列表，包含要在其中查找模块的目录的名称

platform：一个平台标识符，如win32或rhel6

stdin：标准输入流，一个类似于文件的对象

stdout：标准输出流，一个类似于文件的对象

stderr：标准错误流，一个类似于文件的对象

变量sys.argv：包含传递给python解释器的参数，其中包括脚本名

函数sys.exit：退出当前程序。可以向它提供一个整数，指出程序是否成功，这是一种unix约定，大多数情况下，使用该参数的默认值（0，表示成功）即可。也可向它提供一个字符串，这个字符串将成为错误消息，程序退出时将显示指定的错误消息以及一个表示失败的编码。

映射sys.modules：将模块名映射到模块（仅限当前已导入的模块）

变量sys.path：它是一个字符串列表，其中的每个字符串都是一个目录名，执行import语句时将在这些目录中查找模块。

变量sys.platform：是运行解释器的“平台”名称，

2、os

environ：包含环境变量的映射

system(command)：在子shell中执行操作系统命令

sep：路径中使用的分隔符

pathsep：分割不同路径的分隔符

linesep：行分隔符（\n，\r，\r\n）

urandom(n)：返回n个字节的强加密随机数据

os.environ：包含环境变量，如要访问的环境变量PYTHONPATH，可使用表达式os.environ[PATHONPATH]；也可用于修改环境变量。

os.system：用于运行外部程序。还有其它用于执行外部程序的函数，如execv或popen。前者退出python解释器，并将控制权交给被执行的程序，而后者创建一个到程序的连接。

变量os.sep：是用于路径名中的分隔符。在unix中标准的分隔符为（/）；在windows中标准分隔符为（\\）

os.pathsep：可用来组合多条路径。pathsep用于分割不同的路径名，在unix中为（：），在windows中为（；）

变量os.linesep：用于文本文件中的行分隔符：在unix中为单个换行符（\n)，在windows中为回车和换行符（\r\n）

函数urandom：使用随系统而异的随机源

启动浏览器：

在Unix中：os.system('/usr/bin/firefox')；

在windows中：os.system(r'C:\"Promgram Files (x86)"\"Mozilla Firefox"\firefox.exe)；(路径中有空白，需用引号将其括起来)

另可使用函数os.startfile：os.startfile(r'C:\Promgram Files (x86)\Mozilla Firefox\firefox.exe)；（路径中有空白也无影响）

在windows中，使用os.system和os.startfile启动外部程序后，当前的python程序将继续运行；而在unix中，当前Python程序将等待命令os.system结束。

使用webbrowser模块：该模块中包含一个名为open的函数，可以启动浏览器并打开指定的URL：

>>>import webbrowser

>>>webbbrowser.open('http://www.python.org')

3、fileinput

模块fileinput能够迭代一系列文本文件中的所有行。

input([files[,inplace[,backup]]]：帮助迭代多个输入流中的行。

filename()：返回当前文件的名称

lineno()：返回（累计的）当前的行号

filelineno()：返回在当前文件中的行号

isfirstline：检查当前行是否是文件中的第一行

isstdin()：检查最后一行是否来自sys.stdin

nextfile()：关闭当前文件并移动到下一个文件

close()：关闭序列

fileinput.input：返回一个可在for循坏中进行迭代的对象。如果要覆盖默认行为（确定要迭代哪些文件），可以序列的方式向这个函数提供一个或多个文件名。还可以将参数inplace设置为True（inplace=True)，这样讲就地进行处理。对于访问的每一行，都需打印出替代的内容，这些内容将被写回到当前输入文件中。就地处理时，可选参数backup用于给从原始文件创建的备份文件制定扩展名。

函数fileinput.filename：返回当前文件（即当前所处理的行所属文件）的文件名。

函数fileinput.lineno：返回当前的行号。这个值是累计的，因此处理完一个文件并接着处理下个文件时，不会重置行号。

函数fileinput.filelineno：返回当前行在当前文件中的行号，每处理完一个文件并接着处理下个文件时，将重置这个行号并从1重新开始。

函数fileinput.isfirstline：在当前行是当前文件中的第一行时返回True，否则返回False。

函数fileinput.isstdin：在当前文件是sys.stdin时返回True，否则返回False。

函数fileinput.nextfile：关闭当前文件并跳到下一个文件，且计数时忽略跳过的行。

函数fileinput.close：关闭整个文件链并结束迭代。

eg：给文件中的每一行添加行号，每行代码最多包含40个字符，并在第41个字符处开始添加注释。

#numberlines.py

inport fileinput

for line in fileinput.input(inplace=True):

line = line.rstrip()

num = fileinput.lineno()

print('{:<50} # {:2d}'.format(line,num))

结果：

#numberlines.py #1

inport fileinput #2

for line in fileinput.input(inplace=True): #3

line = line.rstrip() #4

num = fileinput.lineno() #5

print('{:<50} # {:2d}'.format(line,num)) #6

4、集合、堆、双端队列

集合：是由内置的类Set实现的，所以可以直接创建集合，无需导入模块Sets

>>>set(range(10))

---> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

可以使用序列（或其它可迭代对象）来创建集合，也可使用花括号{}显式的指定（不能仅使用花括号{}来创建空集合，因为这样将创建一个空字典）

>>>type({}) ---><class 'dict'>

必须在不提供任何参数的情况下调用set。集合主要用于成员资格检查，因此将忽略重复的元素；集合中的元素排列顺序是不固定的；

>>> {0,1,2,3,4,5,0,1,2,3,6,7,8,9}

---> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

集合操作：交集，并集，位操作

堆：一种数据结构，是一种优先队列。优先队列能够以任意的顺序添加对象，并随时找出（并删除）最小的元素。

模块heapq：包含一些堆操作函数的模块。必须使用列表来表示堆对象本身：

heappush(heap,x)：将x压入堆中

heappop(heap)：从堆中弹出最小的元素

heapify(heap)：让列表具备堆特征

heapreplace(heap,x)：弹出最小的元素，并将x压入堆中

nlargest(n,iter)：返回iter中n个最大的元素

nsmallest(n,iter)：返回iter中n个最小的元素

函数heappush用于在堆中添加一个元素。不能将其用于普通列表，而只能用于使用各种堆函数创建的列表（原因是元素的顺序很重要）。

>>>from heapq import *

>>>from random import shuffle

>>>data = list(rang(10))

>>>data ---> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>shuffle(data)

>>>data ---> [2, 1, 5, 7, 6, 8, 9, 3, 4, 0]

>>>heap = []

>>>for n in data

heappush(heap,n)

>>>heap

--->[0, 1, 5, 3, 2, 8, 9, 7, 4, 6]

>>> heappush(heap,0.5)

>>> heap

[0, 0.5, 5, 3, 1, 8, 9, 7, 4, 6, 2]

堆特征：位置i处的元素总是大于位置i//2处的元素（反过来：小于位置2*i和2*i+1处的元素）

函数heappop：弹出最小的元素（总是位于索引0处），并确保剩余元素中最小的那个元素位于索引0处，

>>> heap ---> [0, 0.5, 5, 3, 1, 8, 9, 7, 4, 6, 2]

>>> heappop(heap)

0

>>> heap ---> [0.5, 1, 5, 3, 2, 8, 9, 7, 4, 6]

函数heapify通过执行尽可能少的移位操作将列表变成合法的堆（即具备堆特征）：若堆不是使用heappush创建的，应在使用heappush和heappop之前使用这个函数：

>>> heap = [5,1,6,7,2,3,8,4,0,9]

>>>heapify(heap)

>>> heap --->[0, 1, 3, 4, 2, 6, 8, 5, 7, 9]

函数heapreplace：从堆中弹出最小的元素，再压入一个新元素

>>> heap = [5,1,6,7,2,3,8,4,0,9]

>>> heapreplace(heap,1.5)

0

>>> heap ---> [1, 1.5, 3, 4, 2, 6, 8, 5, 7, 9]

双端队列（及其它集合）

双端队列也是从可迭代对象创建的；可用于在需要按添加元素的顺序进行删除。在模块collections中，包含类型deque以及其它几个集合类型

>>>from collections import deque

>>> q = deque(range(5))

>>> q ---> deque([0, 1, 2, 3, 4])

>>> 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 ---> deque([6, 0, 1, 2, 3, 4])

>>> 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])

注：rotate移动元素的位置

双端队列支持在队首（左端）高效的附加和弹出元素，而列表无法这样做；另还可以高效的旋转元素（将元素向左或向右移动，并在到达一端时环绕到另一端）

5、time

模块time：包含用于获取当前时间，操作时间和日期，从字符串中读取日期，将日期格式化为字符串的函数。

日期可以表示为实数（从新纪元1月1日0时起过去的秒数，unix中新纪元为1970年），也可表示为包含9个整数的元组。

元组：（2008,1,21,12,2,56,0,21,0）表示2008年1月21日12时2分56秒，这一天是星期一，2008年的第21天（不考虑夏令时）

元组中的字段：

0：年

1：月

2：日

3：时

4：分

5：秒 （范围0~61，考虑了闰一秒和闰两秒的情况）

6：星期* （范围0~6：0表示星期一）

7：儒略日（范围1~366）

8：夏令时（0、1或-1）布尔值（True或False）

asctime([tuple])：将时间元组转换为字符串

localtime([secs[)：将秒数转换为表示当地时间的日期元组

mktime([tuple])：将时间元组转换为当地时间

sleep([secs])：休眠secs秒

striptime(string[,format])：将字符串转换为时间元组

time()：当前时间（从新纪元时间开始后的秒数，以UTC为准）

函数time.asctime：将当前时间转换为字符串

>>> import time

>>> time.asctime() ---> 'Sun Jun 3 10:48:55 2018'

若不想使用当前时间，也可向其提供一个日期元组（如localtime创建的日期元组），要设置更复杂的格式，可使用函数strftime>

函数time.localtime：将一个实数（从新纪元开始后的秒数）转换为日期元组（本地时间），若要转换为国际标准时间，应使用gmtime。

函数time.mktime：将日期元组转换为从新纪元后的秒数，与localtime的功能相反

函数time.sleep：让解释器等待指定的秒数。

函数time.strptime：将一个字符串（其格式与asctime所返回字符串的格式相同）转换为日期元组。

函数time.time：返回当前的国际标准时间，以从新纪元开始的秒数表示

另模块datatime：提供了日期和时间算术支持，模块timeit：可帮助计算代码段的执行时间

6、random

模块random：包含生成伪随机数的函数。另真正的随机：模块os中的函数urandom

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个值不同的元素

7、shelve、json

shelve：数据存储；模块shelve中的函数open，将一个文件名作为参数，并返回一个shelf对象，用来存储

>>> s = shelve.open('test.txt')

>>> s['x'] = ['a','b','c']

>>> s['x'].append('d')

>>> s['x'] ---> ['a', 'b', 'c']

注：当查看shelf对象中的元素时，将使用存储版重建该对象，而当将一个元素赋值给键时，该元素被存储

要准确的修改使用模块shelve储存的对象，必须将获取的副本赋给一个临时变量，并在修改这个副本后再次存储：

>>> temp = s['x']

>>> temp ---> ['a', 'b', 'c']

>>> temp.append('f')

>>> temp ---> ['a', 'b', 'c', 'f']

>>> s['x'] ---> ['a', 'b', 'c']

>>> s['x'] = temp

>>> s['x'] ---> ['a', 'b', 'c', 'f']

8、re

模块re：提供对正则表达式的支持

（1）正则表达式：

-通配符：句点（.）只与一个字符匹配，而不与0个或两个字符匹配（换行符除外）

-对特殊字符进行转义：反斜杠(\)

-字符集：[a-z]：a~z的任何字母；[a-zA-Z0-9]：大小写字母和数字。字符集只能匹配一个字符；

要指定排除字符集：在开头添加^字符；

-二选一和子模式：管道字符(|)，'python|perl'；子模式：'p(ython|erl)'

-可选模式和重复模式：通过在子模式后面加上问号，将其指定为可选的，即可包含可不包含

eg：r'(http://)?(www\.)?python\.org'

注：对句点进行了转义；每个可选的子模式都可以出现，也可以不出现；

(pattern)*：pattern可重复0、1或多次

(pattern)+：pattern可重复1或多次

(pattern){m,n}：pattern可重复m~n次

字符串的开头和末尾：在字符串的开头或末尾查找匹配的字符串：使用脱字符^指定开头，使用$指定字符串的末尾

（2）模块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)：对字符串中所有的正则表达式特殊字符都进行转义

注：flags为可选参数，用于修改正则表达式的解读方式

函数re.compile：将用字符串表示的正则表达式转换为模式对象，调用search，match等函数时，如果提供的事用字符串表示的正则表达式，都必须在内部将它们转换为模式对象

函数re.search：在给定的字符串中查找第一个与指定正则表达式匹配的子串。如果找到这样的子串，将返回MatchObject(结果为真），否则返回None（结果为假）

函数re.match：在给定字符串开头查找与正则表达式匹配的子串；函数match在模式与字符串开头匹配时就返回True，而不是要求模式与整个字符串匹配；若要与整个字符串都匹配，需要在模式末尾加上一个$符号

函数re.split：根据与模式匹配的子串来分割字符串，类似于字符串方法split；如使用空格和逗号(,)作为分隔符来分割字符串：re.split('[, ]+',some_content)

注：如果模式包含括号()，将在分割得到的子串之间插入括号中的内容，eg：re.split('o(o)','foobar')，其结果为：['f', 'o', 'bar']

参数maxsplit：指定最多分割的次数

函数re.findall：返回一个列表，其中包含所有与给定模式匹配的子串

eg：找出字符串中包含的所有单词：

>>>pat='[a-zA-Z]+'

>>>text='"HM.... ERR......are you sure?" he said,sounding insecure.'

>>>re.findall(pat,text)

---> ['HM', 'ERR', 'are', 'you', 'sure', 'he', 'said', 'sounding', 'insecure']

查找所有的标点符号：

>>>pat = r'[.?\-",]+' --对符号(-)进行了转义

>>>re.findall(pat,text)

---> ['"', '....', '......', '?"', ',', '.']

函数re.sub：从左往右将与模式匹配的子串替换为指定内容

eg：>>>pat = '{name}'

>>>text = 'hello {name}......'

>>>re.sub(pat,'Alex',text)

---> 'hello Alex......'

re.escape：是一个工具函数。用于对字符串中所有可能被视为正则表达式运算符的字符进行转义。使用这个函数的情况：字符串很长，其中包含大量的特殊字符，而不想输入大量的反斜杠转义

（3）匹配对象和编组

在模块re中，查找与模式匹配的子串的函数都在找到是返回MatchObject对象。这个对象包含与模式匹配的子串信息，还包含模式的哪部分与子串的哪部分匹配的信息。这些子串称为编组。

编组就是放在圆括号内的子模式，是根据左边的括号数编号的，其中编组0指的是整个模式。

re匹配对象的重要方法：

group([group1,...])：获取与给定子模式（编组）匹配的子串

start([group])：返回与给定编组匹配的子串的起始位置

end([group])：返回与给定编组匹配的子串的终止位置（与切片一样，不包含终止位置）

span([group])：返回与给定编组匹配的子串的起始位置和终止位置

eg：

>>>m = re.match(r'www\.(.*)\..{3}','www.python.org')

>>>m.group(0) ---> 'www.python.org'

>>>m.group(1) ---> 'python'

>>>m.start(1) ---> 4

>>>m.end(1) ---> 10

>>>m.span(1) ---> (4, 10)

（4）替换中的组号和函数

在替代字符串中使用组号：在替换字符串中，任何类似于"\\n"的转义序列都将被替换为与模式中编组n匹配的字符串。

如：将"*something*"替换为"<em>something</em>

创建正则表达式：

>>>emphasis_pattern=r'\*([^\*]+)\*'

或者在调用模块re中的函数时使用标志VERBOSE，可以在模式中添加空白（空格，制表符，换行符）

>>>emphasis_pattern=re.compile(r'''\*([^\*]+)\*''',re.VERBOSE)

>>>re.sub(emphasis_pattern,r'<em>\1</em>','hello,*world*')

----> 'hello,<em>world</em>'

>>> emphasis_pattern=r'\*(.+)\*' ---以星号开头和结尾的内容匹配，匹配了从第一个星号到最后一个星号的全部内容

>>>re.sub(emphasis_pattern,r'<em>\1</em>','*this* is *it*')

---> '<em>this* is *it</em>'

>>> emphasis_pattern=r'\*(.+?)\*'

>>>re.sub(emphasis_pattern,r'<em>\1</em>','*this* is *it*') ---使用运算符+？，将匹配一个或多个通配符，但匹配尽可能少的内容

---> '<em>this</em> is <em>it</em>'

转载于:https://www.cnblogs.com/skyzy/p/9432968.html