Python基础学习第八天

文章目录

• Python 私有属性、单继承和方法重写
• • 1. 私有属性和方法
  • 2. 伪 私有属性和私有方法
  • 3. 继承
  • • 3.1 继承的概念
    • 3.2 继承的语法
    • 3.3 继承的传递性
    • 3.4 多继承
  • 4. 多态
  • 5. 类属性
  • • 5.1类的结构
    • 5.2 类属性和实例属性
    • 5.3 类的获取机制
  • 6. 类方法和静态方法
  • • 6.1 类方法
    • 6.2 静态方法
    • 6.3 案例综合
  • 7.单例设计模式
  • • 7.1 设计模式
    • 7.2 __new__ 方法
    • 7.3 Python 中的单例

Python 私有属性、单继承和方法重写 1. 私有属性和方法

• 在实际开发中，对象 的 某些属性或方法 可能只希望 在对象的内部被使用，而 不希望在外部被访问到
• 私有属性 就是 对象 不希望公开的 属性
• 私有方法 就是 对象 不希望公开的 方法
• 在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

设置私有属性之前：
class Girl:
    def __init__(self, name):
        self.name = name
        self.age = 18
    def secret(self):
        print("{}的年龄是{}岁".format(self.name, self.age))
Anna = Girl("小美")
Anna.secret()
print("小美")
print(Anna.age)  # 可以从外部访问属性

私有属性在外界不能被直接访问：
class Girl:
    def __init__(self, name):
        self.name = name
        self.__age = 18  # 将 age 设置成私有属性
    def secret(self):
        print("{}的年龄是{}岁".format(self.name, self.__age))
Anna = Girl("小美")
Anna.secret()
print(Anna)
# 私有属性，不能被外界访问！
print(Anna.__age) 
"""
程序运行结果：
AttributeError: 'Girl' object has no attribute '__age'
"""

私有方法,在外界不能直接被调用
class Girl:
    # 定义属性
    def __init__(self, name):
        self.__name1 = name
        self.__age = 18  # 如果希望属性不能在 外部被调用，可以定义该属性为私有 属性

    def __secret(self):  # 如果希望方法不能在外部被调用，可以定义该方法为 私有方法
        print(f"{self.__name1}的年龄是{self.__age}")
xiaomei = Girl("小美")
""" 对象不能在类的外部 访问私有属性 调用私有方法
print(xiaomei.__age)  # 对象访问属性
xiaomei.__secret()  # 对象调用方法
"""
""""
程序运行结果：
AttributeError: 'Girl' object has no attribute '__secret'
"""

2. 伪 私有属性和私有方法

Python 中，并没有 真正意义 的 私有
在给 属性、方法 命名时，实际是对 名称 做了一些特殊处理，使得外界无法访问
处理方式： 在 名称 前面加上 _类名 --> _类名__名称

提示：在日常开发中，不要使用这种方式，访问对象的 私有属性 或 私有方法

Anna = Girl("小美")
Anna._Girl__secret()
print(Anna._Girl__age)
print(Anna)

3. 继承

面向对象三大特性

1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
2. 继承 实现代码的重用，相同的代码不需要重复的编写
3. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

3.1 继承的概念

子类 拥有 父类 的所有 方法 和 属性

class Animal:
    def __init__(self):
        self.color = "grey"
    def eat(self):  #
        print("eat")
    def drink(self):
        print("drink")
    def run(self):
        print("run")
    def sleep(self):
        print("sleep")
# 创建 Dog 类，继承自 Animal类
class Dog(Animal):
    def bark(self):
        print("旺旺")
# 根据 Dog 类 创建对象
wangcai = Dog()
print(wangcai.color)  # 子类对象 能够 访问 父类 封装的 属性
wangcai.bark()  # 子类，可以根据自己的需求，来单独开发自己的 方法
# 子类对象，能够访问 父类 封装的方法
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
class XTQuan(Dog):
    def fly(self):
        print(" i can fly....")
xtdog = XTQuan()
xtdog.fly()
xtdog.bark()
xtdog.eat()
xtdog.sleep()

3.2 继承的语法

class 子类名(父类名)：
pass
子类 继承自 父类，可以直接 享受 父类中已经封装好的方法,不需要再次开发
子类 中应该根据 职责，封装 子类特有的 属性 和 方法

专业术语
Dog 类 是 Animal 类的 子类，Animal 类是 Dog 类的 父类，Dog 类从Animal 类 继承
Dog 类 是 Animal 类的 派生类，Animal 类是 Dog 类的 基类，Dog 类从Animal 类 派生

3.3 继承的传递性

