Day13 面向对象编程

1. 编程思想

不同程序员在遇到问题解决问题的思维不同

1.面向过程的编程（穷人思想） - 基本语法和逻辑

2.函数式编程（小资思想） - 掌握函数（遇到问题先考虑有没有已存在的函数具备解决问题的能力，没有就创建这个函数）

3.面向对象编程（富豪思想） - 掌握类、对象（变量、函数）

2. 认识类和对象

2.1 什么是类、什么是对象

类就是拥有相同功能和相同属性的对象的集合:抽象的概念;对象就是类的示例,是类型、类别

• 人是类，具体的一个人就是对象
• 电脑是类，具体的一台电脑就是对象（有具体的品牌、CPU、显示屏）
• list是类，[10, 20]就是列表的对象

2.2 定义类（创建类）

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

• 功能 - 函数
• 属性 - 保存数据的变量

语法：

class 类名:
    类的说明文档
    类的内容
1
2
3

说明：
1）class - 关键字；固定写法
2）类名 - 程序员自己命名
规范：见名知意，采用驼峰式命名并且首字母大写。（驼峰式：第二个单词的首字母也大写）
3）： - 固定写法
4）类的说明文档 - 多行注释
5）类的内容 - 相同功能和相同属性。
有方法（对象方法、类方法、静态方法）和属性（对象属性、类属性）组成
方法 - 定义在类中的函数
属性 - 定义在类中的变量

创建一个人类的类

class Person:
    '''
    人类
    '''
    num = 61          # num是属性

    def eat(self):    # eat是方法
        print('吃饭')

    def sleep(self):
        print('睡')
1
2
3
4
5
6
7
8
9
10
11

2.3 创建对象

语法： 类名() - 创建指定类对应的一个对象，并且将对象返回

p1 = Person()
p2 = Person()
print(p1, p2)
1
2
3

3. 类中的方法

定义在类中的函数用，用来描述具备的功能
类中的方法有三种：对象方法、类方法、静态方法

3.1 对象方法

a.怎么定义：将函数直接定义在类中
b.怎么调用：通过对象来调用 - 对象.xxx()
c.特点：自带参数self，通过对象调用对象方法的是参数self不需要传参，系统会自动将当前对象传给self（self，谁调用就指向谁）
d.什么时候用：如果实现函数的功能需要用到对象属性就使用对象方法

3.2 类方法

a.怎么定义：定义函数前加装饰器’@classmethod’
b.怎么调用：通过类来调用 - 类名.xxx()
c.特点：自带参数cls，调用的时候不需要传参，系统自动将当前类传给cls
d.什么时候用：如果实现函数的功能不需要对象属性需要类就用类方法

3.3 静态方法

a.怎么定义：定义函数前加装饰器’@staticmethod’
b.怎么调用：通过类来调用 - 类名.xxx()
c.特点：没有特点
d.什么时候用：实现函数功能既不需要对象属性也不需要类，就用静态方法

class A:
    def func1(self):
        print(f'self:{self}')
        print('对象方法')

    def func11(self, x, y):
        print('对象方法2')

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

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


a = A()
b = A()
print(f'a:{a}')
# 通过对象调用对象方法
a.func1()
b.func11(200, 200)
a.func11(x=100, y=200)

# 通过类调用对象方法
A.func2()

# 通过静态调用对象方法
A.func3()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

a:<main.A object at 0x000001C843A57B20>
self:<main.A object at 0x000001C843A57B20>
对象方法
对象方法2
对象方法2
类方法
静态方法

4. 初始化方法

4.1 魔法方法

方法名以__（两个下划线）开头, 并且以__结尾的自带的方法，就是魔法。
所有的魔法方法都会在特定的时机，特定的情况下自动调用

常用的魔法方法：__init__方法、__repr__方法

4.2 repr

打印对象的时候会自动调用对象对应的类中的__repr__方法，来制定打印规则（函数的返回值是什么，对象的打印结果就是什么）
返回值必须是字符串！

class A:
    def __repr__(self):
        return 'abc'
    pass


a = A()   # 使用类
print(f'a1:{a}')

a2 = A()
print(f'a2:{a2}')
1
2
3
4
5
6
7
8
9
10
11

a1:abc
a2:abc

4.3 init

