Python学习笔记Day05 - 内置模块

目录

• 1.模块的导入
• 2.import模块的本质就是把模块.py解释一遍
• importlib模块
• 3.time，datetime模块，random模块
  • time模块-时间的表示
  • datatime时间加减
  • random模块
• 4. os模块,shutil模块 文件处理模块
  • os模块
  • shutil模块 文件处理模块，比os好
• 5.shelve 数据序列化/持久化，类似pickle
• 6.xml, json数据序列化传输
  • xml模块
  • json模块 - 数据序列化
• 7.configparser模块 - 配置文件处理
• 8.正则表达式 Re
• 9.map模块
• 10.hashlib模块 - 数据加密
• 11. 异常处理try,except
• 12.assert

1.模块的导入

import module1,module2
from module1 import *   # 导入所有，易冲突
from module1 import m1,m2,m3
from module1 import logger as logger_long   # 重命名

2.import模块的本质就是把模块.py解释一遍

import包的本质是运行其下的__init__.py文件
不能直接调用包下的模块,需要在init中from . import module1（相对导入）
例：

import package1
package1.module1  # 无法调用

importlib模块

import importlib

aa = importlib.import_module("lib.aa")
print(aa.name)

3.time，datetime模块，random模块

time模块-时间的表示

import time

print(time.time())  # 获得当前时间戳*********s，以1974年开始计算

# 不加参数默认当前时间
print(time.localtime())  # 时间tuple，年，月，日...
# time.struct_time(tm_year=2018, tm_mon=9, tm_mday=23, tm_hour=16, tm_min=34, tm_sec=57,
# tm_wday=6, tm_yday=266, tm_isdst=0)   一周中的第几天，一年中的第几天，是否夏令时DST（0否）
# 24个时区，UTC+8
print(time.timezone)    # 时区，以s为单位

t = time.localtime()
# time.sleep(5)

print(time.gmtime())    # 时间戳转换成时间tuple(UTC0)，默认当前时间
print(time.localtime())    # 时间戳转换成时间tuple(本地)，默认本地当前时间

print(time.mktime(t))    # 时间tuple(本地)转换成时间戳，必须填入tuple

print(time.strftime("%Y-%m-%d %H:%M:%S", t))  # 将时间tuple转化成格式化字符串 2018-09-23 17:05:32
print(time.strptime("2018-09-23 17:05:32", "%Y-%m-%d %H:%M:%S"))  # 将格式化字符串转换成时间tuple

print(time.asctime())     # 时间tuple(本地)转换成格式化字符串，默认当前时间
print(time.ctime())     # 时间戳(本地)转换成格式化字符串，默认当前时间

# print(help(time.strftime))
'''
    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.
'''

datatime时间加减

import datetime

print(datetime.datetime.now())  # 当前时间  2018-09-23 17:43:05.334686

print(datetime.datetime.now() + datetime.timedelta(3))  # 3天后的时间
print(datetime.datetime.now() + datetime.timedelta(hours=3))  # 3h后的时间

c_time = datetime.datetime.now()
print(c_time.replace(minute=3, hour=2))  # 时间替换

# 1.把datetime转成字符串
def datetime_toString(dt):
    print("1.把datetime转成字符串: ", dt.strftime(dt,"%Y-%m-%d %H:%M:%S"))

# 2.把字符串转成datetime
def string_toDatetime():
    print("2.把字符串转成datetime: ", datetime.datetime.strptime("2018-09-23 17:43:05", "%Y-%m-%d %H:%M:%S"))

random模块

import random

print(random.random())  # 0.6445010863311293  # 生成一个0到1的随机符点数: 0 <= n < 1.0
print(random.uniform(1, 10))  # 9.887001463194844
print(random.randint(1, 7))  # 生成随机整数n: a <= n <= b
print(random.randrange(1, 100, 2))  # 从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，
print(random.choice('liukuni'))  # random.choice从序列中获取一个随机元素。
# 下面是使用choice的一些例子：
print(random.choice("学习Python"))  # 学
print(random.choice(["JGood", "is", "a", "handsome", "boy"]))  # List
print(random.sample([1, 2, 3, 4, 5], 3))  # [1, 2, 5]   # 从指定序列中随机获取指定长度的片断。
print(random.sample('abcdefghij', 3))  # ['f', 'h', 'd']
items = [1, 2, 3, 4, 5, 6, 7]
random.shuffle(items)  # 打乱
print(items)