C 类从 B 类继承，B类又从 A 类继承
那么 C 类就具有 B 类和 A 类的所有属性和方法
子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

class Animal:
    def __init__(self):
        self.color = "grey"
    def eat(self):  #
        print("站起前脚，吃东西")
    def drink(self):
        print("drink"
    def run(self):
        print("run")
    def sleep(self):
        print("sleep")
class Dog(Animal):
    def eat(self):  # 虽然父类 有  eat 方法，但是子类在使用该方法的时候，不适合，需要对父类的方法进行重写
        """ 重写父类方法，
                1. 完全覆盖父类方法  只保留父类方法的名字，父类方法的功能不保留， 全部重写
                2. 在父类方法的基础上，对方法进行 扩展(保留父类方法的功能)
        """
        super().eat()  # super().的方式，保留父类方法的功能，对父类方法进行扩展
        print("狗狗喜欢用盆吃东西~")
    def bark(self):
        print("旺旺")
# python 2.x 扩展继承 的写法
    def run(self):
        # print("run")
        Animal.run(self)  # super().run()
        print("蹦蹦跳跳的跑了。。。。")
wangcai = Dog()
wangcai.eat()
wangcai.run()

父类的 私有属性 和 私有方法

• 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
• 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法
  • 私有属性、方法 是对象的隐私，不对外公开，外界 以及 子类 都不能直接访问
  • 私有属性、方法 通常用于做一些内部的事情

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200  # 私有属性
    def __test(self):  # 私有方法
        print(f"我是私有方法，但是我在类的内部，可以访问 num1---> {self.num1}  &  num2--->{self.__num2}")
    def pub(self): # 父类的公有方法
        # 父类的公有方法，可以访问自己的私有属性、 调用自己的私有方法
        print(f"父类的公有方法，可以访问自己的私有属性--->{self.__num2}")
        # 父类的公有方法，可以调用自己的 私有方法
        self.__test()
class B(A):
    # 在子类的内部，能否访问 父类的私有属性
    def demo(self):
        print(f"子类能否访问父类的公有属性{self.num1}")  #
        # print(f"子类能否访问父类的私有属性 ? --->{self._A__num2}")  # 伪私有属性， 不推荐使用
        """
        print(f"子类能否访问父类的私有属性 ? --->{self.__num2}") 
        # 报错信息如下：AttributeError: 'B' object has no attribute '_B__num2'. Did you mean: '_A__num2'?
        """
        # 在子类的内部，能否调用父类的私有方法
        # self._A__test()  # 伪私有方法  不推荐使用
        # 想要在 子类访问父类的私有方法  调用父类的私有属性？
        # 思路1： 在父类创建一个 共有方法，在这个方法中，访问父类的私有属性 可行！  调用父类的私有方法  可行！
        # 思路2： 子类能否调用父类的 公有方法？ --->可以，因为 ，子类能够继承父类的方法
obj_b = B()
obj_b.demo()
obj_b.pub()

3.4 多继承

子类 可以拥有 多个父类，并且具有 所有父类 的 属性 和 方法
例如： 孩子 会继承自己 父亲 和 母亲 的 特性

# 父类1
class Base1:
    def demo1(self):
        print("我是Base1的  demo1 方法")
# 父类2
class Base2:
    def demo2(self):
        print("我是Base2的  demo2 方法")

# 子类继承自 父类
class Derived(Base1,Base2):
    def test(self):
        self.demo1()
        self.demo2()
obj = Derived()  # 创建的  子类对象
obj.test()
obj.demo1()
obj.demo2()

如果 不同的父类 中存在 同名的方法，子类对象 在调用方法时，会调用 哪个父类中的方法呢？
提示： 开发时，应该尽量避免这种容易产生混淆的情况！

• 如果 父类之间 存在 同名的属性或者方法，应该 尽量避免 使用多继承

# 父类1
# class Base1:  # 本质上，父类 也继承自 object 类
class Base1(object):  # 该书写方式，默认和 class Base1: 是一样的
    def demo1_1(self):
        print("我是Base1的  demo1 方法")
# 父类2
class Base2:
    def demo2(self):
        print("我是Base2的  demo1 方法")

# 子类继承自 父类
class Derived(Base2, Base1):  #
    def test(self):
        self.demo1()
obj = Derived()
# obj.test()
obj.demo1()
print(Derived.__mro__)  # 查看 Derivde 类 调用方法 或者 访问属性的 顺序
"""
(, , , )
当 Derived 类的对象，在调用方法或访问属性的时候， 一个查找的路径
object  如果按照查找顺序，都找不到，最后 会在 object 类中进行查找, 
如果，最后找到 object类，也没有该方法，或者属性，就会报错
object 类 是所有类的父类
"""
"""
在多继承中，父类的方法 出现重名， 子类在调用父类方法的时候，会选择先继承的 父类方法
    注意： 在开发中，尽量不要出现 方法同名的情况，避免出现混淆。
    建议： Base1---> demo1 可以修改成 demo1_1
           Base2--->  demo1 可以修改成  demo2_1
"""

4. 多态

• 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中 定义类的准则–
• 继承 实现代码的重用，相同的代码不需要重复的编写
  • 设计类的技巧
  • 子类针对自己特有的需求，编写特定的代码
• 多态 不同的 子类对象，调用相同的 父类方法，产生不同的执行结果
  • 多态 可以增加代码的灵活度
  • 以 继承 和 重写父类方法 为前提
  • 是调用方法的技巧，不会影响到类的内部设计
    
    

"""
1.在 Dog 类中封装方法 game
普通狗只是简单的玩耍
2.定义 XiaoTianDog 继承自 Dog，并重写 game 方法
哮天犬需要在天上玩耍
3.定义 Person 类，并且封装一个 和狗玩 的方法
在方法内部，直接让 狗对象 调用 game 方法
"""
class Dog(object):
    def __init__(self, name):
        self.name = name

   def game(self):
        print(f"{self.name}在完飞盘~")
class XTDog(Dog):
    # 1 属性name,继承自 Dog 类，不需要重写
    # 2 重写 game 方法
    def game(self):
        super().game()  # 扩展父类方法
        print(f"{self.name} 在天上玩耍~")
wangcai = Dog("旺财")  # Dog类产生的对象
xt = XTDog("飞天旺财")  # XTDog 类产生的对象
class Person(object):
    def __init__(self, name):
        self.name = name
    def game_with_dog(self, dog):
        print(f"{self.name}和{dog.name}快乐的玩耍~")
        dog.game()
xiaoming = Person("小明")
xiaoming.game_with_dog(wangcai)
xiaoming.game_with_dog(xt)

案例小结
Person 类中只需要让 狗对象 调用 game 方法，而不关心具体是 什么狗
game 方法是在 Dog 父类中定义的
在执行程序时，传入不同的 狗 对象 （这些对象可以继承自统一个父类，也可以是父类、子类的对象）实参，就会产生不同的执行效果

class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self):
        print(f"{self.name}在 eating。。。。")
