Python面向对象、继承的基本语法、单继承和多层继承、子类重写父类的同名方法、子类调用父类的同名方法、继承中的 init 、 多继承、私有权限、类属性、类方法、静态方法、多态、鸭子类型

简介: 称为类 B 继承类 A特点: B类的对象可以使用 A类的属性和方法优点: 代码复用.重复相同的代码不用多次书写.名词:类A: 父类 基类类B: 子类 派生类2. 单继承和多层继承[理解]单继承: 如果一个类只有一个父类,把这种继承关系称为单继承多继承: 如果一个类有多个父类,把这种继承关系称为多继承多层继承: C–> B --> A3. 子类重写父类的同名方法[掌握]重写: 子类定义和父类名字相同的方法.为什么重写: 父类中的方法,不能满足子类对象的需求,所以

@[toc]

1. 继承的基本语法[掌握]

  • 继承: 描述的类与类之间所属关系.
  • 基本语法:
class 类B(类A):
    pass
  • 称为类 B 继承类 A
  • 特点: B类的对象可以使用 A类的属性和方法
  • 优点: 代码复用.重复相同的代码不用多次书写.
  • 名词:

    1. 类A: 父类 基类
    2. 类B: 子类 派生类
# 1. 定义是个 动物类 animal类
class Animal(object):
    # 2. 在animal类书写 play方法,输出二哈在拆家....
    def play(self):
        print('二哈在拆家....')


# 3. 定义Dog类继承animal类,
class Dog(Animal):
    pass


# 4. 创建dog类对象.调用父类的方法
dog = Dog()
dog.play()

2. 单继承和多层继承[理解]

  • 单继承: 如果一个类只有一个父类,把这种继承关系称为单继承
  • 多继承: 如果一个类有多个父类,把这种继承关系称为多继承
  • 多层继承: C--> B --> A
# 1. 定义是个 动物类 animal类
class Animal(object):  # 对于Animal类和object类来说,单继承
    # 2. 在animal类书写 play方法,输出二哈在快乐的拆家....
    def play(self):
        print('二哈在快乐的拆家....')


# 3. 定义Dog类继承animal类,
class Dog(Animal):  # Dog --> Animal 也是单继承, Dog --> Animal --> object 这种继承关系称为多层继承
    def bark(self):
        print('萨摩耶在睡觉.......')


# 定义类 XTQ类, 继承 Dog类
# 多层继承中,子类可以使用所有继承链中的类中的方法和属性
class XTQ(Dog):  # XTQ --> Dog 单继承, XTQ --> Dog --> Animal 类, 多层继承
    pass


xtq = XTQ()
xtq.bark()  # 调用父类Dog中的方法
xtq.play()  # 调用爷爷类 animal类中的方法

3. 子类重写父类的同名方法[掌握]

  • 重写: 子类定义和父类名字相同的方法.
  • 为什么重写: 父类中的方法,不能满足子类对象的需求,所以要重写.
  • 重写之后的特点: 子类对象调用子类自己的方法,不再调用的方法,父类对象调用父类自己的方法.
# 1. 定义Dog类, 书写bark方法, 输出 萨摩耶在睡觉
class Dog(object):
    def bark(self):
        print('萨摩耶在睡觉.........')


# 2. 定义XTQ类,继承Dog类. 重写父类中的bark方法, 输出 萨摩耶在洗澡
class XTQ(Dog):
    def bark(self):
        print('萨摩耶在洗澡--------')


# 创建Dog类对象
dog = Dog()
dog.bark()  # 父类自己的

# 创建XTQ类对象
xtq = XTQ()
xtq.bark()

4. 子类调用父类的同名方法[掌握]

# 1. 定义Dog类, 书写bark方法, 输出 萨摩耶在睡觉
class Dog(object):
    def bark(self):
        print('萨摩耶不理主人.........')


# 2. 定义XTQ类,继承Dog类. 重写父类中的bark方法, 输出 萨摩耶在洗澡
class XTQ(Dog):
    def bark(self):
        print('萨摩耶跑过来了--------')

    def see_host(self):
        """看见主人之后,要跑过来,不能不理主人"""
        print('看见主人了,', end='')
        # self.bark()
        # 想要在子类中调用父类的同名方法
        # 方法一: 父类名.方法名(self, 其他参数), 通过实例对象.方法名() 调用方法,不需要给self传递实参值,
        # python解释器会自动将对象作为实参值传递给self形参, 如果是通过类名.方法() 调用,python解释器就不会自动传递实参值,需要手动给self形参传递实参值
        Dog.bark(self)

        # 方法二  super(类A, self).方法名(参数) , 会调用当类A 的父类中的方法
        super(XTQ, self).bark()  # 调用 XTQ类父类中的bark方法

        # 方法三  是方法二的简写, super().方法名(参数) ==> super(当前类, self).方法名()
        super().bark()


