《零基础学Python（第二版）》（六）

标签：python

六、模块   

       1. 编写模块

       模块就是一个扩展名为.py的python程序。解释器的作用就是将.py的文件转化为.pyc文件，而.pyc文件是由字节码(bytecode)构成的，然后计算机执行.pyc文件。，当python解释器读取了.py文件，先将它变成由字节码组成的.pyc文件，然后这个.pyc文件交给一个叫做python虚拟机的东西去运行。如果.py文件修改了，python解释器会重新编译。总之，有了.pyc文件后，每次运行就不需要从新让解释器来编译.py文件了，除非.py文件修改了。这样，python运行的就是那个编译好了的.pyc文件。这里推荐了一个链接：说说Python程序的执行过程。

        如果要作为程序执行，则__name__ == "__main__"；如果作为模块引入，则变量__name__的值是模块名称。用这种方式就可以区分是执行程序还是作为模块引入了。在一般情况下，如果仅仅是用作模块引入，可以不写if __name__ == "__main__"。

        在python中，所有模块都被加入到了sys.path里面了。用下面的方法可以看到模块所在位置，列表所包括位置内的.py文件都可以作为模块引入。

import sys
import pprint
pprint.pprint(sys.path)
# ['D:\\python\\examples',
 # 'C:\\windows\\system32\\python27.zip',
 # 'D:\\python\\DLLs',
 # 'D:\\python\\lib',
 # 'D:\\python\\lib\\plat-win',
 # 'D:\\python\\lib\\lib-tk',
 # 'D:\\python',
 # 'D:\\python\\lib\\site-packages']

import sys
import a
a.aa()

       2. 标准库

       用import导入模块，用点号引用其方法。还可以用from..import..，直接引用模块的方法，或者import...as...（from...import...as...）给引入的模块或方法重命名。当使用from xx import *的时候，就是将__all__里面的方法引入，如果没有这个，就会将其它所有属性、方法等引入，包括那些以双划线或者单划线开头的变量、函数。__doc__是模块的文档即三个引号包含的字符串。__file__是模块所在的位置。

import sys
import a
import pprint
print dir(pprint)		#['PrettyPrinter', '_StringIO', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '_commajoin', '_id', '_len', '_perfcheck', '_recursion', '_safe_repr', '_sorted', '_sys', '_type', 'isreadable', 'isrecursive', 'pformat', 'pprint', 'saferepr', 'warnings']
print pprint.__all__	#['pprint', 'pformat', 'isreadable', 'isrecursive', 'saferepr', 'PrettyPrinter']
print pprint.__file__	#D:\python\lib\pprint.pyc
print a.__doc__			#This is a module

import sys
print "filename: ", sys.argv[0]			#2.py
print "the length: ", len(sys.argv)		#1

            sys.exit()是退出当前的程序的一个方法。如果用sys.exit()退出程序，会返回SystemExit异常。函数中的return是终止当前的函数，并返回相应值，但是sys.exit()的含义是退出当前程序，并发起SystemExit异常。如果使用sys.exit(0)表示正常退出。如果要测试，需要在某个地方退出的时候有一个有意义的提示，可以用sys.exit("I wet out at here.")，那么字符串信息就被打印出来。

import sys
for i in range(10):
	if i==5:
		sys.exit("exit")
	print "i=",i
# i= 0
# i= 1
# i= 2
# i= 3
# i= 4
# exit

            sys.path可以查找模块所在的目录，以列表的形式显示出来。如果用append()方法，就能够向这个列表增加新的模块目录。

            sys.stdin,表示标准输入，sys.stdout,表示标准输出，sys.stderr表示标准错误。print()的本质就是sys.stdout.write(object + ‘\n‘)。通过sys.stdout能够做到将输出内容从“控制台”转到“文件”，称之为重定向。当sys.stdout = f之后，就意味着将输出目的地转到了打开（建立）的文件中，如果使用print()，即将内容输出到这个文件中，在控制台并无显现。

import sys
f = open("d:\\xixi.txt","w")
sys.stdout = f
print "Hello world"
f.close

