python-模块系列

楚时邀月 2024-10-20 22:39:36 原文

-->

模块，用一砣代码实现了某个功能的代码集合。

类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

自定义模块
第三方模块
内置模块

自定义模块

自定义模块很好理解了，就是自己写的模块，它可以是一个.py的文件，也可以是一个文件夹（如果是文件夹必须有__int__的目录才是模块，否则就是一个普通目录）

1.定义模块

aaarticlea/png;base64,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" alt="" />

day12就是一个模块，因为存在__init__.py,day7就不是一个模块，因为没有__init__.py文件

一定有人会在心里问__init__.py里面是啥，为啥就这么吊，有它就是模块，没它就不是模块

aaarticlea/png;base64,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" alt="" />

最终结果却令人大失所望，__init__.py里面啥都木有，说白了就是一个空文件，但是你没有它就不行，就不是模块而是文件夹，如果你建了一个文件夹，又想变成模块，你自己在里面创建一个__init__.py就行了。

2.导入模块

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

 import module

 from module.xx.xx import xx

 from module.xx.xx import xx as rename

 from module.xx.xx import *

导入模块其实就是告诉Python解释器去解释那个py文件

导入一个py文件，解释器解释该py文件
导入一个包，解释器解释该包下的 __init__.py 文件【py2.7】

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

import sys

print sys.path

结果：

['', '/usr/lib64/python26.zip', '/usr/lib64/python2.6', '/usr/lib64/python2.6/plat-linux2', '/usr/lib64/python2.6/lib-tk', '/usr/lib64/python2.6/lib-old', '/usr/lib64/python2.6/lib-dynload', '/usr/lib64/python2.6/site-packages', '/usr/lib/python2.6/site-packages', '/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info']

如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。

 import sys

 import os

 project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 sys.path.append(project_path)

内置模块

内置模块说白了就是python系统自带的一些常用模块，将一些常用的模块封装到了里面，在你使用的时候不用去安装，直接去引用就可以了。

1.sys模块

用于提供对Python解释器相关的操作：

 sys.argv           命令行参数List，第一个元素是程序本身路径

 sys.exit(n)        退出程序，正常退出时exit(0)

 sys.version        获取Python解释程序的版本信息

 sys.maxint         最大的Int值

 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

 sys.platform       返回操作系统平台名称

 sys.stdin          输入相关

 sys.stdout         输出相关

 sys.stderror       错误相关

实例展示：

 sys.argv #命令行参数List，第一个元素是程序本身路径

 print sys.argv

 python /root/test.py 123

 返回结果：['/root/test.py', '']

 sys.exit(n)        #退出程序，正常退出时exit(0)

 sys.version         #获取Python解释程序的版本信息

 返回结果：

 2.6.6 (r266:84292, Nov 22 2013, 12:16:22)

 [GCC 4.4.7 20120313 (Red Hat 4.4.7-4)]

 sys.path    #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

 返回结果：

 ['', '/usr/lib64/python26.zip', '/usr/lib64/python2.6', '/usr/lib64/python2.6/plat-linux2', '/usr/lib64/python2.6/lib-tk', '/usr/lib64/python2.6/lib-old', '/usr/lib64/python2.6/lib-dynload', '/usr/lib64/python2.6/site-packages', '/usr/lib/python2.6/site-packages', '/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info']

 sys.platform    #返回操作系统名称

 返回结果：

 'linux2'

 sys.builtin_module_names #列表包含 Python 解释器中所有内建模块的名称

 返回结果：

 ('__builtin__', '__main__', '_ast', '_codecs', '_sre', '_symtable', '_warnings', 'errno', 'exceptions', 'gc', 'imp', 'marshal', 'posix', 'pwd', 'signal', 'sys', 'thread', 'zipimport')

 sys.modules #字典包含所有加载的模块. import 语句在从磁盘导入内容之前会先检查这个字典.

 返回结果：

 {'abrt_exception_handler': <module 'abrt_exception_handler' from '/usr/lib64/python2.6/site-packages/abrt_exception_handler.pyc'>, 'os': <module 'os' from '/usr/lib64/python2.6/os.pyc'>}