# 创建XTQ类对象
xtq = XTQ()
xtq.see_host()

5. 继承中的 init [掌握]

# 1. 定义Dog类
class Dog(object):
    def __init__(self, name):
        # 添加属性
        self.age = 0
        self.name = name

    def __str__(self):
        return f'名字为:{self.name}, 年龄为{self.age}'


# 2. 定义XTQ类继承Dog类
class XTQ(Dog):
    # 子类重写了父类的__init__ 方法,默认不再调用父类的init方法, 需要手动的调用父类的init方法
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def __str__(self):
        return f'名字为:{self.name}, 年龄为{self.age}, 毛色为:{self.color}'


# 3. 创建XTQ类对象
xtq = XTQ('萨摩耶', '纯白色')
print(xtq)

6. 多继承[理解]

  • 如果一个类有两个及以上的父类,就把这种继承关系称为多继承.
# 1. 定义Dog类, 定义doing方法,和 eat方法
class Dog(object):
    def doing(self):
        print('萨摩耶在睡觉.....')

    def eat(self):
        print('吃狗粮.....')


# 2. 定义God类, 定义 play方法和eat方法
class God(object):
    def play(self):
        print('萨摩耶在洗澡....')

    def eat(self):
        print('吃烤串不加料....')


# 3. 定义XTQ类, 继承Dog类和God类
# class XTQ(Dog, God):  # XTQ 类有两个父类,这个继承关系称为多继承,XTQ类对象,可以调用两个父类中的属性和方法
class XTQ(God, Dog):  # XTQ 类有两个父类,这个继承关系称为多继承,XTQ类对象,可以调用两个父类中的属性和方法
    pass


# 4. 创建XTQ类对象
xtq = XTQ()
xtq.doing()  # 调用 Dog父类中的方法
xtq.doing()  # 调用 God父类中的方法

xtq.eat()  # 两个父类都存在eat方法,子类对象调用的是 第一个父类中的方法

6.1 多继承调用指定父类中的方法

# 1. 定义Dog类, 定义doing方法,和 eat方法
class Dog(object):
    def doing(self):
        print('萨摩耶在睡觉.....')

    def eat(self):
        print('吃狗粮.....')


# 2. 定义God类, 定义 play方法和eat方法
class God(object):
    def play(self):
        print('萨摩耶在洗澡....')

    def eat(self):
        print('吃烤串不加料....')


# 3. 定义XTQ类, 继承Dog类和God类
# class XTQ(Dog, God):  # XTQ 类有两个父类,这个继承关系称为多继承,XTQ类对象,可以调用两个父类中的属性和方法
class XTQ(God, Dog):  # XTQ 类有两个父类,这个继承关系称为多继承,XTQ类对象,可以调用两个父类中的属性和方法
    def eat(self):
        print('子类重写eat方法,调用子类自己的方法')
        # 调用指定父类中的方法
        # 方法一  类名.方法名(self, 参数)
        # Dog.eat(self)
        # God.eat(self)

        # 方法二 super(类A, self).方法名(参数)  类A的父类(继承顺序链的下一个类)中的方法
        # super(XTQ, self).eat()  # God 类中的方法
        super(God, self).eat()  # 调用的Dog类中的方法
        # super(Dog, self).eat()  # 调用的object类中的方法,注意: object类中没有eat方法,代码报错


# 4. 创建XTQ类对象
xtq = XTQ()
xtq.doing()  # 调用 Dog父类中的方法
xtq.play()  # 调用 God父类中的方法

xtq.eat()  # 两个父类都存在eat方法,子类对象调用的是 第一个父类中的方法

# 类名.__mro__ 可以当前类的继承顺序链,也叫做方法的调用顺序
# print(XTQ.__mro__)

在这里插入图片描述

6.2 类名.__mro__方法

代码是6.1的代码,把最后一行解注释
类名.__mro__ 可以当前类的继承顺序链,也叫做方法的调用顺序
在这里插入图片描述

7. 私有权限[理解]

  • 访问权限控制: 在什么地方可以使用和操作.
  • 私有权限:
    定义: 在方法和属性前加上两个下划线, 就变为私有.

    1. 不能在类外部通过对象直接访问和使用, 只能在类内部访问和使用
    2. 不能被子类继承
  • 公有: 不是私有的,就是公有的.

7.1私有属性

  • 私有属性,只需要在原属性名前加上两个下划线,即可
  • 目的: 保证数据的相对安全,
  • 想要访问和使用私有属性: 定义一个公有的方法,通过这个方法使用

