面向对象基础

面向对象基础

编程思想

编程思想：程序员在遇到问题解决问题的思维模式。
1.面向过程编程(穷人思想) - 基本语法、逻辑
2.函数式编程(小资思想) - 掌握函数(有函数用函数，没有函数创建函数)
3.面向对象编程(富豪思想) - 要有类、对象(变量、函数)

认识类和对象

1.什么是类、什么是对象

类就是拥有相同功能和相同属性的对象的集合 - 抽象的概念
对象就是类的实例(类具体的表现)
类就是类型、类别
如：
人是类，具体的应该 人就是它的对象
电脑是类，我的桌上这台电脑是它的对象
杯子是类，我桌上的三个杯子是它的对象
list是类，[10, 20]是列表的对象

2.定义类(创建类)

用代码描述清楚这个类是拥有哪些想吐的功能和哪些相同属性的对象的集合
功能 - 函数
属性 - 保存数据的变量
语法：
class 类名：
(缩进)类的说明文档
(缩进)类的内容
说明：
1)class - 关键字；固定写法
2)类名 - 程序员自己命名(采用驼峰式命名并且首字母大写；驼峰式 - 从第二个单词开始单词首字母大写)
3): - 固定写法
4)类的说明文档 - 多行注释
5)类的内容 - 相同功能和相同属性；由方法(对象方法、类方法、静态方法)和属性(对象属性、类属性)组成
方法 - 定义在类中的函数
属性 - 定义在类中的变量

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

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

    def sleep(self):
        print('睡')

3.创建对象

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

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

类中的方法

方法：定义在类中的函数用来描述具备的功能
类中的方法：对象方法、类方法、静态方法
1)对象方法
a.怎么定义:将函数字节定义在类中
b.怎么调用:通过对象来调用 - 对象.xxx()
c.特点:自带参数self，通过对象调用对象方法的时候，参数self不需要传参，系统会自动将当前对象传给self，self谁调用就指向谁。
d.什么时候用：如果实现函数的功能需要用到对象属性就使用对象方法
2)类方法
a.怎么定义:定义函数前加装饰器’@classmethod’
b.怎么调用:通过类来调用 - 类名.xxx
c.特点:自带参数cls，调用时不需要传参，系统自动将当前类传给cls。
d.什么时候用：如果实现函数功能不需要对象属性需要类就是用类方法
3)静态方法
a.怎么定义:定义函数前加装饰器’@staticmethod’
b.怎么调用:通过类来调用 - 类名.xxx
c.特点:没有特点
d.什么时候用：实现函数功能既不需要对象属性也不需要类属性就用静态方法

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

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

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


# 通过对象调用对象方法
a = A()
b = A()
print(f'a:{a}')
a.func1()
# 通过类调用类方法
A.func2()
# 通过类调用静态方法
A.func3()

初始化方法

1.魔法方法

方法名以’__‘开头并且以’__'结尾的自带的方法，就是魔法方法
所有的魔法方法都会特定的情况下被自动调用。
常用的魔法方法:__init__方法、__repr__方法
1)__repr__方法：
打印对象的时候会自动调用对象对应的类中的__repr__方法，来定制打印规则(函数的返回值时什么，对象的打印结果就是什么)，
返回值必须时字符串。

class A:
    def __repr__(self):    # 左右是两个下划线
        return 'abc'


a1 = A()
print(f'a1:{a1}')
a2 = A()
print(f'a2:{a2}')

2)___init__方法:
创建类的对象的时候会自动调用类中的__init___方法

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


b1 = B()
b2 = B()


class C:
    # 在类中添加__init__方法的时候，除了方法名和方法类型不能动，可以随意添加参数和随意添加函数体
    def __init__(self, x, y):
        print('C的init方法')


# 创建类的对象的时候需不需要参数，需要及格参数，由类中__init__方法决定
c1 = C(10, 20)
c2 = C(100, 200)
c3 = C(x=1, y=2)

属性

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)

2.对象属性赋初始值的方式

class Person:
    def __init__(self, name, gender='男'):
        self.name = name    # 使用没有默认值的参数来赋值
        self.age = 1    # 赋固定的值(无法修改)
        self.gender = gender    # 使用有默认值的参数来赋值(可以修改)

    def __repr__(self):
        # return f'name:{self.name}, age:{self.age}, gender:{self.gender}'
        return str(self.__dict__)


