Python系列5之模块

模块

1. 模块的分类

　　模块,又称构件,是能够单独命名并独立地完成一定功能的程序语句的集合(即程序代码和数据结构的集合体)。

　　（1）自定义模块

　　　　自己定义的一些可以独立完成某个功能的一段程序语句，可以是一个文件，也可以是一个目录。

　　（2）第三方模块

　　　　是由其他人写的一些程序语句，我们可以用它来实现自己的功能。

　　（3）内置模块

　　　　是由python自己带的一些实现某种特定功能的组件。

2. 模块的导入

　　（1）python默认的模块寻找路径

　　　　当开始导入一个模快的时候，python默认的会先找到第一个路径去看一下是否有这个模块，如果没有接着再到下一个路径中去找，知道最后一个路径。

　　　　从这个路径中我们可以知道，只要我们的模块在这个路径中，就可以被导入。

C:UserszhouPycharmProjectsfullstack26_19	est
C:python_softwarepython3.5.2python35.zip
C:python_softwarepython3.5.2DLLs
C:python_softwarepython3.5.2lib
C:python_softwarepython3.5.2
C:python_softwarepython3.5.2libsite-packages

　　（2）自定义模块的导入

　　　　<1>. 自定义模块在python的默认路径中

　　　　　　第一种方式，导入文件，然后文件去调用函数

　　　　　　下图左边的为目录树，lib，index和module1在同一目录下，module2，module3在lib目录下，右边的为index文件导入模块的方法。

　　　　　　到操作某个文件的时候， 默认的就会把此文件的路径加入默认路径中。

　　　　　　　　*  module1可以直接导入，因为与index在同一文件夹下

　　　　　　　　* module2和module3要通过以下方式进行导入，因为他们不在一个目录中，要首先找到与index同级的目录才可以

　　　　　　

　　　　　　第二种方式，导入函数

　　　　　　直接调用函数

　　　　　　lib.module2：默认调用函数时，目录之间用点去分割

　　　　　　

　　　　<2>. 自定义模块不在python的默认路径中

　　　　　　　我们需要把自定义模块的路径加入到python默认的路径中，然后就可以像上面的的方法一样进行调用了。　　　　

# sys模块在后面会有说明，此处的append是把D：路径加入
# 然后D盘的所有模块就可以导入了
import sys
sys.path.append('D:')
for i in sys.path:
    print(i)

　　（3）内置模块和第三方模块的导入

　　　　内置模块的和第三方模块的导入很简单，直接用import 模块名称  就可以了，因为内置模块和自定义模块的的路径其实就是在python的默认寻找路径中，所以可以直接用import导入。

　　　　第三方模块的安装：

　　　　<1>. 安装管理工具

　　　　　　pip  install  requests

　　　　<2>. 下载源码安装

一. os

　　1. os模块的作用

　　　　os（operating system）操作系统的意思，所以，从名字就可以看出来，此模块主要是和系统级别相关的一些功能。

　　2. os模块的方法

os.join(路径1， 路径2)                  把这两个路径合成一个路径
    # 例题：
        a = os.path.join('zhou\PycharmProjects\fullstack2\6_1\6_10','test1.py')
        print(a)
    # 结果：
        zhouPycharmProjectsfullstack26_16_10	est1.py
        
os.state(路径)：                       显示当前路径的一些状态信息 如： 大小，uid，gid，修改时间，创建时间
os.getcwd():                         不需要参数，就是显示出当前文件所在目录
os.mkdir(路径， 权限)                   windows下创建目录，注意是双斜杠

os.rmdir()                           windows下删除目录， 如果目录不为空，则不能删除
    # 例题：  
        os.mkdir('C:\Users\zhou\PycharmProjects\fullstack2\6_1', 640)
        os.rmdir('C:\Users\zhou\PycharmProjects\fullstack2\6_1')
        
