python面向对象

1、魔法方法

在python中， __ xx __（）的函数叫做魔法方法，指具有特殊功能的函数

1.1、__ init __（）

作用：初始化对象

class Washer():
    def __init__(self):
        self.width = 500
        self.height =800
    def print_info(self):
        print(f'洗衣机的宽度是{self.width},高度是{self.height}')

haier1 = Washer()
haier1.print_info()

注意：

1）、__ init （）方法，在创建一个对象时默认被调用，不需要手动调用。

2）、 __ init __（）（self）中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去

2、带参数的__ init __（）

class Washer():
    def __init__(self,width,height):
        self.width = width
        self.height =height
    def print_info(self):
        print(f'洗衣机的宽度是{self.width},高度是{self.height}')

haier1 = Washer(10,20)
haier1.print_info()
haier2 = Washer(30,40)
haier2.print_info()

3、__ str __（）

放置解释说明的文字

class Washer():
    def __init__(self):
        self.width = 300
    def __str__(self):
        return """解释说明"""

haier1 = Washer()
print(haier1)

4、__ del __（）

当删除对象时，python解释器会默认调用__ del __（）方法

class Washer():
    def __init__(self):
        self.width = 300

    def __str__(self):
        return """解释说明"""


haier1 = Washer()
print(haier1)

2、理解面象对象

是一种抽象化的编程思想。面象对象就是将编程当成一个事务，对外界来说，事务时直接使用的，不用管他内部的情况。而编程就是设置事务能做什么事。

3、类和对象

用类去创建对象。创建的过程是实例化

3.1、定义类

class 类名（）：
    代码。。。。。。。

class Washer():
    def wash(self):
        print('能洗衣服')
haier=Washer()
print(haier)
haier.wash()   #实例方法

3.2、创建对象

对象名=类名（）

3.3、self

调用函数的对象

class Washer():
    def wash(self):
        print('能洗衣服')
        print(self)

haier = Washer()
print(haier)
haier.wash()  #打印对象和打印self 对象地址一样

一个类创建多个对象

class Washer():
    def wash(self):
        print('能洗衣服')
        print(self)

haier1 = Washer()
haier1.wash()
haier2 = Washer()
haier2.wash()

4、添加和获取对象属性

4.1、类外面添加对象属性

对象名.属性名=值

class Washer():
    def wash(self):
        print('能洗衣服')
        print(self)

haier1 = Washer()
haier1.wash()
haier2 = Washer()
haier2.wash()

4.2、类外面获取对象属性

对象名.属性名

class Washer():
    def wash(self):
        print('能洗衣服')

haier1 = Washer()
haier1.width = 400
haier1.height = 500
print(f'洗衣机的宽度是{haier1.width}')
print(f'洗衣机的高度是{haier1.height}')

4.3、类里面获取对象属性

self.属性名

class Washer():
    def wash(self):
        print('能洗衣服')

    #获取实例属性
    def print_info(self):
        print(self.width)
        print(f'洗衣机的宽度是{haier1.width}')
        print(f'洗衣机的高度是{haier1.height}')

haier1=Washer()
haier1.width = 400
haier1.height = 500
haier1.print_info()

5、综合应用

5.1、烤地瓜

需求：被烤时间和对应的地瓜状态：

0-3：生的 3-5：半生不熟 5-8：熟的 超过8分钟：烤糊了

添加调料：用户按照自己意愿添加调料

class SweetPotato():
    def __init__(self):
        # 被烤的时间
        self.cook_time = 0
        # 烤的状态
        self.cook_static='生的'
        # 调料列表
        self.condiments =[]

    def cook(self,time):
        self.cook_time += time
        if 0<=self.cook_time<3:
            self.cook_static='生的'
        elif 3<=self.cook_time<5:
            self.cook_static='半生不熟'
        elif 5<=self.cook_time<8:
            self.cook_static='熟了'
        elif self.cook_time>=8:
            self.cook_static='烤糊了'

    def add_condiments(self,condiment):
        """添加调料"""
        self.condiments.append(condiment)

    def __str__(self):
        return f'这个地瓜的被烤过的时间是{self.cook_time},状态是{self.cook_static},放的调料是{self.condiments}'


digua1 = SweetPotato()
digua1.add_condiments('酱油')
digua1.cook(2)
print(digua1)

5.2、家具

class Furniture():
    def __init__(self,name,area):
        self.name =name
        self.area =area



class Home():
    def __init__(self,address,area):
        self.address =address
        self.area =area
        self.free_area = area
        self.furniture = []

    def __str__(self):
        return f'房子地理位置在{self.address},房屋面积{self.area},剩余面积{self.free_area},家具有{self.furniture}'

    def add_funiture(self,item):
        """容纳家具"""
        if self.free_area >= item.area:
            self.furniture.append(item.name)
            self.free_area -= item.area
        else:
            print('家具太大，剩余面积不足，无法容纳')


#双人床：6
bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)

#房子
jia1 = Home('北京',1000)
print(jia1)

jia1.add_funiture(bed)
print(jia1)

6、继承

继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法。

#定义父类
class A(object):
    def __init__(self):
        self.num =1
    def info_print(self):
        print(self.num)

#定义子类，继承父类
class B(A):
    pass

在python中，所有类默认继承object类，object类是顶级类或基类，其它子类叫做派生类

6.1、单继承

一个类同时继承一个父类

#师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu=['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#定义徒弟类，继承师父类
class Prentice(Master):
    pass

#用徒弟类创建对象，调用实例实行和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

6.2、一个类同时继承多个父类

#师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu=['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu=['黑马煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#定义徒弟类，继承师父类
class Prentice(School,Master):
    pass

#用徒弟类创建对象，调用实例实行和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。

6.3、子类重写父类同名方法和属性

#师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu=['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu=['黑马煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#定义徒弟类，继承师父类
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


#用徒弟类创建对象，调用实例实行和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

#结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

6.4、mro

得到类的继承层级顺序

print(Prentice.__mro__)

6.5、子类调用父类的同名方法和属性

故事：顾客也想吃到古法和黑马的煎饼果子

#师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu=['古法煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu=['黑马煎饼果子配方']
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

#定义徒弟类，继承师父类
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

    #调用父类的方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


#用徒弟类创建对象，调用实例实行和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

6.6、多层继承

故事：N年后，daqiu老了，想要把所有技术传承给自己的徒弟

class Tusun(Prentice):
    pass

xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

6.7super()方法

一次性继承所有父类

    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要修改。1、麻烦、代码冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)
        #方法二：super()
        #2.1 super(当前类名，self).函数()
        # super(Prentice,self).__init__
        # super(Prentice, self).make_old_cake()
        #2.2无参数super()
        super().__init__()
        super().make_old_cake()

super()可以自动查找父类。调用顺序遵循____mro____类属性顺序，比较适合单继承使用

6.8、私有权限

在python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类

在属性和方法前面加__

        self.__money = 2000000   #money是私有属性
    def __info_print(self):
        print('这是私有属性')   #私有方法

6.9、获取和修改私有属性值

在python里面，一般定义函数名get_xx用来获取私有属性，set_xx中修改私有属性值。

    def get_money(self):
        return self.__money
    def set_money(self):
        self.__money = 500