@[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.1dict方法

通过__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)

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

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

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

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

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

5. 继承中的 init [掌握]

6. 多继承[理解]

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

6.2 类名.mro方法

7. 私有权限[理解]

7.1私有属性

7.1.1dict方法

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

7.2私有方法

8. 类属性[理解]

9. 类方法

10. 静态方法[掌握]

11. 多态[理解]

12. 鸭子类型

热门文章

最新文章

相关课程

相关电子书

推荐镜像

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

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

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

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

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

5. 继承中的 init [掌握]

6. 多继承[理解]

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

6.2 类名.__mro__方法

7. 私有权限[理解]

7.1私有属性

7.1.1__dict__方法

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

7.2私有方法

8. 类属性[理解]

9. 类方法

10. 静态方法[掌握]

11. 多态[理解]

12. 鸭子类型

热门文章

最新文章

相关课程

相关电子书

推荐镜像

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

6.2 类名.mro方法

7.1.1dict方法