Python基础-常用模块

 

1. 模块初识

1.1 什么是模块

什么是模块

常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

但其实import加载的模块分为四个通用类别：　

　　1 使用python编写的代码（.py文件）

　　2 已被编译为共享库或DLL的C或C++扩展

　　3 包好一组模块的包

　　4 使用C编写并链接到python解释器的内置模块

使用模块的目的

　　通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

模块的导入和应用

模块的导入应该在程序开始的地方，比如：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time
import os
import sys

 

 

1.2 常用模块

1.2.1 collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典

 

 

namedtuple

namedtuple模块可以给tuple命名，应用在坐标点、圆的表示等

坐标点

from collections import namedtuple

point = namedtuple('Point',{'x','y'})
p = point(1,2)
print(p.x,p.y)

 

表示圆的圆心坐标和半径

from collections import namedtuple

cycle = namedtuple('cycle',{'x','y','r'})
c1 = cycle(1,2,2)
print(c1.r)

 

 

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
q
deque(['y', 'a', 'b', 'c', 'x'])

 

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

 

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

 

 OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']

 

 

defaultdict 

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

 

原生字典解决方式

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]

 

defaultdict使用方法

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

 

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

 

 

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

 

1.2.2 time模块

和时间有关系的我们就要用到时间模块。在使用模块之前，应该首先导入这个模块。

1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

 

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’

python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

  

(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

print(time.localtime())

time.struct_time(tm_year=2018, tm_mon=5, tm_mday=7, tm_hour=17, tm_min=20, tm_sec=17, tm_wday=0, tm_yday=127, tm_isdst=0)

 

首先我们导入time模块，来认识一下python中表示时间的几种格式：

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)

 

 

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

 几种格式直接的转换

 

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳　
#time.mktime(结构化时间-->时间戳时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

 

 

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

 

 

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017' 

 

 

计算时间差

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

 

 思路：

1. 将两个时间节点转化成时间戳，计算时间戳的差值

2. 将差值当成新的时间戳，获取结构化时间

3.这个结构化时间就相当于从时间戳起始时间过的时间段。

4.在结构化时间中减去开始的1970年 1月，得到的结果就是时间差的结构化时间，再转化成格式化时间。

 

1.2.3 random模块 随机数

>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838
#恒富：发红包

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数

#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回，返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']

#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

 

 

生成验证码练习

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="".join([code,str(add)])

    return code

print(v_code())

 

 

1.2.4 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下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量


