Python23 内置模块讲解

1.标准库（内置模块）

2.开源模块（第三方模块）

3.自定义模块（自己写的.py文件模块）

import random

checkcode = ''
for i in range(4):    #指定4位验证码的长度
    current = random.randint(0,9)    #指定随机数字
    checkcode+=str(current)    #将随机的数字加入到变量中
print (checkcode)    #打印随机的验证码

checkcode = ''
for i in range(4):    #循环4次，相当于4位长度的验证码
    current = random.randint(0,4)    #设定current随机数字与range范围相等
    if current == i:        
        tmp = chr(random.randint(65,90)) #随机匹配：当current等于i时，就随机一个字母
    else:
        tmp=random.randint(0,9)    #当current不等于i时，就随机一个数字
    checkcode+=str(tmp)    #将tmp产生的数字或字母加入到checkcodee变量中
print (checkcode)

import shutil

f1 = open('test1.txt',encoding='utf-8')

f2 = open('test2.txt','w',encoding='utf-8')

shutil.copyfileobj(f1,f2)

import zipfile

z = zipfile.ZipFile('laxi.zip', 'w')

z.write('a.log')

z.write('data.data')

z.close()

z = zipfile.ZipFile('laxi.zip', 'r')

z.extractall()

z.close() 

import tarfile

tar = tarfile.open('your.tar','w')

tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')

tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')

tar.close()

tar = tarfile.open('your.tar','r')

tar.extractall()  # 可设置解压地址

tar.close() 

s1={"k1":"v1"}

st=json.dumps(s1)

print(st,type(st))

s='{"k1":"v1"}'

dic=json.loads(s)

print(dic,type(dic)) 

输出结果为：

{"k1": "v1"} <class 'str'>

{'k1': 'v1'} <class 'dict'> 

li=[11,22,33]

li=json.dump(li,open('db','w'))

li=json.load(open('db','r'))

print(li,type(li)) 

输出结果为：

[11, 22, 33] <class 'list'>

import pickle

i=[11,22,33]

r=pickle.dumps(li)

print(r)

result=pickle.loads(r)

print(result) 

　结果为：

b'\x80\x03]q\x00(K\x0bK\x16K!e.'

[11, 22, 33] 

import pickle

i=[11,22,33]

pickle.dump(i,open('db','wb'))

result=pickle.load(open('db','rb'))

print(result) 

    结果为：

[11, 22, 33]

f = shelve.open('user.db','wc')

f['baidu'] = 'www.baidu.com'

f['qq'] = 'www.qq.com'

f['360'] = 'www.360.cn'

f.close()

f = shelve.open('user.db','a+')

print(f['baidu'],f['qq'],f['360']) 

结果为：

www.baidu.com

www.qq.com

www.360.cn 

f=shelve.open('user_db','c')

f["user"]={"数码电器": {"打印机": "3600", "手机": "3800", "电脑": "8000", "照相机": "10000"},

     "服装百货": {"方便面": "4", "夹克": "300", "牛仔裤": "288", "王老吉": "6"},

     "化妆品": {"韩束": "388", "欧诗漫": "666", "欧莱雅": "888", "百雀羚": "259"},

     "汽车":{"帕沙特": "250000", "奇瑞": "100000", "特斯拉": "999999", "宝马X5": "550000"}

     }

a=(f["user"])

a.update({"食品":{"猪肉":"12","牛肉":"28","鸡肉":"8","羊肉":"32",}})

f["user"]=a

f.close()

f=shelve.open('user_db','a')

print(f["user"]) 

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")  #要处理xmltest.xml文件
root = tree.getroot()
print(root)     #只会打印出内存地址
print(root.tag)   #会打印出内存地址对应的内容

遍历xml文档
for child in root:
    print(child.tag, child.attrib)  

    for i in child:
        print(i.tag, i.text,i.attrib)

i.tag表示rank（标签名）

i.text表示2 （值）

i.attrib表示updated="yes"> （属性）