标准输出和标准错误 (通常缩写为 stdout 和 stderr) 是内建在每一个 UNIX 系统中的管道。
当你 print 某些东西时，结果前往 stdout 管道；
当你的程序崩溃并打印出调试信息 (例如 Python 中的 traceback (错误跟踪)) 的时候，信息前往 stderr 管道

 sys.stdout         #输出相关

 for i in range(3):

     print'Dive in'

 Dive in

 Dive in

 Dive in

 import sys

 for i in range(3):

     sys.stdout.write('Dive in')

 Dive inDive inDive in

 for i in range(3):

     sys.stderr.write('Dive in')

 Dive inDive inDive in

     sys.stderror #错误相关

stdout 是一个类文件对象；调用它的 write 函数可以打印出你给定的任何字符串。

实际上，这就是 print 函数真正做的事情；它在你打印的字符串后面加上一个硬回车，然后调用 sys.stdout.write 函数。

在最简单的例子中，stdout 和 stderr 把它们的输出发送到相同的地方

和 stdout 一样，stderr 并不为你添加硬回车；如果需要，要自己加上。

stdout 和 stderr 都是类文件对象，但是它们都是只写的。

它们都没有 read 方法，只有 write 方法。然而，它们仍然是类文件对象，因此你可以将其它任何 (类) 文件对象赋值给它们来重定向其输出。

重定向展示

 #!/usr/bin/env python

 #-*-coding:utf-8-*-

 import sys

 print 'Dive in'        # 标准输出，输出到终端上

 saveout = sys.stdout        # 终在重定向前保存stdout，这样的话之后你还可以将其设回正常

 fsock = open('/root/out.log', 'w')      # 打开一个新文件用于写入。如果文件不存在，将会被创建。如果文件存在，将被覆盖。

 sys.stdout = fsock                 # 所有后续的输出都会被重定向到刚才打开的新文件上。

 print  'This message will be logged instead of displayed'    # 这样只会将输出结果“打印”到日志文件中；屏幕上不会看到输出

 sys.stdout = saveout   # 在我们将 stdout 搞乱之前，让我们把它设回原来的方式。

 print 'dsadasdadadasdadasda' # 标准输出，输出到终端上

 fsock.close()     # 关闭日志文件。

结果展示：

aaarticlea/png;base64,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" alt="" />

这就是 print 函数真正做的事情；它在你打印的字符串后面加上一个硬回车，然后调用 sys.stdout.write 函数

sys.stdin实例：

 import sys

 while True:

     print '请输入两个数字，中间用空格隔开'

     line = sys.stdin.readline()

     if not line:

         break

     a = line.split()

     print int(a[0]) + int(a[1])

关于raw_put()和readline()的区别：解析文章：http://www.cnblogs.com/dolphin0520/archive/2013/03/27/2985492.html

sys.stdin.readline( )会将标准输入全部获取，包括末尾的'\n'，但是raw_input( )获取输入时返回的结果是不包含末尾的换行符'\n'的。

小实例：模拟进度条：

#!/usr/bin/env python

# _*_ coding:utf-8 _*_

import sys

for i in range(101):

   #显示进度条百分比  #号从1开始 空格从99递减

   hashes = '#' * int(i / 100.0 * 100)

   sys.stdout.write("\r%s %s%%" % (hashes, i))  #必须两个%%才是，因为一个%是取模，python解释器会默认过滤

   sys.stdout.flush() #强制刷新屏幕缓冲区使其一行输出

   time.sleep(0.5)

2.os模块

