测试学习——Python学习（七）

测试学习——Python学习（七）

内容提要

• 私有和公有权限
• 属性分类（实例属性，类属性）
• 方法分类（实例方法、类方法、静态方法）
• 继承
• 多态

封装

私有和公有（访问控制权限）

1. 公有权限

• 直接书写的方法和属性, 都是公有的
• 公有的方法和属性, 可以在任意地方访问和使用

2. 私有权限

• 在类内部, 属性名或者方法名 前边加上两个 下划线 , 这个属性或者方法 就变为 私有的* * 私有的方法和属性, 只能在当前类的内部使用

3. 如果想要在类外部操作私有属性，需要在类内部定义公有方法，我们通过公有方法操作
4. 对象.dict 魔法属性，可以将对象具有的属性组成字典返回

# 定义一个Person类，属性name,age(私有)
class Person:
    def __init__(self,name,age):
        self.name=name
        # 私有的本质, 是 Python 解释器执行代码,发现属性名或者方法名前有两个_, 会将这个名字重命名
        # 会在这个名字的前边加上 _类名前缀,即 self.__age ===> self._Person__age
        self.__age=age
    def __str__(self):
        return f'名字: {self.name}, 年龄: {self.__age}'
xm=Person('xiaoming',18)
print(xm)
# 在类外部直接访问 age 属性
# print(xm.__age) # 会报错, 在类外部不能直接使用私有属性
# 直接修改 age 属性
xm.__age=20 # 这个不是修改私有属性, 是添加了一个公有的属性 __age
print(xm)
print(xm._Person__age)
xm._Person__age=19
print(xm)

属性和方法

python中一切皆是对象，即使用class定义的类也是对像

对象的划分

实例对象

1. 通过 类名() 创建的对象, 我们称为实例对象,简称实例
2. 创建对象的过程称为是类的实例化
3. 我们平时所说的对象就是指 实例对象(实例)
4. 每个实例对象, 都有自己的内存空间, 在自己的内存空间中保存自己的属性(实例属性)

类对象

1. 类对象 就是 类, 或者可以认为是 类名
2. 类对象是 Python 解释器在执行代码的过程中 创建的
3. 类对象的作用: ① 使用类对象创建实例 类名(), ② 类对象 也有自己的内存空间, 可以保存一些属性值信息 (类属性)
4. 在一个代码中, 一个类 只有一份内存空间

属性的划分

实例属性

• 实例对象具有的属性
• 在 init 方法中, 使用 self.属性名 = 属性值 定义 在其他方法中是 使用 self.属性名 来获取(调用)
• 实例属性,在每个实例中 都存在一份

类属性

• 类对象具有的属性
• 在类内部,方法外部,直接定义的变量 ,就是类属性 使用: 类对象.属性名 = 属性值 or 类名.属性名 = 属性值 类对象.属性名 or 类名.属性名
• 只有 类对象 中存在一份

方法的划分

方法, 使用 def 关键字定义在类中的函数就是方法

实例方法

• 在类中直接定义，参数一般写作self,表示实例对象
• 如果在方法中需要使用实例属性(即需要使用 self), 则这个方法必须定义为 实例方法
• 对象.方法名() # 不需要给 self 传参

类方法

• 在方法名字的上方书写 @classmethod 装饰器(使用 @classmethod 装饰的方法)

class Demo: 
     @classmethod 
     def func(cls): # 参数一般写作 cls, 表示的是类对象(即类名) class 
     pass

• 前提, 方法中不需要使用 实例属性(即 self)
• 用到了类属性, 可以将这个方法定义为类方法,(也可以定义为实例方法)
• `# 1. 通过类对象调用
  类名.方法名() # 也不需要给 cls 传参, python 解释器自动传递

• 2. 通过实例对象调用

   实例.方法名() # 也不需要给 cls 传参, python 解释器自动传递`
  

静态方法

• 在方法名字的上方书写 @staticmethod 装饰器(使用 @staticmethod 装饰的方法)

class Demo
      @statucmethod
      def func(): #一般没有参数
          pass

• 前提, 方法中不需要使用 实例属性(即 self)
• 也不使用 类属性, 可以将这个方法定义为 静态方法

• 1. 通过类对象调用

    类名.方法名() 
  

  • 2. 通过实例对象调用

     实例.方法名()
    

案例

1. 定义一个 Dog 类, 定义一个类属性 count,用来记录创建该类对象的个数. (即每创建一个对象,count 的值就要加 1)实例属性 name

