Day18-面向对象

Day18-面向对象

1、正则补充

from re import fullmatch, search, findall, finditer

fullmatch（正则，字符串） - 完全匹配，如果匹配成功返回匹配对象，否则返回None

match（正则，字符串） - 匹配字符串开头，如果匹配成功返回匹配对象，否则返回None

search（正则，字符串） - 匹配第一个满足正则的字符串，如果匹配成功返回匹配对象，否则返回None

findall（正则，字符串） - 获取所有满足正字的字符串，返回值是一个列表，列表中的元素是字符串

finditer（正则，字符串） - 获取字符串中所有满足正则的字串，返回一个迭代器，迭代器中元素是最匹配对象

sub（正则，字符串1，字符串2）/sub（正则，字符串1，字符串2，N）

split（正则，字符串）/split（正则，字符串，N）

匹配对象 - 获取匹配结果

result = search(r’(\d{2})([a-z]{3})', ‘是否合计23mkn822h计划书89js923’)
print(result) <re.Match object; span=(4, 9), match=‘23mkn’>

匹配对象.group( ) - 获取整个正则表达式在字符串中的匹配结果

print(result.group()) ‘23mkn’

匹配对象.group(N) - 获取正则中第N个分组匹配到的结果（捕获第N个分组的内容）

print(result.group(1)) ‘23’
print(result.group(2)) ‘mkn’

result = findall(r’\d{3}', ‘爱好精神亢奋234hjkha 0292数据-2781好久回顾67shjbb298’)
print(result) [‘234’, ‘029’, ‘278’, ‘298’]

result = finditer(r’\d{3}', ‘爱好精神亢奋234hjkha 0292数据-2781好久回顾67shjbb298’)
print(result) <callable_iterator object at 0x7fc6e620e8e0>
print(next(result)) # <re.Match object; span=(6, 9), match=‘234’>

result = findall(r’(\d[A-Z]){2}', ‘爱8K7Mjkhah是件好事就8Y上发挥空间8R8H’)
print(result) [‘7M’, ‘8H’]

result = finditer(r’(\d[A-Z]){2}', ‘爱8K7Mjkhah是件好事就8Y上发挥空间8R8H’)
print([x.group() for x in result])

正则参数

1）忽略大小写 - 匹配的时候小写字母可以直接和对应的大写字母匹配

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

方法2： 给正则相关函数的flags赋值为I或IGNORECASE

result = fullmatch(r’(?i)abc’, ‘AbC’)
print(result)

from re import I, IGNORECASE
result = fullmatch(r’abc’, ‘AbC’, flags=IGNORECASE)
print(result)

单行匹配

正则匹配的时候默认是多行匹配，多行匹配的时候，不可以和\n进行匹配

单行匹配下，可以和\n进行匹配

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

方法2： 给正则相关函数的flags赋值为S

from re import S
result = fullmatch(r’(?s)a.b’, ‘a\nb’)
print(result)

result = fullmatch(r’a.b’, ‘a\nb’, flags=S)
print(result)

file_content = open(‘data.txt’, encoding=‘utf-8’).read()
result = findall(r’(?s)名字：(.+?);', file_content)
print(result)

一起用：

result = fullmatch(r’(?si)a.b’, ‘A\nb’)
print(result)

result = fullmatch(r’a.b’, ‘A\nb’, flags=I|S)
print(result)

2、编程思想

面向过程编程（穷人思想） - 遇到问题马上就想怎么按照步骤一步一步解决这个问题

函数式编程（小资思想） - 遇到问题先思考有没有一个已经存在的函数具备这个功能，如果有直接调用函数，没有就去创建具备这个功能的函数

面向对象编程（富豪思想） - 遇到问题就先思考有没有一个对象具备解决这个问题的的能力，如果有就直接用，没有就创建一个这样的对象，没有还要创建类

计算1+2+3+4+…+100
s = 0
for x in range(1, 101):
s += x
print(s)

print(sum(range(1, 101)))

3、认识类和对象

类 - 类型、分类

类就是拥有相同功能相同属性的对象的集合 - 类是一个抽象的概念

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

例如：人是类 - 具体的一个人就是人的对象

​ 杯子是类 - 具体的一个杯子就是杯子的对象

定义类（创建类） - 用代码说清楚这个类是拥有哪些相同功能和哪些相同属性的对象的集合

定义类的任务：用代码说清楚这个类是拥有哪些相同功能和哪些相同属性的对象的集合

相同功能 - 用函数描述功能

相同属性 - 用变量描述属性

定义类的语法：

class 类名：

类的说明文档

类的内容（由属性和方法组成）

说明：

class - 关键字，固定写法

类名 - 由程序员自己命名

要求：是标识符，不是关键字

规范：见名知义，采用驼峰式命名，并且第一个字母大写，不适应系统函数名、类名、模块名

‘：’ - 固定写法

类的说明文档 - 多行注释

类的内容 - 由属性和方法组成

属性 - 定义在类中的变量

方法 - 定义在类中的函数

class Person:
“”“人类”“”
pass

创建对象
语法：
类名()

p1 = Person()
p2 = Person()
print(p1)
print(p2)

4、类中的方法

方法就是定义在类中的函数，它是用来描述这个类具备的相同功能有哪些

方法分为：对象方法、类方法、静态方法

01）对象方法

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

怎么调用：通过’对象.xxx( )'的形式调用对象方法

特点：自带参数self，通过对象调用这个方法的时候self不需要传参，系统会自动将当前对象传给self（谁调用self就指向谁）

使用场景：如果实现函数的功能需要对象（需要对象属性），就将函数定义为对象方法

02）类方法

怎么定义：在定义函数前加装饰器：@classmethod

怎么调用：通过’类.xxx( )'的形式调用类方法

特点：自带参数cls，通过对象调用这个方法的时候cls不需要传参，系统会自动将当前对象传给cls（谁调用cls就指向谁）

使用场景：如果实现函数的功能不需要对象，就使用静态方法或者类方法

03）静态方法

怎么定义：在定义函数前加装饰器：@staticmethod

怎么调用：通过’类.xxx( )'的形式调用静态方法

特点：无

使用场景：如果实现函数的功能不需要对象，就使用静态方法或者类方法

class A:
def func1(self):
print(‘对象方法’, self)

def func11(self, x, y=2):
    print(x, y)

@classmethod
def func2(cls):
    print('类方法', cls)

@staticmethod
def func3():
    print('静态方法')

a = A() # 创建A的对象
b = A()
print(‘a:’, a)
print(‘b:’, b)

用对象调用对象方法(给对象发func1的消息)

b.func1()
a.func11(100, 200)
a.func11(y=100, x=50)

用类调用类方法

A.func2()
print(‘A:’, A)

用类调用静态方法

A.func3()

5、初始化方法

__init__方法   -  初始化方法

__init__方法是Python类中的一个魔法方法。

魔法方法：类中所有名字以两个下划线开头并且以两个下划线结尾的方法名都是魔法方法，所有的魔法方法都不需要程序员去调用，系统

会在特定情况下自动调用对应的魔法方法。

注意：python的类有哪些魔法方法是固定的，每个魔法方法什么时候调用也是固定。

__init__在通过类创建对象的时候会被自动调用。（每次通过类创建对象的时候，系统都会自动调用这个类中的__init__方法）

class A:
def init(self):
print(‘init方法被调用’)

a = A()
b = A()

class B:
def init(self, x, y=2):
print(‘B的init被调用’, x, y)

创建类的对象的时候需不需要参数，需要几个参数由这个类中的__init__方法决定

a1 = B(10, 20)
a2 = B(y=20, x=10)

6、属性

属性就是定义在类中的变量，属性分为类属性和对象属性两种

01）类属性

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

使用：通过’类.xxx’的形式来使用类属性

什么时候用：如果属性值不会因为对象不同而不一样就定义为类属性

02）对象属性

定义：以’self.属性名=值’的形式定义在——int——方法中

使用：通过’对象.xxx’的形式来使用对象属性

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

class A:

​ x、name是类属性
​ x = 10
​ name = ‘小明’

# y和m是对象属性
def __init__(self):
    self.y = 20
    self.m = 'abc'

通过类使用类属性

print(A.x, A.name)
A.name = ‘张三’
print(A.name)

通过对象使用对象属性

obj1 = A()
print(obj1.y, obj1.m)

对象属性赋默认值的方法：

a. 赋一个固定的值

b. 用一个没有默认值的形参赋值

c. 用一个有默认值的形参赋值

class Person:
    def __init__(self, name, gender='女'):
        self.name = name
        self.gender = gender

p1 = Person(‘张三’, ‘男’)
p2 = Person(‘小花’)
print(p1.name, p2.name)

案例：定义圆类，拥有属性半径和圆周率，方法：求圆的面积、求圆的周长

class Circle:
pi = 3.1415926

def __init__(self, r):
    self.r = r

def get_area(self):
    # self = c1
    # self = c2
    # 在实现函数功能的时候如果需要对象属性，就通过self来提供
    return Circle.pi * self.r ** 2

c1 = Circle(1)
c2 = Circle(10)
print(c1.get_area())
print(c2.get_area())

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

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

r1 = Rectangle(10, 5)
r2 = Rectangle(25, 15)
print(r1.perimeter())
print(r2.perimeter())