Python模块

#author F

#模块的定义:用来从逻辑上组织python代码(变量/函数/类/逻辑),本质就是实现一个功能(以py结尾的python文件 module.py, 使用模块->import module)
#包:本质就是一个文件夹(目录),必须带有一个__init.py__文件, 是从逻辑上组织模块的

name = "Aux Air conditioner"
def sayHello():
    print("hello aoteman")


#导入方法
# 1.直接import,导入多个时用逗号分隔
# 2.from module import *,from module import logger,from module import logger as logger_module 和 import module 的区别;
# 3.from module import logger() 错误
# 如何导入一个包?


#import本质
# 导入模块的本质就是把python文件解释一遍
# 导入包的本质就是在解释包下面的 __init.py__文件
# import的前提是 找到他的目录 把包或者模块的目录加入到sys.path中sys.path.[append/insert](os.path.dirname(os.path.abspath(__file__)))
# import test (test = test.py all code)
# from test import name (name = 'code')
# 如何使用包下面的模块中的方法?
# import package
# package.test.test() ##init.py中使用import test (from . import test#从当前目录导入test ###.代表当前init.py的路径)


#导入优化
# from module import test #可以避免重复检索`


#模块的分类
# 1.标准库
# 2.开源模块(第三方模块)
# 3.自定义模块

#===============================标准库=======================================
# a.时间模块=>time与datetime
#     1)time.time():时间戳
#       time.timezone:和UTC差的时间
#       time.sleep():睡
#       gmtime():把s转换成utc时间
#       localtime():转换为本地时间(元组)
#       time.mktime():元组形式转换为时间戳
#       strftime("%Y-%m-%d %H:%M:%S", 元组的时间格式)  元组转格式化时间      strftime("格式",struct_time)
#       strptime("2016-11-25 7:08:26","%Y-%m-%d %H:%M:%S") 格式化时间转元组 strptime(struct_time,"格式")
#       asctime():转换元祖时间为str
#       ctime():转换时间戳为str
#       datetime.datetime类和date类
#       datetime.datetime.now(): 获取当前时间
#       datetime.datetime.now()+datetime.timedelta(+3): 获取时间,几天前几天后的时间 ; 默认是天
#       datetime.datetime.now()+datetime.timedelta(-3): 获取时间,几天前几天后的时间
#       datetime.datetime.now()+datetime.timedelta(hours=3): 获取时间,几天前几天后的时间
#       datetime.datetime.now()+datetime.timedelta(minutes=-3): 获取时间,几天前几天后的时间
#     2)格式化的字符串
#     3)struct time元组的九个元素 time.localtime()
#     世界标准时间UTC 中国时间UTC+8

# b.random模块
#     1)random
#         random.random() #0.26596789
#         random.uniform(1,10) #9.894946
#         random.randomint(1,3) #[1,3] 包括两端
#         random.randrange(1,3) #[1,3) 顾前不顾后
#         random.choice("hello") #随机取值 传参序列或字符串
#         random.sample("sfetryeyety",3) #[t, e, y]
#         items = [1,2,3,4,5,6,7]
#         random.shuffle(items) #洗牌 [5,6,...] 乱序

# c.os模块:提供对操作系统调用的一些接口
#     1)os.getcwd()获取当前目录
#       os.chdir("dirname") #changedir 改变工作目录 #os.chdir("c:\\Users") os.chdir(r"c:\Users\Data")
#       os.curdir #返回当前目录
#       os.pardir #返回上级目录
#       os.mkdirs("dirname1/diename2") #递归创建目录
#       os.removedirs("dirname1") #目录为空则删除并递归到上级目录 如若也为空 也删除
#       os.mkdir("dirname") #生成单级目录 相当于shell 中 的mkdie dirname
#       os.rmdir("dirname") #删除单级目录 若目录不为空则无法删除,报错 相当于shell中的rmdir dirname
#       os.listdir("dirname") #列出指定目录下的所有文件和子目录 包括隐藏文件 并以列表方式打印
#       os.remove() #删除一个文件
#       os.rename("oldname","newname") #重命名文件/目录
#       os.stat("path/filename") #获取其文件/目录信息
#       os.sep    #输出操作系统指定路径分隔符 win \\ linux \
#       os.linesep #输出当前平台的 行终符 win \r\n linux \n os \r
#       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.spilit的第一个目录
#       os.path.basename(path) #返回path最后的文件名 如果path以\或者/结尾 则返回空值
#       os.path.exists(path) #path存在 返回True 不存在则返回 False
#       os.path.isabs(path) #path是绝对路径则返回True
#       os.path.isfile(path) #path是一个存在的文件 返回True  不存在返回False
#       os.path.isdir(path) #path是一个存在的目录 返回True
#       os.path.join(path1[,path2,...]) #将多个路径组合后返回 第一个绝对路径之前的参数将被忽略
#       os.path.getatime(path) #返回path所指向的目录或文件的最后存储时间
#       os.path.getmtime(path) #返回path所指向的目录或文件的最后修改时间

