python笔记（2）

笔记（2）"/>

python笔记（2）

正则表达式

用事先定义好的特定字符制定一个规则，对目标字符串进行过滤（检索、截取、替换）

作用

1.给定字符串是否符合正则表达式的过滤逻辑（即匹配）
2.从字符串截取想要的部分
3. 对目标字符串进行替换
###正则表达式的使用 re模块
match方法
re,match尝试从字符串起始位置匹配一个模式，如果不是起始位置匹配成功的话，返回None
re.match(patter,string,flags=0)
pattern:正则表达式，string目标字符串
使用group返回字符串本身
#测试match方法的使用
import re
s = “hello python”
pattern = “hello”
o = re.match(pattern,s)
if o is not None:#加上判断，group方法不会异常
print(“匹配成功的字符串是：{0}”.format(o.group()))#返回匹配的字符串
print(o.span())#返回匹配字符串的范围
print(o.start())#返回起始偏移量
else:
print(“not match”)

#测试flags参数的使用
print(“flag参数的使用”)
s = “hello python”
pattern = “Hello”
o = re.match(pattern,s,flags=re.I)#re.I不区分大小写
print(o)
print(dir())#查看o的属性
print(o.group())#返回匹配的字符串
print(o.span())#返回匹配字符串的范围
print(o.start())#返回起始偏移量
常用的字符
.可以匹配任意字符，除了\n
[]匹配列表中的字符
\w匹配字母、数字、下划线
\W匹配不是字母数字下划线
\s匹配空白字符，即\n，\t
\S匹配不是空白字符
\d匹配数字，即0-9
\D匹配非数字
#常用字符的使用
print("----------.的使用----------")
import re
#s = “a”
#s = “A”
s = “9”
s = “"
s = “\n”#除了\n都可以
pattern = “.”
o = re.match(pattern,s)
print(o)
print("----------\d的使用----------")
s = “0”
s = “A”
#s = “9”
pattern = “\d”
o = re.match(pattern,s)
print(o)
print("----------\D的使用----------")
s = “0”
s = “A”
s = “9”
pattern = “\D”
o = re.match(pattern,s)
print(o)
print("----------\s的使用----------")
s = " "
s = “\n”
s = “\t”
s = " "
s = “t”
pattern = “\s”
o = re.match(pattern,s)
print(o)
print("----------\S的使用----------")
s = " "
#s = “\n”
#s = “\t”
#s = " "
#s = “t”
pattern = “\S”
o = re.match(pattern,s)
print(o)
print("----------\w的使用----------")
s = “a”
s = “A”
s = "”
s = " "
s = “8”
pattern = “\w”
o = re.match(pattern,s)
print(o)
print("----------\W的使用----------")
s = “a”
s = “A”
s = “"
s = " - "
#s = “8”
pattern = “\W”
o = re.match(pattern,s)
print(o)
print("----------[]的使用----------")
s = “2”
s = “4”
#s = “a”
#s = “3”
#s = “8”
pattern = ‘[2,4,6,8]’
o = re.match(pattern,s)
print(o)
重复
限定符：匹配0次或多次
+匹配一次到多次
？匹配一次或0次
{m} 重复m次
{m,n}重复m 到n次，n可以省略，表示m到任意次
{m,}至少m次
#匹配手机号码
import re
print("-------手机号码-------")
s = “13297963579”
pattern = “1[35789]\d\d\d\d\d\d\d\d\d”
o = re.match(pattern,s)
print(o)
#重复数量符号
import re
print("------的使用（0或多次）------")
pattern = "\d"
s = “123qwe”
s = “qwe”
o = re.match(pattern,s)
print(o.group())
print("------+的使用(至少一次)------")
pattern = “\d+”
s = “123qwe”
s = “qwe”
o = re.match(pattern,s)
print(o)
#print(o.group())
print("------?的使用(0or1)------")
pattern = “\d?”
s = “123qwe”
#s = “qwe”
o = re.match(pattern,s)
print(o)
print(o.group())
print("------{m}的使用(0or1)------")
pattern = “\d{2}”
s = “123qwe”
#s = “qwe”
o = re.match(pattern,s)
print(o)
print(o.group())
print("------{m,n}的使用(0or1)------")
pattern = “\d{2,4}”
s = “12345qwe”
#s = “1qwe”
o = re.match(pattern,s)
print(o)
print(o.group())
print("------{m,}的使用(0or1)------")
pattern = “\d{2,}”
s = “12345qwe”
s = “1qwe”
o = re.match(pattern,s)
print(o)
print(o.group())
原生字符串
#转义字符的使用
print(“d:\a\b\c”)#要两个\才能输出
print("\nabc")
print("\tabc")
import re
s = “\\t123”
pattern = "\\\\t\d"#原生字符串四个\，正则表达式要有8个
pattern = r\\t\d* #加上r变为原生字符串
o = re.match(pattern,s)
print(o)
边界字符
^匹配字符串开头
KaTeX parse error: Undefined control sequence: \b at position 9: 匹配字符串结尾 \̲b̲匹配一个单词的边界 \B匹配非…"
o = re.match(pattern,qq)
print(o)
if o is not None:
print(o.group())
print("___________------”)
#匹配以hello开始的
s = ‘hello world’
s = ‘hell python’
pattern = r’^hello.’
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
print("_________\b单词左边界------")
#匹配单词的边界
s = ‘hello world’
s = ‘123 abthon’
pattern = r’.\bab’#必须以ab开始的单词
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
print("_________\b单词右边界------")
#匹配单词的边界
s = ‘hello world’
s = ‘hell abthab’
pattern = r’.ab\b’#必须以ab结尾的单词
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
print("_________\B非单词边界------")
#匹配单词的边界
s = ‘hello world’
s = ‘123 ababc’
pattern = r’.\Bab’
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
#匹配1-99数字
import re
pattern = “[1-9]\d?$”
s = “100”
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())

