pytho day6 <正则表达式、常用模块、反射>

本节介绍：

一：正则表达式：

正则表达并不是python 独有的。在各个语言里都有该语法的介绍。正则表达是处理字符串的强大的处理工具。拥有自己的独特的

处理方法。和处理引擎。虽然性能没有python 字符串自己函数和方法。但是由于功能强大。

如上：正则表达式的大致匹配过程是：一次拿出表达式和文本中的字符进行比较，如果没个字符都能匹配，则匹配成功

否则匹配失败。

正则表达式其实是含有文本和特殊字符的字符串，这些文本和特殊字符的模式可以识别各种字符串。

正则表达式的匹配分两种情况：搜索和匹配。搜索search 是在在字符串任意位置查找到匹配的模式。匹配（match）在字符串开始全部或者一部分找到匹配模式。

正则表达式支持的元字符和语法：

.   匹配任意除换行符'\n'外的字符。在DOTALL模式中也能匹配换行符。

 import re
 str_a='abcdb'
 pp=re.findall('a.c',str_a)
 print(pp)
 ['abc']

\ 转义符。使后一个字符改变，变为原先的含义。如果字符创中有字符*可以用\*或者[*]进行匹配。

 import re
 str_a='ab*db'
 pp=re.findall('.\*.',str_a)
 print(pp)
 ['b*d']

 import re
 str_a='ab*db'
 pp=re.findall('.[*].',str_a)
 print(pp)
 ['b*d']

[...] 字符集（字符类）.对应的位置可以是字符集中的任意一个字符。字符集中的字符可以逐个列出来，也可以指定范围如[abc]或者[a-c]。第一个字符如果^表示取反，如[^abc]表示不是abc其他的字符。

所有特殊字符在[]中都失去原先的特殊含义。在字符集中如果使用]、-或^可以用转义符\进行转移。或把]   、-放在第一个字符，^ 放在非第一个字符位置。

 import re
 str_a='ab*db'
 pp=re.findall('[a*b]',str_a)#满足字符集中[]任意一个字符就输出。
 print(pp)
 ['a', 'b', '*', 'b']

import re
str_a='ac*db'
pp=re.findall('[^ab]',str_a)#表示非ab字符以外的字符
print(pp)
['c', '*', 'd']

 import re
 str_a='ac.db'
 pp=re.findall('[^.ab]',str_a)
 print(pp)
 ['c', 'd']

预定义字符集（可以写在字符集[]中）

\d  表示数字[0-9]

 import re
 str_a='ac.d65b'
 pp=re.findall('[d\db]',str_a)
 print(pp)
 ['d', '', '', 'b']

 import re
 str_a='ac.d6b'
 pp=re.findall('d\db',str_a)
 print(pp)
 ['d6b']

\D 表示非数字[^\d]

import re
str_a='ac.d6bdab'
pp=re.findall('d\Db',str_a)
print(pp)
['dab']

 import re
 str_a='ac.d6bdab'
 pp=re.findall('[\D]',str_a)
 ppr1=re.findall('[^\d]',str_a)
 print(pp)
 print(ppr1)
 ['a', 'c', '.', 'd', 'b', 'd', 'a', 'b']
 ['a', 'c', '.', 'd', 'b', 'd', 'a', 'b']

import re
str_a='ac.d6bdab'
ppr1=re.findall('d\db',str_a)
print(ppr1)
['d6b']