# 生成随机验证码
import random

checkcode = ''
for i in range(4):  # 四位验证码
    current = random.randrange(0, 4)
    if current != i:  # 随机字母
        temp = chr(random.randint(65, 90))  # 字母65~69，chr将整数转换成对应的ASCII字符
    else:  # 随机数字
        temp = random.randint(0, 9)
    checkcode += str(temp)
print(checkcode)

4. os模块,shutil模块 文件处理模块

os模块

import os

print(os.getcwd())
# os.chdir(r"C:\DATA\Code")

print(os.getcwd())
# os.curdir
print(os.getcwd())
path = os.curdir
print(path + '\day5')

# 操作
# os.chdir(r"C:\DATA\Code")    #切换目录
# print(os.getcwd())    #获取当前目录
# print(os.curdir)    #返回当前目录
# print(os.pardir)    #返回父目录
# # os.makedirs(r'C:\DATA\Code\study\day5\test')   #生成多级递归目录,上级目录不存在则创建
# # os.removedirs(r'C:\DATA\Code\study\day5\test')  #逐层清理空文件夹
# os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname，上级目录不存在报错
# os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

# 获取信息
# os.listdir('dirname')    列出所有文件和子目录，包括隐藏文件，并以列表方式打印
# 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.remove()  删除一个文件
# os.rename("oldname","newname")  重命名文件/目录

# os.system('ipconfig /all')  #系统命令符

# os.path.basename(__file__) #文件名
# os.path.dirname(__file__) #目录名
# os.path.abspath(path)  返回path规范化的绝对路径
# os.path.split(path)  将path分割成目录和文件名二元组返回
# os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
# os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
# os.path.exists(r'C:\DATA\Code\study\day5\test') #是否存在       isfile  isdir
# os.path.isabs(r'C:\DATA\Code\study\day5\test') #是否绝对路径
# os.path.join(r'C:',r'\DATA\Code\study\day5\test') #连接   第一个绝对路径前的值将被忽略
# os.path.getatime(r'C:\DATA\Code\study\day5\test.txt') #最后存储时间
# os.path.getmtime(r'C:\DATA\Code\study\day5\test.txt') #最后修改时间

shutil模块 文件处理模块，比os好

# 内置模块shutil
# http://www.cnblogs.com/wupeiqi/articles/4963027.html
import shutil

# f1 = open('test', 'r')
# f2 = open('test2.txt', 'a')
# shutil.copyfileobj(f1, f2)
shutil.copyfile('test2.txt', 'test3.txt')  # 与上述代码作用一样
shutil.make_archive('C:\DATA\Code\study\day5', 'zip')
# shutil.copystat("本节笔记","笔记3")  #拷贝状态的信息，包括：mode bits, atime, mtime, flags

# shutil.copytree("test4","new_test4")   # 递归的去拷贝文件，拷贝子目录及文件
# shutil.rmtree("new_test4") # 递归的去删除文件，删除子目录及文件
# shutil.move(src, dst) #递归的去移动文件

# shutil.make_archive("shutil_archive_test", "zip","E:\PyProjects\day1")    #创建压缩包并返回文件路径

import zipfile

z = zipfile.ZipFile("day5.zip", "w")  # 打开

z.write("p_test.py")  # 将文件压缩近z
print("-----")  # 干点别的事
z.write("笔记2")  # 继续压缩

z.close()

5.shelve 数据序列化/持久化，类似pickle

# 序列化
# shelve模块是一个简单的key，value将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式
import shelve
import datetime

d = shelve.open('shelve_test')  # 打开一个文件

# 数据存储，将产生三个文件dat，bak，dir
# class Test(object):
#     def __init__(self,n):
#         self.n = n
# t = Test(1213)
# info = {'age':22,"job":'it'}
# name = ["alex", "rain", "test"]
#
# d["name"] = name  # 持久化列表
# d["info"] = info  # 持久dict
# d['t1'] = t     # 持久化类的实例
# d['date'] = datetime.datetime.now()


