模块
time&datetime 模块 时间
random 模块 随机数
shutil 模块 文件、文件夹、压缩包
json & pickle 模块 字符串 python特有的类型 与 python数据类型间进行转换
shelve 模块 以key,value将内存数据通过文件持久化
xml 模块 不同语言或程序之间进行数据交换，跟json差不多，但json使用起来更简单
configparser 模块 生成和修改常见配置文档
hashlib 模块 加密
logging 模块 记录日志
re 模块 处理字符串
time & datetime 模块
time 模块
import time print(" time applications ".center(80,"*")) print(time.process_time()) # 测量处理器运算时间，不包括sleep时间 print(time.time()) # 时间戳，1970 年的时间到现在，以秒计算 print(time.gmtime()) # utc 时间的sturct time（格林威治时间） print("--------- 本地时间 -----------") print(time.altzone) # 返回与utc时间的时间差，已秒计算 print(time.localtime()) # 返回本地时间的struct time对象格式 print(time.localtime(time.time())) # 返回本地时间的struct time对象格式 print(time.localtime(time.time()+3600*3)) # 修改本地时间并返回struct time对象格式 t1 = time.localtime(time.time()) print(t1.tm_year,t1.tm_yday) # year to day month to day print("----------- 时间格式 ------------") # 返回时间格式 week month day H:M:S year print(time.asctime()) print(time.asctime(time.localtime())) print(time.ctime()) print("---------- 日期字符串 转 时间对象 转 时间戳 -----------") # 日期字符串 转 时间对象 struct_time = time.strptime("2016-11-11 23:30","%Y-%m-%d %H:%M") #struct_time = time.strptime("16-11-11 23:30","%y-%m-%d %H:%M") print(struct_time) # 获取了时间对象，但是不能对其进行运算，得转成时间戳才能运算 struct_time_stamp = time.mktime(struct_time) # 转时间戳 print(struct_time_stamp) print("----------- 时间戳 转 时间对象 转 字符串 -----------") # 时间戳 转 时间对象 struct_time2 = time.localtime(struct_time_stamp) print(struct_time2) # 时间对象 转 字符串 string_time = time.strftime("%Y_%m_%d_%H_%M.log",struct_time2) print(string_time)
***************************** time applications ****************************** 0.156001 1494746244.919801 time.struct_time(tm_year=2017, tm_mon=5, tm_mday=14, tm_hour=7, tm_min=17, tm_sec=24, tm_wday=6, tm_yday=134, tm_isdst=0) --------- 本地时间 ----------- -3600 time.struct_time(tm_year=2017, tm_mon=5, tm_mday=14, tm_hour=8, tm_min=17, tm_sec=24, tm_wday=6, tm_yday=134, tm_isdst=1) time.struct_time(tm_year=2017, tm_mon=5, tm_mday=14, tm_hour=8, tm_min=17, tm_sec=24, tm_wday=6, tm_yday=134, tm_isdst=1) time.struct_time(tm_year=2017, tm_mon=5, tm_mday=14, tm_hour=11, tm_min=17, tm_sec=24, tm_wday=6, tm_yday=134, tm_isdst=1) 2017 134 ---------- 时间格式 ------------ Sun May 14 08:17:24 2017 Sun May 14 08:17:24 2017 Sun May 14 08:17:24 2017 ---------- 日期字符串 转 时间对象 转 时间戳 ----------- time.struct_time(tm_year=2016, tm_mon=11, tm_mday=11, tm_hour=23, tm_min=30, tm_sec=0, tm_wday=4, tm_yday=316, tm_isdst=-1) 1478907000.0 ---------- 时间戳 转 时间对象 转 字符串 ----------- time.struct_time(tm_year=2016, tm_mon=11, tm_mday=11, tm_hour=23, tm_min=30, tm_sec=0, tm_wday=4, tm_yday=316, tm_isdst=0) 2016_11_11_23_30.log
datetime 模块
import datetime print(" datetime applications ".center(80,"*")) print("--------------- 本地时间 ----------------") print(datetime.datetime.now()) # 当前本地时间 print(datetime.datetime.fromtimestamp(time.time())) # 时间戳 直接转 日期格式 #print(datetime.datetime.fromtimestamp(time.time()-3600)) # 时间戳 直接转 日期格式 print("--------------- 时间运算 ----------------") # 时间运算 print(datetime.datetime.now() + datetime.timedelta(days = 3)) # 当前时间 +3 天 print(datetime.datetime.now() - datetime.timedelta(days = 3)) # 当前时间 -3 天 print(datetime.datetime.now() + datetime.timedelta(hours = 3)) # 当前时间 +3 小时 print(datetime.datetime.now() + datetime.timedelta(minutes = 30 )) # 当前时间 +30 分钟 print("--------------- 时间替换 ----------------") # 时间替换 now = datetime.datetime.now() print(now.replace(month=1,day=3))
*************************** datetime applications **************************** --------------- 本地时间 ---------------- 2017-05-14 08:17:24.970803 2017-05-14 08:17:24.970804 --------------- 时间运算 ---------------- 2017-05-17 08:17:24.970803 2017-05-11 08:17:24.970803 2017-05-14 11:17:24.970803 2017-05-14 08:47:24.970803 --------------- 时间替换 ---------------- 2017-01-03 08:17:24.970803
字符串 & 时间戳 的转换：
字符串 ---------------------------------------> 时间对象(stuct_time) ---------------> 时间戳(stuct_time_stamp)
time.strptime("日期字符串内容"，"想转的日期格式"） time.mktime(stuct_time)
时间戳 --------------------------------------> 时间对象(stuct_time) ----------------> 字符串(string_time)
time.gmtime(stuct_time_stamp) time.strftime("想转的日期格式", stuct_time)
or
time.localtime(stuct_time_stamp)
random 模块
生成随机数：
import random print(random.random()) print(random.randint(1,5)) print(random.randrange(1,10)) print(random.sample(range(100),5)) # 100 里随机选5 print(random.sample("abcde",2)) # abcde 里随机选2
string 模块：
import string print(string.ascii_letters) print(string.digits) print(string.hexdigits)
随机验证码：
import random import string # method 1 str_source = string.ascii_letters + string.digits print(''.join(random.sample(str_source,6))) # method 2 checkcode = '' for i in range(4): # 4位 随机数 current = random.randrange(0,4) if current != i: temp = chr(random.randint(65,90)) # chr(65)--> "A" chr(90)--> "Z" else: temp = random.randint(0,9) checkcode += str(temp) print(checkcode)
shutil 模块
a) 文件、文件夹的处理
import shutil f1 = open("random mod.py") f2 = open("random new.py","w") shutil.copyfileobj(f1,f2) # copy data from file-like object fsrc to file-like object fdst, 将文件内容拷贝到另一个文件中 shutil.copyfileobj(fsrc, fdst[, length]) # 可以拷贝部分内容 shutil.copyfile(src, dst)# Copy data from src to dst. 调用的copyfileobj的底层函数，当然前提是目标地址是具备可写权限 shutil.copymode(src,dst) # Copy mode bits from src to dst. 内容、组、用户均不变 shutil.copystat(src, dst) # Copy all stat info (mode bits权限, atime最后访问时间, mtime最后修改时间, flags) from src to dst shutil.copytree(src, dst) # copy一个目录 shutil.copy(r"C:UsersapplePycharmProjectss14day3haproxy","test")# Copy data and mode bits. The destination may be a directory.不用打开文件的copy. shutil.copy2(src,dst) # Copy data and all stat info. The destination may be a directory. 内容+权限+状态 shutil.rmtree(path) # 删除文件 shutil.move(src, dst) # 移动文件
b)压缩包处理：
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#shutil.make_archive(base_name, format,...) #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录 ret = shutil.make_archive("wwwwwwwwww", format = 'gztar', root_dir='/Users/wupeiqi/Downloads/test') #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录 ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", format = 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
c) shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的
ZipFile 模块：
import zipfile # 添加压缩文件 zip_obj = zipfile.ZipFile(r"c:zip_test.zip","w") zip_obj.write("test") # 添加要压缩的文件 zip_obj.write(r"C:UsersAdminisratorPycharmProjectss14day5") # 添加只有目录，文件是空的 zip_obj.close() # 解压 zip_obj = zipfile.ZipFile(r"c:zip_test.zip","r") zip_obj.extractall() zip_obj.close()
TarFile 模块：
# 压缩 tar = tarfile.open(r"c:your.tar","w") tar.add("C:UsersAdminisratorPycharmProjectss14day5",arcname = "day5") # 可以添加目录以及内容 tar.add(r"c:zip_test.zip") tar.close() # 解压 tar = tarfile.open('your.tar','r') tar.extractall() # 可设置解压地址 tar.close()
json & pickle 模块
用于序列化的两个模块
- json，用于字符串 和 python数据类型间进行转换
- pickle，用于python特有的类型 和 python的数据类型间进行转换（eg. 函数）
Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load
PS :
json和pickle读文件只能处理只有一行的文件数据,所以基本用json和pickle读写只处理一次，所以只有dump一次，load一次。
如果想存好几个状态，就只能存好几个文件 或者 使用shelve模块来处理多次
json（反）序列化：
import json info = { "name": "alex", "age":22, } f = open("test.test","w") f.write(json.dumps(info)) # 字典 转 字符串，并写入文件 # = json.dump(info,f) print(type(json.dumps(info))) # str f.close() f2 = open("test.test","r") data = json.loads(f2.read()) # 字符串 转 字典 print(type(data)) # dict print(data["age"]) f.close()
json（反）序列化 之 多dumps/loads：
import json info = { "name": "alex", "age":22, } f = open("test.test","w") f.write(json.dumps(info)) # 可以存多次 info["age"] = 21 f.write(json.dumps(info)) f.close() f2 = open("test.test","r") data = json.loads(f2.read()) # dumps 多次以后，不能使用loads；必须只有dumps一次，loads一次 print(data["age"]) # 如果想存好几个状态，就只能存好几个文件
pickle（反）序列化：
import pickle def sayhi(name): print("hello,",name) info = { "name": "alex", "age":22, "func":sayhi } f = open("test.test","wb") # 二进制文件 f.write(pickle.dumps(info)) # 字典 转 bytes,不是写入的乱码噢 # = pickle.dump(info,f) print(type(pickle.dumps(info))) # bytes f.close() #def sayhi(name): # print("hello,",name) # print("hello2,",name) f2 = open("test.test","rb") data = pickle.loads(f2.read()) # bytes 转 字典 print(type(data)) # dict print(data["func"]("AAA")) f2.close()
shelve 模块
shelve模块是一个简单的 key, value 将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式
import shelve def stu_data(name,age): print("register stu",name,age) name = ["alex","roger","vivian"] info = { "name":"alex", "age":22 } d = shelve.open("shelve_test") d["test"] = name # 持久化列表 d["info"] = info d["func"] = stu_data d.close()
import shelve def stu_data(name,age): print("Yoo! register stu",name,age) f = shelve.open("shelve_test") print(f["test"]) print(f["info"]) print(f["func"]("david",23)) f.close()
xml 模块
xml是实现不同语言或程序之间进行数据交换的协议（xml协议在各个语言里都支持），跟json差不多，但json使用起来更简单
至今很多传统公司如金融行业的很多系统的接口还主要是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>
创建/增：
import xml.etree.ElementTree as ET # 创建/增加 namelist = ET.Element("NameList") # 创建根节点 name = ET.SubElement(namelist,"name",attrib={"whatever":"yes","name":"Alex"}) age = ET.SubElement(name,"age") age.text = "22" role = ET.SubElement(name,"role") role.text = "teacher" name2 = ET.SubElement(namelist,"name",attrib={"name":"SanPao"}) age = ET.SubElement(name2,"age") age.text = "22" role = ET.SubElement(name2,"role") role.text = "teacher" et = ET.ElementTree(namelist) #生成文档对象 et.write("text3.xml",encoding="utf-8",xml_declaration=True) ET.dump(namelist) # 打印生成的格式
删除：
import xml.etree.ElementTree as ET for country in root.findall('country'): rank = int(country.find('rank').text) if rank > 50: root.remove(country) # 删除xml文档内容country tree.write('output.xml')
修改：
import xml.etree.ElementTree as ET # 修改 for node in root.iter("year"): new_year = int(node.text) +1 node.text = str(new_year) # 改text node.set("check","yes") # 更属性 tree.write("xmltest.xml")
查找：
import xml.etree.ElementTree as ET tree = ET.parse("test.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.attrib,i.text) #只遍历year 节点 for node in root.iter('year'): print(node.tag,node.attrib,node.text) # or for child in root: print(child.tag, child.attrib) for i in child.iter("year"): print(i.tag,i.attrib,i.text)
configparser 模块
用于生成和修改常见配置文档
软件的常见文档格式：
[DEFAULT] ServerAliveInterval = 45 Compression = yes CompressionLevel = 9 ForwardX11 = yes [bitbucket.org] User = hg [topsecret.server.com] Port = 50022 ForwardX11 = no
创建/增：
import configparser # 创建/增加 config = configparser.ConfigParser() config["DEFAULT"] = {'ServerAliveInterval': '45', 'Compression': 'yes', 'CompressionLevel': '9'} config['DEFAULT']['ForwardX11'] = 'yes' # 增加的 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 sec = config.add_section('wupeiqi') # 增加的 with open('config.ini', 'w') as f: config.write(f)
删除：
import configparser # 删除 config.remove_option(section_name,"forwardx11") config.write(open("config2.ini","w"))
修改：
import configparser # 修改 config.set(section_name,"host port","3000") config.write(open("config2.ini","w"))
查找：
import configparser # 读/查 config = configparser.ConfigParser() config.read("config.ini") print(config.sections()) #print(config.defaults()) print(config.has_section('wupeiqi')) # or print(config['bitbucket.org']['User']) # or print(config.sections()[1]) section_name = config.sections()[1] print(config[section_name]["host port"]) print(config.options(section_name)) # 打印自己的和全局的key # 循环 for i in config["bitbucket.org"]: # 循环自己的和全局的key print(i) for i,v in config["bitbucket.org"].items(): # 打印自己的和全区的key+value print(i,v) # or print(config.items(section_name)) # 打印自己的和全区的key+value
hashlib 模块
用于加密相关的操作
主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法：
import hashlib # 不同的算法 # ######## md5 ######## hash = hashlib.md5() hash.update(b'admin') print(hash.hexdigest()) # ######## sha1 ######## hash = hashlib.sha1() hash.update(b'admin') print(hash.hexdigest()) # ######## sha256 ######## 这个用的比较多, 比md5安全 hash = hashlib.sha256() hash.update(b'admin') print(hash.hexdigest()) # ######## sha384 ######## hash = hashlib.sha384() hash.update(b'admin') print(hash.hexdigest()) # ######## sha512 ######## 比较慢 hash = hashlib.sha512() hash.update(b'admin') print(hash.hexdigest())
ps：
import hashlib >>>m = hashlib.md5() >>>m.update(b"alex") >>>print(m.hexdigest()) 534b44a19bf18d20b71ecc4eb77c572f >>> >>>m.update(b"li") >>>print(m.hexdigest()) 5f48164ebf9ea14d675ff31bce71c7da >>> >>> >>> >>>m2 = hashlib.md5() >>>m2.update(b"alexli") >>>print(m2.hexdigest()) 5f48164ebf9ea14d675ff31bce71c7da # 与上面分开update的“alexli”一致
hmac模块：
散列消息鉴别码，简称HMAC，用于网络消息加密传输。双方先要约定好key，然后P1用key加密并发送，P2用key ＋ 消息明文进行加密，再与P1的消息对比，来验证消息的真实性
import hmac h = hmac.new(b'salt', b'hello') # key,msg,digestmod print(h.hexdigest())
logging 模块
提供了标准的日志接口，存储各种格式的日志。
logging的日志可以分为 debug(), info(), warning(), error()，critical() 5个级别
| Level | When it’s used |
|---|---|
DEBUG |
Detailed information, typically of interest only when diagnosing problems. |
INFO |
Confirmation that things are working as expected. |
WARNING |
An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected. |
ERROR |
Due to a more serious problem, the software has not been able to perform some function. |
CRITICAL |
A serious error, indicating that the program itself may be unable to continue running. |
把日志写到文件：
import logging # 日志写到文件 logging.basicConfig(filename = "app.log",level = logging.DEBUG) logging.basicConfig(filename = "app.log",level = logging.WARNING) # 往后追加，只追加WARNING及WARNING以后的 logging.basicConfig(filename = "app.log", level = logging.WARNING, format = "%(asctime)s %(filename)s: %(lineno)d %(funcName)s %(levelname)s: %(message)s", datefmt='%m/%d/%Y %I:%M:%S %p') logging.debug("test debug") logging.info("test") # 单独打印没有输出，是因为模块有默认的日志级别 logging.warning("user [alex] attempted wrong password more than 3 times") logging.error("test error") logging.critical("server is down") def app_run(): logging.warning("app has been run too long") app_run()
关于日志格式：
|
%(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 |
用户输出的消息 |
既又写入文件，又在屏幕上打印：
import logging ### 既又写入文件，又在屏幕输出，同时 ### # create logger logger = logging.getLogger('TEST-LOG') logger.setLevel(logging.DEBUG) # 设置最低的等级 # create console handler and set level to debug ch = logging.StreamHandler() # 屏幕 ch.setLevel(logging.WARNING) # create file handler and set level to warning fh = logging.FileHandler("access.log",encoding="utf-8") # 日志 fh.setLevel(logging.ERROR) # create formatter ch_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 输出的屏幕格式 fh_formatter = logging.Formatter("%(asctime)s %(filename)s: %(lineno)d -- %(levelname)s: %(message)s")# 日志格式 # add formatter to ch and fh ch.setFormatter(ch_formatter) fh.setFormatter(fh_formatter) # 告诉logger 去两个地址去输出 # add ch and fh to logger logger.addHandler(ch) logger.addHandler(fh) logger.warning("warning commit") logger.error("error happend")
文件自动截断：
import logging
from logging import handlers
logger = logging.getLogger("TEST") #
log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3,encoding="utf-8") # 按大小截断
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3,encoding="utf-8") # 按时间截断
# interval是时间间隔。
# when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
# S 秒
# M 分
# H 小时
# D 天
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
import time
logger.warning("test1")
time.sleep(2)
logger.warning("test12")
time.sleep(2)
logger.warning("test13")
logger.warning("test14")
time.sleep(2)
logger.warning("test15")
logger.warning("test16")
re（正则表达式） 模块
经常用来处理字符串
常用正则表达式符号：
import re data = "c3R1c2FABCkabbbbb͸abaackjkjdb89y2abca" print(re.search("^c3",data)) # 匹配字符串开头 print(re.search("ca$",data)) # 匹配字符串结尾 print(re.findall("ab*",data)) # 匹配*号前的字符0次或多次 print(re.findall("ab+",data)) # 匹配前一个字符1次或多次 print(re.findall("ab?",data)) # 匹配前一个字符0次或1次 print(re.findall("ab{2}",data)) # 匹配前一个字符m次 print(re.findall("ab{1,5}",data)) # 匹配前一个字符n到m次 print(re.findall("abc|ABC",data)) # 匹配|左或右的字符 print(re.search("abc|ABC","ABCBCDabc").group()) # 字符串里哪个先出现就是哪个 print(re.search("(abc){2}a(123|456)c", "abcabca456c").group())# 分组匹配 print("----------------------------------------------------") print(re.search("Aalex","alexabc").group()) # 匹配字符开头，同^ print(re.search("abc","alexabc").group()) # 匹配字符结尾，同$ print(re.findall(".","a7b4c5jhh6986")) # 默认匹配除 之外的任意一个字符 print(re.findall(".","a7b4c5jh h69 86",flags = re.S)) print(re.findall("d","a7b4c5jhh6986")) # 匹配数字0-9 print(re.findall("d+","a7b4c5jhh6986")) # 匹配数字0-9 print(re.findall("D","a7b4c5jhh6986")) #匹配非数字 print(re.findall("w","#a7b4c5jhh6986%")) # 匹配[A-Za-z0-9] print(re.findall("W","#a7b4c5jhh6986%")) # 匹配非[A-Za-z0-9] 特殊字符 print(re.findall("s","ab c1 3")) # 匹配空白字符、 、 、 , 结果 ' ' print(re.search("s+","ab c1 3").group()) print("---------------------------------------------------- ") print(re.search("(?P<province>d{4})(?P<city>d{2})(?P<birthday>d{4})","371481199306143242").groups()) # 分组匹配 print(re.search("(?P<province>d{4})(?P<city>d{2})(?P<birthday>d{4})","371481199306143242").groupdict("city")) # 分组匹配
<_sre.SRE_Match object; span=(0, 2), match='c3'> <_sre.SRE_Match object; span=(39, 41), match='ca'> ['abbbbb', 'ab', 'a', 'a', 'ab', 'a'] ['abbbbb', 'ab', 'ab'] ['ab', 'ab', 'a', 'a', 'ab', 'a'] ['abb'] ['abbbbb', 'ab', 'ab'] ['ABC', 'abc'] ABC abcabca456c ---------------------------------------------------- alex abc ['a', '7', 'b', '4', 'c', '5', 'j', 'h', 'h', '6', '9', '8', '6'] ['a', '7', 'b', '4', 'c', '5', 'j', 'h', ' ', 'h', '6', '9', ' ', '8', '6'] ['7', '4', '5', '6', '9', '8', '6'] ['7', '4', '5', '6986'] ['a', 'b', 'c', 'j', 'h', 'h'] ['a', '7', 'b', '4', 'c', '5', 'j', 'h', 'h', '6', '9', '8', '6'] ['#', '%'] [' ', ' '] ---------------------------------------------------- ('3714', '81', '1993') {'province': '3714', 'city': '81', 'birthday': '1993'}
常用的匹配语法：
import re # findall print(re.findall("d+","c3R1c2FkamZoYWpza2ZuYXNkZndoZWlxa253ZXdpNzI5Mzg3NDkyNHdoZTkyM28yandlZgo"))# 找出按要求所有的对象 并 返回一个list tt = "Tina is a good girl, she is cool, clever, and so on..." print(re.findall('w*oow*',tt)) #print(re.findall(r'w*oow*',tt)) # match print(re.match("com","comwww.runcomoob").group())# 从头开始match，开头如果有，返回match的对象；开头如果没有，则出错 # search print(re.search('dcom','www.4comrunoob.5com').group()) # 在字符串里查找，找到第一个匹配值就返回这个值，没找到就出错 print(re.search("(d{1,3}.){3}d{1,3}","inet 地址: 192.168.12.55 广播：192.168.12.255").group()) # split print(re.split('d+','one1two22three3four4five5')) # 按要求隔开字符串 # sub text = "Jason is a handsome boy." print(re.sub(r's+', '-', text)) print(re.sub(r's+', '-', text,count=2)) # re.sub(pattern, repl, string, count) # 其中第二个函数是替换后的字符串；本例中为'-' # 第四个参数指替换个数。默认为0，表示每个匹配项都替换 # 反斜杠 print(re.split("\\",r"c:userapplePycharmProjects")) # ps print(re.split('a','ABC',flags = re.I)) # 忽略大小写 print(re.search(r"^a"," abc eee",flags=re.MULTILINE))# 多行模式
['3', '1', '2', '2', '253', '5', '3', '28'] ['good', 'cool'] com 4com 192.168.12.55 ['one', 'two', 'three', 'four', 'five', ''] Jason-is-a-handsome-boy. Jason-is-a handsome boy. ['c:', 'user', 'apple', 'PycharmProjects'] ['', 'BC'] <_sre.SRE_Match object; span=(1, 2), match='a'>