python面向对象之类和继承

1 类

1.1 类基本语法

# 1.定义类
class Washer():

    def wash(self):
        print('洗衣服。。。')
        print(self)     

# 2.创建对象
haier = Washer()

# 3.1 打印对象
print(haier)   # 输出对象地址
# 3.2 使用方法
haier.wash()  #  self输出 调用该函数的对象地址

1.2 self 调用该函数的对象

1.3 外部定义类属性并获取

• 语法

对象.属性 = 值  # 定义
对象.属性   # 调用

• 代码

# 5.外部定义属性并调用
haier.height = 400
haier.width = 500

print(haier.height)
print(haier.width)

1.4 类里面获取对象属性

• 语法

self.属性

• 代码

class Washer():

    def wash(self):
        print('洗衣服。。。')
        print(self)

    # 类里面调用对象属性
    def print_info(self):
        print(f'冰箱宽度为{self.width}')  # 类内部调用属性
        print(f'冰箱高度为{self.height}')
haier = Washer()
haier.width = 400
haier.height = 800

haier.print_info() 

1.5 __init__()特殊函数

__init__()初始化对象，默认被调用，默认第一个参数为self

• 语法

    def __init__(self,属性1):
        self.属性 = 属性

• 代码

# 定义类，使用__init__函数，并初始化属性，在方法中调用该属性
class Washer():

    def __init__(self,h,w):
        self.h = h
        self.w = w

    def print_info(self):
        print(f'洗衣机高：{self.h},宽：{self.w}')

#创建对象
haier = Washer(10,100)
geli = Washer(30,300)
#调用对象方法

haier.print_info()
geli.print_info()

1.6 __str__() 和 __del__()特殊方法

• 语法

    def __str__(self):
        return '解释说明：这个一个说明书'
    将原本print(对象) 输出的对象地址 更改为 return的值
    将无意义的地址 更改为 有意义的信息

    def __del__(self):
        print(f'{self}对象已删除')
    默认调用__del__()方法，结束时自动删除对象

1.7 小结

• 面向对象组成之类

  • 类
    • 创建类

    class 类名():
        方法
    

  • 对象

    对象名 = 类名()
    

• 添加对象属性

  • 类里面

  self.属性名 = 值
  

  • 类外面

  对象名.属性名 = 值
  

• 调用对象属性

  • 类里面

  self.属性名
  

  • 类外面

  对象名.属性名
  

• 特殊方法

  • __init__()
  • __str__()
  • __del__()

2 继承

2.1 继承基本语法

• 语法

class 类名1(object):
    代码

class 类名2(类名1):
    pass

此时 类2 继承了 类1 的所有方法和属性

默认所有类都继承object类，object为顶级类或基类，其他所有子类称派生类

2.2 单继承

只继承了一个父类

# 创建父类
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 子类继承
class B(A):
    pass

# 子类直接调用父类方法属性
result = B()
result.info_print()

2.3 多继承

一个子类继承多个父类，同时继承所有父类的属性和方法

如果多个父类相同的属性和方法，则继承第一个

class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

    def haha(self):
        print('haha')

class Aaa(object):

    def __init__(self):
        self.num = 2

    def info_print(self):
        print(self.num)

class B(Aaa, A):   # 继承第一个Aaa类的同名属性方法
    pass


result = B()
result.info_print()  # 2
result.haha()   # haha

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

通过 子类名.__mro__ 打印子类的所有父类

class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

    def haha(self):
        print('haha')

class Aaa(object):

    def __init__(self):
        self.num = 2

    def info_print(self):
        print(self.num)

class B(Aaa, A):

    def __init__(self):   # 重写了父类的同名方法
        self.num = 3    # 重写了父类的同名属性

    def haha(self):     # 重写了父类的同名方法
        print('HAHA')


result = B()
result.info_print()  #  3
result.haha()      # HAHA

print(B.__mro__) 
# (<class '__main__.B'>, <class '__main__.Aaa'>, <class '__main__.A'>, <class 'object'>)

2.5 子类调用父类同名属性方法

• 语法

class B(A1,A2):
    ...
    def 同名方法名(self):
        self.__init__()
        方法代码
    
    def 新方法名(self):
        父类名.__init__(self)     # 必须初始化父类的属性，这样后面父类调用的才是父类的属性
        父类名.同名方法名(self)

• 实例

class A1(object):  # 父类1
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

    def haha(self):
        print('haha')

class A2(object):  # 父类2

    def __init__(self):
        self.num = 2

    def info_print(self):
        print(self.num)

class B(A2, A1):  # 子类继承多父类同名方法

    def __init__(self):
        self.num = 3

    def info_print(self):
        self.__init__()   # 防止调用父类同名属性方法后被覆盖
        print(self.num)

    def A1_info_print(self):  # 调用父类的同名函数
        A1.__init__(self)     # 必须初始化父类的属性，这样后面父类调用的才是父类的属性
        A1.info_print(self)

    def A2_info_print(self):
        A2.__init__(self)
        A2.info_print(self)



result = B()
result.info_print()  # 3
result.A1_info_print()  # 1   
result.A2_info_print()  # 2
result.info_print()  # 3

2.6 多层继承

B类继承了A类，C类继承了B类，则C类继承了A、B所有的方法和属性

2.7 super在子类中调用父类的函数

如果有多个父类，默认调用第一个
可以通过多层继承迭代调用父类

    def super_print(self):
        # 2.1 super(类名,self)调用父类方法
        super(B,self).__init__()
        super(B,self).info_print()

        # 2.2 super() 调用父类方法  常用方式
        super().__init__()
        super().info_print()

2.8 私有属性和方法

• 语法

self.__属性

def __函数名():

此时类外面无法直接访问

2.9 私有属性的访问和设置

• 通过get_xx() 和 set_xx()函数访问设置

class B(A1,A2):

    def __init__(self):
        self.num = 3
        self.__num = 5

    def get_num(self):
        return self.__num

    def set_num(self,num):
        self.__num = num

result = B()
print(result.get_num())  # 访问私有属性
result.set_num(100)      # 设置私有属性
print(result.get_num())  

• 也可以直接访问私有属性，只是需要添加 _类名 ，被隐藏了
  print(result._B__num)

2.10 继承小结

• 继承基本方式
  • 单继承
  • 多继承
  • 多层继承
• 同名方法属性
  • 重写父类的同名方法
  • 访问父类的同名方法
    • 再写方法调用
    • super(类名,self)
    • super()快速调用 （最常用）
• 私有属性和方法定义及如何访问