Python之路【第5天】

模块

目录

1. 模块
2. os模块
3. sys模块
4. shutil模块
5. shelve 模块
6. xml处理模块
7. ConfigParser模块
8. hashlib模块
9. logging模块
10. 浅谈面向对象

---

模块，用代码实现了某个功能的代码集合。
如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

自定义模块
内置模块
开源模块

import sys
import os
导入一个py文件，解释器解释该py文件
导入一个包，解释器解释该包下的 init.py 文件

os模块

用于提供系统级别的操作

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
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.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

sys模块

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

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

shutil模块

高级的 文件、文件夹、压缩包 处理模块

1. shutil.copyfileobj(fsrc,fdst,length) #将文件的内容拷贝到另一个文件中，可以是部分内容
2. shutil.copyfile(src,dst) #拷贝文件
3. shutil.copymode(src,dst) #仅拷贝权限。
4. shutil.copystat(src,dst) #拷贝文件和权限
5. shutil.copytree(src,dst,symlinks=False,ignore=None) #递归拷贝文件
6. shutil.rmtree(path) #递归取删除文件
7. shutil.move(src,dst) #递归取移动文件
8. shutil.make_archive(base_name,format,…)
   base_name： 压缩包的文件名，也可以是压缩包的路径。
   format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
   root_dir： 要压缩的文件夹路径（默认当前目录）
   owner： 用户，默认当前用户
   group： 组，默认当前组
   logger： 用于记录日志，通常是logging.Logger对象

import shutil
ret = shutil.make_archive("aa", 'gztar', root_dir='/test')

shelve 模块

shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

import shelve
d=shelve.open("shelve_test")
class  Test(object):    #创建一个类
    def __init__(self,n):  #为该类赋一个变量
        self.n=n

t=Test(123)
t2=Test(456)
name=["aa","bb","cc"]
d["test"]=name  #持久化列表
d["t1"]=t  #持久化类
d["t2"]=t2

a=shelve.open("shelve_test")
b1=a.get("t1")
print("t1的内容：",b1.n)
b2=a.get("t2")
print("t2的内容：",b2.n)
print("test的内容：",a.get("test"))
#结果为：
t1的内容： 123
t2的内容： 456
test的内容： ['aa', 'bb', 'cc']

xml处理模块

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单
至今很多传统公司如金融行业的很多系统的接口还主要是xml

生成一个xml文件，文件名为 test.xml

import xml.etree.ElementTree as ET
new_xml=ET.Element("data")
name=ET.SubElement(new_xml,"stu",attrib={"name":"aa"})
age=ET.SubElement(name,"age",attrib={"updated":"no"})
sex=ET.SubElement(name,"sex")
age.text="18"
sex.text="F"

name=ET.SubElement(new_xml,"stu",attrib={"name":"bb"})
age=ET.SubElement(name,"age",attrib={"updated":"no"})
sex=ET.SubElement(name,"sex")
age.text="20"
sex.text="M"

et=ET.ElementTree(new_xml)
et.write("new_text.xml",encoding="utf-8",xml_declaration=True)
ET.dump(new_xml)
#结果为：
<?xml version='1.0' encoding='utf-8'?>
<data>
    <stu name="aa">
        <age updated="no">18</age>
        <sex>F</sex>
    </stu>
    <stu name="bb">
        <age updated="no">20</age>
        <sex>M</sex>
    </stu>
</data>

对test.xml 进行 查看，修改，删除操作

#导入模块
import xml.etree.ElementTree as ET
tree=ET.parse("test.xml")
root=tree.getroot()
print(root.tag) #打印根节点
#遍历xml文档
for child in root:
    #打印子节点及其属性
    print(child.tag,child.attrib)
    for i in child:
        print("----",i.tag,i.text)  #打印子节点的值

#修改年龄+1
for node in root.iter("age"):  #遍历子节点的age值
    new_age=int(node.text)+1   #将年龄加油
    node.text=str(new_age)
    node.set("updated","yes")  #将更新设置为yes
tree.write("xmltest.xml")  #执行写操作
print("更新成功")

#删除node
for stu in root.findall("stu"):  #遍历子节点的所有值
    age=int(stu.find("age").text)  #将年龄找出来
    if age>20:
        root.remove(stu)  #如果年龄大于20则删除该节点
tree.write("xmltest.xml")  #执行写操作
print("删除成功")

#结果为：
data
stu {'name': 'aa'}
---- age 18
---- sex F
stu {'name': 'bb'}
---- age 20
---- sex M
更新成功
删除成功
----------其中xmltest.xml内容为------------
<data>
    <stu name="aa">
        <age updated="yes">19</age>
        <sex>F</sex>
    </stu>