\s 空白字符：[空格 \t \r \n \f\v]

 import re
 str_a='ac \nd6bdab'
 ppr1=re.findall('ac\s\sd',str_a)
 print(ppr1)
 ['ac \nd

\S 表示非空白字符。[^\s]

import re
str_a='ac \nd6bdab'
ppr1=re.findall('[^\s]',str_a)
ppr2=re.findall('[\S]',str_a)
print(ppr1)
print(ppr2)
['a', 'c', 'd', '', 'b', 'd', 'a', 'b']
['a', 'c', 'd', '', 'b', 'd', 'a', 'b']

\w 表示单词字符 [a-z,A-Z ,0-9]

 import re
 str_a='ac \nd6bdab'
 ppr1=re.findall('[\w]',str_a)
 ['a', 'c', 'd', '', 'b', 'd', 'a', 'b']

\W表示非单词字符[^\w]

 import re
 str_a='ac \nd6bdab'
 ppr1=re.findall('[\W]',str_a)

 [' ', '\n']

数量词 用在字符或者（...）之后。

* 表示匹配前一个字符0个或者无限个。

 import  re
 a='ccaaaccaa'
 t=re.findall('a*',a)
 print(t)
 ['', '', 'aaa', '', '', 'aa', ''] #返回一个列表结果集合如果没匹配直接返回None

+表示前一个字符出现一次或者多次。

 import  re
 a='ccaaaccaa'
 t=re.findall('a+',a)
 print(t)
 ['aaa', 'aa'] 

?表示前一个字符出现0次或者1次。

 import  re
 a='ccaaaccaa'
 t=re.findall('a?',a)
 print(t)
 ['', '', 'a', 'a', 'a', '', '', 'a', 'a', '']

{n}表示前一个字符出现的次数。也可以指定出现次数限制{n,m}

 import  re
 a='ccaaaccaa'
 t=re.findall('ca{3}',a)
 print(t)
 ['caaa']

 import  re
 a='ccaaaccaa'
 t=re.findall('ca{2,3}',a)
 print(t)
 ['caaa', 'caa']

^不在字符集[]中表示以什么开头，在字符集中表示非字符集中字符以外的意思。也可以用\A 也表示以什么开头。这么写是为了没有caret键盘使用的。

 import  re
 a='caaaccaa'
 t=re.findall('^ca',a)
 print(t)
 ['ca']

 import  re
 a='caaaaab'
 t=re.findall('[^c,a]',a)
 print(t)
 ['b']

$表示以前一个字符结尾。或者以\Z  也表示以什么结尾的。

 import  re
 a='caaaaab'
 t=re.findall('.+b$',a)
 print(t)
 ['caaaaab']

re1|re2表示符合re1模式或者符合re2模式的正则的表达式。

 import  re
 a='caaaaab'
 t=re.findall('^c|b$',a)
 print(t)
 ['c', 'b']

[^....]表示匹配除字符集中任意字符之外的字符。字符集里可以是范围，也可以是枚举的字符。

 import  re
 a='caaaaab'
 t=re.findall('[^a]',a)
 print(t)
 ['c', 'b']

 import  re
 a='caaaaab'
 t=re.findall('[^a,b]',a)
 print(t)
 ['c']

 import  re
 a='caaaaabd'
 t=re.findall('[^a-c]',a)
 print(t)
 ['d']

(....)匹配括号里的正则表达式，并形成子组、就是对一个正则表达式的匹配结果进行再次分组匹配。

 import  re
 a='1+2+(2-(1+3))'
 t=re.findall('\(([^(,)]+)\)',a)
 print(t)
 ['1+3']

外层表达是匹配带()然后分组里的表达式是：且不包含()的字符串。

\b 或者\B 表示的是单词边界。\b表示无论在字符串的开头还是符串的中间，都可以进行匹配。

需要注意是前面需要用r元字符，表示后面的正则表达式是原始字符串进行处理而不进行转义。只有在\b模式情况下 需要这么做。因为在ASSIC 中 \b表示退格符(backspace)也就是08 需要加入r表示在处理时候把\b不进行转义当做原始字符串处理。

 import  re
 a='abc d the cccc'
 t=re.findall(r'\babc\b',a)#需要注意是前面需要用r元字符，表示后面的正则表达式是原始字符串进行处理而不进行转义。只有在\b模式情况下 需要这么做。还有\b前后需要单词边界也就是说是空格或者其他隔开
 print(t)
 ['abc']

 import  re
 a='abc d the cccc'
 t=re.findall(r'\bthe\b',a)
 print(t)
 ['the']

 import  re
 a='abc d the cccc'
 t=re.findall('\Bthe\B',a)
 print(t)
 []

 import  re
 a='abc dthecccc'
 t=re.findall('\Bthe\B',a)
 print(t)
 ['the']

 import  re
 a='thecccc'
 t=re.findall('\Bthe\B',a)
 print(t)
 []

需要注意\B \B之间只能匹配字符串中的字符，而且前后需要的字符不可以是空格，不能匹配开头。

特殊情况：

元字符?在+ 、*的后面表示匹配的字符串越短越好。在其他的字符前面也表示越短越好。

 import  re
 a='caaabd'
 t=re.search('a+',a)
 print(t)
 <_sre.SRE_Match object; span=(1, 4), match='aaa'>

 import  re
 a='caaabd'
 t=re.search('a+?',a)
 print(t)
 <_sre.SRE_Match object; span=(1, 2), match='a'>

re模块函数：

1：findall

findall,获取非重复的匹配列表；如果有一个组则以列表的形式返回，且每个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每个匹配均是元组；

空的匹配也会包含在结果中。findall(pattern,string,flags=0)

 import  re
 a='acdd4.wee2'
 r=re.findall('\.w.+',a)
 print(r)
 ['.wee2']

 import  re
 a='acdd4.wee2'
 r=re.findall('(\.)w.+',a)
 print(r)
 ['.']

 import  re
 a='acdd4.wee2'
 r=re.findall('\.(w)(.+)',a)
 print(r)
 [('w', 'ee2')]

 origin = "hello tom bcd abcd lge acd 19"
 t = re.findall("a((\w*)c)(d)", origin)
 print(t)
 [('bc', 'b', 'd'), ('c', '', 'd')]

2：sub函数，是指正则匹配模型中，将匹配成功的字符串替换。

sub(pattern,repl,string,count=0,flags=0)

pattern:正则模型

repl：要替换的字符串或者可执行对象。（替换成什么对象或者字符串！）

string：要匹配的字符串。

count：匹配的次数。

flags：匹配模式。

与分组无关。

 import re
 a = 'acderf23f'
 r=re.sub('^a.{2}',"",a,1)
 print(r）
 000erf23f

3：split函数

根据正则表达式的匹配的字符串进行切割。

split(pattern,string,maxsplit=0,flags=0)

pattern:正则模型

string：要匹配的字符串

maxsplit：指定分割个数0表示全部切割。默认是0。

flags：匹配模式。

 a = 'acderf23f'
 r=re.split('de.{2}',a)
 print(r)
 ['ac', '23f']

 import re
 a = 'acderf23faaadeccc'
 r=re.split('de.{2}',a,1)
 print(r)
 ['ac', '23faaadeccc']

import re
a = 'acderf23faaadeccc'
r=re.split('(de.{2})',a,0)
print(r)
['ac', 'derf', '23faaa', 'decc', 'c']

如果想显示切割的部分字符串可以用分组来处理()来保留自己想要的部分的。

4：match函数：

从字符串开头进行匹配，如果没有的话返回None 等同于^

match(pattern,string,flags=0)

pattern:正则表达式模型。

string：被匹配的字符串。

flags:匹配的模式。

无分组：匹配的字符串自动放在group里，因为没有分组，所以groups里没结果。

 import re
 a = 'acderf23faaadeccc'
 r=re.match('a.{2}',a)
 print(r.group())
 print(r.groups())
 print(r.groupdict()
 acd
 ()
 {}

有分组：

 import re
 a = 'acderf23faaadeccc'
 r=re.match('a(.{2})',a)
 print(r.group())
 print(r.groups())
 print(r.groupdict())
 acd
 ('cd',)
 {}

r.group()储存的是分组匹配字符串信息。r.groups()储存的是分组信息。r.groupsdict()储存的是别名信息。

 

 import re
 a = 'acderf23faaadeccc'
 r=re.match('a(?P<key>.{2})',a)###?P<自己命名key值>相当于给这个分组定义一个别名。
 print(r.group())
 print(r.groups())
 print(r.groupdict())
 acd
 ('cd',)
 {'key': 'cd'}

5：search函数

对字符串进行搜索，匹配到第一个就结束。无匹配返回值是None

 import re
 a = 'acderf23faaadecaaccccc'
 r=re.search('aa.{2}',a)
 print(r.group())
 print(r.groups())
 print(r.groupdict())
 aaad
 ()
 {}

 import re
 a = 'acderf23faaadecaaccccc'
 r=re.findall('aa.{2}',a)
 print(r)
 ['aaad', 'aacc']

有分组：

 import re
 a = 'acderf23faaadecaaccccc'
 r=re.search('a(a.{2})',a)
 print(r.group())
 print(r.groups())
 print(r.groupdict())
 aaad
 ('aad',)
 {}

 import re
 a = 'acderf23faaadecaaccccc'
 r=re.search('a(?P<test>a.{2})',a)
 print(r.group())
 print(r.groups())
 print(r.groupdict())
 aaad
 ('aad',)
 {'test': 'aad'}

常用的正则表达式的匹配：

IP：
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手机号：
^1[3|4|5|8][0-9]\d{8}$
邮箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

 二：算法

冒泡算法：

概念：它重复地走访过要排序的数列，一次比较两个元素大小，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

实现：

 NUM_LIST=[,,,,,,]
 LEN=len(NUM_LIST)
 for m in range(LEN-):
     for i in range(LEN-):
         if NUM_LIST[i] >NUM_LIST[i+]:
             NUM_LIST[i],NUM_LIST[i+]=NUM_LIST[i+],NUM_LIST[i]
 print(NUM_LIST)
 [, , , , , , ]

三：模块

os模块

1：os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

 import os
 print(os.getcwd())
 C:\python2\day6:

os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","new") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 用于分割文件路径的字符串
os.name 字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
2：os.path.abspath(path) 返回path规范化的绝对路径

 import os
 print(os.path.abspath(__file__))
 C:\python2\day6\s3

os.path.split(path) 将path分割成目录和文件名二元组返回
3：os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素

 import os
 print(os.path.dirname(os.path.abspath(__file__)))
 C:\python2\day6

：os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

 import os
 print(os.path.basename(__file__))
 s3

5：os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False

 import os
 print(os.path.exists('C:\python2\day6\\3.py'))
 True

os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
6：os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 import os
 p_dir='C:\python2'
 c_dir='day6'
 print(os.path.join(p_dir,c_dir))
 C:\python2\day6

os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

sys模块：主要用于python解释器相关的。

1：sys.argv:获取参数，第一个参数是文件路径（相对路径）

2：sys.exit()程序退出。

3：sys.version 获取解释版本。

 import sys
 print(sys.version)
 3.5. (v3.5.1:37a07cee5969, Dec   , ::) [MSC v.  bit (Intel)] 

4：sys.path:获取python加载模块的路径。初始化的使用PYTHONPATH的值。

5：sys.plarform获取操作系统版本。

 import sys
 print(sys.platform)
 win32 

6：

sys.stderr 错误输出
sys.stdin 输入相关
sys.stdout 输出相关
练习：进度条模拟：

 import sys
 import time

 def view_bar(num, total):
     rate = float(num) / float(total)
     rate_num = int(rate * )
     r = '\r%d%%' % (rate_num, )###\r回到行首位置。
     sys.stdout.write(r)##输出一行 不带\n
     sys.stdout.flush()##将缓存区内容刷到终端，我们写的东西现在缓存区，然后在写在终端。

 if __name__ == '__main__':
     for i in range(, ):
         time.sleep(0.1)
         view_bar(i, )

四：反射：很重要！

背景：当用户访问网站的时候，输入url的时候，网站后台可以根据用户的输入的字符串，去执行后台程序的相应的方法，相当于web的路由系统。是路由系统的雏形。

概念：利用字符串形式的去对象中操作（寻找(getattr)、检查(hasattr)、删除(delattr)、设置(setattr)）成员。

注意：

函数名和字符串是不一样，函数名代指函数体，类似变量，而字符串只是类型为字符串没其他意思。

 import  web
 choice=input('Entre your url:')
 if hasattr(web,choice):##判断字符串choice在对象web是否有叫choice的名字的方法和函数中。返回值是布尔值。
     fun=getattr(web,choice)##getattr是获取对象web模块的中的choice成员的方法，这里是函数。
     fun()##然后调用该函数。
 else:
     print('sorry you access web is not exits!')
 Entre your url:a
 sorry you access web is not exits!

hasattr判断对象中是否该成员。getattr是获取对象的成员，如上，并没有调用该对象。如果需要调用，需要调用执行该成员，上例子是函数，需要执行func(）。
输入的字符串需要和调用的对象成员名字一致，否则调用不成功。
也就是应用场景需要根据用户的输入，来执行相应的方法。应用场景最多是web开发中。
setattr和delattr 进行操作的是在内存中，在程序再次加载的时候，之前的操作将会失效。