import copy
class MyCopy(object):
    def __init__(self, value):
        self.value = value
    def __repr__(self):
        return str(self.value)
foo = MyCopy(7)
a = ["foo", foo]
b = a[:]
c = list(a)
d = copy.copy(a)
e = copy.deepcopy(a)
a.append("abc")
foo.value = 17
print "original: %r\nslice: %r\nlist(): %r\ncopy(): %r\ndeepcopy(): %r\n" % (a,b,c,d,e)
# original: ['foo', 17, 'abc']
# slice: ['foo', 17]
# list(): ['foo', 17]
# copy(): ['foo', 17]
# deepcopy(): ['foo', 7]

       3）os：提供了访问操作系统服务的功能。可以用os.rename来重命名文件或目录，参数里第一个文件是原文件名称，第二个是打算修改成为的文件名。另外可用os.remove来删除文件。

import os 
os.rename("d:\\xixi.txt","d:\\heihei.txt")
os.remove("d:\\haha.txt")

import os 
print os.listdir("d:\\python")
# ['DLLs', 'Doc', 'examples', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'python-2.7.9.amd64.msi', 'python.exe','pythonw.exe', 'README.txt', 'Scripts', 'tcl', 'Tools']

import os 
print os.getcwd()	#D:\python\examples
os.chdir(os.pardir)	
print os.getcwd()	#D:\python

import os 
import shutil
print os.getcwd()	#D:\python\examples
os.makedirs("new/new1/new2")
os.chdir("new")
path = os.getcwd()	
print path 			#D:\python\examples\new
shutil.rmtree(path)

import os 
path = os.getcwd()
print path
print os.stat(path)		#nt.stat_result(st_mode=16895, st_ino=0L, st_dev=0, st_nlink=0, st_uid=0, st_gid=0, st_size=4096L, st_atime=1438572074L,st_mtime=1438572074L, st_ctime=1419340093L)
path = path + "\\a.py"
print os.stat(path)		#nt.stat_result(st_mode=33206, st_ino=0L, st_dev=0, st_nlink=0, st_uid=0, st_gid=0, st_size=58L, st_atime=1419340104L, st_mtime=1438484418L, st_ctime=1419340103L)

       4）heapq：heapq中的heap是堆，q就是queue（队列）的缩写。在实际中最大的应用便是排序，即堆排序。堆排序的优势不仅更快，更重要的是有效地使用内存，还有就是简单易用。比如删除数列中最小的值，就是在排序基础上进行的操作。利用heappush()函数可以将数据放到堆里面之后，会自动按照二叉树的结构进行存储。用heappop()函数可以从heap堆中删除了一个最小元素，并且返回该值。但是，这时候的heap显示顺序是按照完全二叉树的规范重新进行排列的。

import heapq
heap = []
heapq.heappush(heap,3)
heapq.heappush(heap,9)
heapq.heappush(heap,2)
heapq.heappush(heap,4)
heapq.heappush(heap,0)
heapq.heappush(heap,8)
print heap				#[0, 2, 3, 9, 4, 8]
heapq.heappop(heap)
print heap				#[2, 4, 3, 9, 8]

import heapq
a = [0,1,2,3,4,5,6]
heapq.heapify(a)
print a					#[0, 1, 2, 3, 4, 5, 6]
print heapq.heappop(a)	#0
heapq.heappush(a,'w')
print a					#[1, 3, 2, 6, 4, 5, 'w']

import heapq
a = [0,1,2,3,4,5,6]
heapq.heapify(a)
print heapq.heapreplace(a,3.14)		#0
print a								#[1, 3, 2, 3.14, 4, 5, 6]

from collections import deque
lis = [1,2,3,4]
qlis = deque(lis)
qlis.append(5)
qlis.appendleft(6)
print qlis			#deque([6, 1, 2, 3, 4, 5])
qlis.pop()
qlis.popleft()
print qlis			#deque([1, 2, 3, 4])