用于提供系统级别的方案

 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

 os.curdir  返回当前目录: ('.')

 os.pardir  获取当前目录的父目录字符串名：('..')

 os.makedirs('dirname1/dirname2')    可生成多层递归目录

 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

 os.remove()  删除一个文件

 os.rename("oldname","newname")  重命名文件/目录

 os.stat('path/filename')  获取文件/目录信息

 os.sep    输出操作系统特定的路径分隔符，win下为"\\",http://edu.51cto.com/index.php?do=lesson&id=103882Linux下为"/"

 os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

 os.pathsep    输出用于分割文件路径的字符串

 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

 os.system("bash command")  运行shell命令，直接显示

 os.environ  获取系统环境变量

 os.path.abspath(path)  返回path规范化的绝对路径

 os.path.split(path)  将path分割成目录和文件名二元组返回

 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

 os.path.isabs(path)  如果path是绝对路径，返回True

 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

3.hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

最常用的md5方法：

 import hashlib

 hash = hashlib.md5() #以md5方式加密

 hash.update('abcd') #更新哈希对象，以字符串

 print hash.hexdigest()#返回十六进制数字字符串e2fc714c4727ee9395f324cd2e7f331f

 print hash.digest() #返回摘要，作为二进制数据字符串值

查看支持的加密算法：

 print hashlib.algorithms     #列出所有加密算法

 #('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')

各种加密实例展示：

 import hashlib

 # ######## md5 ########

 hash = hashlib.md5() #以md5的方式加密

 hash.update('admin')

 print hash.hexdigest()

 print hash.digest()

 ######## sha1 ########

 hash = hashlib.sha1()#以sha1的方式加密

 hash.update('admin')

 print hash.hexdigest()

 # ######## sha256 ########

 hash = hashlib.sha256() #以sha256的方式加密

 hash.update('admin')

 print hash.hexdigest()

 # ######## sha384 ########

 hash = hashlib.sha384() #以sha384的方式加密

 hash.update('admin')

 print hash.hexdigest()

 # ######## sha512 ########

 hash = hashlib.sha512() #以sha512的方式加密

 hash.update('admin')

 print hash.hexdigest()

这么多方式，能不能把加密方式当参数传入啊，python当然可以啦，人生苦短我用python啊！

 new(name, string='') #用new 方法，name是指定的加密方式，string是加密的字符串，这地方可以和update一起用，组成加盐方式加密

      """

      Return a new hashing object using the named algorithm;

      optionally initialized with a string.

      """

 import hashlib

 #这两个方式其实是一样，但是用new方法更灵活，可以传如加密方式

 h = hashlib.new('md5')

 print h

 h.update('beginman')

 print h.hexdigest() #666fc5baa93a7fb207c5bfff03b67732

 s = hashlib.md5()

 s.update('beginman')

 print s.hexdigest() #666fc5baa93a7fb207c5bfff03b67732

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

 hash = hashlib.md5('wolegequ')#这个地方的是你自己在程序里面加的，不要轻易告诉别人，这样相当于自己又加了遇到防线。

 hash.update('zhemediao')

 print hash.hexdigest()
#d38300d8efb8f70d5828487ff7ca917

还有厉害的加密方法：python 还有一个 hmac 模块，它内部对我们创建 key 和内容再进行处理然后再加密。

import hmac

h = hmac.new('wolegequ')

h.update('zhemediao')

print h.hexdigest()
#31f4ff4c716b9bc8d12009fc336c5fd2

增量更新文件太大的时候，可以分多次读入：就是将加密的字符串割成小字符串。

 import hashlib

 hash = hashlib.md5('wolegequ')

 hash.update('zhemediao')#可以切割成多个使用update方法

 hash.update('bixude')#

 print hash.hexdigest()

 #6cf2ea119f173704dea8860281df3313

 #这个方法和一次更新的结果一样

 hash1 = hashlib.md5('wolegequ')

 hash1.update('zhemediaobixude')#一整次更新

 print hash1.hexdigest()

 #6cf2ea119f173704dea8860281df3313

属性hashlib.algorithms包含支持的算法。

属性hash.digest_size ：结果hash的大小

