码迷,mamicode.com
首页 > 其他好文 > 详细

模块(查漏补缺)

时间:2019-01-04 23:36:06      阅读:286      评论:0      收藏:0      [点我收藏+]

标签:标准输出   传统   日志文件   有用   clu   文件名   第一个   comm   flatten   

路径问题

有项目文件如下,如果 test.py 作为执行文件,在 test.py 里面导入 test1.py 是不行的"import test1.py",因为 test.py 作为执行文件后,Python解释器会从 test.py的当前路径开始寻找(mypage包下),而不会进入包 mypage2,因此要想在 test.py 中导入 test1.py,要写成" form mypage2 import test1.py";同理,如果是test.py 要导入 test1.py,而 test1.py 要导入 test2.py,那么 test1.py 里面也不能写成“import test2.py”,而要写成"form mypage2 import test2.py",因为执行文件还是“test.py”。

“”“

mypage

  • mypage2

    • test1.py

    • test2.py

  • test,py

”“”

"import"模块的导入过程分为两步:1、找到执行文件的当前路径,和导入模块名拼接起来;2、执行导入的模块名;

例如在“test.py”中"import test1.py"(test.py作为执行文件),就是“F:\xxx\mapage\”(test.py的路径) + "test1.py"。这路径当然找不到文件“test1.py”了,因此报错。但如果改成"form mypage2 import test1.py",相当于拼接了“mypage2\test1.py”,变成“F:\xxx\mapage\mypage2\test1.py”,这样就可以了。

另一个小点,如果把test1.py作为执行文件,在"test1.py"导入"test2.py",如果写成“from mypage2 import test2.py”,这样相当于“F:\xxx\mapage\mypage2\” + "mypage2\test2.py",变成“F:\xxx\mapage\mypage2\mypage2\test2.py”,此时报错,要写成“import test2.py”。

time模块

三种时间表示

在Python中,通常有这几种方式来表示时间:

  • 时间戳(timestamp) :         通常来说,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。
  • 格式化的时间字符串
  • 元组(struct_time)   :         struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)
技术分享图片
import time
 
# 1 time() :返回当前时间的时间戳
time.time()  #1473525444.037215
 
#----------------------------------------------------------
 
# 2 localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供,则以当前时间为准。
time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
# tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
time.localtime(1473525444.037215)
 
#----------------------------------------------------------
 
# 3 gmtime([secs]) 和localtime()方法类似,gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。
 
#----------------------------------------------------------
 
# 4 mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))#1473525749.0
 
#----------------------------------------------------------
 
# 5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式:‘Sun Jun 20 23:21:05 1993‘。
# 如果没有参数,将会将time.localtime()作为参数传入。
print(time.asctime())#Sun Sep 11 00:43:43 2016
 
#----------------------------------------------------------
 
# 6 ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为
# None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016
 
print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016
 
# 7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time(如由time.localtime()和
# time.gmtime()返回)转化为格式化的时间字符串。如果t未指定,将传入time.localtime()。如果元组中任何一个
# 元素越界,ValueError的错误将会被抛出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
 
# 8 time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime(2011-05-05 16:37:06, %Y-%m-%d %X))
 
#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)
 
#在这个函数中,format默认为:"%a %b %d %H:%M:%S %Y"。
 
 
# 9 sleep(secs)
# 线程推迟指定的时间运行,单位为秒。
 
# 10 clock()
# 这个需要注意,在不同的系统上含义不同。在UNIX系统上,它返回的是“进程时间”,它是用秒表示的浮点数(时间戳)。
# 而在WINDOWS中,第一次调用,返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
# 时间,即两次时间差。
time模块用法

技术分享图片技术分享图片

random模块

import random
 
print(random.random())#(0,1)----float  得到0到1之间的浮点数
 
print(random.randint(1,3))  #[1,3]  取得到‘3‘
 
print(random.randrange(1,3)) #[1,3)  取不到‘3‘
 
print(random.choice([1,23,[4,5]]))#23  随机取一个
 
print(random.sample([1,23,[4,5]],2))#[[4, 5], ‘23‘]  随机取出自定义的个数
 
print(random.uniform(1,3))#1.927109612082716  随机取出自定义的从a到b之间的浮点数
 
 
item=[1,3,5,7,9]
random.shuffle(item)  # 随机打乱顺序
print(item)
技术分享图片
import random

def v_code():

    code = ‘‘
    for i in range(5):

        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code += str(add)
    return code

print(v_code())

验证码
验证码

os模块

os模块是与操作系统交互的一个接口