from collections import deque
lis = [1,2,3,4]
qlis = deque(lis)
qlis.rotate()			#deque([4, 1, 2, 3])
print qlis
qlis.rotate(2)			#deque([2, 3, 4, 1])
print qlis
qlis.rotate(-2)			#deque([4, 1, 2, 3])
print qlis

      6） calendar：calendar(year,w=2,l=1,c=6)可以返回year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

import calendar
year = calendar.calendar(2015)
print year
                                  # 2015

      # January                   February                   March
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
          # 1  2  3  4                         1                         1
 # 5  6  7  8  9 10 11       2  3  4  5  6  7  8       2  3  4  5  6  7  8
# 12 13 14 15 16 17 18       9 10 11 12 13 14 15       9 10 11 12 13 14 15
# 19 20 21 22 23 24 25      16 17 18 19 20 21 22      16 17 18 19 20 21 22
# 26 27 28 29 30 31         23 24 25 26 27 28         23 24 25 26 27 28 29
                                                    # 30 31

       # April                      May                       June
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
       # 1  2  3  4  5                   1  2  3       1  2  3  4  5  6  7
 # 6  7  8  9 10 11 12       4  5  6  7  8  9 10       8  9 10 11 12 13 14
# 13 14 15 16 17 18 19      11 12 13 14 15 16 17      15 16 17 18 19 20 21
# 20 21 22 23 24 25 26      18 19 20 21 22 23 24      22 23 24 25 26 27 28
# 27 28 29 30               25 26 27 28 29 30 31      29 30

        # July                     August                  September
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
       # 1  2  3  4  5                      1  2          1  2  3  4  5  6
 # 6  7  8  9 10 11 12       3  4  5  6  7  8  9       7  8  9 10 11 12 13
# 13 14 15 16 17 18 19      10 11 12 13 14 15 16      14 15 16 17 18 19 20
# 20 21 22 23 24 25 26      17 18 19 20 21 22 23      21 22 23 24 25 26 27
# 27 28 29 30 31            24 25 26 27 28 29 30      28 29 30
                          # 31

      # October                   November                  December
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
          # 1  2  3  4                         1          1  2  3  4  5  6
 # 5  6  7  8  9 10 11       2  3  4  5  6  7  8       7  8  9 10 11 12 13
# 12 13 14 15 16 17 18       9 10 11 12 13 14 15      14 15 16 17 18 19 20
# 19 20 21 22 23 24 25      16 17 18 19 20 21 22      21 22 23 24 25 26 27
# 26 27 28 29 30 31         23 24 25 26 27 28 29      28 29 30 31
                          # 30

import calendar
print calendar.isleap(2000)				#True
print calendar.isleap(2015)				#False
print calendar.leapdays(2000,2015s)		#4

import calendar
print calendar.month(2015,8)
    # August 2015
# Mo Tu We Th Fr Sa Su
                # 1  2
 # 3  4  5  6  7  8  9
# 10 11 12 13 14 15 16
# 17 18 19 20 21 22 23
# 24 25 26 27 28 29 30
# 31
print calendar.monthcalendar(2015,8)
# [[0, 0, 0, 0, 0, 1, 2], [3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22, 23], [24, 25, 26,27, 28, 29, 30], [31, 0, 0, 0, 0, 0, 0]]

import calendar
print calendar.monthrange(2015,8)		#(5, 31)
print calendar.weekday(2015,8,12)		#2

import time
print time.time()            #1439364831.35
t = time.localtime()        
print t                        #time.struct_time(tm_year=2015, tm_mon=8, tm_mday=12, tm_hour=15, tm_min=33, tm_sec=51, tm_wday=2, tm_yday=224, tm_isdst=0)
print t[1]                    #8
print time.gmtime()            #time.struct_time(tm_year=2015, tm_mon=8, tm_mday=12, tm_hour=7, tm_min=35, tm_sec=57, tm_wday=2, tm_yday=224, tm_isdst=0)

import time
print time.asctime()	#Wed Aug 12 15:40:43 2015
print time.ctime()		#Wed Aug 12 15:40:43 2015

import time
t = time.localtime()
print time.mktime(t)		#1439365413.0

