2.23-学习总结

re模块和面向对象

一、re模块

import re

# 1. re.compile(正则表达式)    --根据正则表达式创建一个正则表达对象
re_obj = re.compile('\d{3}')
re_obj.fullmatch('456')
re_obj.search('dsjfkad45fdsa789')

# 2. re.fullmatch(正则表达式，字符串)    --获取字符串和正则表达式完全匹配的结果，如果失败返回None
# 如果匹配成功，返回匹配对象
result = re.fullmatch(r'(\d{3})-([a-z]{3})', '123-dsa')
print(result)       # <re.Match object; span=(0, 3), match='123'>

# 1) 获取匹配到的字符串(重要)
# 匹配对象.group()  --获取整个表达式匹配的结果
# 匹配对象.group(N)  --获取正则表达式中第N个分组匹配的结果，如果没有分组，报错
print(result.group())   # 123-dsa
print(result.group(2))   # dsa

# 2) 获取匹配结果在原字符串中的位置，返回开始和结束下标（结束下标取不到）
print(result.span())        # (0, 7)
print(result.span(2))       # (4, 7)

# 3) 获取原字符串
print(result.string)        # 123-dsa

# 3.re.match(正则表达式，字符串)     --将字符串的开头和正则表达式进行匹配
re_str = r'\d{3}'
print(re.fullmatch(re_str, '123'))
print(re.match(re_str, '188dsaasa456sa46sa'))

# 4. re.search(正则表达式，字符串)   --在字符串中第一个满足正则的字串，没有返回None，有就返回该对象
print(re.search(re_str, 'dsafnvjc5664fnds'))    # match='566'>

# 5. re.findall(正则表达式，字符串) --取满足正则中的所有字串，返回一个列表
print(re.findall(r'\d{3}', 'dsa456xzc213fdfds9988'))    # ['456', '213', '998']

# 6. re.finditer(正则表达式，字符串) --获取字符串中所有满足正则的字串，只是返回值是一个序列，里面的元素是匹配对象
result = re.finditer(r'(\d{2})-([a-z]{2})', 'd大发23-sa竞赛89-ds几艘爱79-sd')
for x in result:
    print(x.group(), x.group(1), x.group(2))    # 23-sa 23 sa
                                                # 89-ds 89 ds
                                                # 79-sd 79 sd

# 7. re.sub(正则表达式，字符串1，字符串2)    --将2中的所有满足正则的字串替换成1
re_str1 = '复健科455dsan79dnakn89'
result = re.sub(r'\d+', '=', re_str1)
print(result)   # 复健科=dsan=dnakn=

# 8. re.split(正则表达式，字符串)  --将字符串中满足正则的字串作为切割点，返回一个序列，里面的元素是每一个字串
sentence = '你猜下咯没猜错a但是可能b大玫琳凯是帽搭配上c都能开饭店'
result = re.split(r'[abc]', sentence)
print(result)   # ['你猜下咯没猜错', '但是可能', '大玫琳凯是帽搭配上', '都能开饭店']

二、认识类和对象

# 1.定义类
"""
语法：
class 类名：
    类的说明文档
    类的内容

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

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

    pass


# 2.创建对象
"""
语法：
对象名 = 类()
"""
stu1 = Student()
print(stu1)     # <__main__.Student object at 0x0000025D1CA42DC0>
stu2 = Student()
print(stu2)     # 0x00000295092C3FA0>

三、对象方法

# 方法：对象/实例方法、类方法和静态方法
# 1.对象方法
"""
定义：直接定义在类中的函数就是对象方法
调用：通过对象调用   --对象.方法名()
特点：自带参数self，在调用时不用传参
s:<__main__.Person object at 0x0000023343043FD0>
self:<__main__.Person object at 0x0000023343043FD0>
系统谁去调用，传的参数就是谁（s去调用，将s的参数传给self）
"""


class Person:
    def eat(self):  # eat是对象方法
        print(f'self:{self}')   # 打印self的位置
        print('吃饭')

    def sleep(self):    # sleep是对象方法
        print('睡觉')


s = Person()    # 创建对象
print(f's:{s}')  # 打印s的位置
s.eat()         # 调用（不需要传参，系统默认传进去一个参数）

四、初始化方法和构造函数

# 1.python的类有一个特殊的对象方法叫__init__，这个方法在通过创建对象的时候会被系统自动调用
# 补充：魔法方法—方法名以__开头并且__结尾，所有魔法方法系统会自动调用
class Dog:
    def __init__(self):
        print('init被调用')


dog1 = Dog()    # init被调用(自动调用，在创建对象时候)


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


c1 = Cat('小白', 18)      # 猫的init 小白 18
c2 = Cat(name='小松', age=25)     # 猫的init 小松 25

五、属性

# 类中的数据信息就是属性，动作信息就是方法
# 属性：类属性（字段），对象属性
# 1.类属性
"""
怎么定义：直接定义在类中的变量就是类属性
怎么使用：类.类属性名
什么时候用：属性值不会因为对象的不同而不一样（就是对象不同，但是属性值是不变的）
"""


class Person:
    a = 100     # a就是类属性


print(Person.a)         # 100
Person.a = 200
print(Person.a * 2)     # 400


# 2.对象属性
"""
怎么定义：定义在__init__方法里面(‘self.属性名=值’的形式定义)
怎么使用：通过对象使用（对象.属性）
什么时候用：属性值会因为对象不同而不一样，就定义成对象属性
"""


class Person:
    def __init__(self):
        self.name = '小明'
        self.age = 18
        self.gender = '男'


p1 = Person()
print(p1.name, p1.age, p1.gender)       # 小明 18 男


class Student:
    def __init__(self, name1, tel1='110'):
        self.name = name1   # 必须给name赋值
        self.study_id = '000'
        self.tel = tel1     # 可以选择性的给tel赋值


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

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


class Rectangle:
    def __init__(self, long1, wide1):
        self.long = long1
        self.wide = wide1

    def area(self):
        print(f'面积：{self.long * self.wide}')

    def perimeter(self):
        print(f'周长：{(self.long + self.wide) * 2}')


r1 = Rectangle(2, 4)
r1.area()
r1.perimeter()