属性hash. block_size ： hash内部块的大小

 #!/usr/bin/env python

 #-*- coding:utf-8 -*-

 __author__ = 'wyf'

 import hashlib

 def md5(passwd):

     hash = hashlib.md5('admin')

     hash.update(passwd)

     return hash.hexdigest()

 def registered (user,passwd):#注册用户函数

     with open('db.conf','a') as f:

         temp = user +'|'+ md5(passwd)

         f.write(temp+'\n')

 def login(user,passwd):

     with open('db.conf','r') as f1:

         for i in f1:

             u,p = i.strip().split('|')

             if u == user and p == md5(passwd):

                 return  True

 def main():

     print u'1、登录；2、注册；3.退出'

     chooseNum = raw_input('请输入选择的操作》》》:')

     if chooseNum == '':

         user = raw_input('请输入用户名》》》:')

         passwd = raw_input('请输入密码》》》:')

         if login(user,passwd):

             print '登录成功'

         else:

             print '登录失败'

     elif chooseNum =='':

         user = raw_input('请输入用户名》》》:')

         passwd = raw_input('请输入密码》》》:')

         registered(user,passwd)

 if __name__ == '__main__':

     main()

登录小练习

4.json和pickle

用于序列化的两个模块

pickle，用户python特有的类型和python的数据类型间进行转换。
json，用于字符串和python的数据类型间进行转换。

pickle模块：

pickle模块使用的数据格式是python专用的，并且不同版本不向后兼容，同时也不能被其他语言识别。要和其他语言交互，可以使用内置的json包，使用pickle模块你可以把python对象直接保存到文件，而不需要把他们转化为字符串，也不用底层的文件访问操作把它们写入到一个二进制文件里。 pickle模块会创建一个python语言专用的二进制格式，你基本上不用考虑任何文件细节，它会帮你干净利落地完成读写独享操作，唯一需要的只是一个合法的文件句柄。

pickle模块中的两个主要函数是dump()和load()。dump()函数接受一个文件句柄和一个数据对象作为参数，把数据对象以特定的格式保存到给定的文件中。当我们使用load()函数从文件中取出已保存的对象时，pickle知道如何恢复这些对象到它们本来的格式。
dumps()函数执行和dump() 函数相同的序列化。取代接受流对象并将序列化后的数据保存到磁盘文件，这个函数简单的返回序列化的数据。
loads()函数执行和load() 函数一样的反序列化。取代接受一个流对象并去文件读取序列化后的数据，它接受包含序列化后的数据的str对象, 直接返回的对象。

dumps和dump区别展示：

#!/usr/bin/env python

#-*- coding:utf-8 -*-

import pickle

s = '{"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}'

f = open('abc.txt','r+')

a = pickle.dump(s,f) #dump除了传存储对象还有 打开的文件句柄

f.close()

f1 = open('abc1.txt','r+')

a1 = pickle.dumps(s) # dumps 直接传存储对象

f.write(a1)

f.close()

loads和load是dumps和dump的反操作因此都一样。

json模块：

似乎pickle已经和吊了，能满足几乎所有的序列化和反序列话，但是不要忘记前面提到的pickle只是python特有的操作，只能python才能操作，如果这样的话是不是太局限了？这时候json就有存在的意义了，它可以跨语言进行数据交换，基本上大多数语言都支持json，如果是两个跨语言的数据交换，json是最好的选择，你只要说哥们json吧。但是有一点必须注意，json是很多语言都支持，这也导致了一些局限性，有些python支持的数据类型，json不支持，因此json序列化一般为字典和列表。

json的用法和pickle一样，提供了四个功能：dumps、dump、loads、load。

实例：

 s = '{"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}'

 s1 = {"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}

 import json

 result = json.loads(s)#将字符串转换成对象

 print result,type(result)

 #{u'status': 200, u'aaa': [11, 22, 33, 44, 55, 66], u'desc': u'ininia'} <type 'dict'>

 result1 = json.dumps(s1)#将对象转换成字符串

 print result1,type(result1)

 #{"status": 200, "aaa": [11, 22, 33, 44, 55, 66], "desc": "ininia"} <type 'str'>