Python学习第十一天

最新推荐文章于 2024-07-12 19:06:42 发布
最新推荐文章于 2024-07-12 19:06:42 发布
阅读量323 收藏 1
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44687626/article/details/106753035
版权

封装设计思想
1. 识别对象
2. 分配职责
3. 建立交互

"""
    封装设计思想

        需求：老张开车去东北
            类：承担行为
            对象：承担数据
         1. 识别对象
            老张           车
         2. 分配职责
                去()         行驶()
         3. 建立交互
            老张调用车
"""

# lz = Person("老张")
# ls = Person("老孙")

"""
# 写法1：直接创建对象
# 语义： 老张去东北用一辆新车
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self,position):
        print(self.name,"去",position)
        car = Car()
        car.run()

class Car:
    # 实例方法
    def run(self):
        print("汽车在行驶")

lw = Person("老王")


lw.go_to("东北")
lw.go_to("西北")
"""

"""
# 写法2：在构造函数中创建对象
# 语义： 老张开车自己的车去东北
class Person:
    def __init__(self, name=""):
        self.name = name
        self.car = Car()

    def go_to(self,position):
        print(self.name,"去",position)
        # 第一次.: 从栈帧到人对象
        # 第二次.: 从人到车对象
        self.car.run()

class Car:
    # 实例方法
    def run(self):
        print("汽车在行驶")

lw = Person("老王")
lw.go_to("东北")
lw.go_to("西北")
"""

# 写法3：通过参数传递对象
# 语义：人通过交通工具(参数传递而来)去东北
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self,position,vehicle):
        print(self.name,"去",position)
        vehicle.run()

class Car:
    # 实例方法
    def run(self):
        print("汽车在行驶")

lw = Person("老王")
c01 = Car()
lw.go_to("东北",c01)

类与类调用语法
写法1：直接创建对象调
写法2：构造函数创建对象调
写法3：构造函数创建对象调

"""
    总结
        类与类调用语法
"""


# 函数互相调用：通过函数名直接调用
# def func01():
#     func02()
#
# def func02():
#     print("func02")
#
# func01()

# 写法1：直接创建对象调
# class A:
#     def func01(self):
#         b = B()
#         b.func02()
#
# class B:
#     def func02(self):
#         print("func02")
#
# g01 = A()
# g01.func01()


# 写法2：构造函数创建对象调
# class A:
#     def __init__(self):
#         self.b = B()
#
#     def func01(self):
#         self.b.func02()
#
# class B:
#     def func02(self):
#         print("func02")
#
# g01 = A()
# g01.func01()

# 写法3：构造函数创建对象调
class A:
    def func01(self, c):
        c.func02()


class B:
    def func02(self):
        print("func02")


g01 = A()
g02 = B()
g01.func01(g02)

继承
语法角度讲
继承方法
1. 代码:
class 父类:
def 父类方法(self):
方法体
class 子类(父类)：
def 子类方法(self):
方法体
儿子 = 子类()
儿子.子类方法()
儿子.父类方法()
2. 说明：子类直接拥有父类的方法.

"""
    继承
        财产：钱不用儿子挣，但是儿子能花
        皇位：江山不用太子打，但是太子能登基
        编程：代码不用子类写，但是子类能使用
"""


# 从思想讲：先有子再有父
# 从编码讲：先有父再有子

# 多个类有代码的共性，且属于共同一个概念。
class Person:
    def say(self):
        print("说话")

class Student(Person):
    def study(self):
        self.say()
        print("学习")

class Teacher(Person):
    def teach(self):
        print("教学")

# 创建子类对象,可以调用父类方法和子类方法
s01 = Student()
s01.say()
s01.study()

# 创建父类对象,只能调用父类方法
p01 = Person()
p01.say()

# isinstance(对象,类型)  判断关系
# 学生对象  是一种  学生类型
print(isinstance(s01, Student)) # True
# 学生对象  是一种  人类型
print(isinstance(s01, Person)) # True
# 学生对象  是一种  老师类型
print(isinstance(s01, Teacher)) # False
# 人对象  是一种 学生类型
print(isinstance(p01, Student)) # False

# issubclass(类型,类型)  判断关系
# 学生类型  是一种  学生类型
print(issubclass(Student, Student)) # True
# 学生类型  是一种  人类型
print(issubclass(Student, Person)) # True
# 学生类型  是一种  老师类型
print(issubclass(Student, Teacher)) # False
# 人类型  是一种 学生类型
print(issubclass(Person, Student)) # False

