python 模块

1 time模块

在python中,通常有三种表示时间的方式:时间戳、格式化时间字符串、结构化时间。

1 时间的表示方式

  1. 时间戳
         通常来说,时间戳表示的是从1970年1月1日08:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。为什么要有这样一种表示法呢?因为计算机不像人,有“年月日”的概念,这样一种秒的表示法,是为了给计算机来读
print(time.time())    #结果:1493622474.759625
  1. 格式化时间字符串(Format String)
         是为了给人看的
print(time.strftime("%Y-%m-%d %X"))   #结果:2017-05-01 15:14:03
  1. 结构化时间(struct_time)
         用来对时间进行操作
         struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)
print(time.localtime())    #默认的参数是当前的时间戳
t=time.localtime()
print(t.tm_year,t.tm_mon,t.tm_mday)

结果:

time.struct_time(tm_year=2017, tm_mon=5, tm_mday=1, tm_hour=15, tm_min=17, tm_sec=18, tm_wday=0, tm_yday=121, tm_isdst=0)
2017 5 1
  1. 其他
print(time.clock())  #以浮点数计算的秒数返回当前的CPU时间
                      #用于测试程序运行时间

2 几种时间的形式转换

先讲讲localtime和gmtime的区别:

print(time.localtime())

print(time.gmtime())

结果:

time.struct_time(tm_year=2017, tm_mon=5, tm_mday=1, tm_hour=15, tm_min=27, tm_sec=1, tm_wday=0, tm_yday=121, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=1, tm_hour=7, tm_min=27, tm_sec=1, tm_wday=0, tm_yday=121, tm_isdst=0)

他们都是结构化时间的表示法,但两者相差8个小时。

time.localtime()获取的是当前地区时间(东8区,北京时间) (推荐)
time.gmtime()获取的是世界标准时间(格林尼治时间)

#时间戳->结构化时间
print(time.localtime(3600*24))   #time.struct_time(tm_year=1970, tm_mon=1, tm_mday=2, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=2, tm_isdst=0)

#时间戳<-结构化时间
print(time.mktime(time.localtime()))   #1493624339.0


#结构化时间->格式化时间
print(time.strftime("%Y-%m-%d %X",time.localtime()))    #2017-05-01 15:40:46

#结构化时间<-格式化时间
print(time.strptime("2017-03-30","%Y-%m-%d"))   #time.struct_time(tm_year=2017, tm_mon=3, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=89, tm_isdst=-1)

#结构化时间和时间戳->格式化时间
print(time.ctime(time.time()))     #Mon May  1 15:50:25 2017

print(time.asctime(time.localtime()))     #Mon May  1 15:50:25 2017
  

2 random模块

import random

print(random.random())  #大于0小于1的小数

print(random.randint(1,3))  #大于等于1小于等于3的小数


print(random.randrange(1,3))    #大于等于1小于3的小数

print(random.choice([1,3,5,7]))   #从序列随机选取一个
#3

print(random.sample([1,2,3,4,5],2))  #从序列随机选取2个
#[2, 3]

print(random.uniform(1,3))    #大于1小于3的小数
#1.66606716724746

li=[1,2,3,4,5]
random.shuffle(li)   #随机将顺序打乱
print(li)
#[1, 5, 4, 2, 3]

练习:生成验证码

#随机生成5个a-z A-Z 0-9的数

import random

def v_code():
    code=""
    for i in range(5):
       r1= random.randint(0,9)
       r2=chr(random.randint(97,122))
       r3=chr(random.randint(65,90))
       r=random.choice([str(r1),r2,r3])
       code+=r
    print(code)

v_code()      #cp8rX

3 hashlib

     python的hashlib提供的常用摘要算法,如MD5,SHA1等。
     什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的bytes数据转换为一个长度固定的数据串(通常用16进制的字符串表示)
     摘要算法是通过摘要函数对任意长度的bytes数据data计算出规定长度的摘要digest,目的是为了检查原始数据是否被人篡改过
     摘要算法之所以能指出数据是否被篡改过,就是因为摘要函数是一个单向函数,计算f(data)很容易,但通过digest反推data却非常困难。而且,对原始数据做一个bit的修改,都会导致计算出的摘要完全不同。

     以常见的摘要算法MD5为例,计算出一个字符串的MD5值:

import hashlib

m5=hashlib.md5()
m5.update("egg".encode("utf-8"))
print(m5.hexdigest()) 
#结果:0e9312087f58f367d001ec9bae8f325a

     如果数据量巨大,可以分块多次调用update():

l=hashlib.md5()
l.update(b"110")
l.update(b"egg")
#可以合并着写,结果一样:l.update(b"110egg")
print(l.hexdigest()) 
#5a680543e062ec341ecf6b0047246a80

     用于常用的口令的MD5很容易被计算出来。所以,在存储用户口令时,会对原始口令加一个复杂字符串来实现,俗称“加盐”

m=hashlib.md5(b"110")   #加盐
m.update(b"egg")
print(m.hexdigest())
#5a680543e062ec341ecf6b0047246a80

注意:文件体积越大,计算摘要的时间也越长。通常把大体积的文件,分成多块,再来计算摘要。


4 os模块

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

os.walk(path) 以迭代器的形式返回当前目录下的子文件夹和子文件名
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.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.path.getsize(path) 返回path的大小

5 sys模块

sys模块是python解释器的

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

6 序列化

http://www.cnblogs.com/yangzhenwei123/p/6802018.html

7 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

     日志的等级(由低到高):NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL
     在默认情况下,python中的logging模块是将日志打印到标准输出,且只显示大于等于WARNING级别的日志,默认的日志格式为日志级别:Logger名称:用户:输出消息。

1 配置日志级别,日志格式,输出位置

logging.basicConfig(level=logging.INFO,  #调节日志打印等级
                    format="%(asctime)s %(filename)s [line:%(lineno)d]  %(levelname)s %(message)s",
                    datefmt="%a %d %b %Y  %H:%M:%M",    #调节上面%(asctime)s 显示的时间格式
                    filename="test.log",   #把日志定向到文件名 ,config只能选择一种显示方式:屏幕或文件
                   # filemode="a",      #文件的写模式 "w"和"a",默认追加写
                   )

logging.debug("debug message")
logging.info("info message")
logging.warning("waring message")
logging.error("error message")
logging.critical("critical message")

test.log文件的内容:

Mon 01 May 2017  17:17:17 logging_module.py [line:26]  INFO info message
Mon 01 May 2017  17:17:17 logging_module.py [line:28]  WARNING waring message
Mon 01 May 2017  17:17:17 logging_module.py [line:30]  ERROR error message
Mon 01 May 2017  17:17:17 logging_module.py [line:32]  CRITICAL critical message

在logging.basicConfig()函数中可通过具体参数来修改logging模块的默认设置:
filename:用来指定文件名创建FileHandler(后边会具体讲解handler的概念),将日志文件重定向到文件。默认是标准输出。
filemode:文件的打开模式,默认是“a”,还可以指定为“w”。
format:指定handler使用的日志显示格式。
datefmt:指定日期格式时间。
leverl:设置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 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)

logger=logging.getLogger()  #产生一个logger对象

logger.setLevel(logging.INFO)   #设置日志的等级

fh=logging.FileHandler("logger2.log")   #产生一个要存储日志的文件的句柄
sh=logging.StreamHandler()   #产生一个流(打印到屏幕)句柄

formatter=logging.Formatter("%(asctime)s %(filename)s [line:%(lineno)d]  %(levelname)s %(message)s")

fh.setFormatter(formatter)
sh.setFormatter(formatter)

logger.addHandler(fh)   #给日志对象添加一个日志文件句柄,将日志输出定向到日志文件
logger.addHandler(sh)   #给日志对象添加一个流句柄,将日志输出定向到屏幕文件

#不同于config只能定向到屏幕或者文件,logger对象能同时定向到这两个。所以推荐使用logger

logger.debug("debug message")

logger.info("info message")

logger.warning("waring message")

logger.error("error message")

logger.critical("critical message")

结果:

