python高级2

最新推荐文章于 2024-09-27 10:11:28 发布

qq_36227329

最新推荐文章于 2024-09-27 10:11:28 发布

阅读量61

点赞数

分类专栏： python测试开发笔记文章标签： python flask 开发语言

本文链接：https://blog.csdn.net/qq_36227329/article/details/127996750

版权

python测试开发笔记专栏收录该内容

40 篇文章 1 订阅

订阅专栏

面向对象

1.类的定义

语法

class 类名():
    属于该类的属性和行为

缩进也是四个空格

2.属性的定义

# 属性的定义
# 属性分为：静态属性和实例属性
# 静态属性指的实例对象所共有的属性
# 实例属性指的每一个实例对象所独有的属性
# self指的是实例化对象本身
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
        # # 输出老虎的体重，
        # print(self.w)
# 要产生对象，其实就是根据类进行实例化而已
# 在类的实例化的时候，会执行初始化方法init
print("----------------------------------")
t1 = Tiger(200)
# 实例属性
print("t1的体重：", t1.w)
# 访问静态属性:1、通过实例化对象访问t1.name    2.也可以通过 类名.属性名 访问静态属性
print("name静态属性的值为：", t1.name)
print("name静态属性的值为：", Tiger.name)

3.方法的定义

# 方式对应的就是行为，其实是使用函数来表示
"""
静态方法：静态方法就是所有的实例对象所共有的方法
实例方法：每一个实例对象所独有的方法，实例方法方法名后面的括号中self指的是实例化对象本身
类方法：针对整个类而言的, 类方法中可以访问静态属性
判断那个方法要定义成那种类型：根据是否要操作实例属性做判断。如果方法要使用实例属性，则是实例方法
实例方法中可以访问实例属性、静态属性
但是静态方法中，不能访问实例属性，只能访问静态属性
"""
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
    # 喂食的方法
    def food(self, feed):
        # 判断
        if feed == "meet":
            print("喂对了，动物的体重加10斤")
            # 访问实例属性
            self.w += 10
        else:
            print("喂错了，动物的体重减10斤")
            self.w -= 10
    # 叫声
    def roar(self):
        print(f"{Tiger.name}wow!!!wow!!!wow!!!")
        self.w -= 5
    # 静态方法
    @staticmethod
    def jump():
        print(f"{Tiger.name}都会跳跃&&&&&")
    # 类方法
    @classmethod
    def a(cls):
        # 在类方法中访问静态属性有两种方法，1. 类名.静态属性  2.cls.静态属性
        # 之所以会有两种写法是因为 cls其实指的就是这个类
        # print(Tiger.name)
        print(cls.name)
        print("我是一个类方法")
# 实例化产生对象
t1 = Tiger(200)
# 通过实例化对象能不能访问实例方法呢？
t1.roar()
t1.food("meet")
# 访问静态方法：静态方法有两种访问的方式 1. 实例化对象.静态方法名  2.类名.静态方法名
t1.jump()
Tiger.jump()
# 类方法的使用 : 1. 实例化对象.类方法名 2. 类名.类方法名
t1.a()
Tiger.a()

4.对象的组合

# 房间类：
# 对象的组合的时候，是将小对象当做大对象的一个属性传入即可
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
    # 喂食的方法
    def food(self, feed):
        # 判断
        if feed == "meet":
            print("喂对了，动物的体重加10斤")
            # 访问实例属性
            self.w += 10
        else:
            print("喂错了，动物的体重减10斤")
            self.w -= 10
    # 叫声
    def roar(self):
        print(f"{Tiger.name}wow!!!wow!!!wow!!!")
        self.w -= 5
    # 静态方法
    @staticmethod
    def jump():
        print(f"{Tiger.name}都会跳跃&&&&&")
class Room():
    def __init__(self, num, animal):
        # 房间号
        self.num = num
        # 房间中的动物
        self.animal = animal
# 实例化出来一只老虎
t1 = Tiger(200)
# 实例化房间类
r1 = Room(1, t1)
# 访问动物的静态属性
print(r1.animal.name)
# 访问动物的实例属性
print(r1.animal.w)
# 调用老虎的相关方法
r1.animal.food("grass")

5.继承

语法：

# 东北虎
class NeTiger(Tiger):
    def __init__(self,w):
        Tiger.__init__(self, w)

# 对象的继承
# 子类继承父类， 一个父类可以有多个子类，一个子类可以继承多个父类
# 子类继承了父类就拥有了父类的一切属性和方法
# 老虎  东北虎、华南虎、孟加拉虎、西伯利亚虎
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
    # 喂食的方法
    def food(self, feed):
        # 判断
        if feed == "meet":
            print("喂对了，动物的体重加10斤")
            # 访问实例属性
            self.w += 10
        else:
            print("喂错了，动物的体重减10斤")
            self.w -= 10
    # 叫声
    def roar(self):
        print(f"{Tiger.name}wow!!!wow!!!wow!!!")
        self.w -= 5
    # 静态方法
    @staticmethod
    def jump():
        print(f"{Tiger.name}都会跳跃&&&&&")
    # 类方法
    @classmethod
    def a(cls):
        # 在类方法中访问静态属性有两种方法，1. 类名.静态属性  2.cls.静态属性
        # 之所以会有两种写法是因为 cls其实指的就是这个类
        # print(Tiger.name)
        print(cls.name)
        print("我是一个类方法")