p1 = Person('小明')
print(p1.name, p1.age, p1.gender)
p2 = Person('小花', '女')
print(p2.name, p2.age, p2.gender)
print(p1)  # {'name': '小明', 'age': 1, 'gender': '男'}
print(p2)  # {'name': '小花', 'age': 1, 'gender': '女'}

练习1：定义一个圆的类，拥有属性：半径(对象属性)和圆周率(类属性)，拥有方法求周长和求面积

class Circle:
    pi = 3.1415926

    def __init__(self):
        self.r = 2

    # 类中实现函数功能的时候如果需要的数据是属性，不需要提供额外的参数
    def get_area(self):
        # self = c1, self = c2   (谁调用指向谁)
        # 如果需要类属性直接用类来提供
        # 如果需要对象属性用self来提供
        return Circle.pi * self.r ** 2

    def get_perimeter(self):
        return 2 * Circle.pi * self.r


c1 = Circle()
c2 = Circle()
c2.r = 3
print(c1.get_area(), c2.get_area())

练习2：创建一个矩形类(根据生活拓展类的内容)

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

    def area(self):
        return self.long * self.wide

    def perimeter(self):
        return 2 * self.long + 2 * self.wide

    def __repr__(self):
        # return f'长度:{self.long}, 宽度:{self.wide}, 面积:{self.area()}, 周长:{self.perimeter()}'
        return f'<{str(self.__dict__)[1:-1]}>'


r1 = Rectangle(10, 20)
print(r1.area(), r1.perimeter())
print(r1)   # 长度:10, 宽度:20, 面积:200, 周长:60
r2 = Rectangle(5, 5)
print(r2)   # <'long': 5, 'wide': 5>

属性的增删改查

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

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

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


stu1 = Student('小红', 12, 67)
stu2 = Student('小花', 19, 100)
print(stu1, stu2)

2.对象的对象属性支持增删改查

1)查 - 获取属性值
a.对象.属性 - 获取指定属性的值(属性不存在，报错)
b.getattr(对象, 属性名) - 获取指定属性的值(属性不存在，报错)
c.getattr(对象, 属性名, 默认值) - 获取指定属性的值

print(stu1.name)   # 小红
print(getattr(stu2, 'name'))   # 小花

# print(stu1.gender)  # 报错！
# print(getattr(stu1,'gender'))   # 报错
print(getattr(stu1, 'gender', '男'))    # 男

2)增、改
a.对象.属性 = 值 - 当属性存在时，修改指定属性对应的值；当属性不存在的时候，给对象添加属性。

print(stu1)   # {'name': '小红', 'age': 12, 'score': 67}
stu1.age = 22
print(stu1)   # {'name': '小红', 'age': 22, 'score': 67}
stu1.gender = '女'
print(stu1)   # {'name': '小红', 'age': 22, 'score': 67, 'gender': '女'}

b.setattr(对象,属性名,值) - 当属性存在时，修改指定属性对应的值；当属性不存在的时候，给对象添加属性。

setattr(stu1, 'score', 76)
print(stu1)   # {'name': '小红', 'age': 22, 'score': 76, 'gender': '女'}
setattr(stu1, 'study_id', '001')
print(stu1)   # {'name': '小红', 'age': 22, 'score': 76, 'gender': '女', 'study_id': '001'}

attr相关函数可以动态操作对象属性

value = input('请输入你想要查看的数据：')
# print(stu1.value)
print(getattr(stu1, value))

3)删
del 对象.属性 - 删除指定属性
delattr(对象,属性名) - 动态的确定需要删除的属性

print(stu1)  # {'name': '小红', 'age': 22, 'score': 76, 'gender': '女', 'study_id': '001'}

del stu1.age
print(stu1)  # {'name': '小红', 'score': 76, 'gender': '女', 'study_id': '001'}

delattr(stu1, 'name')
print(stu1)   # {'score': 76, 'gender': '女', 'study_id': '001'}

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

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

继承

1. 继承 - 让子类直接用拥有父类的属性和方法

父类就是一个大的类，子类是这个大的类下面的一个小的分类

2. 继承的语法

class 类名(父类):
(缩进)类的说明文档
(缩进)类的内容
注意：定义类的时候如果没有写父类，这个类默认继承object(基类)

# class Person:  == class Person(object):
class Person:
    pass

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()

3.子类添加内容

子类在拥有父类的属性和方法的同时，往往需要由属于自己特有的一些属性和方法.
1)添加类属性和方法
直接在子类中定义新的类属性和新的方法
2)添加对象属性
需要在子类的__init__方法中通过super()去调用父类的__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)