os.makedir()                         递归创建目录
os.removedir()                       递归删除目录
    # 例题： 6_1目录不存在，递归创建，然后remove递归删除
        os.makedirs('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10', 640)
        os.removedirs('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        
os.listdir(路径)：                     列出当前目录下的所有内容，相当于list
os.chdir(路径)                        改变当前路径，相当于cd
    # 例题：
        os.chdir('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        print(os.getcwd())
        
os.curdir                            返回到当前路径
os.pardir                            返回到父目录
    # 例题：
        print(os.curdir)----> .
        print(os.pardir)----> ..
        
os.rename(旧文件的名字，新文件的名字)      重命名
    # 例题:
    os.rename('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10\test1','C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10\test1.py')

os.name                              当前操作系统的名称 windows下为"nt", linux下为"posix"
os.pathsep                           用来分割路径的操作符  ";"
os.linesep                           操作系统的换行符，windows下为"	
", linux下为"
"
os.sep                               操作系统特定的路径分隔符，windows下为"", linux下为"/"
os.environ                           当前操作系统的环境变量
    # 例题：
        print(os.sep)   
        print(os.linesep) 在win下显示为两行空格（此处感觉有点奇怪，按理说应该是一行才对）
        print(os.pathsep)
        print(os.name)
        print(os.environ)
        
os.basename()                        得到路径的基名
os.dirname()                         得到路径的父目录
os.path.exists()                     判断路径是否存在
os.path.split()                      把路径的基名和父目录分割开来
os.path.abspath()                    得到他的绝对路径
os.path.isabs()                      判断是不是绝对路径，如果是返回True，如果不是返回Flase
    # 例题：
        a = os.path.dirname('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        b = os.path.basename('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        c = os.path.exists('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        d = os.path.split('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        e = os.path.abspath("test.py")

        print(a)
        print(b)
        print(c)
        print(d)
        print(e)
    # 结果：
        C:UserszhouPycharmProjectsfullstack26_1
        6_10
        True
        ('C:\Users\zhou\PycharmProjects\fullstack2\6_1', '6_10')
        C:UserszhouPycharmProjectsfullstack26_19	est.py
                
os.path.isfile()                     判断路径是不是一个文件
os.path.isdir()                      判断路径是不是一个目录
os.path.getatime()                   最后存取时间
os.path.getctime()                   最后创建时间
os.path.getmtime()                   最后修改时间
    # 例题：
        f = os.path.isfile('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        g = os.path.isdir('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        h = os.path.getatime('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        i = os.path.getctime('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        j = os.path.getmtime('C:\Users\zhou\PycharmProjects\fullstack2\6_1\6_10')
        print(f)
        print(g)
        print(h)
        print(i)
        print(j)
    # 结果：
        False
        True
        1497872812.4467745
        1497864841.8512993
        1497872812.4467745 

二. sys

　　1. sys模块的作用

　　　　sys（system）系统的意思，这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。

　　2. sys模块的使用方法

sys.argv     传入文件的参数
sys.path     默认的模块查询目录
sys.version  Python的版本
sys.exit()   退出程序
sys.platform   使用的平台----->win32
sys.stdout.write()    打印不换行

三. json

　　1. json模块的作用

　　　　当我们从网上的到一个网页的时候，一般会得到三种数据（从网站上得到的数据最终都是字符串）

　　　　　　<1>. html　　html我们都知道是一种标记语言，具有固定的格式。

　　　　　　<2>. json　　json不是一种语言，但是它具有固定的格式，就是类似字典，元组，列表的格式的字符串，我们可以功过json让其进行相互转换

　　　　　　<3>. xml 　   xml是另一种语言，类似于html，也具备固定的格式，有tag，attitude，text等。可以通过xml进行解析

　　2. json模块的使用方法

json.loads()        将字符串格式的字典和元组转换成对应的字典或者元组
    # 例题：
        import json
        s1 = '''{
            "name":"hu",
            "age":1,
            "gender":"man"
        }'''
        a = json.loads(s1)
        print(a, type(a))
    # 结果：
        {'name': 'hu', 'age': 1, 'gender': 'man'} <class 'dict'>
    # 注意s1中不能出现单引号

json.dumps()        将字典或者列表转换成字符串
        
    # 例题：
        import json
        s2 = {'age': 1, 'gender': 'man', 'name': 'hu'}
        a = json.dumps(s2)
        print(a, type(a))    
    # 结果：   
        {"gender": "man", "age": 1, "name": "hu"} <class 'str'>
        

json.dump()     写入中文会是乱码，暂时没有找到转换字符的地方
    # 例题：
        s2 = {
        "name":'zhou',
        "age":12,
        "gender":"woman"
        }
        import json
        json.dump(s2, open('test1', 'a', encoding='utf-8'))
    # 结果： 追加到test1的内容
            {
        "name":"hu",
        "age":1,
        "gender":"man"
        }{"age": 12, "name": "zhou", "gender": "woman"}
        
        
        
json.load()         将文件中的字符串转换成字典类型
    # 例题： test1 文件中的内容就是下面的字典
        import json
        a = json.load(open('test1', 'r', encoding='utf-8'))
        print(a, type(a))
    # 结果：
        {'name': 'hu', 'gender': 'man', 'age': 1} <class 'dict'>　　　

四. re

　　1. re模块的作用

　　　　re是正则表达式，主要用来对字符串的匹配

　　2. re模块的使用方法

　　　　re.match     只在开头进行匹配     

　　　　re.search    只匹配第一次匹配到的

　　　　re.findall     匹配所有匹配到的

# 由结果我们可知，
# 因为开头没有hu，所以a的返回值为None
# 因为search只会匹配第一个，所以只显示了一次hu
# 因为findall会匹配所有的，所以显示了两次

import re
s1 = "hello, hu, hhh, hu"
a = re.match("hu", s1)
b = re.search("hu", s1).group()
c = re.findall("hu", s1)
print(a)
print(b)
print(c)
结果：

None
hu
['hu', 'hu']

　　　　分组的概念，如果没有分组，默认的groups和groupdict都是空

　　　　group　　　　默认所有的都会放入group中

　　　　groups　　　　只有分组的才会放在groups

　　　　groupdict       只有是字典的才会放在groupdict

# ？P<名称>是字典的写入形式
#  从结果我们可以看出来，groups放的是他的组的信息，和字典没有关系
# 而groupdict放的是字典，和groups也没有关系
import re
s1 = "huello, hu, hhh, hu"
a1 = re.match("(?P<name>h)(u)", s1).group()
a2 = re.match("(?P<name>h)(u)", s1).groups()
a3 = re.match("(?P<name>h)(u)", s1).groupdict()
print(a1)
print(a2)
print(a3)
结果：
hu
('h', 'u')
{'name': 'h'}

# 因为他找的只是第一个，所以和match没有太大的区别，
# 他们的结果也是一样的

import re
s1 = "huello, hu, hhh, hu"
a1 = re.search("(?P<name>h)(u)", s1).group()
a2 = re.search("(?P<name>h)(u)", s1).groups()
a3 = re.search("(?P<name>h)(u)", s1).groupdict()
print(a1)
print(a2)
print(a3)

# findall这个方法本深并没有什么分组不分组的，只是如果有小括号，他只会显示小括号里面的内容，并把他们组合成列表

import re
s1 = "huello, hu, hhh, hu"
a1 = re.findall("(h)(u)", s1)
print(a1)
结果：
[('h', 'u'), ('h', 'u'), ('h', 'u')]

　　

import re
s1 = "huello, hu, hhh, hu"
# 只要遇到“hu”字符串，就会进行切分，并且删除此字符串
a1 = re.split('hu', s1)

# 遇到第一个“hu”字符串，进行切分，并且删除此字符串，把字符串分割成两块
a2 = re.split('hu', s1, 1)

## 遇到第一个“hu”字符串，进行切分，不会删除此字符串，把字符串分割成三块
a3 = re.split('(hu)', s1, 1)
print(a1)
print(a2)
print(a3)


结果：
['', 'ello, ', ', hhh, ', '']
['', 'ello, hu, hhh, hu']
['', 'hu', 'ello, hu, hhh, hu']

五. random

　　1. random模块的作用

　　　　random就是为了生成一个随机数

　　2. random的应用

　　　　<1>. 验证码的生成

# 导入random模块
# 调用random.randrange()模块生成一个随机数
# 拼接字符串

import random
yanzhengma = str()
for i in range(6):
    ran = random.randrange(0, 4)
    if ran == 0 or ran == 2:
        yanzhengma += chr(random.randrange(65, 91))
    else:
        yanzhengma += str(random.randrange(0, 10))
print(yanzhengma)

六. hashlib

　　1. hashlib模块的作用

　　　　hashlib主要用来给字符串进行加密。加密的方法有md5， sha1，sha224， sha256，sha384，sha512

　　　　md5算法是不能反解的

　　2. hashlib模块的应用

　　　　<1>. md5的应用　　

　　　　加盐是什么呢？

　　　　　　虽然说md5加密不能反解，但是它只要是同一个密码，用md5生成之后还是一样的，因此，这样的密码还是不安全的，因此我们需要在原来的密码基础上在加上一段只有自己知道的字符，然后生成密码，这样就算是破解了也不会知道自己的密码（这就是我们所说的加盐）

import hashlib
# 创建对象   加盐
hash = hashlib.md5(bytes('lljeg', encoding='utf-8'))
# 生成密码
hash.update(bytes('hu', encoding='utf-8'))
# 显示密码
print(hash.hexdigest())

#18bd9197cb1d833bc352f47535c00320
#498e327141378fa4d31e5b4c6543db22

七. getpass  

　　1. getpass 模块的作用

　　　　getpass主要用来在输入密码的时候不显示，防止密码泄露的。

　　2. getpass的应用

　　　　<1>. getpass密码隐藏输入　　

# 导入getpass模块，然后使用getpass方法，就可以使密码隐藏输入

# 注意的是有时候getpass模块在pycharm是没有办法使用的，只能在终端使用

>>> import getpass
>>> a = getpass.getpass("Password: ")
Password:
>>> print(a)
legj
>>>

八. zipfile 

　　1. zipfile模块的作用

　　　　zipfile主要用于对文件的压缩和解压。

　　2. zipfile模块的使用

　　　　<1>. 解压

# 解压
import zipfile
zi = zipfile.ZipFile('联系.zip', 'r')

# 显示压缩包中的文件名称
# print(zi.namelist())

# 解压全部
zi.extractall()

# 解压某个文件夹
# zi.extract('openssl.txt')
zi.close()

　　　　<2>. 压缩

import zipfile

# 创建一个压缩包，以追加的方式写入压缩包
zi = zipfile.ZipFile('我的压缩包.zip', 'a')

# 压缩一个文件到压缩包中
zi.write('config')
zi.write('log')

# 关闭压缩文件
zi.close()

九. subporcess

　　1. subprocess模块的作用

　　　　subprocess专门用于python执行系统命令

　　2. subprocess模块的使用方法

# 简单命令
call()                  输入是windows终端命令，当命令执行成功，返回1，结果直接打印在终端上（暂时不太清楚和check_all的区别）
check_call()            输入的是windows终端命令，当命令执行成功，返回1，否则返回0 
check_output()          输入的是windows终端命令，会把结果返回给一个变量 
    # 例题：
        a = subprocess.call('ipconfig', shell=True)
        b = subprocess.check_call('ipconfig')
        c = subprocess.check_output('ipconfig')
        print(a, b, c)
    # 结果：  
        只有c会有返回值，a和b都是0 
#复杂命令
subprocess.Popen        创建一个可执行复杂命令的对象
subprocess.PIPE         开辟标准输入输出的管道
    # 例题：
        cmd = subprocess.Popen("python", stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)

        cmd.stdin.write('print(1)
')
        cmd.stdin.write('print(2)')
        cmd.stdin.close()

        a = cmd.communicate()
        print(a, type(a))
        
    # 结果：
        ('1
2
', '') <class 'tuple'>

十. logging 

　　1. logging模块的作用

　　　　logging模块主要用来规范写入日志的格式和写入日志的时间，防止多线程同时修改日志，从而导致日志不安全。

　　2. logging的使用方法

# 日志级别
    CRITICAL = 50
    FATAL = CRITICAL
    ERROR = 40
    WARNING = 30
    WARN = WARNING
    INFO = 20
    DEBUG = 10
    NOTSET = 0

写入同一个日志文件中 logging.basicConfig
    # 例子：
        import logging
        logging.basicConfig(
            filename='logging',
            format = '%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S %p',
            level=logging.INFO
        )
        logging.error('sss')
    # 结果：
        2017-06-19 22:18:41 PM - root - ERROR - <encoding error>: 1111
写入不同的日志文件中
logging.FileHandler         定义日志文件
logging.Formatter           定义日志文件的格式
logging.Logger              定义日志文件的级别
log.addHandler              添加日志文件
log.critical                写入日志文件
    # 例子2：
        import logging

        # 定义格式
        file_1 = logging.FileHandler('log1', 'a')
        fmt1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s')
        file_1.setFormatter(fmt1)

        file_2 = logging.FileHandler('log2', 'a')
        fmt2 = logging.Formatter()
        file_2.setFormatter(fmt2)

        #定义级别
        log = logging.Logger('lsl', logging.INFO)
        log.addHandler(file_1)
        log.addHandler(file_2)

        log.critical('kjjjj')

十一. xml 

　　1. xml模块的作用

　　　　由上面的介绍可知，我们去访问一下网站的时候，一般会返回给我们是三种数据，一个就是html，一个是json，一个就是xml，其实xml本身是一门语言，他具有特定的格式，比如tag（标签），attribute（属性），text（内容），基本上也就是这样的格式。下面的就是这样的一种xml语言

#<>中间的第一个单词被称为tag，tag后面的都是属性
# 没有被<>包裹的就是text


<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year age="19">2022</year>
        <gdppc>14110</gdppc>
    </country>
    <country name="Hu">
        <rank updated="yes">2</rank>
        <year age="19">2022</year>
        <gdppc>14110</gdppc>
    </country>
    <country name="Zhou">
        <rank updated="yes">2</rank>
        <year age="19">2022</year>
        <gdppc>14110</gdppc>
    </country>
    <tt name="hu" />
    <tt name="hu" />
    <tt name="hu" />
    <tt name="hu">
        <vv name="xiaozhou" />
    </tt>
    <tt name="hu">
        <vv name="xiaozhou" />
    </tt>
    <hu hu="sb">
        <zhou zhou="sb" />
    </hu>
</data>

　　2. xml模块的使用方法

　　　　<1>. xml模块对文档的解析

　　　　　　a. 读取文件得到字符串进行解析

　　　　　　　　.tag    得到节点的标签

　　　　　　　　.attrib  得到节点的属性

　　　　　　　　.text    得到节点的内容

# 导入模块
from xml.etree import ElementTree as ET
# 读取xml文件内容
result = open('xml', 'r', encoding='utf-8').read()
# 解析文件内容, 得到root节点的对象
root = ET.XML(result)
# 通过循环遍历root节点下的节点,得到第一层的标签,属性,和内容
for node in root:
    print(node.tag, node.attrib, node.find("rank").text)


结果：
country {'name': 'Liechtenstein'} 2
country {'name': 'Hu'} 2
country {'name': 'Zhou'} 2

　　　  　　b. 直接打开文件进行解析

　　　　　　　　.parse  直接打开文件进行解析

　　　　　　　　.iter   寻找内容并进行迭代

　　　　　　　　.set   设置节点的属性

　　　　　　　　.write   写入

# 导入模块
from xml.etree import  ElementTree as ET
# 通过parse创建一颗树
tree = ET.parse('xml')
# 通过树找到其根节点
root = tree.getroot()
# 通过循环遍历root节点下的节点,得到第一层的标签,属性,和内容
for node in root:
    print(node.tag, node.attrib, node.find("rank").text)

结果：
country {'name': 'Liechtenstein'} 2
country {'name': 'Hu'} 2
country {'name': 'Zhou'} 2

# 导入模块
from xml.etree import  ElementTree as ET
# 通过parse创建一颗树
tree = ET.parse('xml')
# 通过树找到其根节点
root = tree.getroot()
# 通过循环遍历root节点下的节点,得到第一层的标签,属性,和内容
for node in root.iter("year"):
    # print(node.tag, node.attrib, node.find("rank").text)
    print(node)
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("name", "hu")
tree.write("xml")

　

　　　　<2>. xml模块创建xml文档

from xml.etree import ElementTree as ET
# 创建几个节点
ele = ET.Element('man', {'hu':'sb'})
son = ET.Element('woman', {'zhou':'sbsb'})

ele.append(son)
# 创建一个tree，指向跟节点
tree = ET.ElementTree(ele)
tree.write('outer.xml')

from xml.etree import ElementTree as ET
# 创建几个节点
ele = ET.Element('man', {'hu':'sb'})
son = ele.makeelement('woman', {'zhou':'sbsb'})

ele.append(son)
# 创建一个tree，指向跟节点
tree = ET.ElementTree(ele)
tree.write('outer.xml')

from xml.etree import ElementTree as ET

root = ET.Element('data', {'sb':'sb'})
ET.SubElement(root, 'root', {'sb':'sb'})

tree = ET.ElementTree(root)
tree.write('outer2')

tree.write('outer2', encoding='utf-8', xml_declaration=True)