# d.sys模块
#     1)sys.argv 命令行参数List,第一个元素是程序本身路径
#       sys.exit(n) 退出程序,正常退出时exit(0)
#       sys.version 获取python解释程序的版本信息
#       sys.maxint 最大的int值
#       sys.path 返回模块的搜索路径,初始化时使用python环境变量的值
#       sys.platform  返回操作系统平台名称
#       sys.stdout.write('please:')
#       val = sys.stdin.readline()[:-1]

# e.shutil模块 : 用来copy文件 , 高级的文件文件夹压缩包处理模块
#     1)shutil.copyfileobj(fsrc,fdst[,length])
#       shutil.copyfile(src,dst)
#       shutil.copymode(src,dst)  仅拷贝权限 用户属组等都保持原来的 不变
#       shutil.sopystat(src,dst)  拷贝权限的 所有信息 但不创建文件
#       shutil.copy(src,dst)  拷贝文件和 权限
#       shutil.copy(src,dst) 拷贝文件和状态信息
#       shutil.ignore_patterns(*pattens)
#       shutil.copytree(src,dst)  递归拷贝
#       shutil.rmtree()  递归压缩
#       shutil.move(src,dst) 递归移动文件
#       shutil.make_archive(base_name,format,...) 创建压缩包并返回文件路径  路径最好不要包含自己压缩包所在的地方
#         base_name:压缩包的文件名 也可以是压缩包的路径
#         format:压缩包的种类 zip tar bztar gatar
#         root_dir:要压缩的文件夹路径
#         owner:用户 默认当前用户
#         group:组, 默认当前组
#         logger:用于记录日志, if 通常是logging.Logger对象
#  zipfile模块:
#       z = zipfile.Zipfile("manmanjieya.zip","w")
#       z.write("a.log")
#       print("休息一下")
#       z.write("b.log")
#       z.close()
#       #解压
#       z = zipfile.Zipfile("manmanjieya.zip","r")
#       z.extractall()
#       z.close()
#
#  tarfile模块:
#     t = tarfile.open("you.tar","r")
#     t.add(".../a.zip",arcname="bbs.zip")
#     t.add(".../b.zip",arcname="bbs2.zip")
#     tar.close()
#     #解压
#     z = tarfile.open("manmanjieya.zip","r")
#     z.extractall()
#     z.close()

# f.json与packle模块 : 用于序列化的两个模块
#     json:用于字符串与python数据类型之间的转换
#     packle:用于python特有的类型和python的数据类型之间的转换
#     json:dumps , dump , loads , load
#     pickle:dumps, dump , loads, load
#   shelve模块
#     sf = shelve.open("filename")
#     info = {"name":"ASD", "job":"workkk"}
#     name = ["sss", "asdasda", "asd"]
#     sf["name"] = name
#     sf["info"] = info
#     sf.close()
#     file = shelve.open("filename")
#     file.get("name")
#     file.get("info")
#     file.get("date")

