第四周Day2 —— Python的re模块和面向对象

2022-03-13 07:21:21

第四周Day2 —— Python的re模块和面向对象

一、re模块

1.re.compile(正则表达式)

​ 根据正则表达式创建一个正则表达式对象。

re_obj = re.compile('\d{3}')
re_obj.fullmatch('234')
re_obj.search('daskfk789fsdfsdf456sdfsd122')

2.re.fullmatch(正则表达式, 字符串)

​ 获取字符串和正则表达式完全匹配的结果（看整个字符串是否满足正则的规则）。

​ 如果匹配失败，返回None；如果匹配成功，返回匹配对象。

result = re.fullmatch(r'(\d{3})-([a-z]{2})', '897-yk')
print(result)      # <_sre.SRE_Match object; span=(0, 6), match='897-yk'>

  1. 获取匹配到的字符串（重要）

    • 匹配对象.group() - 获取整个正则表达式匹配到的结果
    • 匹配对象.group(N) - 获取正则表达式中第N个分组匹配到的结果
    print(result.group())     # 897-yk
print(result.group(1))    # 897
print(result.group(2))    # yk

  2. 获取匹配结果在原字符串中的位置信息，返回开始下标和结束下标，结束下标取不到。

    print(result.span())      # (0, 6)
print(result.span(1))     # (0, 3)
print(result.span(2))     # (4, 6)

  3. 获取原字符串

    print(result.string)      # 897-yk

3. re.match(正则表达式, 字符串)

​ 将字符串的开头和正则表达式进行匹配。

re_str = r'\d{3}'
print(re.match(re_str, '123asdaiuiodoias'))   
# <_sre.SRE_Match object; span=(0, 3), match='123'>

4. re.search(正则表达式, 字符串)

​ 在字符串中查到第一个满足正则的字串，如果没有找打返回None，如果找到了返回匹配对象。

print(re.search(re_str, 'dasfasfa132dasda'))   
# <_sre.SRE_Match object; span=(8, 11), match='132'>

5. re.findall(正则表达式, 字符串)

​ 获取字符串中所有满足正则的字串，返回值是列表，列表中的元素是满足正则的字串。

print(re.findall(re_str, 'asda456dasda789dasda244da'))   # ['456', '789', '244']
# 没有分组
print(re.findall(r'\d{2}-[A-E]{2}', '阿萨德积分23-ABss赛欧9856-CD;da00-AA-897'))
# ['23-AB', '56-CD', '00-AA']

# 有一个分组
print(re.findall(r'(\d{2})-[A-E]{2}', '阿萨德积分23-ABss赛欧9856-CD;da00-AA-897'))
# ['23', '56', '00']

# 有两个分组
print(re.findall(r'(\d{2})-([A-E]{2})', '阿萨德积分23-ABss赛欧9856-CD;da00-AA-897'))
# [('23', 'AB'), ('56', 'CD'), ('00', 'AA')]

6. re.finditer(正则表达式, 字符串)

​ 获取字符串中所有满足正则的字串，返回值是一个迭代器（序列），序列中的元素是匹配对象。

result = re.finditer(r'(\d{2})-([A-E]{2})', '阿萨德积分23-ABss赛欧9856-CD;da00-AA-897')
# print(list(result))
for x in result:
    print(x.group(), x.group(1), x.group(2))
    # 23-AB 23 AB
    # 56-CD 56 CD
    # 00-AA 00 AA

7. re.sub(正则表达式, 字符串1, 字符串2)

​ 将字符串2中所有满足正则表达式的子串全部都替换成字符串1。

str1 = '撒大大456大上京东897到世45界大赛4561大四'
result = re.sub(r'\d+', '+', str1)
print(result)     # 撒大大+大上京东+到世+界大赛+大四

练习：王者荣耀脏话屏蔽

message = '你丫是傻  叉吗? 我操你大爷的. Fuck you.'
result = re.sub(r'(?i)傻\s*(叉|b|B|瓜)?|丫|操|大爷|f\s*u\s*c\s*k', '*', message)
print(result)      # 你*是*吗? 我*你*的. * you.

8. re.split(正则表达式, 字符串)

​ 将字符串中满足正则的子串作为切割点进行切割。

sentence = '好似判断哈a大家按时到吉安市b都爱函数的c大家搜到将爱收'
result = re.split(r'[a-c]', sentence)
print(result)      # ['好似判断哈', '大家按时到吉安市', '都爱函数的', '大家搜到将爱收']

二、 忽略大小写和单行匹配

1. 忽略大小写

  1. 方法一：在正则表达式的最前面加(?i)

    print(re.fullmatch(r'(?i)123[a-z]', '123M'))  
# <_sre.SRE_Match object; span=(0, 4), match='123M'>

  2. 方法二：flags=re.I

    print(re.fullmatch(r'(?i)123[a-z]', '123M', flags=re.I)) 
# <_sre.SRE_Match object; span=(0, 4), match='123M'>

2. 单行匹配

  • （默认）多行匹配的时候：.不能匹配换行

  • 单行匹配的时候：.可以匹配换行

print(re.fullmatch('123.abc', '123\nabc'))   # None

  1. 方法一：在正则表达式最前面加(?s)

    print(re.fullmatch('(?s)123.abc', '123\nabc'))