import time
t = time.strftime("%y,%m,%d")        
print t                                #15,08,12
print time.strftime("%y/%m/%d")        #15/08/12
print time.strptime(t,"%y,%m,%d")    #time.struct_time(tm_year=2015, tm_mon=8, tm_mday=12, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=224, tm_isdst=-1)

              1. datetime.date：日期类，常用的属性有year/month/day

import datetime
today = datetime.date.today()
print today			#2015-08-12
print today.year	#2015
print today.month	#8
print today.day		#12

             2. datetime.time：时间类，常用的有hour/minute/second/microsecond

import datetime
t = datetime.time(1,2,3)
print t					#01:02:03
print t.hour			#1
print t.minute			#2
print t.second			#3
print t.microsecond		#0
print t.tzinfo			#none

            3. datetime.datetime：日期时间类

            4. datetime.timedelta：时间间隔，即两个时间点之间的时间长度，主要用来做时间的运算。

import datetime
now = datetime.datetime.now()
print now								#2015-08-12 16:03:09.479000
a = now + datetime.timedelta(hours=5)
print a									#2015-08-12 21:03:09.479000
b = now + datetime.timedelta(weeks=2)
print b-a								#13 days, 19:00:00

            5. datetime.tzinfo：时区类

       9）urllib：用于读取来自网上（服务器上）的数据。urlopen(url, data=None, proxies=None)主要用于打开url文件，然后就获得指定url的数据，接下来就如同在本地操作文件那样来操作。得到的对象被叫做类文件，参数说明如下：

              1. url：远程数据的路径，常常是网址

              2. data：如果使用post方式，这里就是所提交的数据

              3. proxies：设置代理

            这个类文件对象也是可迭代的。常用的方法：

              1. read(),readline(),readlines(),fileno(),close()：都与文件操作一样，这里不再赘述。

              2. info()：返回头信息

              3. getcode()：返回http状态码

              4. geturl()：返回url

import urllib
a = urllib.urlopen("http://www.baidu.com")
print a.read()
print a.info()
print a.getcode()			#200
print a.geturl()			#http://www.baidu.com

              1. quote(string[, safe])：对字符串进行编码。参数safe指定了不需要编码的字符。

              2. unquote(string) ：对字符串进行解码。

              3. quote_plus(string [ , safe ] ) ：与urllib.quote类似，但这个方法用‘+‘来替换空格，而quote用‘%20‘来代替空格。

              4. unquote_plus(string ) ：对字符串进行解码。

              5. urlencode(query[, doseq])：将dict或者包含两个元素的元组列表转换成url参数。例如{‘name‘: ‘why‘, ‘age‘: 22}将被转换为"name=laoqi&age=40"

              6. pathname2url(path)：将本地路径转换成url路径。

              7. url2pathname(path)：将url路径转换成本地路径。

import urllib
a = "http://www.baidu.com/name=python book"
print urllib.quote(a)								#http%3A//www.baidu.com/name%3Dpython%20book
b = urllib.quote_plus(a)			
print b												#http%3A%2F%2Fwww.baidu.com%2Fname%3Dpython+book
print urllib.unquote_plus(b)						#http://www.baidu.com/name=python book
print urllib.urlencode({"name":'why',"age":22})		#age=22&name=why

              1. url：文件所在的网址。

              2. filename：可选。将文件保存到本地的文件名，如果不指定，urllib会生成一个临时文件来保存。

              3. reporthook：可选。是回调函数，当链接服务器和相应数据传输完毕时触发本函数。

              4. data：可选。如果用post方式所发出的数据。

import urllib
def go(a,b,c):
    per = 100.0 * a * b / c
    if per > 100:
        per = 100
    print "%.2f%%" % per
url = "http://youxi.66wz.com/uploads/1046/1321/11410192.90d133701b06f0cc2826c3e5ac34c620.jpg"
local = "a.jpg"
print urllib.urlretrieve(url,local,go)
# 0.00%
# 8.13%
# 16.26%
# 24.40%
# 32.53%
# 40.66%
# 48.79%
# 56.93%
# 65.06%
# 73.19%
# 81.32%
# 89.46%
# 97.59%
# 100.00%

        10）urllib2：跟urllib有相似的地方——都是对url相关的操作，也有不同的地方。利用urllib2模块可以建立一个Request对象，它的最直接应用就是可以作为urlopen()方法的参数。

