python_day18_复习_os模块_sys模块_加密hashlib模块_logging日志模块_config配置文件模块_re正则表达式模块

只想说，2018年的十一假期就这样过去了，在实验室呆了六天，在西湖呆了一天，于是博客好几天没更新，就不多写了，得赶快回宿舍了不是。。。

01 复习

#Author:"haijing"
#date:2018/10/5
#列表生产式：
a = [x*2 for x in range(10)]
print(a)  #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#生成器（generater）
# 创建生成器方式一：
# (x*2 for x in range(10))
# 创建生成器方式二：
# def f():
#     yield  #其后面可以有返回值也可以没有
# 此时f()就是一个生成器
next(f())  #计算出一个值，即yield后的返回值

# for循环内部做了三件事：
# 1）调用对象的iter()方法，返回一个迭代器对象
# 2）通过一个while循环:while：
#                          try:
#                              next(list_Iterator)
#                          except StopIteration:
#                              break

#send():给add = yield 的add传参数，但是第一次send()的时候不能传参数
# def f():
#     print('hello world')
#      a = yield 2 #其后面可以有返回值也可以没有
# f().send(None)  #第一次send()的时候不能传参数，此时等价于next(f())
# f().send('ok')

# 迭代器：
# 1 内部有next方法
# 2 内部有iter()方法
li = [1,2,3]
i = iter(li)  #迭代器i

chr()#把一个数字转换成字母

02os模块

#Author:"haijing"
#date:2018/10/5

import os
print(os.getcwd())  #打印day18的目录D:PyCharmPropro02week03day18
# print(os.chdir(r'C:Users'))  #改变当前的工作目录为C:User，r先不管
print(os.curdir) #显示当前目录，打印一个点
print(os.pardir)  #返回上一层目录，打印两个点
# os.makedirs('abc\haijing\he') #在当前目录(day18)下创建两级目录abchaijing，也可以生成更多级的
#刚刚因为没有注释掉第六句，所以报错了，因为day18是在D:PyCharmPropro02week03day18目录下，
#第6句已经将目录改到了c盘，所以会报错

# os.chdir(r'C:Users')
# os.makedirs('abc\haijing\he')  #是打算在C:Users下创建文件夹这两句有问题

# dirs = os.listdir(r'D:PyCharmPropro02week03day18')
# print(dirs)  #['01复习.py', '02os模块.py']
#加一个r是为了防止出现类似
的含义，只要加了r后面的就都是字符串，没有别的意思了
# os.remove(oo.py) #只能删除文件，不能删除文件夹
# os.rename(oldname,newname)

info = os.stat('D:PyCharmPropro02week03day18') #info就是一个对象
print(info)  #os.stat_result(st_mode=16895, st_ino=678354693872687456, st_dev=1879755873, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1538747533, st_mtime=1538747533, st_ctime=1538741647)
print(info.st_size)  #获取day18这个文件夹的大小
print(info.st_atime)  #1538747672.7753518 获取上一次被人修改的时间

# windows下用进行路径的拼接  Linux下用/
print(os.sep)  #打印当前系统环境下的目录分隔符

#在windows下用
进行换行 在Linux下用
进行换行

# print(os.system('D:PyCharmPropro02week03day18'))  #查看 D:PyCharmPropro02week03day18下的文件
print(os.path.abspath('./day18'))  #返回day18的绝对路径D:PyCharmPropro02week03day18day18
#day18位相对路径

print(os.path.dirname('day18'))

os.path.join(a,b) #将路径a和路径b的绝对路径加在一起

03 sys模块

#Author:"haijing"
#date:2018/10/5
# sys是在跟python解释器进行交互

import sys
#在dos环境下执行03sys模块.py时，可以在后面跟参数，打印的话会以列表的形式打印出03sys模块.py和传的参数
#例如：在dos下输入D:PyCharmPropro02week03day18day183sys模块.py  post path
#即打印[03sys模块.py,post,path]
# print(sys.argv)
# def post():     #上传函数
#     print('ok')
#
# def download():    #下载函数
#     print('ok')
#
# if sys.argv[1]=='post':
#     post()
# elif sys.argv[1]=='download':
#     download()