class Cat(Animal):
    def __init__(self, name):
        # super(Cat, self).__init__(name)
        super().__init__(name)  # super(Cat, self).__init__(name)
    def eat(self):
        super(Cat, self).eat()
        print(f"{self.name}要吃鱼。。。")
class Mouse(Animal):
    def __init__(self, name):
        super(Mouse, self).__init__(name)
    def eat(self):
        super(Mouse, self).eat()
        print(f"f{self.name}吃大米。。。")
class Tiger(Animal):
    def __init__(self, name):
        super(Tiger, self).__init__(name)
    def eat(self):
        super(Tiger, self).eat()
        print(f"{self.name}吃肉。。。")
tom = Cat("汤姆")
jerry = Mouse("杰瑞")
tiger = Tiger("跳跳虎")
class Person(object):
    def feedAnimal(self,ani):
        print(f"饲养员喂养{ani.name}")
        ani.eat()
feeder = Person()
feeder.feedAnimal(tom)  # 同样是 饲养员  调用自己的  feedAnimal 这个方法，当 调用的 子类对象
feeder.feedAnimal(jerry)
feeder.feedAnimal(tiger)

5. 类属性 5.1类的结构

术语 — 实例

1. 使用面向对象开发，第 1 步 是设计 类
2. 使用 类名( ) 创建对象， 创建对象 的动作有两步：
   • 在内存中为对象 分配空间----》 new
   • 调用初始化方法 init 为 对象初始化
3. 创建对象后，内存 中就有了一个对象的实实在在 的存在 — 实例
   
   因此，通常也会把：
4. 创建出来的 对象 叫做 类 的 实例
5. 创建对象的 动作 叫做 实例化
6. 对象的属性 叫做 实例属性
7. 对象调用的方法 叫做 实例方法

在程序执行时

• 对象各自拥有自己的 实例属性
• 调用对象方法，可以通过 self
  • 访问自己的属性
  • 调用自己的方法
    结论
    每一个对象，都有自己 独立的内存空间，保存各自不同的属性
    多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用，传递到方法内部