# 东北虎
class NeTiger(Tiger):
    def __init__(self,w):
        Tiger.__init__(self, w)
# 华南虎
class ScTiger(Tiger):
    def __init__(self, w):
        Tiger.__init__(self, w)
# 实例化产生一只东北虎
# net1 = NeTiger(220)
#
# # 调用静态属性
# print(net1.name)
# # 实例属性
# print(net1.w)
#
# # 访问静态方法
# net1.jump()
#
# # 访问实例方法
# net1.roar()
set1 = ScTiger(200)
print(set1.name)
print(set1.w)
set1.roar()
set1.jump()

6.重定义

# 重定义：子类继承父类之后，觉得父类的某个方法不能满足自己，就需要对该方法进行重新定义，
# 重定义的时候，对于父类的方法的改变只仅限于该子类
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
    # 喂食的方法
    def food(self, feed):
        # 判断
        if feed == "meet":
            print("喂对了，动物的体重加10斤")
            # 访问实例属性
            self.w += 10
        else:
            print("喂错了，动物的体重减10斤")
            self.w -= 10
    # 叫声
    def roar(self):
        print(f"{Tiger.name}wow!!!wow!!!wow!!!")
        self.w -= 5
    # 静态方法
    @staticmethod
    def jump():
        print(f"{Tiger.name}都会跳跃5米")
    # 类方法
    @classmethod
    def a(cls):
        # 在类方法中访问静态属性有两种方法，1. 类名.静态属性  2.cls.静态属性
        # 之所以会有两种写法是因为 cls其实指的就是这个类
        # print(Tiger.name)
        print(cls.name)
        print("我是一个类方法")
# 东北虎
class NeTiger(Tiger):
    name = "东北虎"
    def __init__(self, w):
        Tiger.__init__(self, w)
    @staticmethod
    def jump():
        print(f"都会跳跃3米")
# 华南虎
class ScTiger(Tiger):
    def __init__(self, w):
        Tiger.__init__(self, w)
print("______________老虎_____________")
t1 = Tiger(200)
t1.jump()
print(t1.name)
print("_____________东北虎______________")
n1 = NeTiger(100)
n1.jump()
print(n1.name)
print("_____________华南虎______________")
s1 = ScTiger(200)
s1.jump()
print(t1.name)

7.面向对象三大特征

继承
封装
多态

import random
import time
class Tiger():
    # 静态属性
    name = "老虎"
    # 体重（实例属性）
    def __init__(self, w):
        # 属性的定义个变量有点类似
        self.w = w
    # 喂食的方法
    def food(self, feed):
        # 判断
        if feed == "meet":
            print("喂对了，动物的体重加10斤")
            # 访问实例属性
            self.w += 10
        else:
            print("喂错了，动物的体重减10斤")
            self.w -= 10
    # 叫声
    def roar(self):
        print(f"{Tiger.name}wow!!!wow!!!wow!!!")
        self.w -= 5
class Sheep():
    # 静态属性
    name = "羊"
    # 定义一个实例属性
    def __init__(self, w):
        self.w = w
    # 实例方法
    def food(self, feed):
        if feed == "grass":
            print("喂对了，体重加10斤")
            self.w += 10
        else:
            print("喂错了，体重减10斤")
            self.w -= 10
    def roar(self):
        print("miemiemiemiemiemie")
        self.w -= 5
class Room():
    def __init__(self, num, animal):
        # 房间号
        self.num = num
        # 房间中的动物
        self.animal = animal
# 定义一个列表，用于保存房间对象
rooms = []
# 产生10个房间
for i in range(1, 11):
    # 随机产生羊或者老虎
    flage = random.randint(0, 1)
    if flage == 0:
        a = Tiger(200)
    else:
        a = Sheep(100)
    # 实例化出来房间对象
    rooms.append(Room(i, a))
# 获取游戏开始时间
start_time = time.time()
print("游戏即将开始，将进行倒计时：")
while True:
    # 获取游戏结束时间
    end_time = time.time()
    if end_time - start_time >= 20:
        print("游戏即将结束。。。。")
        # 输出房间动物信息
        for r in rooms:
            print(f"第{r.num}号房间的动物是{r.animal.name},动物的体重是：{r.animal.w}")
        break
    # 随机弹出一个房间
    r1 = random.choice(rooms)
    print(f"本次弹出的是{r1.num}号房间")
    # 选择是否要敲门
    f = input("请选择是否敲门：输入y:")
    if f == "y":
        # 调用敲门的实例方法
        r1.animal.roar()
    # 不需要敲门，则可以直接喂食
    feed = input("请输入食物：")
    # 调用喂食的方法
    r1.animal.food(feed)