正则函数及面向对象开发初识---day19

原创

wx62aaee4be59a4 2022-06-17 06:51:12 ©著作权

©著作权归作者所有：来自51CTO博客作者wx62aaee4be59a4的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.正则函数

# ### 正则函数
import re
#search  通过正则匹配出第一个对象返回，通过group取出对象中的值
strvar = "1+2 3*4"
obj = re.search("\d+(.*?)\d+",strvar)
#返回匹配到的内容(匹配到一个就返回)
print(obj.group())  #1+2
#把括号里匹配到的内容扔到元组中返回
res = obj.groups()
print(res)

#match  验证用户输入内容(了解)
"""search 只要在正则表达式的前面加上^ 就和match一模一样"""
strvar = "y13566688771"
strvar = "13566688771"
obj = re.search("^\d+",strvar)
print(obj.group()) #13566688771

obj = re.match("\d+",strvar)
print(obj,group())


#split   切割
strvar = "alex|xboy&wusir-egon"
res = re.split("[|&-]",strvar)
print(res) #['alex', 'xboy', 'wusir', 'egon']


strvar = "alex23423411122334xboyww90909045wusir78"
res = re.split("\d+",strvar)
print(res) # ['alex', 'xboyww', 'wusir', ''] #这后面还有个空格


#sub  替换(正则表达式，替换的字符串，原字符串，[可选替换的次数])
strvar =  "alex|xboy&wusir-egon"
#strvar.replace("|","%")
#strvar.replace("&","%")
#strvar.replace("-","%")

res = re.sub("[|&-]","%",strvar)
print(res) #alex%xboy%wusir%egon
res = re.sub("[|&-]",strvar,1)
print(res) # alex%xboy&wusir-egon  字符串


#subn  替换与sub用法一样，区别在于返回值不同，返回的是元组
res = re.subn("[|&-]","%",strvar)
print(res)  #('alex%xboy%wusir%egon', 3) #返回的第二个参数为修改的次数
res = re.subn("[|&-]","%",strvar,1)
print(res) #('alex%xboy&wusir-egon', 1)


#finditer  匹配字符串中相应的内容 返回迭代器
from collections import Iterator
strvar = "sdfasf234234你好23423"
it = re.finditer(r"\d+",strvar)
print(isinstance(it,Iterator)) #True
"""
lst = list(it)
print(lst)
[
<_sre.SRE_Match object; span=(6, 12), match='234234'>, 
<_sre.SRE_Match object; span=(14, 19), match='23423'>
]

234234
23423
"""
for i in it:
    print(i.group())
    
#compile  指定一个统一的匹配规则
'''
正常情况下，正则表达式执行一次，编译一次
如果需要反复使用，会浪费系统资源，比如内存，cpu

compile 可以使正则编译一次，终身受益，无需反复编译
'''
strvar = "sdfasf234234你好23423"
pattern = re.compile("\d+")
print(pattern) ## re.compile('\\d+')

obj = pattern.search(strvar)
print(obj.group()) # # 234234
lst = pattern.findall(strvar)
print(lst) #['234234', '23423']

#修饰符
#re.I  使匹配对大小写不敏感
strvar = "<h1>123<H1>"
pattern = re.compile("<h1>(.*?)</h1>",flags=re.I)
obj = pattern.search(strvar)
print(obj)
print(obj.group()) #<h1>123</H1>


# re.M  使每一行都能够单独匹配(多行匹配) 影响 ^ 和 $
strvar = """<h1>123</H1>
<p>123</p>
<div>123</div>
"""
pattern = re.compile("^<.*?>(?:/*?)<.*?>$",flags=re.M)
print(pattern.findall(strvar)) #['<h1>123</H1>', '<p>123</p>', '<div>123</div>']


#re.S 使 . 匹配包括换行在内的所有字符
strvar = """give
1112233mefive
"""
pattern = re.compile("(.*?)mefive",flags=re.S)
obj = pattern.search(strvar)
print(obj.group()) 
"""
give
1112233mefive
"""

2.面向对象初始

# ###oop 面向对象程序开发

#(1)  类的定义
class Car:
    pass

class Car(): #推荐
    pass
    
class Car(object):
    pass
    
#(2) 类的实例化
class Car():
    pass
obj = Car()  #类名加()  =>  实例化一个对象


#(3)类的基本结构
'''
类中只有2种成员
    (1)成员属性
    (2)成员方法
'''
class Car():
    #成员属性
    color = "屎黄色的"
    #成员方法
    def func(self):
        print("小车会跑")
        
#反例
'''
类中的代码可以直接指向，但是严禁使用，不要直接把代码裸露在类中
应该把相应的逻辑放在成员方法当中处理
'''
class Car():
    if r == 5:
        print(4567)


#正确方法
class Car():
    def func(self):
        if 5 == 5:
            print(4567)
            
#(4) 类的命名
'''
类的命名推荐使用大驼峰命名法
mycar => MyCar
dahuangfeng =>  DaHuangFeng
'''

#面向对象总结：
面向过程：
(1)优点：效率高，执行速度快
(2)缺点：维护性差，移植性差，表达不出一类的语意
面向对象:
(1)优点：可读性，可移植性，可维护性高
(2)缺点：执行效率稍慢