210223课 re模块和面向对象

210223课 re模块和面向对象

re模块

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

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

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

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

获取字符串和正则表达式完全匹配的结果

看整个字符串是否满足正则的规则；如果匹配失败返回None，如果匹配成功返回匹配对象

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

1) 获取匹配到的字符串

匹配对象.group() - 获取整个正则表达式匹配到的结果

匹配对象.group(N) - 获取正则表达式中第N个分组匹配到的结果

print(result.group())   # 897-yu
print(result.group(1))  # 897
print(result.group(2))  # yu

2) 获取匹配结果在原字符串中的位置信息

返回开始下标和结束下标(结束下标取不到)

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

3) 获取原字符串

print(result.string)

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

将字符串开头和正则表达式进行匹配; 如果匹配失败返回None，如果匹配成功返回匹配对象

re_str = r'\d{3}'
print(re.fullmatch(re_str, '278'))
print(re.match(re_str, '234hjjh考核科技哈弗23'))

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

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

print(re.search(re_str, '史蒂芬霍金看2940数控889刀具ss'))

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

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

print(re.findall(r'\d{3}', '史蒂芬653霍金看2940数控889刀具ss'))

• 如果正则有一个分组

print(re.findall(r'\d{2}-[A-E]{2}', '是否23-ABss试试9223-CB；sd00-AA--009'))   # ['23-AB', '23-CB', '00-AA']
print(re.findall(r'(\d{2})-[A-E]{2}', '是否23-ABss试试9223-CB；sd00-AA--009'))  # ['23', '23', '00']

• 如果正则有两个分组

print(re.findall(r'(\d{2})-([A-E]{2})', '是否23-ABss试试9223-CB；sd00-AA--009'))  # [('23', 'AB'), ('23', 'CB'), ('00', 'AA')]

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

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

result = re.finditer(r'(\d{2})-([A-E]{2})', '是否23-ABss试试9223-CB；sd00-AA--009')

print(list(result))

for x in result:
    print(x.group(), x.group(1), x.group(2))

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

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

str1 = '送积分换23水电费29束带结发0圣诞节发货891数据'
result = str1.replace('23', '+')
result = result.replace('29', '+')
print(result)

result = re.sub(r'\d+', '+', str1)
print(result)   # 送积分换+水电费+束带结发+圣诞节发货+数据

# 练习：王者荣耀脏话屏蔽功能

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

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

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

sentence = '数据库烦得很a上课的飞机和a双方都客家话b是开放和c双方都好看和'
result = re.split(r'[a-c]', sentence)
print(result)  # ['数据库烦得很', '上课的飞机和', '双方都客家话', '是开放和', '双方都好看和']

9, 忽略大小写

# 'abc' -> 'abc'、'ABC'、'Abc'、'ABc'
# 方法一：在正则表达式的最前面加 (?i)
print(re.fullmatch(r'(?i)123[a-z]', '123M'))
# 方法二：flags=re.I
print(re.fullmatch(r'123[a-z]', '123K', flags=re.I))

10,单行匹配

多行匹配(默认)
多行匹配的时候：.不能匹配换行 (默认)

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

from re # 导入re模块
# 方法一：在正则表达式的最前面加 (?s)
print(re.fullmatch('123.abc', '123\nabc'))   # None

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

# 方法二: 正则后面加flags=re.S
print(re.fullmatch('123.abc', '123\nabc', flags=re.S))   
# <re.Match object; span=(0, 7), match='123\nabc'>

# 既忽略大小写又单行匹配
print(re.fullmatch('(?is)123.abc', '123\nABC'))   
# <re.Match object; span=(0, 7), match='123\nABC'>
print(re.fullmatch('123.abc', '123\nABC', flags=re.S | re.I))
# <re.Match object; span=(0, 7), match='123\nABC'>

面向对象

1,编程思想

1)面向过程编程

2)函数式编程

3)面向对象编程

# 计算5的阶乘！
# 面向过程编程
s = 1
for x in range(1, 5+1):
    s *= x

# 函数式编程
import math
math.factorial(5)

def f(n):
    s = 1
    for x in range(1, n+1):
        s *= x
    return s

# 面向对象编程
class Math:
    @classmethod
    def f(cls, n):
        s = 1
        for x in range(1, n + 1):
            s *= x
        return s

2,类：即拥有相同属性和功能的对象的集合

**对象：**即类的具体表现

1) 定义类

用代码描述类拥有的相同属性和功能的对象的集合
语法：
class 类名:
类的说明文档
类的内容
说明：
class 关键字，固定写法
类名 自定义，是标识符，不是关键字
所有单词首字母大写，见名知义
说明文档 3个双引号开头和结尾的注释
类的内容 主要包含类中的属性和方法（定义在类中的函数）
属性分为：类属性（字段）和对象属性
方法分为：对象/实例方法、类方法和静态方法

class Student:
    """学生类"""
    pass

2) 创建对象

语法: 对象=类()

stu1 = Student()
print(stu1)
# <__main__.Student object at 0x0000000002106580>

stu2 = Student()
print(stu2)

3,对象方法

**定义：**直接定义在类中函数就是对象方法
**调用：**通过对象来调用
**语法：**对象.方法名()
**特点：**自带参数self,self参数在调用时不需要传参
谁调用，self就对应谁

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

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


p = Person()
print(f'p:{p}')
p.eat()   # eat(p)

p.sleep(23)
p.sleep(time=10)

4,初始化方法和构造函数

魔法方法

Python的类有一个特殊的对象方法叫 _ _ init _ _
此方法在通过类创建对象的时候会被自动调用

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

1)创建对象的时候会自动调用类中的_ _ init _ _方法

2)创建对象的时候需要参数，需要几个参数由类中的_ _ _ init _ _方法决定

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


dog1 = Dog()
dog2 = Dog()


class Cat:
    def __init__(self, name, age=3):
        print('猫的init', name, age)


c1 = Cat('小花', 7)
c2 = Cat('小白')
c3 = Cat(name='花花', age=2)

5,属性

类中的数据信息就是属性，动作信息就是方法
属性分为类属性和对象属性

1) 类属性（字段）

直接定义在类中的变量就是类属性
通过类使用
**语法：**类.类属性
属性值不会因为对象不同而不一样

2) 对象属性

以‘self.属性名=值’的形式定义在类中 _ _ init _ _ 方法里面
属性值会因为对象不同而不一样，就定义为对象属性
**语法：**对象.属性

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

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


# 使用类属性
print(Person.a, Person.b)

Person.a = 100
print(Person.a * 2)

# 使用对象属性
p1 = Person()
print(p1.name, p1.age, p1.gender)
p1.name = '小花'
print(p1.name, p1.age, p1.gender)

p2 = Person()
p2.name = '小红'
p2.age = 20
p2.gender = '女'


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


stu1 = Student('小明')
print(stu1.name)

stu2 = Student('小红')
print(stu2.name)


# 练习：定义一个矩形类，拥有属性：长和宽，
# 拥有方法：计算周长和面积
class Rect:
    def __init__(self, l=10, w=10):
        self.length = l
        self.width = w
    def area(self):
        print(f'面积:{self.width * self.length}')
    def perimeter(self):
        print(f'周长:{(self.length + self.width) * 2}')

r1 = Rect()
r2 = Rect(10, 100)
r1.area()
r2.area()
r1.perimeter()
r2.perimeter()