2017-05-01 18:00:56,892 logging_module.py [line:61]  INFO info message
2017-05-01 18:00:56,892 logging_module.py [line:63]  WARNING waring message
2017-05-01 18:00:56,892 logging_module.py [line:65]  ERROR error message
2017-05-01 18:00:56,892 logging_module.py [line:67]  CRITICAL critical message

     logging库提供了多个组件:Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口,Handler发送日志到适当的目的地,Filter提供了过滤日志信息的方法,Formatter指定日志显示格式。
     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()输出不同级别的日志,只有日志等级大于或等于设置的日志级别的日志才会被输出。

import logging

logger1=logging.getLogger("mylogger1")
logger1.setLevel(logging.DEBUG)
logger2=logging.getLogger("mylogger1")
logger2.setLevel(logging.INFO)
fh=logging.FileHandler("logger1.log")
sh=logging.StreamHandler()

formatter=logging.Formatter("%(asctime)s %(filename)s [line:%(lineno)d]  %(levelname)s [%(name)s] %(message)s")

fh.setFormatter(formatter)
sh.setFormatter(formatter)

logger1.addHandler(fh)
logger1.addHandler(sh)

logger2.addHandler(fh)
logger2.addHandler(sh)

logger1.debug("debug message")
logger1.info("info message")
logger1.warning("waring message")
logger1.error("error message")
logger1.critical("critical message")

logger2.debug("debug message")
logger2.info("info message")
logger2.warning("waring message")
logger2.error("error message")
logger2.critical("critical message")

结果:

2017-05-01 21:05:43,001 logging_module.py [line:92]  INFO [mylogger1] info message
2017-05-01 21:05:43,001 logging_module.py [line:93]  WARNING [mylogger1] waring message
2017-05-01 21:05:43,001 logging_module.py [line:94]  ERROR [mylogger1] error message
2017-05-01 21:05:43,001 logging_module.py [line:95]  CRITICAL [mylogger1] critical message
2017-05-01 21:05:43,001 logging_module.py [line:98]  INFO [mylogger1] info message
2017-05-01 21:05:43,001 logging_module.py [line:99]  WARNING [mylogger1] waring message
2017-05-01 21:05:43,001 logging_module.py [line:100]  ERROR [mylogger1] error message
2017-05-01 21:05:43,001 logging_module.py [line:101]  CRITICAL [mylogger1] critical message

      logger1和logger2对应同一个Logger实例。所以后一次的设置setLevel()会覆盖前一次设置的值。

import logging

logger1=logging.getLogger()

logger2=logging.getLogger("mylogger1")

fh=logging.FileHandler("logger1.log")
sh=logging.StreamHandler()

formatter=logging.Formatter("%(asctime)s %(filename)s [line:%(lineno)d]  %(levelname)s [%(name)s] %(message)s")

fh.setFormatter(formatter)
sh.setFormatter(formatter)

logger1.addHandler(fh)
logger1.addHandler(sh)

logger2.addHandler(fh)
logger2.addHandler(sh)

logger1.debug("debug message")
logger1.info("info message")
logger1.warning("waring message")
logger1.error("error message")
logger1.critical("critical message")

logger2.debug("debug message")
logger2.info("info message")
logger2.warning("waring message")
logger2.error("error message")
logger2.critical("critical message")

结果:

2017-05-01 21:14:17,051 logging_module.py [line:93]  WARNING [root] waring message
2017-05-01 21:14:17,051 logging_module.py [line:94]  ERROR [root] error message
2017-05-01 21:14:17,051 logging_module.py [line:95]  CRITICAL [root] critical message
2017-05-01 21:14:17,051 logging_module.py [line:99]  WARNING [mylogger1] waring message
2017-05-01 21:14:17,051 logging_module.py [line:99]  WARNING [mylogger1] waring message
2017-05-01 21:14:17,051 logging_module.py [line:100]  ERROR [mylogger1] error message
2017-05-01 21:14:17,051 logging_module.py [line:100]  ERROR [mylogger1] error message
2017-05-01 21:14:17,051 logging_module.py [line:101]  CRITICAL [mylogger1] critical message
2017-05-01 21:14:17,051 logging_module.py [line:101]  CRITICAL [mylogger1] critical message

      通过logger1 = logging.getLogger()显示的创建了root Logger,而logger2 = logging.getLogger('mylogger1')创建了root Logger的孩子(root.)mylogger1。而孩子,孙子,重孙……既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。
      孩子,孙子,重孙……可逐层继承来自祖先的日志级别、Handler、Filter设置,也可以通过Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。设置自己特别的日志级别、Handler、Filter。若不设置则使用继承来的值。