类是一个特殊的对象
Python 中 一切皆对象：
class AAA： 定义的类属于 类对象
obj1 = AAA( ) 属于 实例对象
在程序运行时，类 同样 会被加载到内存
在 python 中，类 是一个特殊的对象 —— 类对象
在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例
除了封装 实例 的 属性 和 方法 外，类对象 可以拥有自己的 属性 和 方法
1.类属性
2.类方法
通过 类名. 的方式可以 访问类的属性或者 调用类的方法

5.2 类属性和实例属性

概念和使用
类属性 就是给 类对象 中定义的 属性
通常用来记录 与这个类相关 的特征
类属性 不会用于 记录 具体对象的特征

"""
定义一个 工具类
每件工具都有自己的 name 实例属性
需求 -- 知道使用这个类，创建了多少个工具对象 类属性
"""
class Tools(object):
    count = 0  # 类属性，用来描述 这个类 创建了多少个 实例
    def __init__(self, name):  # 初始化方法，是用来给对象(实例赋予属性值的)
        self.name = name  # 实例属性
        # 通过这个类创建了 多少个 对象 ，做一个计数  count
        # 思路： 每创建一个对象，就会调用一次 __init__(self) 方法 ，每调用一次 __init__ ，就对 count做一个 +1 的 *** 作
        Tools.count += 1
tool1 = Tools("手电筒")  # 创建实例
tool2 = Tools("扳手")
tool3 = Tools("菜刀")
print(Tools.count)  # 输出  通过类创建的对象数
print(tool1.count)  # 注意： count属性，是 Tools 这个类的，但是 可以被实例访问
print(id(tool1.count), id(Tools.count))  # 1759695208752 1759695208752
tool1.count = 100  # 该定义方式，只是给 tool1 增加了一个属性 count，增加了一个 tool1.count的内存空间
                   # 而不会改变 类属性的值               
print(id(tool1.count), id(Tools.count))  # 1759695211856 1759695208752
print(Tools.count)  # --->3

5.3 类的获取机制

在 python 中 属性的获取 存在一个 向上查找机制

因此，要访问类属性有两种方式：

• 类名.类属性
• 对象.类属性 (不推荐)
  注意
  如果使用 对象.类属性 = 值 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值
  

6. 类方法和静态方法 6.1 类方法

• 类属性 就是针对 类对象 定义的属性
  • 使用 赋值语句 在 class 关键字 下方可以定义
  • 类属性 类属性 用于记录 与这个类相关的特征
• 类方法 就是记录 与这个类相关 的方法
  • 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
• 类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
• 类方法的 第一个参数 应该是 cls
  • 由 哪一个类调用的方法，方法内的 cls 就是 哪一个类的引用
  • 这个参数 和 实例方法 的第一个参数 和 self 类似
  • 提示使用其他名称也可以，不过习惯使用 cls
• 通过 类名，调用 类方法，调用方法时，不需要传递 cls 参数
  • 在方法内部 可以通过 cls，访问 类属性
  • 也可以通过 cls 调用其他的类方法

# 类属性 是用来描述 类对象  的属性
# 类方法  描述 类的 方法
"""
在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
需求:
定义一个 工具类
每件工具都有自己的 name
需求 – 在 类 封装一个 show_tool_count 的类方法，输出使用当前这个类，创建的对象个数
"""
class Tools(object):
    count = 0
    def __init__(self, name):
        self.name = name
        Tools.count += 1
    # 创建类方法
    @classmethod
    def show_tool_count(cls):
        print(f"目前创建了 {cls.count}个 工具实例了！")  # 类方法内部，访问了类属性，也可以调用其他类方法
        # print(self.name)  # 类方法内部，不能访问 实例属性，也不能调用实例方法
tool1 = Tools("burpsuit")
tool2 = Tools("冰蝎")
Tools.show_tool_count()

6.2 静态方法

• 在开发时，如果需要在 类 中封装一个方法，这个方法：
  • 既 不需要 访问 实例属性 或者 调用 实例方法
  • 也 不需要 访问 类属性 或者调用 类方法
• 这个时候，可以把这个方法封装成一个 静态方法
• 静态方法 需要用 修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法
• 通过 类名，调用 静态方法

class Dog:
    def __init__(self):
        self.name = "旺财"
    @staticmethod
    def run():
        """
        定义了一个 静态方法  静态方法不需要访问实例属性 也不需要 调用实例方法
                            静态方法不需要访问类属性 也不需要 调用类方法
        """
        print(f"狗跑了。。。")
wangcai = Dog()  # 根据类创建实例
wangcai.run()

6.3 案例综合