7.1.1__dict__方法

通过__dict__方法找出来私有属性被重新命名的名字,然后再修改私有属性的值,这种方法可以修改私有属性的值,但是不推荐这样写,不安全,可以用7.2的方法来写

# 案例需求: 定义People 类, 定义属性 ICBC_money , 钱不能随便被修改,必须是合法的终端才可以操作
class People(object):
    def __init__(self):
        # python中的私有本质是 修改属性的名字, 在创建对象的时候,会自动的修改属性名
        # 在属性名的前边加上 _类名前缀
        self.__ICBC_money = 0  # 定义私有属性


# 创建People类对象
xw = People()
# 实例对象.__dict__  可以查看对象具有的属性信息,类型是字典,字典的key是属性名, 字典的value是属性值
print('赋值之前:', xw.__dict__)
# print(xw.__ICBC_money)
xw.__ICBC_money = 1000  # 不是修改私有属性,是重新添加一个公有属性
print('赋值之后:', xw.__dict__)
print(xw.__ICBC_money)
xw._People__ICBC_money = 1000
print(xw._People__ICBC_money)
print('修改之后:', xw.__dict__)

在这里插入图片描述

7.1.2 定义公有的方法,提供接口

# 案例需求: 定义People 类, 定义属性 ICBC_money , 钱不能随便被修改,必须是合法的终端才可以操作
class People(object):
    def __init__(self):
        # python中的私有本质是 修改属性的名字, 在创建对象的时候,会自动的修改属性名
        # 在属性名的前边加上 _类名前缀
        self.__ICBC_money = 0  # 定义私有属性

    # 定义公有的方法,提供接口,修改余额
    def get_money(self):
        return self.__ICBC_money

    def set_money(self):
        num = input('输入金额:')
        self.__ICBC_money += int(num)


# 创建People类对象
xw = People()
# 实例对象.__dict__  可以查看对象具有的属性信息,类型是字典,字典的key是属性名, 字典的value是属性值
print('赋值之前:', xw.__dict__)
# print(xw.__ICBC_money)
xw.__ICBC_money = 1000  # 不是修改私有属性,是重新添加一个公有属性
print('赋值之后:', xw.__dict__)
print(xw.__ICBC_money)
# xw._People__ICBC_money = 1000
# print(xw._People__ICBC_money)
# print('修改之后:', xw.__dict__)
print('=' * 20)
print(xw.get_money())  # 0
xw.set_money()
print(xw.get_money())
xw.set_money()
print(xw.get_money())

在这里插入图片描述

7.2私有方法

  • 私有方法: 在方法的前边加上两个__ ,就为私有方法
  • 私有方法,不能在类外部访问
  • 作用: 一般作为类内部的方法使用,不让在外部直接调用, 保证业务逻辑不被破坏
class Dog(object):
    def born(self):
        """吃一顿饭,可以睡5个小时"""
        print('吃了一顿饭...')
        self.__sleep()

    def __sleep(self):
        print('睡了5个小时')


dog = Dog()
# dog.__sleep()
dog.born()

在这里插入图片描述

8. 类属性[理解]

  • 实例==对象
  • 实例对象就相当于java中的没有static修饰的对象,类对象就相当于java中的static所修饰的对象
  • 对象(实例对象):

1.通过class定义的类创建的, 即通过类实例化来的, 又称为实例, 实例对象
2.实例对象定义的属性称为是 实例属性. 通过实例对象(self) 定义的属性都是实例属性
3.实例属性: 每个实例对象中都存在一份,并且值可能是不一样的

  • 类(类对象):

1.通过class定义的,又称为 类对象, 是python解释器在创建类的时候自动创建的
2.作用: 1. 通过类对象,去定义实例对象 2. 类对象可以保存一些属性信息,称为类属性
3.类属性的定义: 在类内部,方法外部定义的变量就是类属性
4.类属性,字内存中只有一份

如何确定一个属性是该定义为实例属性还是类属性?
先假设这个属性为实例属性,查看这个属性值对于不同的实例对象, 属性值是否都一样,并且需要同时变化.
如果是, 则可以定义为类属性
如果不是,则可以定义为实例属性
class Dog(object):
    # 定义类属性, 类名
    class_name = '狗类'
    name = '222'

    def __init__(self, name, age):
        # 定义的都是实例属性
        self.name = name
        self.age = age


# 创建Dog 类对象
dog = Dog('萨摩耶', 2)
print(dog.__dict__)  # 打印dog对象具有的属性

# 类名.__dict__  查看类对象具有的属性
print(Dog.__dict__)