'''
定义一个 Dog 类, 定义一个类属性 count,用来记录创建该类对象的个数.
(即每创建一个对象,count 的值就要加 1)实例属性 name
'''
class Dog:
    count =0 #类属性
    #实例属性，init方法
    def __init__(self,name):
        self.name=name
        Dog.count +=1 #类名.类属性
print(Dog.count)
dog1=Dog('huahua')
print(Dog.count)
dog2=dog1
print(Dog.count)
dog3=Dog('xiaohei')
#使用实例对象.类属性名 来获取类属性的值（(原因, 实例对象属性的查找顺序,
# 先在实例属性中找, 没有找到会去类属性中 找, 找到了可以使用, 没有找到 报错)）
print(dog1.count) # 2
print(dog2.count) # 2
print(dog3.count) # 2

• 定义一个游戏类 Game , 包含实例属性 玩家名字( name ) 1. 要求记录游戏的最高分( top_score 类属性),
• 定义方法: show_help 显示游戏的帮助信息 输出 这是游戏的帮助信息
• 定义方法: show_top_score , 打印输出游戏的最高分
• 定义方法: start_game , 开始游戏, 规则如下

1. 使用随机数获取本次游戏得分 范围 (10 - 100 )之间 2. 判断本次得分和最高分之间的关系
   如果本次得分比最高分高,
   修改最高分
   如果分数小于等于最高分,则不操作
2. 输出本次游戏得分
3. 主程序步骤

1. 创建一个 Game 对象 小王
2. 小王玩一次游戏,
3. 查看历史最高分
4. 小王再玩一次游戏
   5) 查看历史最高分
   6) 查看游戏的帮助信息

import random
class Game:
    top_score=0
    def __init__(self,name):
        self.name=name
    @staticmethod #方法中不需要使用 实例属性(即 self) 也不使用 类属性, 可以将这个方法定义为 静态方法
    def show_help(self):
        print('这是对游戏的帮助信息')
    @classmethod #用到了类属性, 可以将这个方法定义为类方法,(也可以定义为实例方法)
    def show_top_score(self):
        print(f'当前游戏最高分为：{Game.top_score}')

    def start_game(self):
        newscore=random.randint(10,100)
        if newscore>Game.top_score:
            Game.top_score=newscore
        else:
            pass
        print(f'本次游戏得分为：{newscore}')
        return newscore
xm=Game('小明')
for i in range(10):
    a=xm.start_game()
    xm.show_help()
    xm.show_top_score()

继承

1. 继承是描述类与类之间的关系
2. 作用：减少代码的冗余（相同代码无需重复书写）
3. 格式：

#class A(object)
class A:#没有写父类，但也有，object类为最原始的类
     pass
class B(A):#类B继承类A,称A为父类（基类），B为子类（派生类）
       pass
 

4. 单继承：一个类只继承一个父类
   特点：子类继承父类之后，**子类的对象可以直接使用父类中定义的共有属性和方法
   **

class Animal:
     def est(self):
        print('要吃东西')
class Dog(Animal)
      def bark(self):
          print('汪汪汪')
class XTQ(Dog)
     pass
xtq=XTQ()
xtq.bark() #调用父类Dog类的方法
xtq.eat() #可以调用父类的父类中的方法  
          

重写

1. 重写：在子类中定义和父类中名字相同的方法
2. 重写的方式：

• 覆盖(父类中功能完全抛弃,不要,重写书写)
• 扩展(父类中功能还调用,只是添加一些新的功能) (使用较多)

覆盖

直接在子类中 定义和父类中名字相同的方法 ， 直接在方法中书写新的代码

扩展

直接在子类中 定义和父类中名字相同的方法
在合适的地方调用 父类中方法 super().方法()
书写添加的新功能

class XTQ(Dog): # XTQ 类bark 方法不再是汪汪汪叫, 改为 # 1. 先 嗷嗷嗷叫(新功能) 2, 汪汪汪叫(父类中功能) 3. 嗷嗷嗷叫 (新功能)
 def bark(self): print('嗷嗷嗷叫...') 
 # 调用父类中的代码 
 super().bark() 
 print('嗷嗷嗷叫...')

多态

1. 是一种写代码,调用的一种技巧
2. 同一个方法, 传入不同的对象, 执行得到不同的结果, 这种现象称为是多态
3. 多态 可以 增加代码的灵活度 -------- 哪个对象调用方法, 就去自己的类中去查找这个方法, 找不到去父类中找

补充

1. 哈希算法是一个算法， 可以对数据产生一个唯一的值（指纹），比如用户名
2. is 可以用来判断两个对象是不是同一个对象，即 两个对象的引用是否相同
   a is b === > id(a) == id(b)
3. == 只判断数据值是否相同， is 判断引用是否相同