13.面向对象的概述
对于面向过程的思想：
需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,
需要自己编写代码(自己来做) 亲力亲为
对于面向对象的思想：
当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)
14.面向对象的生活举例
洗衣服
l 面向过程（手洗）：脱衣服、找一个盆、加水、加洗衣粉、浸泡30分钟、搓洗、拧衣服、倒掉水、再加水、漂洗、拧衣服、倒掉水、晾衣服。
l 面向对象（机洗）：脱衣服、放入洗衣机、按下开关、拿出衣服晾晒。
买电脑
l 面向过程（自己买）：需要电脑、查询参数信息、横向比较机型、了解打折信息、与店家讨价还价、下单、收快递、开机验货、确认收货。
l 面向对象（找人买）：需要电脑、找秘书帮我买、收电脑。
吃饭
l 面向过程（自己做）：我饿了、买菜、洗菜择菜、切菜、起火、炒菜、盛菜、吃饭、刷碗。
面向对象（出去买）：我饿了、买饭、吃饭。
l 面向过程（手洗）：脱衣服、找一个盆、加水、加洗衣粉、浸泡30分钟、搓洗、拧衣服、倒掉水、再加水、漂洗、拧衣服、倒掉水、晾衣服。
l 面向对象（机洗）：脱衣服、放入洗衣机、按下开关、拿出衣服晾晒。
- 买电脑
l 面向过程（自己买）：需要电脑、查询参数信息、横向比较机型、了解打折信息、与店家讨价还价、下单、收快递、开机验货、确认收货。
l 面向对象（找人买）：需要电脑、找秘书帮我买、收电脑。
- 吃饭
l 面向过程（自己做）：我饿了、买菜、洗菜择菜、切菜、起火、炒菜、盛菜、吃饭、刷碗。
面向对象（出去买）：我饿了、买饭、吃饭。
15.类与对象的关系
类:
是用来描述现实世界中的某一类事物的.
如何描述那一类事物?
把那一类事物的共同特点抽取出来.
从两方面抽取共同特点:
属性: 静的方面的信息,比如 姓名,身高,体重等等.
行为: 动的方面的信息,比如 吃饭,睡觉,学习,走路.
一个类就是个 class
在类里面 :
使用 属性 表示 属性.
使用 方法 表示 行为.
对象:
就是那一类事物中的一个个体.
类与对象关系:
类是用来描述那一类对象的.
描述了那一类对象的共同的属性和行为.
必须先有类,在通过类创建对象.
按照面向对象的思想开发的步骤:
1.定义类
2.通过类创建对象
3.通过对象调用功能(方法)
16.类的定义格式
定义格式:
class 类名:
方法列表
1.self参数的作用
class Student:
"""
方法中的self表示 正在调用方法的对象,哪个对象正在调用方法,self就表示哪个对象.
python解释器能够根据self的值确定是哪个对象正在调用方法.
"""
def study(self, course):
print(f"学习{course}")
s1 = Student()
s1.study("python")
s2 = Student()
s2.study("python")
2.__init__方法的作用
class Student:
"""
是一个魔法方法
比较特殊,python解释器会自动在对象刚刚创建出来之后,立即调用这个方法
初始化对象: 给对象添加属性并赋值
通过self给对象添加属性:
self.属性名 = 属性值
属性是存储在对象里面的.
属性是属于对象的.
访问属性:
对象名.属性名
"""
def __init__(self):
# 添加姓名
self.name = "欧阳铁娃"
# 添加年龄
self.age = 20
# 添加性别
self.gender = "man"
"""
方法中的self表示 正在调用方法的对象,哪个对象正在调用方法,self就表示哪个对象.
python解释器能够根据self的值确定是哪个对象正在调用方法.
"""
def study(self, course):
print(f"学习{course}")
s1 = Student()
s1.study("python")
# 访问属性:对象名.属性名
print(s1.name)
print(s1.age)
print(s1.gender)
# 修改属性的值
s1.gender = "female"
print(s1.gender)
3.给__init__方法传递自定义参数初始化属性值
class Student:
"""
在__init__方法中添加了几个形参,用来接收 创建对象时 传递过来的属性值的
可以在 形参的值 赋值给 属性.
"""
def __init__(self, name, age, gender):
# 添加姓名
self.name = name
# 添加年龄
self.age = age
# 添加性别
self.gender = gender
def study(self, course):
print(f"学习{course}")
s1 = Student("司马狗剩", 20, "男")
# 访问属性:对象名.属性名
print(s1.name)
print(s1.age)
print(s1.gender)
s2 = Student("欧阳铁娃", 22, "女")
# 访问属性:对象名.属性名
print(s2.name)
print(s2.age)
print(s2.gender)
4.定义属性的其它方式
1. 在 __init__方法中 通过self添加属性
2. 在 其它方法 通过self添加属性
3. 在 在类的外面 通过 对象 添加属性
5.__str__方法
6.烧烤地瓜案例的分析
面向对象设计的套路:
1.判断那段文件描述的哪个对象,描述的是哪个对象 就 创建那个对象的类;
2.根据文字描述 确定 应该定义哪些属性和方法:
对象有的东西,一定是属性;
对象能做的事情,一定是方法;
3.根据文字描述,确定应该在方法中做什么事情;
7.烧烤地瓜案例的代码实现
# -*- coding:utf-8 -*-
class BakedSweetPotato(object):
def __init__(self):
'''
烧烤时间
烧烤程度
烧烤配料
'''
self.cookedLevel = 0
self.cookedString = "生"
self.condiments = list()
def cook(self, time):
self.cookedLevel += time
if self.cookedLevel < 3:
self.cookedString = "生"
elif self.cookedLevel < 5:
self.cookedString = "半生不熟"
elif self.cookedLevel < 8:
self.cookedString = "熟了"
else:
self.cookedString = "烤麸了"
def __str__(self):
msg = "已经烧烤%d分钟,现在是%s" % (self.cookedLevel, self.cookedString)
if len(self.condiments)>0:
msg = msg + "("
for temp in self.condiments:
msg = msg+temp+","
msg.strip(",")
msg += ")"
return msg
def add_condiments(self,name):
self.condiments.append(name)
print("添加配料:%s成功"%name)
8.属性值可以是一个对象(扩展)
9.存放家具的案例
class House(object):
'''
属性:占地面积,地址
存放的家具列表
方法:添加家具
'''
def __init__(self,floor_area,address):
'''
表示剩余面积和地址
:param floor_area:
:param address:
'''
self.floor_area = floor_area
self.address = address
self.furniture = list()
def __str__(self):
msg = "当前房间可用面积为%.2f"%self.floor_area
if len(self.furniture)>0:
msg += "("
for temp in self.furniture:
msg = msg+ temp +","
msg = msg.strip(",")
msg = msg+")"
return msg
def add_furniture(self,furniture):
'''
添加家具
:return:
'''
if furniture.area<self.floor_area:
self.furniture.append(furniture.name)
self.floor_area -= furniture.area
print(f"添加{furniture.name}成功")
else:
print("面积不够无法添加")
class Furniture(object):
'''
属性:占地面积,名字
'''
def __init__(self,name,area):
"""
初始化
:param name:
:param area:
"""
self.name = name
self.area = area
def __str__(self):
"""
说出类型和占地面积
:return:
"""
msg = self.name + "占地面积为" + str(self.area)
return msg
newHome = House(100,"北京")#100平米
print(newHome)
# 创建一个床对象
newBed = Furniture("床",20)
print(newBed)
# 把床安放到家里
newHome.add_furniture(newBed)
print(newHome)
# 创建一个床对象
newBed2 = Furniture('席梦思',30)
print(newBed2)
# 把床安放到家里
newHome.add_furniture(newBed2)
print(newHome)
10.私有属性的定义和使用
"""
私有属性:
这样的属性只能在类的里面访问,不能在类的外面的访问.
定义私有属性的格式:
self.__属性名 = 属性值
访问私有属性的格式:
self.私有属性
"""
class Student:
def __init__(self, name, age, gender):
self.name = name
# self.age = age
# 定义私有属性 __age
self.__age = age
self.gender = gender
def set_age(self, age):
"""
修改私有属性的值
:param age: 传递过来的年龄,把它赋值给私有属性
"""
if 0 <= age < 150:
self.__age = age
else:
print("年龄应该在0-150之间,请重新赋值!!!")
def get_age(self):
# 返回私有属性值的
return self.__age
def study(self, course):
print(f"学习{course}")
# 访问私有属性
print(self.__age)
s1 = Student("爽儿", 18, "女")
s1.name = "美丽的爽儿"
# AttributeError: 'Student' object has no attribute '__age'
# 没有属性 ___age,意思是说没有权限访问私有属性
# print(s1.__age)
# s1.__age = 200
s1.set_age(100)
# s1.study("心理学")
# 获得私有属性 __age的值
print(s1.get_age())
11.私有方法的定义和使用
"""
为什么把方法定义成私有的?
在定义方法时,都已经想好了,这个方法不允许在类的外面被调用.
如何定义私有方法?
跟之前定义方法一样,只是在方法名前加两个下划线:__
私有方法的特点:
只能在类的里面访问,不能在类的外面访问.
"""
class Student:
def __init__(self, name, age, gender):
self.name = name
# self.age = age
# 定义私有属性 __age
self.__age = age
self.gender = gender
def set_age(self, age):
"""
修改私有属性的值
:param age: 传递过来的年龄,把它赋值给私有属性
"""
if 0 <= age < 150:
self.__age = age
else:
print("年龄应该在0-150之间,请重新赋值!!!")
def get_age(self):
# 返回私有属性值的
return self.__age
def study(self, course):
print(f"学习{course}")
# 访问私有属性
# print(self.__age)
self.__tla("爽儿")
def __tla(self, gf_name):
print(f"我要与{gf_name}谈一场轰轰烈烈的恋爱!!!")
s1 = Student("铁娃", 18, "女")
# 不能在类的外面访问 私有方法.
# s1.__tla("爽儿")
s1.study("人工智能")
12.封装的总结
概念:
把不需要对外暴露的代码隐藏起来.
封装的几种形式:
1.函数:使用函数包裹一个代码块
def print_hello():
for i in range(0, 10):
print("hello python")
random.randint(10, 100)
2.类:使用类 包裹 数据和行为
3.方法:包裹一个代码块
4.定义私有属性
5.定义私有方法
好处:
1.避免代码重复,提高代码重复使用率;
2.实现功能的设计 与 调用 进行分离;
3.提高开发效率;