# print(sys.path)
# print(sys.path.append('需要添加的路径'))
print(sys.platform) #win32 表明是windows系统
if sys.platform == 'win32':   #如果是在windows系统下
    os.system('dir')
else:                 #否则是在Linux系统下
    os.system('ls')

04 hashlib加密模块

#Author:"haijing"
#date:2018/10/6

#即加密模块,不可逆，但有人可以破解，但是破解者也是去撞，和要破解的去匹配
#md5就是一个加密算法
#在python3中字符串的类型都是unicode的类型，但是m.update('a')必须是一个字节类型(二进制数)，所以需要encode()字符转换
#所写的hello world就是一个unicode(万国码)类型
import hashlib
m = hashlib.md5()
print(m)  #<md5 HASH object @ 0x02A27698>对象的名字
m.update('hello world'.encode('utf8')) #对hello world进行加密，同时加.encode('utf8')是做一个字符转换
print(m.hexdigest()) #将hello world 加密为5eb63bbbe01eeed093cb22bb8f5acdc3，hexdigest是将加密之后的取出来方法

m.update('haijing'.encode('utf8')) #在加密hello world的基础上，再对haijing进行加密
print(m.hexdigest())

m2 = hashlib.md5()
m2.update('hello worldhaijing'.encode('utf8'))
print(m2.hexdigest())

#另一种加密方法 sha3_256()
m3 = hashlib.sha3_256()  #sha3系列很多加密算法，但是sha3_256效率最高
m3.update('hello world'.encode('utf8'))
print(m3.hexdigest())  #644bcc7e564373040999aac89e7622f3ca71fba1d972fd94a31c3bfbf24e3938

05 logging日志模块

#Author:"haijing"
#date:2018/10/6

#日志:可以把所有操作命令记录下来

# import logging
#
# logging.basicConfig(level=logging.DEBUG,
#                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
#                     datefmt='%a, %d %b %Y %H:%M:%S',
#                     filename='test.log',
#                     filemode='w')
# logging.debug('debug message')  #因为级别不够，所以不打印
# logging.info('info message')  #因为级别不够，所以不打印
# logging.warning('warning message') #其内容可以随意的改
# logging.error('error message')
# logging.critical('critical message')

#asctime、filename、lineno、levelname、message都是变量
#level级别此时已经设置到了最低的级别debug
#format格式
# datefmt='%a, %d %b %Y %H:%M:%S',  时间格式
#写的内容放在filename='/tmp/test.log'中
#在哪一行调用的日志记录，就会记录在lineno中
#levelname级别名字
# filemode='w'表示记录不会在显示在屏幕中，而是记录到'test.log'中去,会覆盖原有的记录
#filemode='a' 表示记录不会在显示在屏幕中，而是记录到'test.log'中去,不会覆盖原有的记录
#如果没有test.log，会在当前目录下自动创建一个test.log


#logger既能在屏幕上输出 也能在文件中记录 *****
#logger也是放着logging里边的    *****
import logging
logger = logging.getLogger() #取出logger对象
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log') #文件输出流对象

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()   #屏幕输出流对象

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') #标准流对象

#以上创建了四个对象，下面分别对这四个对象工作
fh.setFormatter(formatter) #让fh这个对象有一个输出格式
ch.setFormatter(formatter) #让ch这个对象有一个输出格式

logger.addHandler(fh) #logger对象可以添加多个fh和ch对象，logger这个对象有了fh(文件)输出方式
logger.addHandler(ch) #logger这个对象有了ch(屏幕)输出方式

logger.setLevel(logging.DEBUG) #设置记录级别

logger.debug('logger debug message123')#可以所以的更改显示的内容
logger.info('logger info message123')
logger.warning('logger warning message123')
logger.error('logger error message123')
logger.critical('logger critical message123')
#执行即可在屏幕和文件test.log中同时有操作记录，按照默认warning级别记录的
#所以没有debug的记录
# 在记录之前通过logger.setLevel(logging.Debug) 设置记录的最低级别为debug