每次创建类的对象的时候会自动调用类中的__init__方法

class B:
    def __init__(self):
        print('init方法')


b = B()
b2 = B()
# print(b, b2)


class C:
    # 在类中添加__init__方法的时候，除了方法名和方法类型不能动，可以随意添加参数和随意添加函数体
    def __init__(self, x, y):
        print('C的init方法', x, y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

init方法
init方法

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

c = C(10, 20)
c1 = C(100, 200)
c2 = C(x=1, y=2)
1
2
3

C的init方法 10 20
C的init方法 100 200
C的init方法 1 2

5.属性

5.1 属性分类

分为对象属性和类属性两种

1）类属性
a.怎么创建：在类中直接定义一个变量，这个变量就是类属性
b.怎么使用：通过类来使用 - 类.xxx
c.什么时候用：当属性值不会因为对象不同而不一样的时候就使用类属性

2）对象属性
a.怎么创建：以self.属性名=值的形式定义在类的__init__方法
b.怎么使用：通过对象来使用 - 对象.属性名
c.什么时候用：当属性值会因为对象不同而不一样的时候就使用类属性

class A:
    # x是类属性
    x = 100

    # name 和 num 是对象属性
    def __init__(self):
        self.name = '小明'
        self.num = 10


# 使用类属性
print(A.x)

# 修改类属性的值
A.x = 200
print(A.x)


a = A()
# 使用对象属性的值
print(a.name, a.num)

# 修改对象属性的值
a.name = '小花'
a.num = 11
print(a.name, a.num)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

100
200
小明 10
小花 11

练习：定义一个圆的类，属性半径和圆周率，方法：求周长和求面积

class Circle:
    Pi = 3.1415926

    def __init__(self):
        self.radius = 5

    # 需要类中属性和对象的属性
    # 类中实现函数功能的时候如果需要的数据是属性，不需要提供额外的参数
    # 求面积
    def get_area(self):
        return Circle.Pi * self.radius ** 2

    # 求周长
    def get_perimeter(self):
        return 2 * Circle.Pi * self.radius


c1 = Circle()
c1.radius = 5
print(f'面积为：{c1.get_area()}，周长为：{c1.get_perimeter()}')

c2 = Circle()
c2.radius = 6
print(f'面积为：{c2.get_area()}，周长为：{c2.get_perimeter()}')

c3 = Circle()
c3.radius = 10
print(f'面积为：{c3.get_area()}，周长为：{c3.get_perimeter()}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

5.2 对象属性赋初始值的方式

创建一个人类的类，那如何来赋初始值呢

class Person:
    def __init__(self, name, gender='男'):
        self.name = name      # 通过没有默认值的参数来赋值
        self.age = 0          # 赋一个固定的值
        self.gender = gender  # 使用有默认值的参数来赋值

    def __repr__(self):
        return str(self.__dict__)

p1 = Person('小明')
print(p1.name, p1.age, p1.gender)


p2 = Person('小花', '女')
print(p2.name, p2.age, p2.gender)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习2：创建一个矩形类（根据生活扩展类的内容）

class Ractangle:
    def __init__(self, lenth, width):
        self.lenth = lenth
        self.width = width

    def get_area(self):
        return self.lenth * self.width

    def get_per(self):
        return 2 * (self.lenth + self.width)

    def __repr__(self):
        return print(f'面积为：{self.get_area()}，周长为：{self.get_per()}')


r1 = Ractangle(5, 4)
print(r1.get_area(), r1.get_per())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

20 18

6. 属性的增删改查

6.1 在面向对象编程的时候，可以直接使用对象来代替字典

stu1 = {'name': '小明', 'age': 12, 'score': 67}
stu2 = {'name': '小花', 'age': 19, 'score': 100}
1
2

代替为：

class Student:
    def __init__(self, name, age=0, score=0):
        self.name = name
        self.age = age
        self.score = score

    def __repr__(self):
        return str(self.__dict__)


stu1 = Student('KathAmy', 19, 100)
stu2 = Student('猪猪侠', 1, 100)
print(stu1)
print(stu2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

{‘name’: ‘KathAmy’, ‘age’: 19, ‘score’: 100}
{‘name’: ‘猪猪侠’, ‘age’: 1, ‘score’: 100}

6.2 对象的对象属性支持增删改查的操作

1）查 - 查的意义是获取属性值
a.对象.属性 —— 获取指定属性的值，属性不存在报错
b.getattr(对象, 属性名) —— 获取指定属性的值，属性不存在报错
c.getattr(对象, 属性名, 默认值) —— 获取制定属性的值，属性不存在直接返回默认值

# stu1:{'name': 'KathAmy', 'age': 19, 'score': 100}
# stu2:{'name': '猪猪侠', 'age': 1, 'score': 100}
print(stu1.name)
print(getattr(stu1, 'name'))

# print(stu1.gender)            # 报错！
# print(getattr(stu1, 'gender'))
print(getattr(stu1, 'gender', '男'))
1
2
3
4
5
6
7
8

KathAmy
KathAmy
男

2）增、改
a.对象.属性 = 值 —— 当属性存在的时候修改这个值，当属性不存在的时候给对象添加属性
b.setattr(对象, 属性名, 值) —— 当属性存在的时候修改指定属性对应的值，当属性不存在的是给对象添加属性

print(stu1)    
# {'name': 'KathAmy', 'age': 19, 'score': 100}

stu1.age = 22
print(stu1)    
# {'name': 'KathAmy', 'age': 22, 'score': 100}

stu1.gender = '男'
print(stu1)  
# {'name': 'KathAmy', 'age': 22, 'score': 100, 'gender': '男'}

setattr(stu1, 'study_id', '001')
print(stu1)     
# {'name': 'KathAmy', 'age': 22, 'score': 100, 'gender': '男', 'study_id': '001'}

setattr(stu1, 'score', '76')
print(stu1)     
# {'name': 'KathAmy', 'age': 22, 'score': '76', 'gender': '男', 'study_id': '001'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3）删
del 对象.属性
delatter(对象，属性名)

print(stu1)
# {'name': 'KathAmy', 'age': 22, 'score': '76', 'gender': '男', 'study_id': '001'}

del stu1.age
print(stu1)
# {'name': 'KathAmy', 'score': '76', 'gender': '男', 'study_id': '001'}

delattr(stu1, 'name')
print(stu1)
# {'score': '76', 'gender': '男', 'study_id': '001'}
1
2
3
4
5
6
7
8
9
10

4）判断属性是否存在
hasattr(对象, 属性名)

print(stu1)
# {'score': '76', 'gender': '男', 'study_id': '001'}

print(hasattr(stu1, 'name'))  # False

print(hasattr(stu1, 'score'))  # True

if not hasattr(stu1, 'name'):
    stu1.name = '小明'

print(stu1)
# {'score': '76', 'gender': '男', 'study_id': '001', 'name': '小明'}
1
2
3
4
5
6
7
8
9
10
11
12

7. 继承

7.1 认识继承

让子类直接拥有父类的属性和方法
父类就是一个大的类，子类就是这个大的类下面的小的分类

7.2 继承的语法

'''
class 类名（父类）：
    类的说明文档
    类的内容
'''
1
2
3
4
5

注意：定义类的时候如果没有写父类，这个类默认继承object（基类）–（就像吸血鬼日记中的初代吸血鬼）

class A:
    a = 100

    def __init__(self):
        self.b = 10
        self.c = 20

    def func1(self):
        print('对象方法')

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

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


class B(A):
    pass


print(B.a)

x = B()
print(x.b, x.c)

x.func1()

B.func2()
B.func3()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

100
10 20
对象方法
类方法
静态方法

7.3 在子类添加内容

子类在拥有父类的属性和方法的同时,往往需要由属于自己特有的一些属性和方法
1）添加类属性和方法
直接在子类中定义新的类属性和新的方法

2）添加对象属性
需要在子类的__init__方法中通过supper()去调用父类的__init__方法来继承父类的对象属性

class C(A):
    m = 11

    def __init__(self):
        super().__init__()  # 调用当前父类的__init__()
        self.name = '小明'

    def func11(self):
        print('C的对象方法')

    @classmethod
    def func22(cls):
        print('C的类方法')

    @staticmethod
    def func33():
        print('C的静态方法')

    def func1(self):
        print('C的对象方法2')


print(C.a, C.m)

x = C()
print(x.name)
print(x.b, x.c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

100 11
小明
10 20