# 数据读取
print(d.get("name"))
print(d.get("info"))
print(d.get("date"))
# print(d.get('t1'))

d.close()

6.xml, json数据序列化传输

xml模块

xml是实现不同语言或程序之间进行数据交换的协议，
跟json差不多，但json使用起来更简单，
不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，
至今很多传统公司如金融行业的很多系统的接口还主要是xml。

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.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,i.attrib)

# 只遍历year 节点
for node in root.iter('year'):
    print(node.tag, node.text)

#xml文件创建
new_xml = ET.Element("personinfolist")
personinfo = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "yes"})
name = ET.SubElement(personinfo, "name")
name.text = "Alex Li"
age = ET.SubElement(personinfo, "age", attrib={"checked": "no"})
sex = ET.SubElement(personinfo, "sex")
age.text = '56'
personinfo2 = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "no"})
name = ET.SubElement(personinfo2, "name")
name.text = "Oldboy Ran"
age = ET.SubElement(personinfo2, "age")
age.text = '19'

et = ET.ElementTree(new_xml)  # 生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式


# 修改xml数据
tree = ET.parse("xmltest.xml")
root = tree.getroot()

# 修改
# for node in root.iter('year'):
#     new_year = int(node.text) + 1
#     node.text = str(new_year)
#     node.set("updated_by", "Alex")
#
# tree.write("xmltest.xml")

# 删除node
for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        root.remove(country)

tree.write('output.xml')

json模块 - 数据序列化

import json

# 只能处理简单的数据
ret = 'sdas'
json.dumps()  # 存
json.dumps(ret, ensure_ascii=False, indent=4)  # 为方便查看，不转换成ascii码，且使用4空格缩进
json.loads()  # 取

json.dump()  # 能直接处理类文件对象(具有read()或者write()方法的对象)，
# 比如with open(...) as f的f，不需要将f.read()，就能dump
json.load()

import pickle

# 处理复杂数据
pickle.dumps()  # 保存的是二进制

7.configparser模块 - 配置文件处理