06 config配置文件模块

#Author:"haijing"
#date:2018/10/6

#配置文件：一些经常需要被变更的信息被存储在配置文件中，以后经常需要修改的放在这里
#创建配置文件一
# import configparser
#
# config = configparser.ConfigParser() #config为可以增减删除的对象
#
# config["DEFAULT"] = {'ServerAliveInterval': '45',
#
#                      'Compression': 'yes',
#
#                      'CompressionLevel': '9'}

#创建配置文件二
#创建一个字典config，字典的第一个键为DEFAULT值为等号后的一个字典。
# config["DEFAULT"] 中DEFAULT为一个键，等号后边的是一个值，这个值用字典表示
# import configparser
# config = configparser.ConfigParser() #config为可以增减删除的对象
# config['bitbucket.org'] = {'User':'hg'} #字典cofig的第二个键和值  bitbucket.org:User':'hg
#一下四句相当于创建这样一个字典config['topsecret.server.com':{'Host Port':'50022','ForwardX11':'no'}]
# config['topsecret.server.com'] = {}  #创建一个空字典
# topsecret = config['topsecret.server.com']
# topsecret['Host Port'] = '50022'  # 相当于往创建的空字典config['topsecret.server.com']中添值 Host Port:50022
# topsecret['ForwardX11'] = 'no'  # same here
#
# config['DEFAULT']['ForwardX11'] = 'yes'
#
# with open('example.ini', 'w') as configfile:
#     config.write(configfile) #创建example.ini
#以上相当于创建字典：config{'bitbucket.org':{'User':'hg'},'topsecret.server.com':{'Host Port':50022,'ForwardX11':'no'},'DEFAULT':{'ForwardX11':'yes'}}


#删除配置文件中的某一部分
import configparser
config = configparser.ConfigParser() #一个新的config对象

config.read('example.ini') #关联上example.ini，config对象中就有东西了，所以可以读删
print(config.sections()) #打印example.ini中的键，但是不能打印DEFAULT(默认)
print(config.defaults()) #打印DEFAULT中的内容
print(config['bitbucket.org']['user'])  #取值，打印hg

for key in config['bitbucket.org']:
    print(key)  #打印user、DEFAULT和topsecret.server.com中的forwardx11

#删除
config.remove_section('topsecret.server.com') #删除example.ini中的topsecret.server.com
config.write(open('i.cfg','w')) #生成删除了topsecret.server.com键和值的新文件i.cfg,原文件不动

#修改
config.set('bitbucket.org','user','haijing') #将example.ini下的{'bitbucket.org':{'user':'hg'}}的hg改为haijing


07 re正则表达式模块

#Author:"haijing"
#date:2018/10/7

# 正则表达式的作用：匹配字符串，所有的操作对象为字符串，和元组字典没有关系

# s = 'hello world'
# print(s.find('ll')) #返回
# ret = s.replace('ll','xx')
# print(ret) #打印hexxo world
# print(s.split('w')) #['hello ', 'orld']

#以上均为匹配，引入正则是为了进行模糊匹配
import re
# ret1 = re.findall('ww{2}l','hello world')
# print(ret1)
# ret2 = re.findall('haijing','qwerewwwhaijing') #ret2 = re.findall('haijing','qwerewwwhaijing')中查到是否连续的haijing
# print(ret2) #有就打印haijing

#元字符 . ^ $ * + ? { } [ ]| ( ) 
#元字符（1） .
# import re
# ret3 = re.findall('w..l','hello world') #匹配wxxl xx可以为任意字母 即一个元字符 . 代表任意一个字符
# print(ret3)
# ret4 = re.findall('w.l','hello w
ld')
# print(ret4) #打印为空，说明元字符点不能代表换行符
，其余的均可以

