烤地瓜案列：
'''
烤地瓜安全
'''
抽象一个地瓜类
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表示已经烤好了，超过8表示
if self.total_time < 3:
self.status = '还是个生瓜蛋子'
elif self.total_time < 6:
self.status = '半生不熟'
elif self.total_time < 8:
self.status = '刚刚好，烤的冒油'
elif self.total_time < 10:
self.status = '烤糊了'
else:
self.status = '烤成炭了，直接烧火吧'
# 添加一个加调料的方法
def addCondiments(self,tl):
# 将参数的调料保存起来就可以
self.condiments.append(tl)
# 实现 __str__方法，定义地瓜对象的显示格式
def __str__(self):
s = self.status + f'被烤了 {self.total_time} 分钟'
s += '地瓜使用了以下调料：\n'
for i in self.condiments:
s += (i + '\n')
return s
# 测试
sp1 = SweetPotato()
print(sp1)
sp1.cook(2)
sp1.addCondiments('蜂蜜')
print(sp1)
sp1.cook(2)
sp1.addCondiments('老干妈')
print(sp1)
sp1.cook(2)
sp1.addCondiments('芥末油')
print(sp1)
sp1.cook(5)
print(sp1)
sp2 = SweetPotato()
print(sp2)
类的复合（类中属性是对象）
在设计一个类时,类中包含其它类的对象,称为类的复合
人有一条狗
人想听狗叫
人想听狗叫
'''
# 经过分析，应该设计 两个类
# 一个人类，一个狗类
# 设计狗类
class Dog(object):
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self,n):
for i in range(n):
print('Won...')
# 设计一个人类
class Person(object):
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('glof',1))
# 人调用 想听狗叫的方法
tom.listen_dog_bark(3)
jack = Person('jack',22)
jack.listen_dog_bark(5)
搬家具
向房子中添加家具
'''
# 设计一个家具类
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'我的大House 在{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('长安街3号', 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',1))
home.add_furniture(Furniture('椅子2',1))
home.add_furniture(Furniture('椅子3',1))
home.add_furniture(Furniture('椅子4',1))
home.add_furniture(Furniture('大衣柜',10))
home.add_furniture(Furniture('书桌',10))
print(home)
私有属性
在python抽象类时,默认定义的变量是公有的
公有的变量,可以通过对象在任何位置访问
# 类中公有属性一般不建议使用,破坏程序的封装性,在类的外部可以通过对象直接访问,
对于数据来说,相对不安全
# 类中公有的方法的作用是为外部提供一种接口,通过这个接口可以来实现相应的交互操作
# 私有属性:
因为公有属性的不安全,可以将属性设置成私有,私有属性只能在类的内部使用,而在类的外部是不可以使用的
# 私有方法
将不想公开的实现数据和逻辑通过私有方法进行封装,可以隐藏关键代码.
如果想使用私的方法功能时,可以在类的内部使用,或者在类的外部通过类中提供的公有方法来间接使用
python:
定义属性时，没有任何修饰 的都 是公有的如果在属性或方法前，
加两个下划线前缀，那么这个属性或方法，python 解释 器就认为是私有的
私有属性
class Account(object):
def __init__(self,name,balance):
# self.name = name
# self.balance = balance
# 定义两个私有属性
self.__name = name
self.__balance = balance
# 因为帐户名一旦确认后无需修改，可以不提供set方法
def get_name(self): # get相当于是提供了一个外界查看账户名的方法
return self.__name # 返回查看到的帐户名
# 给余额提供 存取方法
def set_balance(self,new_balance): # 定义一个外界存钱的方法
if isinstance(new_balance,int): # 判断存的钱是否合法
self.__balance = new_balance
else:
print("不能存")
def get_balance(self): # 定义一个取钱/查看钱的方法
return self.__balance
# 定义一个查看信息的方法
def show_info(self):
print(self.__name + '元',self.__balance,'元')
jack = Account('JackMa',99999)
# print(jack)
# print(jack.name)
# print((jack.balance))
# print(jack._Account__name)
# 存取器方法的公有方法
# 存 set / 取 get
# set_属性名，set应该有个参数没有返回值。
# get_属性名，get没有参数有个返回值
# print(jack.get_name())
# print(jack.get_balance())
# jack.set_balance('1111')
# many = jack.get_balance()
# print(many)
# many -= 9999999999
#
jack.set_balance(3)
print(jack.get_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.__downoad_data('http://www.dytt88.net/复联4.mp4')
-
继承概述
程序中的继承,遵循生活的继承方式
被继承的类: 父类, 超类, 基类
衍生出的类: 子类, 派生类新式类中:所有的类,都直接或间接继承 object 类
object 类是所有类的父类
在继承时,子类拥有父类的所有的内容
继承的作用:
复用代码
‘’’
继承的实现
‘’’
# 定义一个父类
class Phone(object):
def __init__(self):
self.name = '电话'
# 定义一个打电话的方法
def call(self,number):
print(f'正在给 { number} 打电话')
# 定义一个子类
class iPhone(Phone):
# 添加一个拍照方法
def carmera(self):
print('正在拍照')
# 当发生继承后，子类会继承父类中的属性和方法，可以直接 使用
iphonex = iPhone()
iphonex.call('13800138000')
iphonex.carmera()
print(iphonex.name)
dgd = Phone()
dgd.call('13800138000')
print(dgd.name)
# dgd.carmera()
-
继承的格式
class 子类名(父类名):
pass在出现继承后
当子类对象去调用方法时,会先在子类中去查找 方法,如果有,那么就执行,如果没有找到,去到父类中去查找 该方法,如果找到执行
找不到再到上一级类中去查找 直到找到object类,如果还没有那么就报错
‘’’
子类不能直接使用父类的私有属性和方法
‘’’
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.__show()
# 通过继承得到的父类的公有方法，间接 执行父类的私有方法
self.display()
测试
s = Son()
s.play()
s.display()
s.__show()
580
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