"""
1.设计一个 Game 类
2.属性
定义一个 类属性 top_score 记录游戏的 历史最高分
定义一个 实例属性 player_name 记录 当前游戏的玩家姓名
3.方法
静态方法 show_help 显示游戏帮助信息
类方法 show_top_score 显示历史最高分
实例方法 start_game 开始当前玩家的游戏
4.主程序步骤
查看帮助信息
查看历史最高分
创建游戏对象，开始游戏
"""
import random
class Game(object):
    top_score = 0  # 类属性，用来记录历史最高分，默认为0
    def __init__(self, name):  # 实例属性 ，通过__init__进行实例化
        self.player_name = name
    @staticmethod  # 静态方法
    def show_help():
        print("欢迎来到猜数字游戏。。。。")
    @classmethod
    def show_top_score(cls):  # 类方法 ，访问了 类属性
        print(f"当前历史最高分是{cls.top_score}")
    def start_game(self):  # 实例方法
        print(f"{self.player_name}进入了游戏。。。。")
        # 开始游戏，产生了分数
        Game.top_score = random.randint(50, 1000)
        print(f"{self.player_name}在游戏中获得了{Game.top_score}分")
Game.show_help()
Game.show_top_score()
xiaoming = Game("小明。。。")
xiaoming.start_game()
Game.show_top_score()
xiaomei = Game("小美")

案例小结

1. 实例方法 – 方法内部需要访问 实例属性
   实例方法 内部可以使用 类名. 访问类属性
2. 类方法 – 方法内部 只 需要访问 类属性 或 其他 类方法
3. 静态方法 – 方法内部，不需要访问 实例属性 和 类属性

7.单例设计模式 7.1 设计模式

- 设计模式 是 前人工作的总结和提炼，通常，被人们广泛流传的设计都是针对 某一特定问题 的成熟的方案 
- 使用 设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性 

• 单例 设计模式
  • 目的 — 让 类 创建的对象，在系统中 只有 唯一的一个实例
  • 每一次执行 类名( ) 返回的对象，内存地址是相同的
• 单例设计模式的应用场景
  • 音乐播放
  • 回收站
  • 对象
  • 打印机
  • 对象
  • ……

7.2 new 方法

• 使用 类名( ) 创建对象时，Python 的解释器 首先 会 调用 new 方法为对象 分配空间
• new 是一个 由 object 基类提供的 内置的静态方法，是要作用有两个：
  • 在内存中为对象 分配空间
  • 返回 对象的引用
• Python 的解释器获得对象的 引用 后，将引用作为 第一个参数，传递给 __init__方法

重写 new 方法的代码非常固定！

• 重写 new 方法 一定要 return super().new(cls)， 用来返回对象的引用
• 否则 Python的解释器 得不到 分配了空间的 对象引用，就不会调用对象的初始化方法
• 注意： new 是一个静态方法，在调用时需要 主动传递cls 参数
  

7.3 Python 中的单例

单例 — 让 类 创建的对象，在系统中 只有 唯一的一个实例– 保证 引用 的唯一性
定义一个 类属性，初始值是 None ，用于记录 单例对象的引用
重写 new 方法
如果 类属性 is None，调用父类方法：new 分配空间，并在类属性中记录结果返回 类属性 中记录的 对象引用

只执行一次初始化工作

• 在每次使用 类名( ) 创建对象时，Python 的解释器都会自动调用两个方法：
  • new 分配空间
  • init 对象初始化
• 在对 new 方法改造后，每次都会得到 第一次被创建对象的引用
• 但是：初始化方法还会被再次调用

'''
需求
让 初始化动作 只被执行一次
解决办法
定义一个类属性 init_flag 标记是否 执行过初始化动作，初始化值为 False
在 __init__ 方法中，判断 init_flag ,如果为 False 就执行初始化动作
然后将 init_flag 设置为 True
这样，再次 自动 调用 __init__ 方法时，初始化动作就不会被再次执行了
'''
class MusicPlayer(object):
    instance = None  # instance设置为初始值 None，如果 创建过对象，
    # 也就是 调用过 new方法了， instance 的值就不是 None了
    init_flag = False  # 定义一个初始值，用于标记 __init__方法，没有被再次执行
    def __new__(cls, *args, **kwargs):  # 重写__new__方法
        if cls.instance is None:  # 如果 之前没有执行过 new方法，则 cls.instance is None
            cls.instance = super().__new__(cls)  # 将 内存id 赋值给 cls.instance
        return cls.instance  # 重写 new方法后，将 内存 id　返回
    def __init__(self):
        if MusicPlayer.init_flag == True:
            return
        print("播放器初始化")
        MusicPlayer.init_flag = True
player1 = MusicPlayer()
player2 = MusicPlayer()
print(id(player1))  # 多个实例  2918561262816引用 是通过 __new__返回的
print(id(player2))