技术分享图片
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: (.)
os.pardir  获取当前目录的父目录字符串名:(..)
os.makedirs(dirname1/dirname2)    可生成多层递归目录
os.removedirs(dirname1)    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir(dirname)    生成单级目录;相当于shell中mkdir 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.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
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.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在,返回True;如果path不存在,返回False
os.path.isabs(path)  如果path是绝对路径,返回True
os.path.isfile(path)  如果path是一个存在的文件,返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录,则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

os模块用法
os模块用法

sys模块

 sys模块是和Python解释器打交道的模块

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
技术分享图片
day21_lesson
- bin
  - init.py
  - bin.py
- module
  - init.py
  - main.py

要在bin.py中导入main.py,需要先获取bin包的上一级”day21_lesson“的路径,然后加入模块搜索路径中,才可以用”from module import main.py“导入main.py
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))  # os.path.abspath(__file__) 获取绝对路径
sys.path.append(BASE_DIR)
获取当前文件的路径并把它加到搜索路径里面
技术分享图片
import sys,time
for i in range(10):
    sys.stdout.write(#)
    time.sleep(1)
    sys.stdout.flush()  # 执行一次就把缓存中的”#“显示出来,不然会等执行完for循环之后再一次性打印出所有的”#“
进度条

json & pickle

之前我们学习过用eval内置方法可以将一个字符串转成python对象,不过,eval方法是有局限性的,对于普通的数据类型,json.loads和eval都能用,但遇到特殊类型的时候,eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式,并返回表达式的值。

import json
x="[null,true,false,1]"
print(eval(x))
print(json.loads(x))

什么是序列化?

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思。

序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。

反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。

json

如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如XML,但更好的方法是序列化为JSON,因为JSON表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式,并且比XML更快,而且可以直接在Web页面中读取,非常方便。

JSON表示的对象就是标准的JavaScript语言的对象,JSON和Python内置的数据类型对应如下:

技术分享图片

#----------------------------序列化
import json
 
dic={name:alvin,age:23,sex:male}
print(type(dic))#<class ‘dict‘>
 
j=json.dumps(dic)
print(type(j))#<class ‘str‘>
 
 
f=open(序列化对象,w)
f.write(j)  #-------------------等价于json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open(序列化对象)
data=json.loads(f.read())#  等价于data=json.load(f)
技术分享图片
import json
#dct="{‘1‘:111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{‘one‘: 1} 自己运行一遍就知道了,切记切记

dct={"1":"111"}
print(json.loads(dct))

#conclusion:
#        无论数据是怎样创建的,只要满足json格式,就可以json.loads出来,不一定非要dumps的数据才能loads

注意点
注意点

pickle

技术分享图片
##----------------------------序列化
import pickle
 
dic={name:alvin,age:23,sex:male}
 
print(type(dic))#<class ‘dict‘>
 
j=pickle.dumps(dic)
print(type(j))#<class ‘bytes‘>
 
 
f=open(序列化对象_pickle,wb)#注意是w是写入str,wb是写入bytes,j是‘bytes‘
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open(序列化对象_pickle,rb)
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 
 
print(data[age])   
View Code

Pickle的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于Python,并且可能不同版本的Python彼此都不兼容,因此,只能用Pickle保存那些不重要的数据,不能成功地反序列化也没关系。

shelve模块

shelve模块比pickle模块简单,只有一个open函数,返回类似字典的对象,可读可写;key必须为字符串,而值可以是python所支持的数据类型

技术分享图片
import shelve
 
f = shelve.open(rshelve.txt)
 
# f[‘stu1_info‘]={‘name‘:‘alex‘,‘age‘:‘18‘}
# f[‘stu2_info‘]={‘name‘:‘alvin‘,‘age‘:‘20‘}
# f[‘school_info‘]={‘website‘:‘oldboyedu.com‘,‘city‘:‘beijing‘}
#
#
# f.close()
 
print(f.get(stu_info)[age])
View Code

xml模块

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

xml的格式如下,就是通过<>节点来区别数据结构的:

技术分享图片
<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据
xml数据

xml协议在各个语言里的都 是支持的,在python中可以用以下模块操作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)
 
#只遍历year 节点
for node in root.iter(year):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
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","yes")
 
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)
xml协议

自己创建xml文档:

技术分享图片
import xml.etree.ElementTree as ET
 
 
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) #打印生成的格式

创建xml文档
创建xml文档

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<br>
with open(example.ini, w) as configfile:
   config.write(configfile)
技术分享图片
import configparser

config = configparser.ConfigParser()

#---------------------------------------------查
print(config.sections())   #[]

config.read(example.ini)

print(config.sections())   #[‘bitbucket.org‘, ‘topsecret.server.com‘]

print(bytebong.com in config)# False

print(config[bitbucket.org][User]) # hg