import urllib2
req = urllib2.Request("http://www.baidu.com")
response = urllib2.urlopen(req)
page = response.read()
print page

              这种方法不仅可以满足以get方式请求页面，并建立类文件对象，如果是通过post向某地址提交数据，也可以建立Request对象。

import urllib2
import urllib
url = "http://www.baidu.com"
values = {"name":'why', "age":22}
data = urllib.urlencode(values)
req = urllib2.Request(url,data)
response = urllib2.urlopen(req)
page = response.read()
print page

              1. 设置HTTP Proxy

              2. 设置Timeout值

              3. 自动redirect

              4. 处理cookie

          对xml，python提供了多种模块来处理。

              1. xml.dom.* 模块：Document Object Model。适合用于处理 DOM API。它能够将xml数据在内存中解析成一个树，然后通过对树的操作来操作xml。但是，这种方式由于将xml数据映射到内存中的树，导致比较慢，且消耗更多内存。

              2. xml.sax.* 模块：simple API for XML。由于SAX以流式读取xml文件，从而速度较快，切少占用内存，但是操作上稍复杂，需要用户实现回调函数。

              3. xml.parser.expat：是一个直接的，低级一点的基于 C 的 expat 的语法分析器。 expat接口基于事件反馈，有点像 SAX 但又不太像，因为它的接口并不是完全规范于 expat 库的。

              4. xml.etree.ElementTree (以下简称 ET)：元素树。它提供了轻量级的python式的API，相对于DOM，ET快了很多 ，而且有很多令人愉悦的API可以使用；相对于SAX，ET也有ET.iterparse提供了 “在空中” 的处理方式，没有必要加载整个文档到内存，节省内存。ET的性能的平均值和SAX差不多，但是API的效率更高一点而且使用起来很方便。

        ElementTree在标准库中有两种实现。一种是纯Python实现：xml.etree.ElementTree ，另外一种是速度快一点：xml.etree.cElementTree 。

        如果使用的是python2.x，可以像这样引入模块：

try:
	import xml.etree.cElementTree as ET
except:
	import xml.etree.ElementTree as ET

       xml示例文件如下：

<bookstore>
    <book category="COOKING">
        <title lang="en">Everyday Italian</title> 
        <author>Giada De Laurentiis</author> 
        <year>2005</year> 
        <price>30.00</price> 
    </book>
    <book category="CHILDREN">
        <title lang="en">Harry Potter</title> 
        <author>J K. Rowling</author> 
        <year>2005</year> 
        <price>29.99</price> 
    </book>
    <book category="WEB">
        <title lang="en">Learning XML</title> 
        <author>Erik T. Ray</author> 
        <year>2003</year> 
        <price>39.95</price> 
    </book>
</bookstore>

       对于遍历查询，先建立起xml解析树，然后可以通过根节点向下开始读取各个元素（element对象）。

try:
	import xml.etree.cElementTree as ET
except:
	import xml.etree.ElementTree as ET
tree = ET.ElementTree(file="d:\\book.xml")
print tree							#<ElementTree object at 0x00000000027D0E10>
root = tree.getroot()
print root.tag						#bookstore
print root.attrib					#{}
for child in root:
	print child.tag,child.attrib
# book {'category': 'COOKING'}
# book {'category': 'CHILDREN'}
# book {'category': 'WEB'}
print root[0].tag					#book
print root[0].attrib				#{'category': 'COOKING'}
print root[0].text					#
print root[0][0].tag				#title
print root[0][0].attrib				#{'lang': 'en'}
print root[0][0].text				#Everyday Italian

<pre name="code" class="python">try:
	import xml.etree.cElementTree as ET
except:
	import xml.etree.ElementTree as ET
tree = ET.ElementTree(file="d:\\book.xml")
for ele in tree.iter(tag="book"):
	print ele.tag,ele.attrib,ele.text