#元字符（2） 通配符 ^
# import re
# ret5 = re.findall('^h...o','hjasdflhello')
# print(ret5) #加一个通配符^的作用是在遇到第一个h就开始匹配，以后再遇到h不再进行匹配

#元字符（3） 结束符 $
# import  re
# ret6 = re.findall('h...o$','qwerrwhello') #从后面开始匹配，可以看到在qwerrwhello的最后有hello，所以可以匹配上
# print(ret6)
# ret7 = re.findall('h...o$','qwerrwhellpl') #则匹配不上

#元字符（4） 重复匹配 * 重复前面字符的个数，个数包括0个
# import re
# re.findall('a.*x','fjkllalexkklll') #a.*x 表示重复点.多次
# re.findall('a*','aaaabaaaaaaa') #不管有多少个a，都可以匹配上

#元字符（5） + 表示重复 ab+ 是至少要有一个b，如果有0个b则匹配不上
re.findall('ab+','abbbbbkkll') #匹配出abbbbb

#元字符（6） ？表示只能取0次或者1次
ret7 = re.findall('a?b','aaabhgklabkkkb')
print(ret7) #['ab', 'ab', 'b'] 有多个a只能匹配1个a，没有a也能匹配出来

#元字符（7） { } 贪婪匹配
#{1,}表示1到正无穷
# re.findall('a{3}b','jklaaab') #匹配出aaab
# re.findall('a{1,3}b','aaaab') #匹配1-3个a和一个b，如有多于三个的a，那就默认匹配最大的、3个a

#结论 ：*等价于{0，+正无穷} +等价于{1，正无穷}  ？等价于{0,1}

#元字符（8） 字符集 [ ] 或的关系
ret8 = re.findall('a[c,d]x','adx') #只能匹配出acx或者adx
print(ret8)
ret9 = re.findall('a[c,d，e]x','aexaaa') #只能匹配出acx或者adx或者aex
print(ret9)
ret10 = re.findall('[c-f]','acdfww') #匹配c到f之间的任意字符
print(ret10) #['c', 'd', 'f']
#字符集 [ ]的作用还有取消元字符的特殊功能
ret11 = re.findall('[w,*]','acdfwwdd*') #此时在[w,*]中的*没有任意字符的意思，只代表字符*
print(ret11) #['w', 'w', '*']

# #上尖号^放在中括号内表示取反 *****
# ret13 = re.findall('[^t]','12tYas') #匹配除了t意外的元素
# print(ret13) #打印['1', '2', 'Y', 'a', 's']
# ret14 = re.findall('[^4,5]','12t45Yas') #4,5是一组，加上尖号，表示均不取4和5，非4非5
# print(ret14) #打印['1', '2', 't', 'Y', 'a', 's']


###2018.10.8###
#元字符（9） 反斜杠
#功能：反斜杠后跟元字符去除特殊功能  反斜杠后跟普通字符实现特殊功能
#正则表达式提供的规范：
# d  匹配任何十进制数；它相当于类 [0-9]。
# d{11} 表示匹配11个数字
# D 匹配任何非数字字符；它相当于类 [^0-9]。
# s  匹配任何空白字符；它相当于类 [ 	

fv]。
# S 匹配任何非空白字符；它相当于类 [^ 	

fv]。
# w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_],有空格则匹配不上。
# W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
#   匹配一个特殊字符边界，比如空格 ，&，＃等
# ret15 = re.findall('d{3}','1293458t42a5Yas') #匹配3个连续在一起的数字
# print(ret15) #打印['129', '345']
# ret16 = re.findall('sasd','1293 asd') #1293和asd中间必须有一个空格才能匹配的到
# print(ret16) #打印[' asd']
# ret17 = re.findall(r'I','hello I am haIjing') #是捕捉特殊字符空格,加r是为了表示是原生字符串，不再交给python解释器，直接给re模块
# print(ret17) #打印['I']  第一个I
# ret18 = re.findall(r'I','hello Iam haIjing') #是捕捉特殊字符空格
# print(ret18) #打印['I']  第一个I