# 用于生成和修改常见配置文档
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']
config['topsecret.server.com']['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)


# 读
conf = configparser.ConfigParser()
conf.read("example.ini")

print(conf.defaults())
print(conf['bitbucket.org']['user'])
#print(conf.sections())
sec = conf.remove_section('bitbucket.org')
conf.write(open('example.ini', "w"))

8.正则表达式 Re

import re

s = '1-2*(-1388337.0476190478-'
a = re.search(r"-[^\+\-]*$", s)  # 匹配
if not a:
    print('a', a)

re.match('', s)  # （从头找一个）re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search('', s)  # （找一个）re.search 扫描整个字符串并返回第一个成功的匹配。
re.findall('', s)  # ***（找所有，返回列表）
re.sub('', '', s)  # （替换,前者替换后者）
pattern = re.compile('')  # （编译正则字符串，提高效率）
pattern.search(s)  # 此处pattern具有与re一致的函数，但参数需要放进compile内

r"a/nb"  # 原始字符串r，=="a//nb", 加r表示\自动转义，不需加\,
# 但用在re中可以匹配"a/nb"，不能匹配"a//nb"，建议使用，能忽略目标对象\转义的影响
# ‘\n’长度为1，r’\n’长度为2

re.findall(r"a.*bc", "a\nbc", re.DOTALL)    # -> a\nbc
re.findall(r"a(.*)bc", "a\nbc", re.DOTALL)  # -> \n
# 不分组时匹配的是全部，分组后匹配的是组内的内容

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式：

line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print ("matchObj.group() : ", matchObj.group()) # Cats are smarter than dogs
   print ("matchObj.group(1) : ", matchObj.group(1)) # Cats
   print ("matchObj.group(2) : ", matchObj.group(2)) # smarter
else:
   print ("No match!!")

匹配规则：

'''
^   匹配字符串的开头
$   匹配字符串的末尾。
.   匹配任意字符，除了/n换行符，(贪婪),加re.DOTALL或re.S参数则可以匹配包括换行符的任意字符。
        re.sub的第4个参数不是flags ，而是counts。re.DOTALL的值是16 因此re.sub(.., re.DOTALL)将只替换16次。  
        将flags指定为关键字参数将解决您的问题：  
        re.sub(r'<fig(.*?)</fig>', ' ', xml, flags=re.DOTALL)
*   匹配0个或多个表达式。(贪婪)
+   匹配1个或多个表达式。(贪婪)
?   匹配0个或1个表达式。加在其他限定符后面表示非贪婪方式
*?, +?, ??  *+?的非贪婪模式，匹配尽可能少的字符
\   对任一特定字符进行转义

\w  匹配字母数字及下划线
\W  匹配非字母数字及下划线
\s  匹配任意空白字符，等价于 [\t\n\r\f].
\S  匹配任意非空字符
\d  匹配任意数字，等价于 [0-9].
\D  匹配任意非数字
\A  匹配字符串开始处
\Z  匹配字符串结束处，如果是存在换行，只匹配到换行前的结束字符串。
\z  匹配字符串结束处
\G  匹配最后匹配完成的位置。
\b  匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B  匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.  匹配一个换行符。匹配一个制表符。等
\1...\9 匹配第n个分组的内容。
\10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

[...]   表示或 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]  不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
a|b 匹配a或b

{n} 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
{n,}    匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
{n, m}  匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

(...)   匹配括号内的表达式，也表示一个组,分组的内容在完成匹配后可以提取出来，而且可以在后面\1引用，称为回溯引用
(?imx)  正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。re.I（忽略大小写），re.L（依赖区域设置），re.M（多行），re.S（点号匹配所有字符），re.U（依赖Unicode），re.X（详细模式）
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: ...)    类似 (...), 但是不表示一个组
(?imx: ...) 在括号中使用i, m, 或 x 可选标志
(?-imx: ...)    在括号中不使用i, m, 或 x 可选标志
(?#...) 注释.
(?=...) 前向肯定界定符（lookahead assertion）。
    当前面的匹配条件后跟 ... 时才匹配，但不引用 ... 的内容。
(?!...) 前向否定界定符（negative lookahead assertion）。
    当前面的匹配条件后不跟 ... 时才匹配，但不引用 ... 的内容。
(?<=...) 后向肯定界定符（positive lookbehind assertion）。
    当后面的匹配条件前面有...时才匹配，但不引用...的内容。...只能匹配固定长度的字符串，不定长度的不能使用.
(?<!...) 后向否定界定符（negative lookbehind assertion）。
    当后面的匹配条件前面没有...时才匹配，但不引用...的内容。
(?(id/name)yes-pattern|no-pattern) ，
    当组id或name对应的组()匹配成功后，匹配yes-pattern的内容，否则匹配no-pattern的内容
'''

9.map模块

http://blog.51cto.com/egon09/1840425

10.hashlib模块 - 数据加密

import hashlib

# m = hashlib.md5()
# m.update(b"Hello")
# print(m.hexdigest())  #16进制md5值
# m.update(b"It's been a long time since we spoken...")

m2 = hashlib.md5()
m2.update("HelloIt's me天王盖地虎".encode(encoding="utf-8"))
print(m2.hexdigest())
#
# s2  = hashlib.sha1()
# s2.update(b"HelloIt's me")
# print(s2.hexdigest())

#hmac，它内部对我们创建 key和内容 再进行处理然后再加密
# 散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。
# 使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；
# 一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，
# 然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，
# 拿加密后的值 跟 发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。
import hmac

h = hmac.new(b"12345","you are 250你是".encode(encoding="utf-8"))
print(h.digest())
print(h.hexdigest())

11. 异常处理try,except

class My_exception(Exception):
    def __init__(self,msg):
        self.messge = msg

    def __str__(self):
        return self.messge

try:
    ll = [1,2,3,4]
    # a =ll[4]
    # raise Exception('主动触发异常')
    # raise My_exception('自定义异常')
except (IndexError,KeyError) as e:  # 抓特定异常
    print(e)
except My_exception as e:   # 抓自定义异常
    print(e)
except Exception as e:  # 抓住所有异常，建议用在最后
    print(e)

else:      # 没出异常
    print('一切正常')

finally:    # 不管是否异常都会执行
    print('一定会走')

12.assert

a = 0
assert a == 1  # 断言，简化if判断，不正确则抛异常

print('重要代码')