Python——面向对象
面向对象
一. 理解面向对象
面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。
面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。
在面向对象编程过程中，有两个重要组成部分： 类 和 对象 。
类: 比如是制造洗衣机时要用到的图纸
对象 : 比如是就是用图纸造出来的洗衣机
类是对一系列具有相同 特征 和 行为 的事物的统称
类和对象的关系：用类去创建一个对象。 那么对象就有自己的特征 和 行为
- 特征即是属性
比如 : 年龄 相貌, 地域 ,身高 体重 - 行为即是方法
比如 : 飞 ,洗 打 烤 ,跑 ,看
类和对象的关系 :对象是由类创造出来的!
注意：先有类，再有对象。
二. 面向对象实现方法
2.1 定义类
Python2中类分为：经典类 和 新式类
- 新式类
class 类名():
代码
......
# 类的写法
class Washer():
pass
注意：类名要满足标识符命名规则,注意,首字母大写!，同时遵循 大驼峰命名习惯 。
- 经典类
不由任意内置类型派生出的类，称之为经典类，现在几乎很少用,但得知道
class 类名:
代码
......
class Washer:
pass
2.2 创建对象
对象又名实例。
- 语法
对象名 = 类名()
# 创建对象
class Washer():
pass
haier1 = Washer()
# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
注意：创建对象的过程也叫实例化对象。
2.3 对象的属性 __init__()
__init__()方法的作用：初始化对象。
通俗一点讲 : __init()__里面就是对象属性的"聚集地"
对象属性既可以在类外面添加和获取，也能在类里面添加和获取。
class Washer(): # 定义初始化功能的函数
def __init__(self): # 添加实例属性
self.width = 500 # 宽度是 500
self.height = 800 # 高度 是 800
haier1 = Washer()
print(haier1.width)
class Washer(): # 定义初始化功能的函数
def __init__(self, color): # 添加实例属性
self.width = 500 # 宽度是 500
self.height = 800 # 高度 是 800
self.yanse = color
haier1 = Washer('yellow')
print(haier1.yanse)
注意：
__init__()方法，在创建一个对象时默认被调用，不需要手动调用__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
2.4 self参数
self指的是调用该函数的对象。
class Washer(): # 定义初始化功能的函数
def __init__(self): # 添加实例属性
self.width = 500 # 宽度是 500
self.height = 800 # 高度 是 800
# print(self)
haier1 = Washer()
print(haier1.width) # 500
# 此时会有两个疑惑 ?
# 1 : __init__ 是一个函数 ,但是为什么没看到调用 ?
# 2 : 函数里面有参数 self ,为什么没看到传参 ?
# 首先看看 self是什么 ? 此时会发现,self 和 haier1 是一样的 所以 ,self就是那个对象
print(haier1) # <__main__.Washer object at 0x0000000000437490>
haier2 = Washer()
# <__main__.Washer object at 0x0000022005857EF0>
print(haier2)
2.5 实例属性与类属性
Python在广义上的属性有两种：类属性、实例属性
实例属性
一般是在构造函数__init__()中定义的，定义必须使用self前缀，只能通过对象名来访问
class Dog():
def __init__(self):
self.age = 5
def info_print(self):
print(self.age)
wangcai = Dog()
print(wangcai.age) # 5
# print(Dog.age) # 报错：实例属性不能通过类访问
wangcai.info_print() # 5
类属性
- 类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
- 类属性可以使用 类对象 或 实例对象 访问。
- 实例属性只能是对象来访问,类对象不可以
- 类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。
class Dog():
tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) # 10
print(wangcai.tooth) # 10
print(xiaohei.tooth) # 10
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
# 修改类属性
Dog.tooth = 12
print(Dog.tooth) # 12
# 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性
wangcai.tooth = 20
print(Dog.tooth) # 12
print(wangcai.tooth) # 20
print(xiaohei.tooth) # 12
类属性的优点
- 记录的某项数据 始终保持一致时，则定义类属性。
- 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有 ，仅占用一份内存，更加节省内存空间。
2.6 保护机制
私有成员：为了数据封装和保密而设的属性，一般只能在类的成员方法中使用访问。如果属性名以两个下划线开头’__'则表示是私有属性。
公有成员：可以公开使用，既可以在内部进行访问，也可以在外部程序中使用。
保护成员：只有类对象和子类对象能访问这些成员，如果属性名以一个下划线开头’_'则表示是私有属性。
class A:
def __init__(self,value1=0,value2=0):
self._value1=value1 #定义保护成员
self.__value2=value2 #定义私有成员
def setValue(self,value1,value2):
self.__value1=value1
self.__value2=value2
def show(self):
print(self._value1)
print(self.__value2)
a=A()
a._value1
a.__value2 # 报错
2.7 对象的方法
class Washer(): # 定义初始化功能的函数
def __init__(self): # 添加实例属性
self.width = 500 # 宽度是 500
self.height = 800 # 高度 是 800
# print(self)
def wash(self): # 实例方法
print(f'我是{self}的方法,这个必须用对象(实例)调用我才能运行')
def broke(self):
print('经过很多年以后,被使坏了.')
haier1 = Washer()
print(haier1.width) # 500
haier1.wash() # 调用实例方法
haier1.broke()
三. 魔法方法
3.1 __str__()
当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。
class Washer():
def __init__(self, width, height):
self.width = width
self.height = height
def __str__(self):
return '这是海尔洗衣机的说明书' # 必须得是字符串形式
haier1 = Washer(10, 20)# 这是海尔洗衣机的说明书
print(haier1)
四. 继承机制
继承是为了代码复用和设计复用而设计的，在继承关系中，已有的、设计好的类称为父类或者基类，新设计的类叫做子类或者派生类，派生类可以继承基类的公有成员，但不能继承私有成员。
4.1 单继承
故事主线：一个烤冷面老师傅，在烤冷面界摸爬滚打多年，研发了一套精湛的摊烤冷面的技术。师父要把这套技术传授给他的唯一的最得意的徒弟。
分析：徒弟是不是要继承师父的所有技术？
# 1. 师父类
class Master():
def __init__(self):
self.kongfu = '[古法烤冷面配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作烤冷面')
# 2. 徒弟类
class Prentice(Master):
pass
# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu)
# 5. 对象调用实例方法
daqiu.make_cake()
4.2 多继承
同时继承多个父类，如果父类中有相同的方法名，而在子类中使用时没有指定父类名，则会按继承的顺序从左到右顺序进行搜索。
class SchoolA():
def make_cake(self):
print('制作schoolA煎饼果子')
def make_noodles(self):
print('制作schoolA烤冷面')
# 创建学校类
class SchoolB():
def make_cake(self):
print('制作schoolB的煎饼果子')
class Prentice(SchoolB, SchoolA):
pass
daqiu = Prentice()
daqiu.make_cake() #输出SchoolB的make_cake
daqiu.make_noodles()
4.3 重载
即子类重写父类同名方法
class SchoolA(object):
def make_cake(self):
print('制作SchoolA煎饼果子')
class SchoolB(object):
def make_cake(self):
print('制作SchoolB煎饼果子')
# 独创配方
class Prentice(SchoolB, SchoolA):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__) # 查看继承顺序
4.4 小难题
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
1 1 1
1 2 1
3 2 3
#Parent.x = 3 父类重新定义了x Parent.x=3
#child1自己有X 故 child1.x = 2
#child2并没有X 执行父类的x child.x = 3
五. 综合应用—烤地瓜
5.1 需求
需求主线：
被烤的时间和对应的地瓜状态：
-
0-3分钟：生的
-
3-5分钟：半生不熟
-
5-8分钟：熟的
-
超过8分钟：烤糊了
添加的调料：
用户可以按自己的意愿添加调料
5.2 步骤分析
需求涉及一个事物： 地瓜，故案例涉及一个类：地瓜类。
(1) 定义类
-
地瓜的属性
- 被烤的时间
- 地瓜的状态
- 添加的调料
-
地瓜的方法
- 被烤
- 用户根据意愿设定每次烤地瓜的时间
- 判断地瓜被烤的总时间是在哪个区间，修改地瓜状态
- 添加调料
- 用户根据意愿设定添加的调料
- 将用户添加的调料存储
- 被烤
-
显示对象信息
(2) 创建对象，调用相关实例方法
5.3 代码实现
(1) 定义类
- 地瓜属性
- 定义地瓜初始化属性，后期根据程序推进更新实例属性
class SweetPotato():
def __init__(self):
# 被烤的时间
self.cook_time = 0
# 地瓜的状态
self.cook_static = '生的'
# 调料列表
self.condiments = []
(2) 定义烤地瓜方法
def cook(self, time):
"""烤地瓜的方法"""
self.cook_time += time
if 0 <= self.cook_time < 3:
self.cook_static = '生的'
elif 3 <= self.cook_time < 5:
self.cook_static = '半生不熟'
elif 5 <= self.cook_time < 8:
self.cook_static = '熟了'
elif self.cook_time >= 8:
self.cook_static = '烤糊了'
(3) 书写str魔法方法，用于输出对象状态
def __str__(self):
return f'这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}'
(4) 创建对象，测试实例属性和实例方法
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
print(digua1)
(5) 定义添加调料方法，并调用该实例方法
def add_condiments(self, condiment):
"""添加调料"""
self.condiments.append(condiment)
def __str__(self):
return f'这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}, 添加的调料有{self.condiments}'
5.4 代码总览
class SweetPotato():
def __init__(self):
# 被烤的时间
self.cook_time = 0
# 地瓜的状态
self.cook_static = '生的'
# 调料列表
self.condiments = []
def cook(self, time):
"""烤地瓜的方法"""
self.cook_time += time
if 0 <= self.cook_time < 3:
self.cook_static = '生的'
elif 3 <= self.cook_time < 5:
self.cook_static = '半生不熟'
elif 5 <= self.cook_time < 8:
self.cook_static = '熟了'
elif self.cook_time >= 8:
self.cook_static = '烤糊了'
def add_condiments(self, condiment):
"""添加调料"""
self.condiments.append(condiment)
def __str__(self):
return f'这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}, 添加的调料有{self.condiments}'
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('酱油')
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒面儿')
print(digua1)
digua1.cook(2)
print(digua1)
digua1.cook(2)
print(digua1)
digua2 = SweetPotato()
digua2.cook(3)
print(digua2)
六. 综合应用—搬家具
5.1 需求
将小于房子剩余面积的家具摆放到房子中
5.2 步骤分析
需求涉及两个事物：房子 和 家具，故被案例涉及两个类：房子类 和 家具类。
(1) 定义类
-
房子类
- 实例属性
- 房子地理位置
- 房子占地面积
- 房子剩余面积
- 房子内家具列表
- 实例方法
- 容纳家具
- 显示房屋信息
- 实例属性
-
家具类
- 家具名称
- 家具占地面积
(2) 创建对象并调用相关方法
5.3 代码实现
(1) 定义类
家具类
class Furniture():
def __init__(self, name, area):
# 家具名字
self.name = name
# 家具占地面积
self.area = area
房子类
class Home():
def __init__(self, address, area):
# 地理位置
self.address = address
# 房屋面积
self.area = area
# 剩余面积
self.free_area = area
# 家具列表
self.furniture = []
def __str__(self):
return f'房子坐落于{self.address}, 占地面积{self.area}, 剩余面积{self.free_area}, 家具有{self.furniture}'
def add_furniture(self, item):
"""容纳家具"""
if self.free_area >= item.area:
self.furniture.append(item.name)
# 家具搬入后，房屋剩余面积 = 之前剩余面积 - 该家具面积
self.free_area -= item.area
else:
print('家具太大，剩余面积不足，无法容纳')
(3) 创建对象并调用实例属性和方法
bed = Furniture('双人床', 6)
jia1 = Home('北京', 1200)
print(jia1)
jia1.add_furniture(bed)
print(jia1)
sofa = Furniture('沙发', 10)
jia1.add_furniture(sofa)
print(jia1)
ball = Furniture('篮球场', 1500)
jia1.add_furniture(ball)
print(jia1)
5.4 代码总览
class Furniture():
def __init__(self, name, area):
# 家具名字
self.name = name
# 家具占地面积
self.area = area
class Home():
def __init__(self, address, area):
# 地理位置
self.address = address
# 房屋面积
self.area = area
# 剩余面积
self.free_area = area
# 家具列表
self.furniture = []
def __str__(self):
return f'房子坐落于{self.address}, 占地面积{self.area}, 剩余面积{self.free_area}, 家具有{self.furniture}'
def add_furniture(self, item):
"""容纳家具"""
if self.free_area >= item.area:
self.furniture.append(item.name)
# 家具搬入后，房屋剩余面积 = 之前剩余面积 - 该家具面积
self.free_area -= item.area
else:
print('家具太大，剩余面积不足，无法容纳')
bed = Furniture('双人床', 6)
jia1 = Home('北京', 1200)
print(jia1)
jia1.add_furniture(bed)
print(jia1)
sofa = Furniture('沙发', 10)
jia1.add_furniture(sofa)
print(jia1)
ball = Furniture('篮球场', 1500)
jia1.add_furniture(ball)
print(jia1)