# g.xml.etree.ElementTree as ET
#     tree = ET.parse("xmltest.xml")
#     root = tree.getroot()
#     print(root) #返回内存地址
#     print(root.tag) #根目录的标签名
#     遍历整个xml文档
#     for child in root:
#         print(child.tag, child.attrib)
#         for i in child:
#             print(i.tag, i.attrib, i.text)
#
#     只遍历year节点
#     for node in root.iter('year'):
#         print(node.tag, node.text)
#     修改
#     for node in root.iter('year'):
#         new_year = int(node.text)+1
#         node.text = str(new_year)
#         node.set("updated","yes")
#     tree.write("xmltest.xml")
#
#     删除
#     for country in root.findall("country"):
#         rank = int(country.find('rank').text)
#         if rank > 50:
#             root.remove(country)
#     自己创建xml
#     new_xml = ET.Element("namelist")
#     name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
#     age = ET.SubElement(name, "age", attrib={"checked": "no"})
#     sex = ET.SubElement(name, "sex")
#     sex.text = '33'
#     name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
#     age = ET.SubElement(name2, "age")
#     age.text = '19'
#
#     et = ET.ElementTree(new_xml)  # 生成文档对象
#     et.write("test.xml", encoding="utf-8", xml_declaration=True)
#
#     ET.dump(new_xml)  # 打印生成的格式

# h.pyYAML:处理ymal文档格式(配置文档) http://pyyaml.org/wiki/PyYAMLDocumentation

# i.ConfigParse模块:用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。
#
#     [DEFAULT]
#     ServerAliveInterval = 45
#     Compression = yes
#     CompressionLevel = 9
#     ForwardX11 = yes
#
#     [bitbucket.org]
#     User = hg
#
#     [topsecret.server.com]
#     Port = 50022
#     ForwardX11 = no
#
# 如果想用python生成一个这样的文档怎么做呢？
#
#     import configparser
#
#     config = configparser.ConfigParser()
#     config["DEFAULT"] = {'ServerAliveInterval': '45',
#                           'Compression': 'yes',
#                          'CompressionLevel': '9'}
#
#     config['bitbucket.org'] = {}
#     config['bitbucket.org']['User'] = 'hg'
#     config['topsecret.server.com'] = {}
#     topsecret = config['topsecret.server.com']
#     topsecret['Host Port'] = '50022'     # mutates the parser
#     topsecret['ForwardX11'] = 'no'  # same here
#     config['DEFAULT']['ForwardX11'] = 'yes'
#     with open('example.ini', 'w') as configfile:
#        config.write(configfile)
# 配置文件的读取
#     import configparser
#     >>> config = configparser.ConfigParser()
#     >>> config.sections()
#     []
#     >>> config.defaults()
#     >>> config.read('example.ini')
#     ['example.ini']
#     >>> config.sections()
#     ['bitbucket.org', 'topsecret.server.com']
#     >>> 'bitbucket.org' in config
#     True
#     >>> 'bytebong.com' in config
#     False
#     >>> config['bitbucket.org']['User']
#     'hg'
#     >>> config['DEFAULT']['Compression']
#     'yes'
#     >>> topsecret = config['topsecret.server.com']
#     >>> topsecret['ForwardX11']
#     'no'
#     >>> topsecret['Port']
#     '50022'
#     >>> for key in config['bitbucket.org']: print(key)
#     user
#     compressionlevel
#     serveraliveinterval
#     compression
#     forwardx11
#     >>> config['bitbucket.org']['ForwardX11']
#     'yes'
#
#     configparser增删改查语法
#
#     [section1]
#     k1 = v1
#     k2: v2
#
#     [section2]
#     k1 = v1
#
#     import ConfigParser
#
#     config = ConfigParser.ConfigParser()
#     config.read('i.cfg')
#     ########## 读 ##########
#     secs = config.sections()
#     print secs
#     options = config.options('group2')
#     print options
#
#     item_list = config.items('group2')
#     print item_list
#
#     val = config.get('group1','key')
#     val = config.getint('group1','key')
#
#     ########## 改写 ##########
#     sec = config.remove_section('group1')
#     config.write(open('i.cfg', "w"))
#
#     sec = config.has_section('wupeiqi')
#     sec = config.add_section('wupeiqi')
#     config.write(open('i.cfg', "w"))
#
#
#     config.set('group2','k1',11111)
#     config.write(open('i.cfg', "w"))
#
#     config.remove_option('group2','age')
#     config.write(open('i.cfg', "w"))