只遍历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'):                #循环year有关的节点
    new_year = int(node.text) + 1        #循环的是字符串，需要转换成数字然后+1（加一年）
    node.text = str(new_year)               #text表示值，将这个值（20XX）转换为字符串
    node.set("updated_by", "Alex")        #新增属性

tree.write("xmltest.xml")                    #将内容写入源文件（xmltest.xml）

for country in root.findall('country'):     #查找所有country
    rank = int(country.find('rank').text)   #查找country下面的rank
    if rank > 50:                           #如果ran中的值大于50就删除当前country
        root.remove(country)

tree.write('output.xml')

import xml.etree.ElementTree as ET

new_xml = ET.Element("personinfolist")  #根节点personinfolist
personinfo = ET.SubElement(new_xml, "personinfo", attrib={"enrolled": "yes"}) #创建new_xml的子节点； personinfo是节点名；attrib是属性

name = ET.SubElement(personinfo, "name")    #该节点是personinfo的子节点
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) #xml_declaration表示生成的格式是xml

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

import configparser

config = configparser.ConfigParser()    #生成处理对象并赋值

config['DEFAULT']={'ServerAliveInterval':'45',
'Compression':'yes',
'CompressionLevel':'9',
'ForwardX11':'yes'}

config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}   #生成配置文件内容，以字典的方式

config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'      #与上面的结果一样，只是写的方式不同

config['topsecret.server.com'] = {}
config['topsecret.server.com']
config['topsecret.server.com']['Host Port'] = '50022'  # mutates the parser
config['topsecret.server.com']['ForwardX11'] = 'no'  # same here

config['DEFAULT']['ForwardX11'] = 'yes'

with open('example.ini', 'w') as configfile:
    config.write(configfile)

import configparser

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

print(conf.defaults())    

print(conf['bitbucket.org']['user'])

sec = conf.remove_section('bitbucket.org')    #删除指定节点
conf.write(open('example.ini', "w"))    #写入

import hashlib

m = hashlib.md5()        #使用MD5算法
m.update(b'Hello')        #b表示bytes类型
print (m.hexdigest())    #使用十六进制打印，hexdigest就表示十六进制格式
m.update(b'Its me')
print (m.hexdigest())

m3 = hashlib.sha3_512()
m3.update(b'HelloIts me')
print (m3.hexdigest())

import hmac
h = hmac.new(b'12345',b'qwerasdf')   #abc123是key，1234qwer是消息,
print (h.hexdigest())

import subprocess
a = subprocess.call(['df','-hT'],shell=False)
print(a)

执行结果：
文件系统                类型      容量  已用  可用 已用% 挂载点
/dev/mapper/centos-root xfs        22G  9.0G   14G   41% /
devtmpfs                devtmpfs  894M     0  894M    0% /dev
tmpfs                   tmpfs     910M     0  910M    0% /dev/shm
tmpfs                   tmpfs     910M   19M  892M    3% /run
tmpfs                   tmpfs     910M     0  910M    0% /sys/fs/cgroup
/dev/sda1               xfs      1014M  233M  782M   23% /boot
tmpfs                   tmpfs     182M  4.0K  182M    1% /run/user/42
tmpfs                   tmpfs     182M   48K  182M    1% /run/user/0
0

import subprocess
a = subprocess.check_call('ifconfig',shell=True)
print(a)