# 访问类属性
# 类名.类属性
print(Dog.class_name)

# 修改类属性  类名.类属性 = 属性值
Dog.class_name = 'Dog类'

print(Dog.class_name)

# 补充, 注意: 如果不存在和实例属性名相同的类属性.则可以使用实例对象访问类属性的值
# 如果存在重名,则使用实例属性访问的一定是实例属性,不是类属性
print(dog.name)

在这里插入图片描述

9. 类方法

  • 类方法和java中c++中用static修饰的静态成员函数相似。
  • 实例方法: 类中默认定义的方法,就是实例方法, 第一个参数为self,表示实例对象
  • 类方法: 使用 @classmethod 装饰的方法,称为类方法, 第一个参数是cls,代表的是类对象自己
  • 什么情况定义为实例方法,什么情况定义为类方法?

1.如果在方法中使用了实例属性, 那么该方法必须定义为实例方法
2.前提:不需要使用实例属性. 需要使用类属性,可以将这个方法定义为类方法

class Dog(object):
    class_name = '狗类'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def play(self):  # 实例方法
        print(f"小狗{self.name} 在快乐的拆家....")

    # def get_class_name(self):  # 是实例方法, 因为没有使用实例属性,所以可以定义为类方法
    #     return Dog.class_name

    @classmethod
    def get_class_name(cls):  # cls 是类方法的默认形参,在调用的时候,不需要手动传递,python解释器会自动传递
        return cls.class_name


dog = Dog('二哈', 2)
dog.play()
print(dog.get_class_name())   # 对象.类方法()

# 类名.类方法()
print(Dog.get_class_name())

10. 静态方法[掌握]

  • 实例方法: 类中默认定义的方法,就是实例方法, 第一个参数为self,表示实例对象
  • 类方法: 使用 @classmethod 装饰的方法,称为类方法, 第一个参数是cls,代表的是类对象自己
  • 静态方法: 使用 @staticmethod 装饰的方法,称为静态方法, 对参数没有特殊要求,可以有,可以没有
  • 什么情况定义为实例方法,什么情况定义为类方法, 什么情况下静态方法?

1.如果在方法中使用了实例属性, 那么该方法必须定义为实例方法
2.前提:不需要使用实例属性. 需要使用类属性,可以将这个方法定义为类方法
3.前提:不需要使用实例属性,同时也不需要使用类属性, 此时可以将这个方法定义为静态方法

class Dog(object):
    class_name = '狗类'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def play(self):  # 实例方法
        print(f"小狗{self.name} 在快乐的玩耍....")

    @staticmethod  # 定义静态方法
    def show_info():
        print('这是一个Dog类')


dog = Dog('萨摩耶', 2)
dog.play()
# 对象.方法名()
dog.show_info()
# 类名.方法名()
Dog.show_info()

11. 多态[理解]

  • 在需要使用父类对象的地方,也可以传入子类对象,得到不同的结果 ---- 多态
  • 实现步骤:

1.子类继承父类
2.子类重写父类中的同名方法
3.定义一个共同的方法, 参数为父类对象.在方法中调用子类和父类同名的方法

"""
在需要使用父类对象的地方,也可以传入子类对象,得到不同的结果 ---- 多态
实现步骤:
1. 子类继承父类
2. 子类重写父类中的同名方法
3. 定义一个共同的方法, 参数为父类对象.在方法中调用子类和父类同名的方法
"""


# 1. 定义Dog类
class Dog(object):
    def __init__(self, name):
        self.name = name

    def play(self):
        print(f'小狗{self.name} 在玩耍.......')


# 2. 定义哮天犬类,继承Dog类
class XTQ(Dog):
    # 3. 重写 play方法
    def play(self):
        print(f'{self.name} 在天上追云彩.....')


# 4. 定义一个共同的方法,
def play_with_dog(obj_dog):
    obj_dog.play()


# 创建Dog类对象@
dog = Dog('萨摩耶')
play_with_dog(dog)

# 创建一个XTQ类的对象
xtq = XTQ('黄鹂鸟')
play_with_dog(xtq)