# Type
# type(对象) == 类型  相等/相同/一模一样
# 学生对象的类型  是  学生类型
print(type(s01) == Student) # True
# 学生对象的类型  是  人类型
print(type(s01) == Person) # False
# 学生对象的类型  是  老师类型
print(type(s01) == Teacher) # False
# 人对象的类型    是  学生类型
print(type(p01) ==  Student) # False

继承数据
1. 代码
class 子类(父类):
def init(self,参数列表):
super().init(参数列表)
self.自身实例变量 = 参数
2. 说明
子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的。此时必须通过super()函数调用父类的构造函数，以确保父类实例变量被正常创建。
继承数据
1. 子类没有构造函数,可以直接使用父类的
2. 子类有构造函数,会覆盖父类构造函数(好像他不存在)
所以子类必须通过super()调用父类构造函数

"""
    继承数据
    代码
	class 子类(父类):
	 	def __init__(self,参数列表):
			super().__init__(参数列表)
			self.自身实例变量 = 参数

        class 儿子(爸爸):
            def __init__(self, 爸爸构造函数参数,儿子构造函数参数):
                super().__init__(爸爸构造函数参数)
                self.数据 = 儿子构造函数参数
"""


class Person:
    def __init__(self, name="", age=0):
        self.name = name
        self.age = age


class Student(Person):
    def __init__(self, name="", age=0, score=0):
        # 通过super()调用父类实例成员
        super().__init__(name, age)
        self.score = score


# 1. 子类没有构造函数,可以直接使用父类的
# s01 = Student()

# 2. 子类有构造函数,会覆盖父类构造函数(好像他不存在)
#    所以子类必须通过super()调用父类构造函数
s01 = Student("小明", 24, 100)
print(s01.name)
print(s01.age)
print(s01.score)

定义
重用现有类的功能，并在此基础上进行扩展。
说明：子类直接具有父类的成员（共性），还可以扩展新功能。
优点
一种代码复用的方式。
缺点
耦合度高：父类的变化，直接影响子类。
练习一

"""
    小明请保洁打扫卫生
         1. 识别对象
            小明     保洁
         2. 分配职责
            通知     打扫
         3. 建立交互
            小明调用保洁的打扫方法

        要求：使用三种写法实现，说出不同的语义.
"""

# 写法一：小明每次请一个新保洁
"""
class Client:
    def __init__(self, name=""):
        self.name = name

    def notify(self):
        print(self.name,"发出通知")
        cleaner = Cleaner()
        cleaner.cleaning()

class Cleaner:
    def cleaning(self):
        print("保洁打扫卫生")

xm = Client("小明")
xm.notify()
"""

# 写法二：小明请自己的保洁
"""
class Client:
    def __init__(self, name=""):
        self.name = name
        self.cleaner = Cleaner()

    def notify(self):
        print(self.name,"发出通知")
        self.cleaner.cleaning()

class Cleaner:
    def cleaning(self):
        print("保洁打扫卫生")

xm = Client("小明")
xm.notify()
"""

# 写法三：小明请家政服务(参数  保洁)
class Client:
    def __init__(self, name=""):
        self.name = name

    def notify(self, household_service):
        print(self.name, "发出通知")
        household_service.cleaning()


class Cleaner:
    def cleaning(self):
        print("保洁打扫卫生")


xm = Client("小明")
bj = Cleaner()
xm.notify(bj)

练习二

"""
    1. 玩家攻击敌人,敌人受伤(播放动画)
    2. 玩家(攻击力)攻击敌人(血量),
        敌人受伤(播放动画,血量减少)
    3. 敌人(攻击力)还能攻击玩家(血量),
        玩家受伤(碎屏,血量减少)
"""

# 1. 类与类调用
# class Player:
#     def attack(self, emeny):
#         emeny.damage()
#
# class Enemy:
#     def damage(self):
#         print("播放受伤动画")
#
# p01 = Player()
# e01 = Enemy()
# p01.attack(e01)

# 2. 调用时增加数据   玩家(攻击力)  -攻击力->  敌人(血量)
"""
class Player:
    def __init__(self, atk=0):
        self.atk = atk
    def attack(self, emeny):
        print("玩家攻击敌人")
        emeny.damage(self.atk)

class Enemy:
    def __init__(self, hp):
        self.hp = hp
    def damage(self, value):
        print("播放受伤动画")
        self.hp -= value
        print("敌人血量是", self.hp)


p01 = Player(50)
e01 = Enemy(100)
p01.attack(e01)
p01.attack(e01)
"""