执行结果：
ens32: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.200.150  netmask 255.255.255.0  broadcast 192.168.200.255
        inet6 fe80::1715:d111:c3d7:a081  prefixlen 64  scopeid 0x20<link>
        ether 00:0c:29:bd:d1:99  txqueuelen 1000  (Ethernet)
        RX packets 757729  bytes 831629447 (793.1 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 207676  bytes 58597215 (55.8 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

import subprocess
a = subprocess.check_call('abcd',shell=True)
print(a)

执行结果：
/bin/sh: abcd: 未找到命令
Traceback (most recent call last):
  File "/tmp/pycharm_project_538/codes_practice/aa1/A4.py", line 2, in <module>
    a = subprocess.check_call('abcd',shell=True)
  File "/usr/local/lib/python3.6/subprocess.py", line 291, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'abcd' returned non-zero exit status 127.

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
obj.stdin.write('print(1) \n')
obj.stdin.write('print(2) \n')
obj.stdin.write('print(3) \n')
obj.stdin.close()

cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close()

print (cmd_out)
print (cmd_error)

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
obj.stdin.write('print(1) \n')
obj.stdin.write('print(2) \n')
obj.stdin.write('print(3) \n')
obj.stdin.close()

out_error_list = obj.communicate()
print (out_error_list)

import subprocess
child1 = subprocess.Popen(["cat","/etc/passwd"], stdout=subprocess.PIPE)
child2 = subprocess.Popen(["grep","0:0"],stdin=child1.stdout, stdout=subprocess.PIPE)
out = child2.communicate()

import subprocess
child = subprocess.Popen('sleep 60',shell=True,stdout=subprocess.PIPE)
Popen.poll() 
用于检查子进程是否已经结束。设置并返回returncode属性。

Popen.wait() 
等待子进程结束。设置并返回returncode属性。

Popen.communicate(input=None)
与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。 Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如 果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。

Popen.send_signal(signal) 
向子进程发送信号。

Popen.terminate()
停止(stop)子进程。在windows平台下，该方法将调用Windows API TerminateProcess（）来结束子进程。

Popen.kill()
杀死子进程。

Popen.stdin 
如果在创建Popen对象是，参数stdin被设置为PIPE，Popen.stdin将返回一个文件对象用于策子进程发送指令。否则返回None。

Popen.stdout 
如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回 None。

Popen.stderr 
如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回 None。

Popen.pid 
获取子进程的进程ID。

Popen.returncode 
获取进程的返回值。如果进程还没有结束，返回None。

import logging

logging.debug('test debug')
logging.info('test info')

logging.warning('the warning info')
logging.error('the error info')
logging.critical('the critical info')

logging.basicConfig(filename='app.log',level=logging.DEBUG)   

logging.basicConfig(filename='app.log',level=logging.WARNING,format='%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')   

Logger.setLevel(lel): #指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt): #添加或删除指定的filter （这个很少用到）
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)： #增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()： #可以设置的日志级别

Handler.setLevel(lel): #指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()： #给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)： #新增或删除一个filter对象

    StreamHandler([strm])
    其中strm参数是一个文件对象。默认是sys.stderr

    FileHandler(filename[,mode])
    filename是文件名，必须指定一个文件名。
    mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。

import logging
logger = logging.getLogger('TEST-LOG')  #获取接口对象
logger.setLevel(logging.DEBUG)      #定义记录告警信息的最低等级

ch = logging.StreamHandler()    #定义Handler，可以输出到屏幕
ch.setLevel(logging.WARNING)    #定义输出到屏幕的告警级别

fh = logging.FileHandler('access.log',encoding='utf-8')      #定义Handler输出到信息的文件名称
fh.setLevel(logging.ERROR)      #定义输出到文件的告警级别

ch_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')   #定义Handler输出到屏幕的格式
fh_formatter = logging.Formatter('%(asctime)s - %(process)d  %(filename)s:%(lineno)d')   #定义Handler输出到文件的格式

ch.setFormatter(ch_formatter)   #关联Handler输出到屏幕的格式
fh.setFormatter(fh_formatter)   #关联Handler输出到文件的格式

logger.addHandler(fh)   #增加被输出的内容，与logger接口对象做关联
logger.addHandler(ch)   #增加被输出的内容，与logger接口对象做关联
#屏幕和文件中都可以被输出

logger.warning('aaaa')  #定义告警级别和信息
logger.error('bbbb')    #定义告警级别和信息

import logging
from logging import handlers    #需要单独import handlers这个函数

logger = logging.getLogger('TEST')
log_file = "test-log.log"
fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3,encoding='utf-8')
#文件名为log_file，每个文件最大存储10字节，最多保留3个备份文件。

formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)

logger.warning("test1")
logger.warning("test2")
logger.warning("test3")
logger.warning("test4")
logger.warning("test5")
logger.warning("test6")

fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)

