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:DATACode")

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

# 操作
# os.chdir(r"C:DATACode")    #切换目录
# print(os.getcwd())    #获取当前目录
# print(os.curdir)    #返回当前目录
# print(os.pardir)    #返回父目录
# # os.makedirs(r'C:DATACodestudyday5	est')   #生成多级递归目录,上级目录不存在则创建
# # os.removedirs(r'C:DATACodestudyday5	est')  #逐层清理空文件夹
# 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下为"	
",Linux下为"
"
# 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:DATACodestudyday5	est') #是否存在       isfile  isdir
# os.path.isabs(r'C:DATACodestudyday5	est') #是否绝对路径
# os.path.join(r'C:',r'DATACodestudyday5	est') #连接   第一个绝对路径前的值将被忽略
# os.path.getatime(r'C:DATACodestudyday5	est.txt') #最后存储时间
# os.path.getmtime(r'C:DATACodestudyday5	est.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:DATACodestudyday5', '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:PyProjectsday1")    #创建压缩包并返回文件路径

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"，建议使用，能忽略目标对象转义的影响
# ‘
’长度为1，r’
’长度为2

re.findall(r"a.*bc", "a
bc", re.DOTALL)    # -> a
bc
re.findall(r"a(.*)bc", "a
bc", re.DOTALL)  # -> 

# 不分组时匹配的是全部，分组后匹配的是组内的内容

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

line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（
、
）之外的任何单个或多个字符
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  匹配任意空白字符，等价于 [	

f].
S  匹配任意非空字符
d  匹配任意数字，等价于 [0-9].
D  匹配任意非数字
A  匹配字符串开始处
  匹配字符串结束处，如果是存在换行，只匹配到换行前的结束字符串。
z  匹配字符串结束处
G  匹配最后匹配完成的位置。
  匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
B  匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

, 	, 等.  匹配一个换行符。匹配一个制表符。等
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('重要代码')