python视频笔记23（正则表达式+密码破解）

【正则表达式】：

eg：给定一个字符串判断是否为手机号码
	def checkPhone(str):
	    if len(str) != 11:
	        return False
	    elif str[1:3] != "30" and str[1:3] != "31" and  str[1:3] != "39" :
	        return False
	    for i in  range(3, 11):
	        if str[i] < "0" or str[i] >"9":
	            return  False
	    return True
	print(checkPhone("131313131313"))
	print(checkPhone("13131313131a"))
	print(checkPhone("21313131313"))
	print(checkPhone("13131313131"))

par = r"^1[3578]\d{9}$"
par = r"^1(([3578]\\d)|(47))\d{8}$"

正则描述：

	python 是再1.5之后增加勒re模块。提供了正则表达式
	re 模块使Python语言拥有了全部的正则表达式功能

模块简介：

	import re
	re.match()

原型：match(pattern, string, flags=0)
patter:匹配的模式
string:要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式
re.I：忽略大小写
re.L：做本地化识别
re.M：多行匹配，影响^ $
re.S：是.匹配包括换行符在内的所有字符
re.U：根据Unicode字符集解析字符, 影响\w \W \b \B
re.X：使我们以更灵活的格式理解正则表达式
功能：尝试从字符串的起始位置匹配一个模式，如果不是起始位置成功的话，返回None

eg：

		import re
		print(re.match("www", "ww.baidu.com"))
		print(re.match("www", "baidu.wwwdu.com"))
		print(re.match("www", "Www.baidu.com", flags=re.I))

扫描整个字符串，返回从起始位置成功的匹配

re.search()

原型：search(pattern, string, flags=0)
patter:匹配的模式
string:要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式
参数：
功能：扫描整个字符串，并返回第一个匹配

eg：

			print (re.search("hello", "world hello "))

re.findall()

原型：findall(pattern, string, flags=0)
patter:匹配的模式
string:要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式
参数：
功能：扫描整个字符串，并返回结果列表正则表达式的元字符：

正则表达式的元字符

匹配单个字符与数字

		. :匹配除换行符以外额任意字符
			print (re.search("." , "Hello World"))
		[0123456789]:匹配[]中所有所包含的任意一个数字
		[字符集合]
		[A-Z]
		[a-z]
		[0-9]
		[0-9a-zA-Z_]
		[^hello]：匹配除了hello这几个字符以外的所有字符，[]中的^ 为脱字符，表示不匹配集合中的字符
		[0-9]：匹配所有的非数字字
		[\d ]：匹配所有的数字，和[0-9]效果相同
		 \w  :匹配数字，字母和下划线，效果和[0-9a-zA-Z_]相同
			 \W  :匹配非数字，字母，下划线
		 \s  :匹配人员的空白符(空格，换行，回车，换页，制表)效果同[ \f\n\r\t]
		 \S  :匹配任意的非空白符

锚字符–边界字符

		^:行首匹配
		$:行尾匹配
	      \A:匹配字符串开始，但是只匹配整个字符串的开头，即使在re.m的模式下也不是匹配他行的行首
	      \Z:匹配字符串开始，但是只匹配整个字符串的结束，即使在re.m的模式下也不是匹配他行的行尾
	      \b:匹配一个单词的边界，也就是值单词和空格间的位置
	      		er\b 可以匹配never但是不能nerve
	      \B:不匹配单词边界

匹配多个字符：

		说明：下方的x.y.z.n.m为假设的普通字符，不是正则元字符
		 x?：匹配一个或者0个x
		 x*：匹配0个或者任意多个x （贪婪匹配）（.*）--表示0个或者多个任意字符（换行符除外）
		 x+：匹配至少一个x
	       x{n}:匹配确当的n个x（n为一个非负整数）
	      x{n,}:匹配至少n个x
	    x{n, m}:匹配至少n个最多m个x 
	    	 x|y:匹配x或y

特殊：

		最小匹配，通常都是尽可能多的匹配，
		*?
		+?
		x?
		(?:x):类似（xyz）,但是不表示一个组
		注释：/* part1 */  /*part2 */
		print (re.findall(r"//*.*/*/", r"/* part1 */  /*part2 */"))

re模块深入：

字符串切割：

			str1 = "hello world"
			print (str1.split(" "))
			print (re.split(r" +", str1))
		re.finditer()

原型：

			match(pattern, string, flags=0)
			patter:匹配的模式
			string:要匹配的字符串
			flags:标志位，用于控制正则表达式的匹配方式
			功能：和findall类似，扫描整个字符串，返回的是一个迭代器
				str = "hello  word  ! hi  world  ! nihao  world"
				d = re.finditer(r".*(world)", str)
				while True:
				    try:
				        l = next(d)
				        print(l)
				    except StopIteration as e:
				        break

字符串的替换和切割：

		sub(pattern,repl， string, count=0, flags=0)
		subn(pattern,repl， string, count=0, flags=0)
			patter:正则表达式（规则）
			repl:指定的用来替换的字符串
			string:目标字符串
			flags:标志位，用于控制正则表达式的匹配方式
			count：最多替换的次数
			功能：在目标字符串中以正则表达式的规则匹配字符串，再把他们替换成指定的字符串，可以指定替换的次数，如果不指定则替换所有字符串
			区别：前者返回一个被替换的字符串，后者返回一个元组，第一个元素被替换的字符串，第二个元素表示被替换的次数

eg：

str = "hello  world"
print (re.sub(r"(good)","nice",str))

分组：

概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能，用（）表示的就是提取出的分组
eg：

		str = "010-12312333"
		m = re.match(r"(?p<first>\d{3})-(?p<last>\d{8})", str)
		#查看各组的匹配情况，group(0)代表的是原始字符串first 和last 是给组起的名字
		print(m.group(0))
		print(m.group(1))
		print(m.group(2))

编译：

当我们使用正则表达式的时候，re模块会做两件事
1：编译正则表达式，如果正则表达式本事不合法会报错
2：用编译后的正则表达式去匹配对象

			compile
			re_telephone = re.compile(pat)	
			re_telephone = re.compile(pat)
			pat = r"^1(([3578]\d)|(47))\d{8}$"
			print(re.match(pat, "123123123123"))
			re_telephone = re.compile(pat)
			print(re_telephone.match("123123123123"))

qq= re.compile(r"¹\d{5,9}$")

【密码破解】：

排列：

	从n个不同元素中取出m（m≤n）个元素，按照一定的顺序排成一列，叫做从n个元素中取出m个元素的一个排列
	[1, 2, 3, 4] 123  132 213 132 312 321
	import itertools
	mysList  =list(itertools.permutations([1,2,3,4], 3))
	print(mysList)
	print(len(mysList))

排列的可能性
n ! / (n-m)!

组合：

从n个不同元素中取出m（m≤n）个元素为一组，叫做从n个元素中取出m个元素的一个组合

	import itertools
	mysList  =list(itertools.combinations([1,2,3,4], 3))
	print(mysList)
	print(len(mysList))
	m!/(n!(m-n)!)

排列组合：

	import itertools
	mysList  =list(itertools.product(
    	"01223456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm",
    	repeat=1
	))
	print(mysList)
	print(len(mysList))

【疯狂破解】：

	import itertools
	import time
	#mysList  =list(itertools.product("01223456789", repeat=4))
	passwd = ("".join(x) 
		for x in itertools.product(
			"0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm",
			repeat = 5))
	while True:
	    try:
	        time.sleep(0)
	        str = next(passwd)
	        print(str)
	    except StopIteration as e:
	        break

---

1. 0-9 ↩︎