# 3.
class Player:
    def __init__(self, hp, atk):
        self.hp = hp
        self.atk = atk

    def attack(self, emeny):
        print("玩家攻击敌人")
        emeny.damage(self.atk)

    def damage(self, value):
        print("碎屏")
        self.hp -= value
        print("敌人血量是", self.hp)


class Enemy:
    def __init__(self, hp, atk):
        self.hp = hp
        self.atk = atk

    def damage(self, value):
        print("播放受伤动画")
        self.hp -= value
        print("敌人血量是", self.hp)

    def attack(self, player):
        print("敌人攻击玩家")
        player.damage(self.atk)


p01 = Player(500, 50)
e01 = Enemy(100, 10)
p01.attack(e01)
e01.attack(p01)

练习三

"""
    创建子类：狗(跑)，鸟类(飞)
    创建父类：动物(吃)
    体会子类复用父类方法
    体会 isinstance 、issubclass 与 type 的作用.
"""


class Animal:
    def eat(self):
        print("吃")


class Dog(Animal):
    def run(self):
        print("跑")


class Bird(Animal):
    def fly(self):
        print("飞")


a01 = Animal()
d01 = Dog()
b01 = Bird()

# 类型 与 类型 的关系
print(issubclass(Animal, Dog))

# 对象 与 类型 的关系
print(isinstance(b01, Animal))

# 狗对象 与 动物类型 相同
print(type(d01) == Animal)

练习四

"""
    创建父类：车(品牌，速度)
    创建子类：电动车(电池容量,充电功率)
    创建子类对象并画出内存图。
"""


class Car:
    def __init__(self, bread="", speed=0):
        self.bread = bread
        self.speed = speed


class ElectricCars(Car):
    def __init__(self, bread, speed, battery_capacity, charging_power=100):
        super().__init__(bread, speed)
        self.battery_capacity = battery_capacity
        self.charging_power = charging_power


