day016-re模块和面向对象

1，re模块

import re

# 1. re.compile(正则表达式)  -  根据正则表达式创建一个正则表达式对象
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)

# 获取原字符串
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)  # ['数据库烦得很', '上课的飞机和', '双方都客家话', '是开放和', '双方都好看和']

2，忽略大小写和单行匹配

import re
# 1.忽略大小写
# 'abc' -> 'abc'、'ABC'、'Abc'、'ABc'
# 方法一：在正则表达式的最前面加 (?i)
print(re.fullmatch(r'(?i)123[a-z]', '123M'))

# 方法二：
print(re.fullmatch(r'123[a-z]', '123K', flags=re.I))

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

单行匹配的时候：.可以匹配换行
方法一：在正则表达式的最前面加 (?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'>
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'>

3，认识类和对象

# 1.什么是类什么对象
# 类：就是拥有相同属性和相同功能的对象的集合（抽象的）
# 对象：对象就是类的实例（类的具体的表现）
# 从生活的角度来看：衣服、人、文具、电脑都是类
# 如果人是类，余婷就是对象、骆昊也是对象
# 如果电脑是类，我桌上的这台电脑就是对象
# 如果车是类，楼下那辆奔驰是对象

# 2.定义类（用代码描述这个类是拥有哪些相同属性和哪些相同功能的对象的集合）
"""
语法：
class 类名:
    类的说明文档
    类的内容

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

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


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


# 3.创建对象
# 语法：对象 = 类()
stu1 = Student()
print(stu1)    # <__main__.Student object at 0x106476f70>

stu2 = Student()
print(stu2)

4，对象方法

# 方法就是定义在类中的函数，分为三类：对象方法、类方法和静态方法
# 1.对象方法
"""
定义：直接定义在类中函数就是对象方法
怎么调用：要通过对象来调用 - 对象.方法名()
特点：自带参数self，而且参数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)

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

# 1.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)

6，属性

# 类中的数据信息就是属性，动作信息就是方法
# 属性分为类属性(字段)和对象属性
# 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(10, 20)
r2 = Rect(10, 100)
r1.area()    # self = r1
r2.area()    # self = r2

r1.perimeter()