search方法

re,search(pattern,string,flags=0)
和match区别：match从开头开始匹配，search可以从中间开始匹配
#search使用,
import re
s = ‘asdfv’
pattern = ‘asd’
m = re.search(pattern,s)
print(m)
print(m.group())
print(’-----match和search区别--------’)
s = ‘asd123fv’
pattern = ‘123’
o = re.match(pattern,s)
m = re.search(pattern,s)
print(m)
print(o)
print(m.group())
#匹配多个字符
import re
pattern = ‘aa|bb|cc’#逻辑或
s = ‘i love aa’
o = re.match(pattern,s)
print(o)
m = re.search(pattern,s)
print(m)
#匹配0-100所有的数字 1-99|100|0
print(’----0-100-----’)
pattern = ‘[1-9]\d? ∣ 100 |100 ∣100|0KaTeX parse error: Expected 'EOF', got '#' at position 97: …)) **择一匹配符** **#̲择一匹配符和列表相同** im…)’
s = ‘010-2345678’
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())#输出匹配结果，不分组
print(o.groups())#以元组形式输出两个分组数据
print(o.group(1))#获取第一个分组，即区号
print(o.groups()[0])#输出元组第一个数据，即分组1
print(’----------web tag data（\num）-------’)
s = ‘head part’
pattern = r"<(.+)><(.+)>.+</\2></\1>"#\1表示第一个分组数据，因为html首尾相同
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
print(’----------web tag data(?P)-------’)
s = ‘head part’
pattern = r"<(?P<k_html>.+)><(?P<k_head>.+)>.+</(?P=k_head)></(?P=k_html)>"#?P<>命名分组，?P=name引用该名字分组数据
o = re.match(pattern,s)
print(o)
if o is not None:
print(o.group())
其他函数的使用
Sub和subn：搜索和替换
Sub返回替换后结果，subn返回元组，第一个元素是替换后的结果，第二个是替换的总数
Re.sub(pattern,repl,string,count=0,flags)count默认是0，即都替换
#sub和subn方法的使用
import re
phone = ‘2004-958-559 # 这是一个国外的电话号码’
print("---------delete note（sub）----------")
pattern = r’#.$’#井号后面都替换
result = re.sub(pattern,’’,phone)
print(‘sub:’,result)
pattern1 = r’#\D’#井号后面非数字
result1 = re.sub(pattern1,’’,phone)
print(‘sub:’,result1)
print("---------delete note（subn）----------")
result = re.subn(pattern,’’,phone)
print(‘subn:’,result) #返回元组，第一个为替换结果，第二个为替换次数
compile函数
编译正则表达式，生成一个对象，供match和search使用
Repile(pattern,[flags])
import re
print(’-------compile------’)
pattern = ‘\w+’
s = ‘1_a’
regex = repile(pattern)
o = regex.match(s)
print(o.group())
finddall函数
在字符串中找到正则表达式所匹配的所有子串，返回列表，没有返回空
Findall（pattern，string，flags=0）
#findall函数的使用
print("----------findall----------")
s = ‘fist 2 aec ee 44 88’
pattern = ‘\D+’#找到所有非数字
o = re.findall(pattern,s)
print(o)
findditer函数
找到所有匹配的子串，把他们作为一个迭代器返回
#finditer函数的使用
print("----------finditer----------")
s = ‘fist 2 aec ee 44 88’
pattern = ‘\d+’#找到所有数字
o = re.finditer(pattern,s)
for i in o:
print(i.group())
split函数
根据正则表达式分割字符串
Re.split(pattern,sting,[maxsplit=0,flags=0])
Maxsplit分割次数，默认为0不限次数
print("----------split----------")
s = ‘fist 2 aec ee 44 88’
pattern = r’a’#遇a分割
o = re.split(pattern,s,1)#最多分割一次
print(o)

