01Python基础阶段_Day08

最新推荐文章于 2024-09-17 23:15:58 发布

最白の白菜

最新推荐文章于 2024-09-17 23:15:58 发布

阅读量116

点赞数

分类专栏： # 01基础阶段文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/qq_43966129/article/details/121011973

版权

01基础阶段专栏收录该内容

11 篇文章 1 订阅

订阅专栏

这篇博客介绍了Python面向对象编程的基础概念，包括类的创建、实例化、属性和方法的使用。展示了如何实现一个烤地瓜类，通过类的复合创建了人和狗的类，模拟人听狗叫的情景。接着讲解了类的私有属性及其优点，强调了封装性和数据安全性。最后，通过继承的概念，展示了子类如何继承父类的属性和方法，并讨论了私有属性在子类中的访问方式。

摘要由CSDN通过智能技术生成

01Python基础阶段_Day08

面向对象烤地瓜分析

向对象对烤地瓜实现

# 烤地瓜案例
# 抽象一个地瓜类
class SweetPotato(object):
    # 实现一个初始化方法,初始地瓜的状态和总烧烤时间
    def __init__(self):
        self.status = "生瓜"
        self.total_time = 0
        # 添加一个用来保存调料的容器属性
        self.condiments = []

    # 实现一个烧烤方法,烧烤时间会被累计到总时间,根据总时间判断地瓜状态
    def cook(self, t):
        # 累加时间
        self.total_time += t
        # 判断时间来改变地瓜状态,0-3生的,3-5半生不熟,5-8已经烤好,超过8表示烤焦
        if self.total_time < 3:
            self.status = "还是生的,"
        elif self.total_time < 6:
            self.status = "半生不熟,"
        elif self.total_time < 8:
            self.status = "刚刚好,"
        else:
            self.status = "烤焦了,"

    # 添加一个加调料的方法
    def addCondiments(self, t1):
        self.condiments.append(t1)

    # 实现_str_方法,定义地瓜对象的显示格式
    def __str__(self):
        s = self.status + f'被烤了{self.total_time}分钟'
        s += ",地瓜使用了以下调料:\n"
        for i in self.condiments:
            s += (str(i) + "\n")
        return s


# 测试
sp1 = SweetPotato()
print(sp1)

sp1.cook(2)
sp1.addCondiments("十三香")
print(sp1)

sp1.cook(4)
sp1.addCondiments("蜂蜜")
print(sp1)

sp1.cook(2)
sp1.addCondiments("辣椒")
print(sp1)

类的复合（类中属性是对象）
在设计一个类时,类中包含其它类的对象,称为类的复合

人有一条狗
人想听狗叫
存放家具的案例

# 类的复合
class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self, n):
        for i in range(n):
            print("旺旺")


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

    # 为人添加一个拥有宠物的方法
    def add_pet(self, pet):
        self.pet = pet

    # 人想听狗叫
    def listen_dog_bark(self, n):
        self.pet.bark(n)


# 测试
tom = Person("Tom", 23)
# 为人的对象添加一条狗

tom.add_pet(Dog("golf", 1))
# 人调用狗叫的方法
tom.listen_dog_bark(2)