import logging
from logging import handlers    #需要单独import handlers这个函数
import time

logger = logging.getLogger('TEST')
log_file = "test-log.log"

fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3,encoding='utf-8')

#使用handlers.TimedRotatingFileHandler，S表示秒，5就是每隔5秒

formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)

logger.warning("test1")
time.sleep(2)
logger.warning("test2")
time.sleep(2)
logger.warning("test3")
logger.warning("test4")
time.sleep(2)
logger.warning("test5")
logger.warning("test6")

re.match(pattern,string, flags=0) 

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

import re
print(re.match('www', 'www.google.com'))
print(re.match('www', 'www.google.com').span())
print(re.match('google', 'www.google.com'))

import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line)    

#将line这个变量作为一个需要匹配的内容；

#这里正则表达式通过()分了两个部分，可以用group来表达，在are之前的(.*)是一部分，在are之后的(.*?) 一个部分，如果去掉的话匹配结果就不同了。

每一个()表示一个分组

if matchObj:
    print ("matchObj.group() : ", matchObj.group())    #匹配所有()和非()表达式中的内容
    print ("matchObj.group(1) : ", matchObj.group(1))    #匹配第一个()中的表达式内容
    print ("matchObj.group(2) : ", matchObj.group(2))    #匹配第二个()中的表达式内容
    print ("matchObj.group(3) : ", matchObj.groups())    #匹配所有()中的表达式美容，并以元组的形式显示
else:
print ("No match!!")

line = 'www.google.com'
rule = re.match(r'.',line)
print (rule)
print (rule.group())

line = 'www.google.com'

rule = re.match(r'.+',line)

rule1 = re.match(r'w',line)    #匹配一个字母
rule2 = re.match(r'w+',line)    #匹配1或多个字母
rule3 = re.match(r'w{2}',line)    #匹配2个字母
rule4 = re.match(r'w{1,3}',line)    #匹配1到3个字母（至少1个，最多3个）

print (rule1.group())
print (rule2.group())
print (rule3.group())
print (rule4.group())

rule5 = re.match(r'w+|.+',line)
rule6 = re.match(r'.+|w+',line)

re.search('www','www.google.com').group()    #注意匹配www时是没有使用r或\转义的，所以匹配的就是www字符本身

re.search('google','www.google.com').group()

re.search('(\d{3})(\d{4})','123456789123456789').groups()

rule = re.search('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}','192.168.1.1').group()
print (rule)

rule = re.search('(\d{1,3}\.){3}\d{1,3}','192.168.1.1').group()    #稍微优化
print (rule)

rule = re.search('([0-2]?[0-9]?[0-9]+\.){3}[0-2]?[0-9]?[0-9]','192.168.1.1').group()
print (rule)

rule = re.search('^((25[0-5]|2[0-4]\d|[1]?\d?\d)\.){3}(25[0-5]|2[0-4]\d|[1]?\d?\d)$','255.168.1.255').group()
print (rule)

rule = re.search('^((25[0-5]|2[0-4]\d|[1]?\d?\d)\.){3}(25[0-5]|2[0-4]\d|[1]?\d?\d)$','256.168.1.255').group()        #第一个IP被协成256，这是不合法的

print (rule)

rule1 = re.search('\d+','ab13aa22cc334bb44adsf234656').group()
rule2 = re.findall('\d+','ab13aa22cc334bb44adsf234656')    #这里不需要group
print (rule1)
print (rule2)

rule3= re.findall('\D+','ab13aa22cc334bb44adsf234656')

print (rule3)

rule1 = re.split('\d+','ab13aa22cc334bb44adsf234656dd')    #最后面加个dd字符串
print (rule1)

rule1 = re.split('\d+','ab13aa22cc334bb44adsf234656dd')    #最后面加个dd字符串
print (rule1)

rule = re.sub('\d+','|','ab13aa22cc334bb44adsf234656dd')
print (rule)

rule = re.sub('\d+','XXX','ab13aa22cc334bb44adsf234656dd',count=2)
print (rule)

rule = re.search('a+','AAAaaa',re.I).group()
print (rule)