贪婪模式和非贪婪模式

Python中的数量词默认是贪婪的，会尽量多的匹配，非贪婪模式会尝试匹配尽量少的字符，后面加上？，使贪婪变为非贪婪。
#贪婪模式和非贪婪模式
import re
print(’----------tanlan---------’)
pattern = r’(.+)(\d±\d±\d+)’
s = ‘This is my tel:132-9796-3579’
v = re.match(pattern,s)
print(v.group(1))
print(v.group(2))
print(’----------feitanlan---------’)
pattern = r’(.+?)(\d±\d±\d+)’
s = ‘This is my tel:132-9796-3579’
v = re.match(pattern,s)
print(v.group(1))
print(v.group(2))
print(’----------shili 2---------’)
pattern = r’abc(\d+)’
s = ‘abc123’
o = re.match(pattern,s)
print(o.groups())
pattern = r’abc(\d+?)’
s = ‘abc123’
o = re.match(pattern,s)
print(o.groups())

异常的处理

try:….一个except
try…多个except
异常类
层次结构：baseexception——exception——nameerror、valueerror等等
#测试异常
print(‘step0’)
try:
print(‘step1’)
a = 3/0
print(‘step2’)
except BaseException as e:#e为异常对象
print(‘yichang’)
print(e)#可以打印出异常信息
print(type(e))#打印异常对象类型
print(‘end!’)
print(‘step0’)
try:
print(‘step1’)
a = 3/2
print(‘step2’)
except BaseException as e:#e为异常对象
print(‘yichang’)
print(e)#可以打印出异常信息
print(type(e))#打印异常对象类型
print(‘end!’)
结果：step0
step1
yichang
integer division or modulo by zero
<type ‘exceptions.ZeroDivisionError’>
end!
step0
step1
step2
end!
#循环输入数字，如果不是数字则处理异常，输入88，结束循环。
while True:
try:
x = input(‘请输入一个数字：’)
print(‘输入的数字{0}’.format(x))
if x == 88:
print(‘exit’)
break
except BaseException as e:
print(e)
print(‘请输入数字’)
print(‘end!’)
try….多个except结构：
#测试try…多个except
while True:
try:
a = input(‘请输入一个被除数：’)
b = input(‘请输入一个除数：’)
c = float(a)/float(b)
print©
except ZeroDivisionError:
print(‘不能除以零’)
except ValueError:
print(‘不能将字符串转化为数字’)
except NameError:
print(‘变量不存在’)
except BaseException as e:
print(e)
try….except…else结构：
没有异常执行else语句
#测试try…except…else结构：
while True:
try:
a = input(‘输入一个被除数：’)
b = input(‘输入一个除数：’)
c = float(a)/float(b)
except BaseException as e:
print(e)
else:
print©
print(‘程序结束！’)
try….except…finally结构：
无论发生异常与否都执行，通常用来释放try块中申请的资源
#测试try…except…finally结构
while True:
try:
a = input(‘请输入一个被除数：’)
b = input(‘请输入一个除数：’)
c = float(a)/float(b)
except BaseException as e:
print(e)
else:
print©
finally:
print(‘无论异常与否，我都执行！’)
print(‘end’)