os.path
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.path.getsize(path) 返回path的大小
'''

 

 

注意：os.stat('path/filename')  获取文件/目录信息 的结构说明

 

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

stat 结构

 

 

1.2.5 sys模块

sys模块是与python解释器交互的一个接口

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

 

 

1.2.6 re模块 正则

想用好re模块，先得熟练使用正则表达式

1.2.6.1正则表达式

在线测试工具 http://tool.chinaz.com/regex/

什么是字符组：

在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。

元字符：

 

量词：

# 量词 量词跟在一个元字符的后面 约束某个字符的规则能够重复多少次

 

 

注意：

前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

贪婪匹配：

# 正则表达式默认 贪婪匹配 会在当前量词约束的范围内匹配最多的次数

正则	待匹配字符	匹配 结果	说明
<.*>	<script>...<script>	<script>...<script>	默认为贪婪匹配模式，会匹配尽量长的字符串
<.*?>	r'\d'	<script> <script>	加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串

常用的非贪婪匹配Pattern

*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复

 

 

 

惰性匹配

 

 

 

正则	待匹配字符	匹配 结果	说明
李.*?	李杰和李莲英和李二棍子	李 李 李	惰性匹配

 

.*?的用法

 

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x

就是取前面任意长度的字符，直到一个x出现

 

1.2.6.2 re模块下的常用方法

import re

# findall 方法
ret = re.findall('a','I am a good boy adsf adfasdf')  # 返回满足匹配条件的所有结果，放到列表里
# print(ret)


# search 方法
# 函数会在字符串内查找匹配模式，只到找到第一个匹配然后返回一个包含匹配信息的对象。
# 通过调用group()方法得到匹配的字符串
# 找第一个
# 返回的值不是一个直接的结果 而是一个内存地址 需要使用.group()取值
# 如果匹配不上 返回None 就不能group

ret = re.search('a','I am a good boy adsf adfasdf')  #
print(ret)  # <_sre.SRE_Match object; span=(2, 3), match='a'> 返回一个包含匹配信息的对象

ret = re.search('abc','I am a good boy adsf adfasdf')  #
print(ret)  # None

ret = re.search('abc','I am a good boy adsf adfasdf').group()  #在未匹配到的结果search后面使用group会报错
print(ret)

ret = re.search('a','I am a good boy adsf adfasdf').group()
print(ret)  # a


# match方法
# match在search的基础上 给每一条正则都加上了一个^ 只匹配字符串的开头
ret = re.match('a', 'abc').group()  # 同search,不过仅在字符串开始处进行匹配
print(ret)


# split 方法  按匹配的正则内容切割字符串
ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

# sub 方法
ret = re.sub('\d', 'H', 'eva3egon4yuan4', 2)#将数字替换成'H'，参数2表示替换2个
print(ret) #evaHegonyuan4

# subnf方法
ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)  #('evaHegonHyuanH', 3)

# complie方法
obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eee')   #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())   #结果 ： 123

# finditer方法
ret = re.finditer('\d','1234aqsdr1234asdr')
print(ret)  #<callable_iterator object at 0x101f586d8> 返回一个存放匹配结果的迭代器
print(next(ret).group())  # next从迭代器取值
print(next(ret).group())
print(next(ret).group())
print([i.group() for i in ret])  #for循环查看剩余的结果，要放到列表里查看

 

注意：

1. findall的查询优先级

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']

2. split的优先级查询

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。

 

二. 常用模块二

2.1 hashlib

 将一个字符串进行摘要运算，拿到一个固定的值。是一个包含了多种算法的模块

2.1.1 md5算法

import hashlib
md5obj = hashlib.md5()   # 实例化一个md5摘要算法的对象
md5obj.update('alex3714'.encode('utf-8')) # 使用md5算法的对象来操作字符串
ret = md5obj.hexdigest() # 获取算法的结果 hex+digest 16进制+消化
print(ret,type(ret),len(ret))

 

 2.1.2 sha算法

import hashlib

md5obj = hashlib.sha1()   # 实例化一个sha1摘要算法的对象
md5obj.update('alex3714'.encode('utf-8')) # 使用sha1算法的对象来操作字符串
ret = md5obj.hexdigest() # 获取算法的结果 hex+digest 16进制+消化
print(ret,type(ret),len(ret))

 

2.1.3 加盐

防止别人撞库的方法

import hashlib

# md5_obj = hashlib.md5()
md5_obj = hashlib.md5('tesla'.encode('utf-8'))   # 使用固定字符串加盐
md5_obj.update('alex'.encode('utf-8'))
ret = md5_obj.hexdigest()
print(ret)

username = 'alex'
md5obj = hashlib.md5(username.encode('utf-8'))   ##  用户注册使用username动态加盐。用户名不可更改
md5obj.update('alex3714'.encode('utf-8'))
ret = md5obj.hexdigest
print(ret)

 

2.1.4 校验文件一致性

# 校验文件一致性
# 自动化 —— python代码来做验证
import hashlib
md5obj = hashlib.md5()   # 实例化一个md5摘要算法的对象
md5obj.update('alex'.encode('utf-8')) # 使用md5算法的对象来操作字符串
md5obj.update('3714'.encode('utf-8')) 

print(md5obj.hexdigest())

# 对'alex3714'进行一次摘要取得的结果和对’alex‘和’3714‘分别进行一次摘要update的结果是一样的。

 

写一个函数，接收两个文件的地址，判断文件是否一致

''

 

 

2.2 configparse

该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），每个节可以有多个参数（键=值）。

文档格式：

[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',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

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())      # 查看分组列表，没有default。因为default是全局的

#  判断一个组是否在文件中
print('bitbucket.org' in config)   # True
print('bitbucket.123' in config)  # False

# 查看一个组的某一个的key的值
print(config['bitbucket.org']['user'])  # hg

# 直接取一个组 拿到一个生成器
print(config['bitbucket.org'])  # <Section: bitbucket.org>
for key in config['bitbucket.org']:
    print(key)  # 拿到所有的key，包括全局的 没有值
    print(config['bitbucket.org'][key]) # 拿到所有的值

# 拿到所有的键值对的元组 包括全局的
print(config.items('bitbucket.org')) #[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]

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

print(config.get('bitbucket.org', 'compression'))

 

 

增删改

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')



config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")


config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

 

 

2.3 logging模块

 

2.3.1 简单配置

logging.basicConfig(level=logging.DEBUG)  # 定义日志级别
logging.debug('debug message')    # 非常细节的日志 —— 排查错误的时候使用
logging.info('info message')     # 正常的日志信息
logging.warning('warning message')  # 警告
logging.error('error message')    # 错误
logging.critical('critical message') # 严重错误

 

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：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='test.log',
                    # filemode='w'
                    )
logging.debug('debug message')    # 非常细节的日志 —— 排查错误的时候使用
logging.info('info message')     # 正常的日志信息
logging.warning('warning message')  # 警告
logging.error('error message')    # 错误
logging.critical('critical message') # 严重错误

 

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
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用户输出的消息

 

2.3.2 使用logger对象的方法配置

支持中文 可以同时输出到屏幕并写入文件

向文件中输入日志：

import logging
# logger对象的配置方法
loggger = logging.getLogger()
# 吸星大法

# 往文件中输入
fh = logging.FileHandler('log.log')  # Handler 处理 创建一个能操作文件的对象fh

loggger.addHandler(fh)
loggger.warning('debug message')

 

向屏幕输出日志

import logging
# logger对象的配置方法
loggger = logging.getLogger()
# 吸星大法

# 往文件中输入
fh = logging.FileHandler('log.log')  # Handler 处理 创建一个能操作文件的对象fh
loggger.addHandler(fh)   # 写入到文件

sh = logging.StreamHandler()   #  设置向屏幕输出
loggger.addHandler(sh)  # 想屏幕输出

loggger.warning('warning message')  # 设置级别 发送报警

 

设置输出格式

import logging
# logger对象的配置方法
loggger = logging.getLogger()
# 吸星大法


formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')   ## 定义不同的输出格式
formatter1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')


# 往文件中输入
fh = logging.FileHandler('log.log')  # Handler 处理 创建一个能操作文件的对象fh
fh.setFormatter(formatter)   ##  将格式绑定到输出文件上
loggger.addHandler(fh)   # 写入到文件

sh = logging.StreamHandler()   #  设置向屏幕输出
sh.setFormatter(formatter1)   # 将格式绑定到输出文件上
loggger.addHandler(sh)  # 想屏幕输出

loggger.warning('warning message')  # 设置级别 发送报警

定义日志界别

import logging
# logger对象的配置方法
loggger = logging.getLogger()
# 吸星大法

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

loggger.setLevel(logging.DEBUG)   ## 全局的筛选，默认在warnning 如不改变，在sh和fh的设置中不能调到debug

# 往文件中输入
fh = logging.FileHandler('log.log', encoding='utf-8')  # Handler 处理 创建一个能操作文件的对象fh
fh.setFormatter(formatter)
loggger.addHandler(fh)   # 写入到文件

sh = logging.StreamHandler()   #  设置向屏幕输出
sh.setFormatter(formatter1)
loggger.addHandler(sh)  # 想屏幕输出

sh.setLevel(logging.DEBUG)

loggger.warning('warning message')  # 设置级别 发送报警
loggger.info('logger info message')
loggger.warning('logger warning message')
loggger.error('error了')
loggger.critical('logger critical message')