# <_sre.SRE_Match object; span=(0, 7), match='123\nabc'>

  2. 方法二：flags=re.S

    print(re.fullmatch('123.abc', '123\nabc', flags=re.S))
# <_sre.SRE_Match object; span=(0, 7), match='123\nabc'>

3. 既忽略大小写又单行匹配

print(re.fullmatch('(?is)123.abc', '123\nABC'))
# <_sre.SRE_Match object; span=(0, 7), match='123\nABC'>
print(re.fullmatch('123.abc', '123\nABC', flags=re.I | re.S))
# <_sre.SRE_Match object; span=(0, 7), match='123\nABC'>

三、面向对象

1. 认识类和对象

  1. 什么是类

    类就是拥有相同属性和相同功能的对象的集合。

    从生活的角度来看：衣服、人、文具、电脑都是类。

  2. 什么是对象

    对象就是类的实例（类的具体的表现）

2. 定义类

​ 用代码描述这个类是拥有哪些相同属性和哪些相同功能的对象的集合。

语法：
class 类名:
	类的说明文档
	类的内容   
	
说明：
class   -   关键字；固定写法
类名     -   程序员自己命名
			要求：是标识符，不是关键字
			规范：驼峰式命名并且首字母大写；见名知义；不使用系统的名字
类的说明文档   -   三个双引号开头和结尾的注释
类的内容   -   主要包含类中的属性和方法
			  属性分为：类属性（字段）和对象属性
			  方法分为：对象（实例）方法、类方法和静态方法

注：方法就是定义在类中的函数

3. 创建对象

语法：
对象 = 类()

4. 对象方法

​ 方法就是定义在类中的函数，分为三类：对象方法、类方法和静态方法。

  1. 对象方法

    定义：直接定义在类中的函数就是对象方法。

    怎么调用：要通过对象来调用 - 对象.方法名()

    特点：自带参数self，而且参数self在调用的时候不需要传参，系统会自动将当前对象传给self（谁调用 self就指向谁）

class Person:
    # eat就是对象方法
    def eat(self):
        print('吃饭')

    # sleep是对象方法
    def sleep(self, time):
        print(f'睡了{time}小时')


p = Person()
p.eat()           # 吃饭
p.sleep(23)       # 睡了23小时
p.sleep(time=23)  # 睡了23小时

5. 初始化方法和构造函数

1. `python`的类有一个特殊的对象方法叫`__init__`，这个方法在通过类创建对象的时候会被自动调用。
 + 创建对象的时候回自动调用类中的`__init__`方法。
 + 创建对象的时候需不需要参数，需要几个参数由类中的`__init__`方法决定。

魔法方法：方法名以__开头并且__结尾，所有的魔法方法都不需要程序员去调用，系统会自动调用。

class Dog:
    def __init__(self):
        print('init被调用')


dog1 = Dog()    # init被调用
dog2 = Dog()    # init被调用


class Cat:
    def __init__(self, name):
        print(f'猫的名字是：{name}')


cat1 = Cat('包子')   # 猫的名字是：包子

6. 属性

​ 类中的数据信息就是属性，动作信息就是方法。

  1. 类属性

    怎么定义：直接定义在类中的变量就是类属性。

    怎么使用：通过类使用 - 类.类属性

    什么时候用：属性值不会因为对象不同而不一样。

class Person:
    # a,b是类属性
    a = 10
    b = 'abc'


print(Person.a, Person.b)
Person.a = 100
print(Person.a)

  1. 对象属性

    怎么定义：以self.属性名=值的形式定义在类中__init__方法里面。

    怎么使用：通过对象使用 - 对象.属性

    什么时候用：属性值会因为对象不同而不一样，就定义成对象属性。

class Person:
    def __init__(self):
        # name、age、sex就是对象属性
        self.name = '小明'
        self.age = 18       
        self.sex = '男'

# 使用对象属性
p1 = Person()
print(p1.name, p1.age, p1.sex)   # 小明 18 男
p1.name = '小花'
p1.sex = '女'
p1.age = 20
print(p1.name, p1.age, p1.sex)   # 小花 20 女

class Student:
    def __init__(self, name1, tel1='110'):
        self.name = name1      # 每次创建对象的时候都必须给name属性赋值
        self.study_id = '000'  # 每次创建学生对象的时候study_id的值都是’000‘，而且创建的时候不可以变
        self.tel = tel1        # 每次创建对象的时候可以选择性的给tel属性赋值或者不赋值

练习：定义一个矩形类，拥有属性：长、宽，拥有方法：计算周长和面积

class Rectangular:
    def __init__(self, length=10, width=20):
        self.length = length
        self.width = width


    def get_area(self):
        area = self.length * self .width
        return area


    def get_perimeter(self):
        perimeter = (self.length + self.width) * 2
        return perimeter


r1 = Rectangular()
print(f'r1的面积：{r1.get_area()}')           # r1的面积：200
print(f'r1的周长：{r1.get_perimeter()}')      # r1的周长：60
r2 = Rectangular(10, 100) 
print(f'r2的面积：{r2.get_area()}')           # r2的面积：1000
print(f'r2的周长：{r2.get_perimeter()}')      # r2的周长：220
上一篇：[性能测试day2]常用指标


下一篇：DL2020_Day2_Gradient Descent