tsl = ElectricCars("特斯拉", 300, 30000, 1000)
print(tsl.bread)
print(tsl.speed)
print(tsl.battery_capacity)
print(tsl.charging_power)
wwwchah
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python-Level1-day13：面向对象思想多态之重写自定义方法；MVC框架
dpq666dpq666
05-20 160
2022年7月10日20:04:07
python面向对象案例
qq_44603301的博客
02-13 3554
面向对象简单对象调用案例 ''' 面向对象案例： 老张开车去东北 案例分析： 对象有：人 交通工具 地点 ''' #定义人的对象 class Person: #初始化人的属性 def __init__(self,name,card): self.name = name self.card = card #定义人使用交通工具的方法 def d...
2021-04-15 第一阶段day11
weixin_44840038的博客
04-15 299
day11一、类的跨类调用1、直接创建对象2、构造函数创建对象3、通过参数传递对象二、类变量与类方法三、Python语言所有变量的小结四、私有成员1、语法： 开头用两个下划线命名2、作用：类外无法访问3、原理：障眼法五、属性1、原理2、过渡版本3、最终版本 一、类的跨类调用 需求：用面向对象的方式描述“老张开车去东北”。 题目分析：老张与车彼此有行为，所以需要构建两个类。 构建类的原因：（1）需要承担行为（2）需要封装数据 共有三种跨类调用的方式： 1、直接创建对象 # 语义： 老张每次去东北都用一辆新
面向对象案例——老张开车去东北
大人的博客
02-13 6401
面向对象实现：老张开车去东北 分析： 老张——人：Person 车——交通工具：TrafficTools 东北——地点：Place class Person: """人的类型""" def __init__(self, name): self.name = name def driving(self, traffic_tools, area): &
完整的老张开车去东北
weixin_30470857的博客
04-14 2024
Console.WriteLine("老张开车去东北。"); string a=Console.ReadLine(); if(a=="撞了") { Console.WriteLine("肇事司机耍流氓。"); string b=Consol...
python学习笔记第五天续
12-22
`capitalize()` 方法将字符串的第一个字符转换为大写，而 `title()` 方法则是使每个单词的首字母变为大写。 字符串的查找和替换功能可以通过 `find()`、`index()` 和 `replace()` 实现。`find()` 或 `index()` 可...
python学习作业第1天.zip
06-14
"python学习作业第1天.zip"这个压缩包可能包含的是初学者在第一天学习过程中接触的一些基本概念和练习。"ljg_resource"作为子文件夹名，可能是存放与学习资源相关的文件，如代码、笔记或教程。 在Python学习的第1天...
【学习日记】python的第三天
01-06
我第一次选的时候报错了！然后我以为是老师写错题目的了，看了答案才知道，我是真的打错了… 【错题笔记】 因为3.代表浮点数，2*浮点数的结果还是浮点数，1+浮点数也是浮点数，所以答案是float 作业 【问题】一个def...
python一百天学习笔记
12-26
1. **基础语法**：这是Python学习的第一步，包括变量定义、数据类型（如整型、浮点型、字符串、布尔型、列表、元组、字典和集合）、运算符、流程控制（如if-else语句、for循环、while循环）、函数定义和调用、模块...
python第11天，python-Day11.rar
05-06
在Python编程语言的学习过程中，第11天通常会涵盖一些进阶的主题，旨在深化对Python的理解和应用能力。以下是对这个阶段可能涉及的一些关键知识点的详细说明： 1. **异常处理**：Python中的错误和异常处理是编程...
Python小白学习笔记六 （面向对象 练习题）
weixin_45610121的博客
08-22 623
面向对象 练习题 练习1： """ 创建父类：车(品牌，速度) 创建子类：电动车(电池容量,充电功率) 创建子类对象并画出内存图。 """ class Car: def __init__(self, bread="", speed=0): self.bread = bread self.speed = speed class ElectricCars(Car): def __init__(self, bread, speed, bat
JavaScript（w3c持续更新。。）
LuckyGuyy的博客
11-28 329
面向过程（pop） 分析出解决问题所需要的步骤，然后用函数一步一步实现，使用的时候再一个一个的依次调用就可以了。 面向对象（oop） 把事务分解成为一个个对象，然后由对象之间分工合作 面向对象的特性： 封装性 继承性 多态性 在JavaScript中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串，数值，数组，函数等。 对象由属性和方法组成 ...
面向对象之老张开车去东北
qq_38110979的博客
02-13 5534
''' 老张开车去东北： OOA：分析 对象：老张——人——Person 车——交通工具——Vehicle 东北——地点——PLace OOD：设计 人： 属性：名字 行为：驾驶 交通工具： 属性：名字 ...
Python_面向对象初步_类_属性_方法_综合案例（10）
稳稳C9的博客
05-09 411
Python_面向对象初步_类_属性_方法_综合案例（10）
【python面向对象】继承与多态（二)
qq_45662225的博客
05-08 458
本文对继承与多态进一步补充，案例通俗易懂。
2018年7月25日python中面向对象编程的练习
i_can_do_it!
07-25 1375
今天遇到的新单词： parameter  n参数 IndentationError  n缩进错误 formatting n格式化 声明一个类型的时候，会用到__init__函数，它的作用是初始化数据，就是赋值， 把值赋给当前对象，只有创建对象时候才会调用 交互界面出现三个点表示代码没有写完，可以用一个缩进加pass继续执行 声明类型中__init__方法后边的括号里面是写对象具有的特征 类...
Python-11_玩家攻击敌人_攻击_受伤
NewMet的博客
03-25 1869
# 玩家（具有攻击力）攻击敌人，敌人（具有血量）受伤后掉血，还可能死亡。 # 敌人攻击玩家，玩家受伤后掉血并屏碎，还可能死亡（结束游戏）。 class Player: """定义一个玩家类""" def __init__(self,name,blood_volume): self.name=name self.blood_volume=bloo...
Python面向对象-回合制游戏攻击模式--基础
m0_46369412的博客
03-23 2484
面向对象这里我学了几天了，一道坎，感觉有些难，分享一下我的一个作业。需求目前是达到了，但是太啰嗦。 1.使用面向对象思想，写出下列场景： 玩家攻击（攻击力）敌人，敌人（血量）受伤后掉血，还可能死亡（播放动画）， 敌人攻击（攻击力）玩家，玩家（血量）受伤后碎屏，还可能死亡（游戏结束）， 设计上要满足类与类行为不同，就是他们的职责不同，比如题目中的攻击是一个，掉血又是另一种行为，死亡...
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
最新发布
weixin_42333261的博客
07-12 279
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
Python 学习笔记 第二版1
08-03
总结起来，Python学习笔记第二版是一份非常全面的Python编程教程。它从基础语法到高级主题，从面向过程到面向对象，详细介绍了Python编程的各个方面。通过阅读学习笔记并完成其中的实例和练习，读者可以掌握Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值