print(config[DEFAULT][Compression]) #yes

print(config[topsecret.server.com][ForwardX11])  #no


for key in config[bitbucket.org]:
    print(key)


# user
# serveraliveinterval
# compression
# compressionlevel
# forwardx11


print(config.options(bitbucket.org))#[‘user‘, ‘serveraliveinterval‘, ‘compression‘, ‘compressionlevel‘, ‘forwardx11‘]
print(config.items(bitbucket.org))  #[(‘serveraliveinterval‘, ‘45‘), (‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘forwardx11‘, ‘yes‘), (‘user‘, ‘hg‘)]

print(config.get(bitbucket.org,compression))#yes


#---------------------------------------------删,改,增(config.write(open(‘i.cfg‘, "w")))


config.add_section(yuan)

config.remove_section(topsecret.server.com)
config.remove_option(bitbucket.org,user)

config.set(bitbucket.org,k1,11111)

config.write(open(i.cfg, "w"))

增删改查
增删改查

hashlib模块

用于加密相关的操作,3.x里代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法

import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
m.update(hello.encode(utf8))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
m.update(alvin.encode(utf8))
 
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af   此时相当于helloalvin
 
m2=hashlib.md5()
m2.update(helloalvin.encode(utf8))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

 

以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。

import hashlib
 
# ######## 256 ########
 
hash = hashlib.sha256(898oaFs09f.encode(utf8))
hash.update(alvin.encode(utf8))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密:

import hmac
h = hmac.new(alvin.encode(utf8))
h.update(hello.encode(utf8))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

logging模块

一 、简单应用

import logging  
logging.debug(debug message)  
logging.info(info message)  
logging.warning(warning message)  
logging.error(error message)  
logging.critical(critical message)  

输出:

WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message

可见,默认情况下Python的logging模块将日志打印到了标准输出中,且只显示了大于等于WARNING级别的日志,这说明默认的日志级别设置为WARNING(日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET),默认的日志格式为日志级别:Logger名称:用户输出消息。

二 、灵活配置日志级别,日志格式,输出位置

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=/tmp/test.log,  
                    filemode=w)  
  
logging.debug(debug message)  
logging.info(info message)  
logging.warning(warning message)  
logging.error(error message)  
logging.critical(critical message)
技术分享图片
cat /tmp/test.log 
Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message

可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为,可用参数有
filename:用指定的文件名创建FiledHandler(后边会具体讲解handler的概念),这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。 
datefmt:指定日期时间格式。 
level:设置rootlogger(后边会讲解具体概念)的日志级别 
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(test.log,w)),默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。

format参数中可能用到的格式化串:
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息
查看输出

三 、logger对象

    上述几个例子中我们了解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()(分别用以记录不同级别的日志信息),logging.basicConfig()(用默认日志格式(Formatter)为日志系统建立一个默认的流处理器(StreamHandler),设置基础配置(如日志级别等)并加到root logger(根Logger)中)这几个logging模块级别的函数,另外还有一个模块级别的函数是logging.getLogger([name])(返回一个logger对象,如果没有指定名字将返回root logger)

     先看一个最简单的过程:

import logging

logger = logging.getLogger()
# 创建一个handler,用于写入日志文件
fh = logging.FileHandler(test.log)

# 再创建一个handler,用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter(%(asctime)s - %(name)s - %(levelname)s - %(message)s)

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.addHandler(ch)

logger.debug(logger debug message)
logger.info(logger info message)
logger.warning(logger warning message)
logger.error(logger error message)
logger.critical(logger critical message)

先简单介绍一下,logging库提供了多个组件:Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口,Handler发送日志到适当的目的地,Filter提供了过滤日志信息的方法,Formatter指定日志显示格式。

     (1)Logger是一个树形层级结构,输出信息之前都要获得一个Logger(如果没有显示的获取则自动创建并使用root Logger,如第一个例子所示)。

      logger = logging.getLogger()返回一个默认的Logger也即root Logger,并应用默认的日志级别、Handler和Formatter设置。
当然也可以通过Logger.setLevel(lel)指定最低的日志级别,可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
      Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()输出不同级别的日志,只有日志等级大于或等于设置的日志级别的日志才会被输出。 

logger.debug(logger debug message)  
logger.info(logger info message)  
logger.warning(logger warning message)  
logger.error(logger error message)  
logger.critical(logger critical message) 

只输出了
2014-05-06 12:54:43,222 - root - WARNING - logger warning message
2014-05-06 12:54:43,223 - root - ERROR - logger error message
2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message
     从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别,所以使用默认的日志级别WARNIING,故结果只输出了大于等于WARNIING级别的信息。

 (2) 如果我们再创建两个logger对象: 