# 家具练习
class Furniture(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f"{self.name}占用了{self.area}平米"


# 设计一个房子类
class House(object):
    def __init__(self, address, area):
        self.address = address
        self.area = area
        self.free_area = self.area * 0.3
        # 定义一个用来保存家具的容器属性
        self.furnitures = []

    # 实现一个添加家具的方法
    def add_furniture(self, fur):
        # 先判断剩余面积是否够
        if fur.area < self.free_area:
            self.furnitures.append(fur)
            self.free_area -= fur.area
            print(f"剩余空间还有{self.free_area}平米")
        else:
            print("空间不够,无法添加新家具!")

    # 实现显示方法
    def __str__(self):
        s = f"我的大房子在{self.address},占地面积{self.area}平米\n"
        s += "家具如下:\n"
        if len(self.furnitures) == 0:
            s += "还没有添加家具"
            return s
        else:
            for f in self.furnitures:
                s += (str(f) + "\n")
            return s


# 测试
home = House("长安城", 100)
print(home)
# 添加家具
bed1 = Furniture("双人床", 5)
home.add_furniture(bed1)
print(home)
home.add_furniture(Furniture("单人床", 3))
home.add_furniture(Furniture("饭桌", 4))
home.add_furniture(Furniture("椅子", 1))
home.add_furniture(Furniture("椅子", 1))
home.add_furniture(Furniture("椅子", 1))
home.add_furniture(Furniture("大衣柜", 10))
home.add_furniture(Furniture("书桌", 10))
print(home)

私有属性的定义和使用

在python抽象类时,默认定义的变量是公有的
公有的变量,可以通过对象在任何位置访问

类中公有属性一般不建议使用,破坏程序的封装性,在类的外部可以通过对象直接访问,

对于数据来说,相对不安全

类中公有的方法的作用是为外部提供一种接口,通过这个接口可以来实现相应的交互操作

私有属性:

因为公有属性的不安全,可以将属性设置成私有,私有属性只能在类的内部使用,而在类的外部是不可以使用的

私有方法

将不想公开的实现数据和逻辑通过私有方法进行封装,可以隐藏关键代码.
如果想使用私的方法功能时,可以在类的内部使用,或者在类的外部通过类中提供的公有方法来间接使用
私有属性的优点
set/get方法对私有属性操作时的好处:
1. 提供精确的访问控制权限
2. 隐藏实现细节,让代码更安全
3. 可以提供更加安全的数据有效性控制
继承概述
程序中的继承,遵循生活的继承方式
被继承的类: 父类, 超类, 基类
衍生出的类: 子类, 派生类

新式类中:所有的类,都直接或间接继承 object 类

object 类是所有类的父类

在继承时,子类拥有父类的所有的内容

继承的作用:
复用代码
继承的格式

class 子类名(父类名):
pass

在出现继承后
当子类对象去调用方法时,会先在子类中去查找方法,如果有,那么就执行,如果没有找到,去到父类中去查找该方法,如果找到执行
找不到再到上一级类中去查找直到找到object类,如果还没有那么就报错
子类使用继承父类的属性和方法
子类不能继承父类的私有属性和私有方法
子类中访问父类中的私有属性和方法
如何为父类中的属性进行初始化
子类中重写和调用父类的方法
子类方法中调用父类的同名方法
多层继承
多继承
多继承的初始化
父类名调用理解
super()调用使用
super(类名，self) 了解
多继承调用指定父类中方法
父类名.方法（）

'''
Python:
    在定义属性时,没有任何修饰的都是公有的
    如果在属性或方法前,加两个下划线前缀,那么这个属性或方法,解释器就会认为是私有的
'''


class Account(object):
    def __init__(self, name, balance):
        # 定义了两个公有属性,这两个属性在类的外部也是可以访问的
        # self.name = name
        # self.balance = balance
        # 因为数据的公有属性破坏程序的封装性,导致数据不安全,所以定义为私有的
        self.__name = name
        self.__balance = balance

    # 定义一个查看信息的方法
    def show_info(self):
        # 在类的内部访问对象的公有属性
        # print(self.name + "有" + self.balance + "元")
        # 在类的内部访问对象的私有属性
        print(self.__name + "有" + self.__balance + "元")


jack = Account("JackMa", 999999)


# 在类的外部访问对象的公有属性
# print(jack.name)
# print(jack.balance)
# jack.name = "郭"
# print(jack.name)
# print(jack.balance)

# 私有方法的使用
class ThunderBird(object):
    # 实现一个初始化方法,用来保存下载任务
    def __init__(self):
        self.__list = []

    # 实现一个公有的方法,用来添加任务
    def add_task(self, url):
        self.__list.append(url)
        # 在类的内部,直接访问私有方法
        self.__download_data(url)

    # 核心代码,用来下载数据的算法
    def __download_data(self, url):
        print(f"通过地址{url}下载数据中....")


# 测试
tb = ThunderBird()
# 通过一个公有方法,间接的访问了对象的私有方法,下载数据
tb.add_task("http://www.dytt88.net/复联4.mp4")


# 私有方法在类的外部是不能拼接访问的
# tb.__downlaod_data("http://www.dytt88.net/复联4.mp4")

# 继承的实现
class Phone(object):
    # 定义一个打电话的方法
    def call(self, number):
        print(f"正在给{number}打电话")


# 定义一个子类
class Iphone(Phone):
    # 添加一个拍照的方法
    def camera(self):
        print("正在拍照")


# 当发生继承后,子类会继承父类中的属性和方法,可以直接使用
iponex = Iphone()
iponex.call("1111111111")
iponex.camera()

# 子类不能直接使用父类的私有属性和方法
class Father(object):
    def __init__(self):
        self.__money = 999
        self.name = "tom"

    def __show(self):
        print("这是父类中的私有方法")
    def display(self):
        print("这是父类中的公有方法")
        self.__show()

# 定义一个子类
class Son(Father):
    # 定义一个自己的方法
    def play(self):
        print("这是子类的方法")
        # 通过继承得到的父类的公有方法,间接执行父类的私有方法
        self.display()
# 测试
s =Son()
s.play()
s.display()