3 Filter

      限制只有满足过滤规则的日志才会输出。
      比如我们定义了filter = logging.Filter('a.b.c'),并将这个Filter添加到了一个Handler上,则使用该Handler的Logger中只有名字带 a.b.c前缀的Logger才能输出其日志。

filter = logging.Filter('mylogger')

logger.addFilter(filter)

这是只对logger这个对象进行筛选

如果想对所有的对象进行筛选,则:

filter = logging.Filter('mylogger')

fh.addFilter(filter)

ch.addFilter(filter)

这样,所有添加fh或者ch的logger对象都会进行筛选。

logging模块http://www.cnblogs.com/yuanchenqi/articles/5732581.html

8 re模块

我们以前对字符串的处理,如调用内置的字符串方法,这种叫完全匹配
而正则表达式提供的是模糊匹配
正则表达式是通过元字符来进行模糊匹配的。

1 常用的元字符: . * + ? {} [] \ () | ^ $

# .   匹配除\n换行以外的任何符号
# *   左边的一个符号 有0个或以上
# +   左边的一个符号 有1个或以上
# ?  左边的一个符号 有0个或1个
#{n}    左边的一个符号 有n个
#{n,}   左边的一个符号 有n个或以上
#{n,m}   左边的一个符号 有n到m个
# ^    以什么开始
# $   以什么结尾
# |  或者          a|b  a或b

#[]  字符集  从字符集里取一个出来   或
            #把大部分符号都变成普通符号,如* , +
            #部分有特殊意义 -  ^  \

# \   转义符   可以把没有特殊意义的符号变成有特殊意义的符号,也可以把有特殊意义的符号变成没有特殊意义的符号。


2 或 |

| 会把规则表达式分成多个部分来匹配。通常与()配合使用

res=re.findall("www\.(?:oldboy)|(?:baidu)\.com","www.oldboy.com")   #此时|把匹配规则分成前后两个部分
print(res)       #['www.oldboy']

res=re.findall("www\.(?:oldboy|baidu)\.com","www.oldboy.com")
print(res)     #['www.oldboy.com']

3 元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\d

\d  匹配任何十进制数;它相当于类 [0-9]。
\D 匹配任何非数字字符;它相当于类 [^0-9]。
\s  匹配任何空白字符;它相当于类 [ \t\n\r\f\v]。
\S 匹配任何非空白字符;它相当于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符;它相当于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9_]
\b  匹配一个特殊字符边界,比如空格 ,&,#等#### 元字符之转义符\

转义\时,需要注意:

#print(re.findall("c\l","abc\l"))   #sre_constants.error: bad escape \l at position 1

#在python,\是有特殊意义的,要打"\",需要"\\",前面那个"\"把后面那个转义成普通符号
#print(re.findall(r"c\l","abc\l"))  #sre_constants.error: bad escape \l at position 1

#此时仍然会报错,因为正则处理的时候,"\"也是转义符,需要用"\\",最后书写时则需要四个(3个也可以)
print(re.findall("c\\\\l","abc\l"))

#如果不用上述,也可以用r,原生字符串来处理
print(re.findall(r"c\\l","abc\l"))    #['c\\l']

      由此可见,解释器执行正则表达式时,会先把规则部分转义一次,再交由正则处理。所以如果需要转义,那么规则部分转义两次。字符串表达式(要处理的)部分转义一次,且字符串部分如果\与右边的字符(或字符串)在ascii表没有对应,那么此时""不发生转义,代表普通的"",如\l表示"\l"两个字符,此时转不转义左边的""都不会出错。但要注意是数字的情况,"\数字"通常都会发生转义,此时必须写双斜杠"\",如ord("\5") ,结果是5;ord("\127") ,结果是87。也可以注意pycharm中这些字符颜色的变化,就能避免这个问题。