12. 鸭子类型

  • 鸭子类型(duck typing)是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定
  • “当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”我们并不关心对象是什么类型,到底是不是鸭子,只关心行为
  • 鸭子类型在动态语言中经常使用,非常灵活,使得python不想java那样专门去弄一大堆的设计模式。
  • 与 duck typing 相对应的风格是 normal typing,后者由对象类型决定了对象的特性。以下对比说明二者区别:
  • 一方面,以 形象化的表述 为例:在使用 normal typing 的语言中,可以编写一个 “鸭子动作” 函数,它能够接受一个类型为 “鸭子” 的对象,并调用它的 “叫”、“跑” 等方法。在运行前,需要进行对象是否确实为 “鸭子” 等类型检查。相应地,在使用 duck typing 的语言中,也可以编写一个 “鸭子动作” 函数,它能够接受一个任意类型的对象,并调用它的 “叫”、“跑” 等方法。换言之,只要传入对象具有正确的 “叫”、“跑” 等方法,就都可以被函数正常接受和调用。但如果这些需要被调用的方法不存在,那么将引发一个运行时错误。
  • 另一方面,以结合语言的表述 为例:C、C++和java属于 normal typing,在 编译阶段进行静态检查,函数定义和传参类型不一致就报错。相应地,Python 属于 duck typing,对象的类型不重要,只要对象具有类型 duck 的方法和属性,那么它就会被当做类型 duck 来使用 (因此经常能够混用类型)。Python 没有静态检查类型匹配情况,只有运行时找不到相应属性和方法时才报错。
  • 此外,如果只了解C、Java、C++ 等静态语言,可能对鸭子类型的理解并不深刻,因为静态语言中,对象的特性取决于其父类。而动态语言则显著有别,例如 Python 的迭代器 (iterator),任何支持迭代协议 (同时实现·__iter__ __next__ 方法) 的对象都可称之为迭代器,但对象本身是什么类型都不受到限制,甚至可以为任何自定义类。
# 1. 定义DOg类
class Dog(object):
    def __init__(self, name):
        self.name = name

    def play(self):
        print(f'小狗{self.name} 在玩耍.......')


# 2. 定义哮天犬类,继承Dog类
class XTQ(Dog):
    # 3. 重写 play方法
    def play(self):
        print(f'{self.name} 在天上追云彩.....')


class Cat(object):
    def __init__(self, name):
        self.name = name

    def play(self):
        print(f'小猫{self.name} 被撸中...')


# 4. 定义一个共同的方法,
def play_with_dog(obj_dog):
    obj_dog.play()


# 创建Dog类对象@
dog = Dog('萨摩耶')
play_with_dog(dog)

# 创建一个XTQ类的对象
xtq = XTQ('黄鹂鸟')
play_with_dog(xtq)


cat = Cat('布偶')
play_with_dog(cat)
目录
相关文章
|
12天前
|
算法 Python
Python多继承时子类如何调用指定父类
通过本文的介绍,希望您能够深入理解Python多继承时子类如何调用指定父类的方法,并在实际项目中灵活运用这些技巧,编写出高效且易维护的代码。
23 11
|
7天前
|
存储 数据处理 Python
Python如何显示对象的某个属性的所有值
本文介绍了如何在Python中使用`getattr`和`hasattr`函数来访问和检查对象的属性。通过这些工具,可以轻松遍历对象列表并提取特定属性的所有值,适用于数据处理和分析任务。示例包括获取对象列表中所有书籍的作者和检查动物对象的名称属性。
18 2
|
11天前
|
算法 Python
Python多继承时子类如何调用指定父类
通过本文的介绍,希望您能够深入理解Python多继承时子类如何调用指定父类的方法,并在实际项目中灵活运用这些技巧,编写出高效且易维护的代码。
30 1
|
21天前
|
关系型数据库 开发者 Python
Python编程中的面向对象设计原则####
在本文中,我们将探讨Python编程中的面向对象设计原则。面向对象编程(OOP)是一种通过使用“对象”和“类”的概念来组织代码的方法。我们将介绍SOLID原则,包括单一职责原则、开放/封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则有助于提高代码的可读性、可维护性和可扩展性。 ####
|
2月前
|
Python
Python面向对象(2)
【10月更文挑战第14天】
Python面向对象(2)
|
2月前
|
设计模式 程序员 C语言
Python面向对象
【10月更文挑战第13天】
Python面向对象
|
2月前
|
索引 Python
python-类属性操作
【10月更文挑战第11天】 python类属性操作列举
27 1
|
7月前
|
Java 程序员 Python
python学习13-面向对象的三大特征、特殊方法和特殊属性、类的浅拷贝和深拷贝
python学习13-面向对象的三大特征、特殊方法和特殊属性、类的浅拷贝和深拷贝
29.从入门到精通:Python3 面向对象继承 多继承 方法重写 类属性与方法
29.从入门到精通:Python3 面向对象继承 多继承 方法重写 类属性与方法
28.从入门到精通:Python3 面向对象 面向对象技术简介 类定义 类对象 类的方法
28.从入门到精通:Python3 面向对象 面向对象技术简介 类定义 类对象 类的方法