视频、源码、课件、软件、笔记：超全面Python基础入门教程【十天课程】博客笔记汇总表【黑马程序员】

Python基础day09【面向对象(封装、继承、多态)、重写、私有权限】

Python基础day09【试题讲解《python基础中期考试》】

Python基础day09 作业解析【面向对象题目(简答题+代码题)】

 

目录

00、复习和反馈

01、继承的基本语法[掌握]

02、单继承和多层继承[理解]

03、子类重写父类的同名方法[掌握]

04、子类调用父类的同名方法[掌握]

05、继承中的init[掌握]

06、多继承[理解]

6.1、多继承简单案例

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

07、私有权限[理解]

7.1、私有属性

7.2、私有方法

08、类属性[理解]

09、类方法

10、静态方法[掌握]

11、多态[理解]

12、鸭子类型中的多态

13、总结

14、试题讲解《python基础中期考试》

---

 

00、复习和反馈

课程考试：基础概念题+基础编程题

01、继承的基本语法[掌握]

程序中的继承

在程序中，继承描述的是多个类之间的所属关系；如果一个类A里面的属性和方法可以复用(重复使用)，则可以通过继承的方式，传递到类B里；那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

继承：描述的类与类之间所属关系。
基本语法：
    class 类B(类A):
       pass
称为类B继承类A
特点：B类的对象可以使用A类的属性和方法。
优点：代码复用，重复相同的代码不用多次书写。
名词：
    类A：父类、基类
    类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() # 快乐地玩耍...

02、单继承和多层继承[理解]