4 分组()

  • 未命名分组
    注意:如果规则里面有多个未命名分组,这些分组会被封装在一个元组中
print(re.findall("(ab)+def","abababdef"))   #['ab']

print(re.findall("(\d)+def","123456def"))    #['6']

print(re.findall("(?:ab)+def","abababdef"))    #['abababdef']

分组()的优先级比其他的元字符的高,默认情况匹配成功,只返回分组内的值。在括号内添加“?:”,可以取消分组的优先级。

  • 命名分组
res=re.search(r"(?P<author>yuanchenqi)/articles/(?P<id>\d+)",r"http://www.cnblogs.com/yuanchenqi/articles/5732581.html")
print(res)    #如果能找到,就返回<_sre.SRE_Match object; span=(23, 50), match='yuanchenqi/articles/5732581'>
              #不能找到就返回None
print(res.group("author"))    #yuanchenqi
print(res.group("id"))      #5732581

此时,相当于给分组添加了别名,可通过别名来提取分组内的匹配条件。

5 re模块提供的匹配的方法:

正则表达式的语法:re.func("regulation","string_expression")

# re.findall() 返回的是列表
s=re.findall("\d+","ad324ds434")
print(s)   #['324', '434']


# re.finditer()
#将结果以迭代器返回
s=re.finditer("\d+","ad324ds434")
#print(s)  <callable_iterator object at 0x000001FC5D932908>

print(next(s))    #<_sre.SRE_Match object; span=(2, 5), match='324'>
print(next(s).group())    #434


#re.search() 只获取匹配的第一个结果,以字符串形式返回
res=re.search("\d+","ad324ds434")
print(res.group())  #324
print(res.group())  #324


#re.match()  只在字符串开始的位置匹配,没有就报错
res=re.match("\d+","2323ad324ds434")
print(res.group())    #2323


#re.split()  以“规则”为分隔符,返回列表(类比字符串里的split())
s=re.split("\d+","fhd56fdfg787ttrtf7878grtr789",2)
print(s)    #['fhd', 'fdfg', 'ttrtf7878grtr789']

s=re.split("l","hello world")
print(s)   #['he', '', 'o wor', 'd']


#re.sub()  替换
res=re.sub("[a-z]","A","32dsfef4343fde434f445f3re",2)
print(res)    #32AAfef4343fde434f445f3re


#re.subn()  替换,返回替换后的结果并且返回替换的次数,以元组方式返回
res=re.subn("[a-z]","A","32dsfef4343fde434f445f3re")
print(res)      #('32AAAAA4343AAA434A445A3AA', 12)


#re.compile("规则")  并用返回的对象去调用上面的方法。
print(re.findall("\d+","dwe32343dwr434f545"))
res=re.compile("\d+")
ret=res.findall("fefer34343fe443fe433")
print(ret)

6 贪婪匹配和非贪婪匹配

  1. 贪婪匹配,即最大长度的匹配结果
    贪婪匹配的量词,也叫匹配优先量词,如{m,n} 、 {m} 、 ? 、 * 、 +
print(re.findall("\d+","123456def243545dghh434"))    #['123456', '243545', '434']
  1. 非贪婪匹配(懒惰模式)
    匹配优先量词后加上“?”,即变成属于非贪婪模式的量词,也叫做忽略优先量词。有{m,n}?、{m,}? 、?? 、*? 和 +?。即在匹配优先量词后面添加?。
    非贪婪模式,就是在整个表达式匹配成功的前提下,尽可能少的匹配,也就是所谓的“非贪婪”,通俗点讲,就是找到一个想要的捡起来就行了,至于还有没有没捡的就不管了。
# print(re.findall("\d+?","123456def243545dghh434"))

#['1', '2', '3', '4', '5', '6', '2', '4', '3', '5', '4', '5', '4', '3', '4']

贪婪匹配和非贪婪匹配 http://www.jb51.net/article/31491.htm

模块的相关链接:http://www.cnblogs.com/yuanchenqi/articles/5732581.html
http://www.cnblogs.com/yuanchenqi/articles/6766020.html

posted @ 2017-05-03 15:14  思否丶  阅读(224)  评论(0编辑  收藏  举报
return