# book {'category': 'COOKING'}
# book {'category': 'CHILDREN'}
# book {'category': 'WEB'}
for ele in tree.iter(tag="title"):
	print ele.tag,ele.attrib,ele.text
# title {'lang': 'en'} Everyday Italian
# title {'lang': 'en'} Harry Potter
# title {'lang': 'en'} Learning XML
for ele in tree.iter():
	print ele.tag,ele.attrib,ele.text
# bookstore {}

# book {'category': 'COOKING'}

# title {'lang': 'en'} Everyday Italian
# author {} Giada De Laurentiis
# year {} 2005
# price {} 30.00
# book {'category': 'CHILDREN'}

# title {'lang': 'en'} Harry Potter
# author {} J K. Rowling
# year {} 2005
# price {} 29.99
# book {'category': 'WEB'}

# title {'lang': 'en'} Learning XML
# author {} Erik T. Ray
# year {} 2003
# price {} 39.95

import os
file = "d:\\book.xml"
try:
	import xml.etree.cElementTree as ET
except:
	import xml.etree.ElementTree as ET
tree = ET.ElementTree(file="d:\\book.xml")
root = tree.getroot()
del root[1]
for price in root.iter("price"):
	new_price = float(price.text) + 7
	price.text = str(new_price)
for book in root.findall("book"):
	price = book.find("price").text
	if float(price) > 40.0:
		root.remove(book)
ET.SubElement(root,"book")
a = root[0]
a.text = "pyhton"
tree.write(file)

          1. tag：string，元素数据种类

          2. text：string，元素的内容

          3. attrib：dictionary，元素的属性字典

          4. tail：string，元素的尾形

          对属性的操作方法有：

          1. clear()：清空元素的后代、属性、text和tail也设置为None

          2. get(key, default=None)：获取key对应的属性值，如该属性不存在则返回default值

          3. items()：根据属性字典返回一个列表，列表元素为(key, value）

          4. keys()：返回包含所有元素属性键的列表

          5. set(key, value)：设置新的属性键与值

          针对后代的操作有：

          1. append(subelement)：添加直系子元素

          2. extend(subelements)：增加一串元素对象作为子元素

          3. find(match)：寻找第一个匹配子元素，匹配对象可以为tag或path

          4. findall(match)：寻找所有匹配子元素，匹配对象可以为tag或path

          5. findtext(match)：寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path

          6. insert(index, element)：在指定位置插入子元素

          7. iter(tag=None)：生成遍历当前元素所有后代或者给定tag的后代的迭代器

          8. iterfind(match)：根据tag或path查找所有的后代

          9. itertext()：遍历所有后代并返回text值

          10. remove(subelement)：删除子元素

          ElementTree对象的方法有：

          1. find(match)

          2. findall(match)

          3. findtext(match, default=None)

          4. getroot()：获取根节点

          5. iter(tag=None)

          6. iterfind(match)

          7. parse(source, parser=None)：装载xml对象，source可以为文件名或文件类型对象

          8. write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None,method="xml")　

      3. 第三方库        
      有两个方法可以安装第三方库：

      1）利用源码安装。在github.com网站可以下载第三方库的源码（或者其它途径），得到源码之后，在本地安装。一般情况，得到的码格式大概都是 zip 、 tar.zip、 tar.bz2格式的压缩包。解压这些包，进入其文件夹，通常会看见一个 setup.py 的文件。然后运行 python setup.py install 就能把这个第三库安装到系统里。卸载所安装的库非常简单，只需要到相应系统的site-packages目录，直接删掉库文件即卸载。

      2）pip安装。https://pypi.python.org/pypi 这个网站是专门用来存储第三方库的，所有在这个网站上的，都能用pip或者easy_install这种安装工具来安装。这也是推荐的用第三方库的管理工具安装。首先，要安装pip，可以这里下载文件get-pip.py，然后执行python get-pip.py来安装。pip安装好了。如果要安装第三方库，只需要执行pip install XXXXXX（XXXXXX代表第三方库的名字）即可。

《零基础学Python（第二版）》（六）

标签：python

原文地址：http://blog.csdn.net/u012421846/article/details/47188699