# j.hashlib模块:用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5算法
#     import hashlib
#
#     m = hashlib.md5()
#     m.update(b"Hello")
#     m.update(b"It's me")
#     print(m.digest())
#     m.update(b"It's been a long time since last time we ...")
#
#     print(m.digest())  # 2进制格式hash
#     print(len(m.hexdigest()))  # 16进制格式hash
#     '''
#     def digest(self, *args, **kwargs): # real signature unknown
#         """ Return the digest value as a string of binary data. """
#         pass
#
#     def hexdigest(self, *args, **kwargs): # real signature unknown
#         """ Return the digest value as a string of hexadecimal digits. """
#         pass
#
#     '''
#     import hashlib
#
#     # ######## md5 ########
#
#     hash = hashlib.md5()
#     hash.update('admin')
#     print(hash.hexdigest())
#
#     # ######## sha1 ########
#
#     hash = hashlib.sha1()
#     hash.update('admin')
#     print(hash.hexdigest())
#
#     # ######## sha256 ########
#
#     hash = hashlib.sha256()
#     hash.update('admin')
#     print(hash.hexdigest())
#
#     # ######## sha384 ########
#
#     hash = hashlib.sha384()
#     hash.update('admin')
#     print(hash.hexdigest())
#
#     # ######## sha512 ########
#
#     hash = hashlib.sha512()
#     hash.update('admin')
#     print(hash.hexdigest())
#
#     还不够吊？python还有一个hmac模块，它内部对我们创建key和内容再进行处理然后再加密散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。使用HMAC时, 消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；
#     一般用于网络通信中消息加密，前提是双方先要约定好key, 就像接头暗号一样，然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密后的值跟发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。

    # import hmac
    # h = hmac.new('天王盖地虎'.encode(encoding="utf-8"), '宝塔镇河妖'.encode(encoding="utf-8"))
    # print(h.hexdigest())
    # https: // www.tbs - certificates.co.uk / FAQ / en / sha256.html

# k.re模块:常用正则表达式符号
#         '.'
#         默认匹配除\n之外的任意一个字符，若指定flagDOTALL, 则匹配任意字符，包括换行
#         '^'
#         匹配字符开头，若指定flags
#         MULTILINE, 这种也可以匹配上(r"^a", "\nabc\neee", flags=re.MULTILINE)
#         '$'
#         匹配字符结尾(整个字符串以xx结尾)，或e.search("foo$", "bfoo\nsdfsf", flags=re.MULTILINE).group()
#         也可以
#         '*'
#         匹配 * 号前的字符0次或多次，re.findall("ab*", "cabb3abcbbac")结果为['abb', 'ab', 'a']
#         '+'
#         匹配前一个字符1次或多次，re.findall("ab+", "ab+cd+abb+bba")
#         结果['ab', 'abb']
#         '?'
#         匹配前一个字符1次或0次
#         '{m}'
#         匹配前一个字符m次
#         '{n,m}'
#         匹配前一个字符n到m次，re.findall("ab{1,3}", "abb abc abbcbbb")
#         结果
#         ['abb', 'ab', 'abb']
#         '|'
#         匹配 | 左或 | 右的字符，re.search("abc|ABC", "ABCBabcCD").group()结果'ABC'
#         '(...)'
#         分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group()结果abcabca456c
#         '\A'
#         只从字符开头匹配，re.search("\Aabc", "alexabc")是匹配不到的
#         '\Z'
#         匹配字符结尾，同$
#         '\d'
#         匹配数字0 - 9
#         '\D'
#         匹配非数字
#         '\w'
#         匹配[A-Za-z0-9]
#         '\W'
#         匹配非[A-Za-z0-9]
#         '\s'
#         匹配空白字符、\t、\n、\r, re.search("\s+", "ab\tc1\n3").group()结果'\t'
#         [a-z]
#         匹配[a-z]之间的一个字符

#         '(?P<name>...)'
#         分组匹配
#         re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})", "371481199306143242").groupdict("city")
#         结果
#         {'province': '3714', 'city': '81', 'birthday': '1993'}
#
#     最常用的匹配语法
#         re.match 从头开始匹配
#         re.search 匹配包含  (用的最多)
#         re.findall 把所有匹配到的字符放到以列表中的元素返回
#         re.split 以匹配到的字符当做列表分隔符
#         re.sub      匹配字符并替换
#
#     反斜杠的困扰:与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
#
#         re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
#         M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
#         S(DOTALL): 点任意匹配模式，改变'.'的行为