"""单继承：如果一个类只有一个父类, 把这种继承关系称为单继承;多继承：如果一个类有多个父类, 把这种继承关系称为多继承.多层继承：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类：多层继承 passxtq = XTQ()xtq.bark() # 调用父类Dog中的方法 汪汪汪叫...xtq.play() # 调用爷爷类animal类中的方法 快乐地玩耍...

03、子类重写父类的同名方法[掌握]

重写：子类定义和父类名字相同的方法。
为什么重写：父类中的方法，不能满足子类对象的需求，所以要重写。
重写之后的特点：子类对象调用子类自己的方法，不再调用的方法，父类对象调用父类自己的方法。

# 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() # 嗷嗷叫~~~

04、子类调用父类的同名方法[掌握]

 

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

05、继承中的init[掌握]

如果子类重写了父类的init方法，在子类中需要调用父类的init方法，给对象添加从父类继承的属性。
注意：子类init方法的形参，一般都先写父类的形参，再写子类自己独有的形参。

说明：虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法。

总结：1.子类在继承的时候，在定义类时，小括号()中为父类的名字；2.父类的属性、方法，会被继承给子类。

# 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__()方法 # 注意：子类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) # 名字：小黑；年龄：0；毛色：红色。

06、多继承[理解]

如果一个类有两个及以上的父类，就把这种继承关系称为多继承。

说明：

多继承可以继承多个父类，也继承了所有父类的属性和方法；注意：如果多个父类中有同名的属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）；多个父类中，不重名的属性和方法，不会有任何影响。

6.1、多继承简单案例

# 1.定义Dog类,定义bark方法和eat方法class Dog(object): def bark(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): pass# 4.创建XTQ类对象xtq = XTQ()xtq.bark() # 调用Dog父类中的方法，汪汪叫...xtq.play() # 调用God父类中的方法，在云中飘一会...xtq.eat() # 两个父类都存在eat方法,子类对象调用的是第一个父类中的方法，吃蟠桃仙丹...

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

# 1.定义Dog类,定义bark方法和eat方法class Dog(object): def bark(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方法,所以代码报错 print('子类重写eat方法,调用子类自己的方法。')# 4.创建XTQ类对象xtq = XTQ()xtq.bark() # 调用Dog父类中的方法，汪汪叫...xtq.play() # 调用God父类中的方法，在云中飘一会...xtq.eat() # 两个父类都存在eat方法,子类对象调用的是第一个父类中的方法# 类名.__mro__：可以查看当前类的继承顺序链,也叫做方法的调用顺序。不需要自己定义内容，自动定义内容。print(XTQ.__mro__) # (, , , )

07、私有权限[理解]

面向对象三大特性：封装、继承、多态。

封装的意义：

将属性和方法放到一起做为一个整体，然后通过实例化对象来处理；隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了；对类的属性和方法增加 访问权限控制。

私有权限：在属性名和方法名前面，加上两个下划线__。

类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。

总结

Python中没有像C++中 public 和 private 这些关键字来区别公有属性和私有属性。Python是以属性命名方式来区分，如果在属性和方法名前面加了2个下划线'__'，则表明该属性和方法是私有权限，否则为公有权限。

---

访问权限控制：在什么地方可以使用和操作。
私有权限：
    定义：在方法和属性前加上两个下划线，就变为私有；
    1.不能在类外部通过对象直接访问和使用，只能在类内部访问和使用；
    2.不能被子类继承。
公有：不是私有的就是公有的。

7.1、私有属性

"""私有属性：只需要在原属性名前加上两个下划线即可。目的：保证数据的相对安全。想要访问和使用私有属性：定义一个公有的方法,通过这个方法使用。"""# 案例需求: 定义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, money): num = input('输入金额：') self.__ICBC_money += int(num) # self.__ICBC_money += money# 创建People类对象xw = People() # 小王# print(xw.__ICBC_money)# 实例对象.__dict__：可以查看对象具有的属性信息,类型是字典,字典的key是属性名,字典的value是属性值print('赋值之前:', xw.__dict__)xw.__ICBC_money = 1000; # 不是修改私有属性,是重新添加一个公有属性print('赋值之后:', xw.__dict__)print(xw.__ICBC_money)print('------------------------------------------------------')print(xw.get_money()) # 0xw.set_money(1000)print(xw.get_money()) # 1000xw.set_money(-500)print(xw.get_money()) # 500

7.2、私有方法

"""私有方法：在方法的前边加上两个__ ,就为私有方法。私有方法：不能在类外部访问。作用：一般作为类内部的方法使用,不让在外部直接调用,保证业务逻辑不被破坏。"""class Dog(object): def born(self): """生小狗的方法,生一个小狗,休息30天""" print('生了一只小狗...') self.__sleep() def __sleep(self): print('休息30天~')dog = Dog()# dog.__sleep() # 报错dog.born()# 生了一只小狗...# 休息30天~

08、类属性[理解]

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

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

如何确定一个属性是该定义为实例属性还是类属性？
先假设这个属性为实例属性，查看这个属性值对于不同的实例对象，属性值是否都一样，并且需要同时变化。
如果是，则可以定义为类属性；如果不是，则可以定义为实例属性。

class Dog(object): # 定义类属性, 类名 class_name = '狗类' def __init__(self, name, age): # 定义的都是实例属性 self.name = name self.age = agedog = Dog('大黄', 2) # 创建Dog类对象print(dog.__dict__) # 打印dog对象具有的属性，{'name': '大黄', 'age': 2}# 类名.__dict__：查看类对象具有的属性,__module__魔法属性print(Dog.__dict__) # {'__module__': '__main__', 'class_name': '狗类', ...}# 访问类属性：类名.类属性print(Dog.class_name) # 狗类# 修改类属性：类名.类属性 = 属性值Dog.class_name = 'Dog类'print(Dog.class_name) # Dog类# 补充, 注意: 如果不存在和实例属性名相同的类属性，则可以使用实例对象访问类属性的值# 如果存在重名,则使用实例属性访问的一定是实例属性,不是类属性print(dog.class_name) # Dog类

09、类方法

"""实例方法: 类中默认定义的方法就是实例方法,第一个参数为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_namedog = 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() # 调用方法1：对象.方法名()，这是一个Dog类！Dog.show_info() # 调用方法2：类名.方法名()，这是一个Dog类！

11、多态[理解]

什么是多态？在需要使用父类对象的地方，也可以使用子类对象，这种情况就叫多态。比如，在函数中，我需要调用某一个父类对象的方法，那么我们也可以在这个地方调用子类对象的方法。

如何在程序中使用多态？可以按照以下几个步骤来写代码：1.子类继承父类；2.子类重写父类中的方法；3.通过对象调用这个方法。

多态的好处：给call_cure(doctor)函数传递哪个对象，在它里面就会调用哪个对象的cure()方法，也就是说在它里面既可以调用son对象的cure()方法，也能调用father对象的cure()方法，当然也可以在它里面调用Father类其它子类对象的cure()方法，这样可以让call_cure(doctor)函数变得更加灵活，额外增加了它的功能，提高了它的扩展性。

"""在需要使用父类对象的地方,也可以传入子类对象,得到不同的结果----多态实现步骤: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、鸭子类型中的多态

Python(解释型语言、动态语言)中的多态可以没有继承：鸭子类型语言。

# 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) # 小猫小花, 被撸中...

13、总结

欲去“惰”字，以不晚起为第一义；欲去“骄”字，以不菲人为第一义；欲去“奢”字，以不浪费为第一义；欲去“病”字，以不颓废为第一义。

14、试题讲解《python基础中期考试》

Python基础day09【试题讲解《python基础中期考试》】