##################################################
logger1 = logging.getLogger(mylogger)
logger1.setLevel(logging.DEBUG)

logger2 = logging.getLogger(mylogger)
logger2.setLevel(logging.INFO)

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug(logger1 debug message)
logger1.info(logger1 info message)
logger1.warning(logger1 warning message)
logger1.error(logger1 error message)
logger1.critical(logger1 critical message)
  
logger2.debug(logger2 debug message)
logger2.info(logger2 info message)
logger2.warning(logger2 warning message)
logger2.error(logger2 error message)
logger2.critical(logger2 critical message)

结果:

技术分享图片

这里有两个个问题:

      <1>我们明明通过logger1.setLevel(logging.DEBUG)将logger1的日志级别设置为了DEBUG,为何显示的时候没有显示出DEBUG级别的日志信息,而是从INFO级别的日志开始显示呢?

       原来logger1和logger2对应的是同一个Logger实例,只要logging.getLogger(name)中名称参数name相同则返回的Logger实例就是同一个,且仅有一个,也即name与Logger实例一一对应。在logger2实例中通过logger2.setLevel(logging.INFO)设置mylogger的日志级别为logging.INFO,所以最后logger1的输出遵从了后来设置的日志级别。

      <2>为什么logger1、logger2对应的每个输出分别显示两次?
       这是因为我们通过logger = logging.getLogger()显示的创建了root Logger,而logger1 = logging.getLogger(‘mylogger‘)创建了root Logger的孩子(root.)mylogger,logger2同样。而孩子,孙子,重孙……既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。

        ok,那么现在我们把

# logger.addHandler(fh)

# logger.addHandler(ch)  注释掉,我们再来看效果:

技术分享图片

因为我们注释了logger对象显示的位置,所以才用了默认方式,即标准输出方式。因为它的父级没有设置文件显示方式,所以在这里只打印了一次。

孩子,孙子,重孙……可逐层继承来自祖先的日志级别、Handler、Filter设置,也可以通过Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。设置自己特别的日志级别、Handler、Filter。若不设置则使用继承来的值。

https://www.cnblogs.com/yuanchenqi/articles/5732581.html

re模块

元字符之字符集[]

元字符之字符集[]里面,除了 “- ^ \”,不能用其它特殊符号,例如“*”。因此在中括号里面的其它特殊字符不用转义。

元字符之转义符 \

例子:

import re
ret=re.findall(c\l,abc\le)
print(ret)#[]
ret=re.findall(c\\l,abc\le)
print(ret)#[]
ret=re.findall(c\\\\l,abc\le)
print(ret)#[‘c\\l‘]
ret=re.findall(rc\\l,abc\le)
print(ret)#[‘c\\l‘]

在不加“r”的前提下,为什么在用四条"反斜杠线"才可以匹配"\I"呢?

本来直接用一次转义符"\"不就好了吗?

本来这个想法是没错的,但前提是只单独对"re"这个模块或者说re这个解释器有用,我们要知道,我们是在Python解释器的环境下使用"re"的,因此会经过Python解释器的编译,再传给“re”处理,而Python解释器也能识别转义符“\”。因此匹配"c\I",re里面需要写成"c\\I",相当于最外层Python解释器要传字符串“c\\I”给re,而两个“\\”会被Python解释器转化等于一个“\”,要想传两个"\"就需要四个“\\\\”。

还有最后输出时也是两个“\\”,因为“re”匹配到了“c\I”,传给Python解释器时,解释器知道“c\I”中的“\”是普通反斜杠线"\",因此会把“\”转换为"\\",这就是匹配到了为什么输出是“c\\I”的原因。

 技术分享图片

元字符之分组()

注意点:

import re
 
ret=re.findall(www.(baidu|oldboy).com,www.oldboy.com)
print(ret)#[‘oldboy‘]     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall(www.(?:baidu|oldboy).com,www.oldboy.com)
print(ret)#[‘www.oldboy.com‘]
import re


ret = re.findall((abc)+, "abcabcabc")
print(ret)  # ["abc"]

ret = re.findall((?:abc)+, "abcabcabc")
print(ret)  # ["abcabcabc"]

 re.split()的分割过程

>>> import re
>>> ret = re.split("ab", "aabcdab")
>>> print(ret)
[a, cd, ‘‘]  # 注意是有空字符串的

分割过程:首先"ab"匹配到了字符串中的“ab”,把字符串分成了“a”和“cdab”两部分,再匹配到了"ab",分成“cd”和“”两部分。

 

模块(查漏补缺)

标签:标准输出   传统   日志文件   有用   clu   文件名   第一个   comm   flatten   

原文地址:https://www.cnblogs.com/linyuhong/p/10212187.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!