#测试finally
try:
f = open(‘c:/a.txt’,‘r’)
content = f.readline()
print(conment)
except:
print(‘文件未找到’)
finally:
print(‘run in finally,close’)
try:
f.close()
except BaseException as e:
print(e)
print(‘end’)
return一般不放在异常处理中，放在结构之外，方法的最后。
常见异常的解决：
1.ntaxerror：语法错误
2.nameerror：尝试访问一个没有申明的变量
3.zerodivisionerror:除数不能为0
4.Valueerror:数值错误
5.typeerror：类型错误
6.attributeerror：访问对象不存在的属性
7.indexerror：索引越界异常
8.keyerror：字典的关键字不存在
with上下文管理
finally块通常放释放资源的代码，通过with上下文管理，可以更加方便的释放资源。
with context_expr[as var]:
语句块
#with上下文管理(不是用来取代finally的，只是作为补充)
with open(‘c:/test/a.txt’,‘r’) as f:
content = f.readline()
print(content)
print(“程序结束！”)
traceback模块
#测试traceback模块的使用
import traceback
try:
print(‘step1’)
num = 1/0
except:
traceback.print_exc()
######将异常信息输出到指定文件中
try:
print(‘step1’)
num = 1/0
except:
with open(‘c:/test/a.txt’,‘a’) as f:
traceback.print_exc(file=f)
自定义异常类：
自定义异常类，通常继承exception或者其子类即可，命名一般以error、exception结尾
自定义异常由raise语句抛出
#测试自定义异常类
class AgeError(Exception):#继承exception类
def init(self,errorInfo):
Exception.init(self)#调用父类构造函数
self.errorInfo = errorInfo
def str(self):
return str(self.errorInfo)+’,年龄错误！,应该在1-150’
######测试代码#######
if name == ‘main’: #如果为true，则模块是作为独立文件运行，可以执行测试代码
age = input(“请输入一个年龄：”)
if age < 1 or age >150:
raise AgeError(age)
else:
print(“正常的年龄：{0}”.format(age))
文件操作io技术
文件有文本文件（txt）和二进制文件。
文本文件存储的是普通字符文本，python默认为Unicode字符集。
二进制文件用字节存储，需要解码。
创建文件对象open（）
open（文件名，打开方式）
r读read模式。
w写write模式，不存在则创建，存在则重写。
a追加append模式，不存在则创建，存在则追加。
b二进制binary模式（可与其他模式组合使用）
+读写模式(可与其他模式组合使用)
文件的写入一般三个步骤：

1. 创建文件对象
2. 写入数据
3. 关闭文件对象