</data>

ConfigParser模块

用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。

import configparser

config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9'}
with open('example.ini', 'w') as configfile:
   config.write(configfile)

hashlib模块

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

import hashlib  #导入哈希模块
m=hashlib.md5()  #初始化
m.update(b"hello")
m.update(b"It is me")
print("Md5二进制:",m.digest())
print("Md5十六进制:",m.hexdigest())
#结果为：
Md5二进制: b'\xb4\x81\rB\xb8\x9fm\xad\xc0\xc34\xd2Ln\xff\xe9'
Md5十六进制: b4810d42b89f6dadc0c334d24c6effe9

散列消息鉴别码，简称HMAC
是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。

#散列消息鉴别码HMAC
import hmac
a=hmac.new(b"secret_key") #可以是任何字符
a.update(b"hello")
print("HMAC加密：",a.hexdigest())
#结果为：
HMAC加密： e177047f432a59e00fe369ec40587175

logging模块

很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别，下面我们看一下怎么用。

import logging
logging.basicConfig(filename="example.log",level=logging.INFO)
logging.debug("this message should go to log file")
logging.info("so do this")
logging.warning("and this ,too")

其中level=loggin.INFO意思是，把纪录级别设置为INFO，也就是说只有是INFO或比INFO级别更高才会被纪录到文件里，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。

日志格式加上时间

import logging
logging.basicConfig(format="%(asctime)s %(message)s",datefmt="%Y-%m-%d %H:%M:%S %p")
logging.warning("danger!!!")
#结果为：
2017-12-11 21:08:29 PM danger!!!

如果想同时把log打印在屏幕和文件日志里

import logging  #导入日志模块
logger=logging.getLogger("TEST_LOG") #日志名称
logger.setLevel(logging.DEBUG)  #设置全局日志级别

ch=logging.StreamHandler()  #调用显示处理函数
ch.setLevel(logging.DEBUG)

fh=logging.FileHandler("access.log")  #调用文件处理函数
fh.setLevel(logging.WARNING)
#设置日志输出的格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

ch.setFormatter(formatter) #格式化显示格式
fh.setFormatter(formatter)  #格式化写入文件的格式

logger.addHandler(ch)  #添加到处理器
logger.addHandler(fh)  #添加到处理器

logger.debug("debug message")  #信息设置
logger.info("info message")
logger.warning("warning message")
logger.error("error message")
logger.critical("critical message")
#结果为：
2017-12-11 21:26:38,788 - TEST_LOG - DEBUG - debug message
2017-12-11 21:26:38,788 - TEST_LOG - INFO - info message
2017-12-11 21:26:38,789 - TEST_LOG - WARNING - warning message
2017-12-11 21:26:38,790 - TEST_LOG - ERROR - error message
2017-12-11 21:26:38,790 - TEST_LOG - CRITICAL - critical message

浅谈面向对象

面向对象 OOP
基本原则：
1，不写重复代码
2，需要经常变更

一个函数无法处理复杂的对象情况，所有需要引入类
以下以 cs为例 创建一个类

class Role(object):  #创建一个类
    member=0   #统计战场人数
    def __init__(self,name,role,weapon):  #定义对象的属性
        self.name=name  #将参数值赋给对象属性
        self.role=role
        self.weapon=weapon

    def add(self):  #对象加入战场函数
        Role.member+=1
        print("%s 加入战场,战场一共[%s]人"%(self.name,self.member))
    def shot(self):  #对象射击动作
        print("%s 正在射击"%self.name)
    def buy_weapon(self,weapon):  #对象购买武器
        print("%s is buging [%s]"%(self.name,weapon))
        self.weapon=weapon   #更新武器
class ET (Role):  #创建一个外星人军团
    def __init__(self,name,role,weapon,kinds):
        #继承了Role的特征， 但是他有变形能力
        super(ET,self).__init__(name,role,weapon)  
        self.kinds=kinds  #将变量赋给该对象的属性
    def kind(self):
        print("%s 开始变身。。。"%self.name)
r1=Role("aa","police","AK-47")
t1=Role("bb","terrorist","B11")
t2=Role("cc","terrorist","B12")
e1=ET("外星人","ET","GG46","变形")
r1.add()
t1.add()
t1.buy_weapon("AK-47")
print("bb的新武器：",t1.weapon)
t2.add()
t2.shot()
e1.add()
e1.kind()
#结果为：
aa 加入战场,战场一共[1]人
bb 加入战场,战场一共[2]人
bb is buging [AK-47]
bb的新武器： AK-47
cc 加入战场,战场一共[3]人
cc 正在射击
外星人 加入战场,战场一共[4]人
外星人 开始变身。。。