#匹配出满足条件的第一个结果
# ret = re.search('haijing','fjakslebhaijing') #ret为一个对象
# print(ret.group())  #打印haijing

# ret = re.search('a.','agj').group()
# print(ret)  #打印ag
# ret = re.search('a.','a.gj').group() #此时加上了，所以不再有a后面加.表示任意字符的意思
# print(ret)  #打印a.
# ret = re.search('a+','a+gj').group() #此时加上了，所以不再有a后面加.表示任意字符的意思
# print(ret)  #打印a+

# print(re.findall(r'\','abcdefg')) #打印['\'] #加r之后re模块就不再交给python解释器了
# print(re.findall('\\','abcdefg')) #打印['\']
#因为在python解释器中也是有特殊含义的，所以在python解释器中的\，交给re模块后变成了


#元字符（10） （）做分组 *****
# print(re.search('(as)+','sdjkfasas').group()) #（）做分组，打印asas
# print(re.search('(as)|3','as3').group()) #as作为一个整体和3或去匹配 |表示或，打印as
# print(re.search('(as)|3','3as').group()) #as作为一个整体和3或去匹配 |表示或，打印3

# ret = re.search('(?P<id>d{3})','weeew34ttt123/ooo') #匹配规则为d{3} 其余均为固定写法
#(?P<id>d(3))最外面的括号代表一个分组?P<id>d(3)，?P是为这个分组起个名字，名字为id，d(3)表示匹配三个数字
# print(ret.group()) #打印123
# print(ret.group('id')) #打印123

ret = re.search('(?P<id>d{3})/(?P<name>w{3})','weeew34ttt123/ooo') #匹配规则为d{3} / w{3} 其余均为固定写法
#(?P<id>d(3))最外面的括号代表一个分组?P<id>d(3)，?P是为这个分组起个名字，名字为id，
# d{3}表示匹配三个数字  w{3}表示匹配三个字母
#(?P<id>d{3})为一个整体
#(?P<name>w{3})为一个整体
#用/把他俩连接起来
print(ret.group()) #打印123/ooo
print(ret.group('id')) #打印123
print(ret.group('name')) #打印ooo

#正则表达式的方法：
# 1、findall():所有结果都返回到一个列表里
# 2、search():返回匹配到第一个对象，改对象可以调用group方法
# 3、match():只在字符串最开始匹配
# print(re.match('asd','fhdsasd')) #打印None
# print(re.match('asd','asdfhdsasd')) #打印asd

print(re.split('a','djkasl')) #打印['djk', 'sl']
print(re.split('[j,a]','djkasl')) #打印['d', 'k', 'sl'] 先用j分为['d','kasl'],再用a分为['d', 'k', 'sl']
#替换
print(re.sub('alex','s..b','ahfalexkl')) #打印ahfs..bkl，将'ahfalexkl'中的alex替换为s..b

#可提高效率的一个方法
obj = re.compile('.com')
ret = obj.findall('ahsss.comjkkl')
print(ret) #打印['.com']

#2018.10.9加
# ret1 = re.findall('a[m,n]w','a,w')
# print(ret1) #打印['a,w']，即逗号会作为一个字符进行匹配
#
# ret8 = re.findall('a[cd]x','adx') #这样也可以，只能匹配出acx或者adx，
# print(ret8)  #打印['adx']

#命名分组（2）中(?P<id>d{3})和(?P<name>w{3})之间也可以不用加/，不加的话就是匹配三个数字和三个字母
# ret = re.search('(?P<id>d{3})(?P<name>w{3})','weeew34ttt123ooo') #匹配规则为d{3} / w{3} 其余均为固定写法
# print(ret.group()) #打印123ooo
# print(ret.group('id')) #打印123
# print(ret.group('name')) #打印ooo

ret3 = re.split('[ad]','ajkdmn') #先将ajkdmn按照a分为"", "jkdmn" 再按照d分为"","jk","mn"
print(ret3) #['', 'jk', 'mn'] #上边不加逗号也可以