?超级详细万文零基础也能学的面向对象—没对象（new一个！） _零基础

落花踏尽游何处，笑入胡姬酒肆中。这篇文章主要讲述?超级详细万文零基础也能学的面向对象—没对象？new一个！相关的知识，希望能为你提供帮助。
?
面向对象(OOP)基本概念面向对象编程 —— Object Oriented Programming 简写 OOP
目标了解面向对象基本概念
面向对象基本概念

我们之前学习的编程方式就是
面向过程的面相过程和面相对象，是两种不同的编程方式
对比面向过程的特点，可以更好地了解什么是面向对象

1.1 过程和函数（科普）

过程是早期的一个编程概念
过程类似于函数，只能执行，但是没有返回值
函数不仅能执行，还可以返回结果

1.2 面相过程和面相对象基本概念1) 面相过程 —— 怎么做？

把完成某一个需求的所有步骤从头到尾逐步实现
根据开发需求，将某些功能独立的代码封装成一个又一个函数
最后完成的代码，就是顺序地调用不同的函数

特点

注重步骤与过程，不注重职责分工
如果需求复杂，代码会变得很复杂
开发复杂项目，没有固定的套路，开发难度很大！

文章图片
?
2) 面向对象 —— 谁来做？

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法

在完成某一个需求前，首先确定职责 —— 要做的事情（方法）
根据职责确定不同的对象，在对象内部封装不同的方法（多个）
最后完成的代码，就是顺序地让不同的对象调用不同的方法

特点

注重对象和职责，不同的对象承担不同的职责
更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路
需要在面向过程基础上，再学习一些面向对象的语法

文章图片
?
类和对象目标

类和对象的概念
类和对象的关系
类的设计

01. 类和对象的概念类和对象是面向对象编程的两个核心概念
1.1 类

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
特征被称为属性
行为被称为方法
类就相当于制造飞机时的图纸，是一个模板，是负责创建对象的

文章图片
?
1.2 对象

对象是由类创建出来的一个具体存在，可以直接使用
由哪一个类创建出来的对象，就拥有在哪一个类中定义的：

属性
方法

对象就相当于用图纸制造的飞机

在程序开发中，应该先有类，再有对象

02. 类和对象的关系类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
类只有一个，而对象可以有很多个

不同的对象之间属性可能会各不相同

类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少
03. 类的设计在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类！

文章图片
?
在程序开发中，要设计一个类，通常需要满足一下三个要素：

类名这类事物的名字，满足大驼峰命名法
属性这类事物具有什么样的特征
方法这类事物具有什么样的行为

大驼峰命名法

CapWords

每一个单词的首字母大写
单词与单词之间没有下划线
3.1 类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类
3.2 属性和方法的确定

对对象的特征描述，通常可以定义成属性
对象具有的行为（动词），通常可以定义成方法

提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

练习 1需求
小明今年 18 岁，身高 1.75，每天早上跑完步，会去吃东西
小美今年 17 岁，身高 1.65，小美不跑步，小美喜欢吃东西

文章图片
?
练习 2需求

一只黄颜色的狗狗叫大黄
看见生人汪汪叫
看见家人摇尾巴

文章图片
?

面相对象基础语法目标
dir 内置函数
定义简单的类（只包含方法）
方法中的 self 参数
初始化方法
内置方法和属性
01. dir 内置函数（知道）

在 python 中对象几乎是无所不在的，我们之前学习的变量、数据、函数都是对象

在 Python 中可以使用以下两个方法验证：

在标识符 / 数据后输入一个 .，然后按下 TAB 键，iPython 会提示该对象能够调用的方法列表使用内置函数 dir 传入
标识符 / 数据，可以查看对象内的所有属性及方法
提示方法名格式的方法是 Python 提供的内置方法 / 属性，稍后会给大家介绍一些常用的内置方法 / 属性

文章图片
?
提示利用好 dir() 函数，在学习时很多内容就不需要死记硬背了
02. 定义简单的类（只包含方法）面向对象是更大的封装，在一个类中封装多个方法，这样通过这个类创建出来的对象，就可以直接调用这些方法了！
2.1 定义只包含方法的类
在 Python 中要定义一个只包含方法的类，语法格式如下：

class 类名:

def 方法1(self, 参数列表):
pass

def 方法2(self, 参数列表):
pass

方法的定义格式和之前学习过的函数几乎一样
区别在于第一个参数必须是 self，大家暂时先记住，稍后介绍 self

注意：类名的命名规则要符合大驼峰命名法

2.2 创建对象
当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

对象变量 = 类名()

2.3 第一个面向对象程序
需求
小猫爱吃鱼，小猫要喝水
分析
定义一个猫类 Cat
定义两个方法 eat 和 drink
按照需求 —— 不需要定义属性

文章图片
?

class Cat:
"""这是一个猫类"""

def eat(self):
print("小猫爱吃鱼")

def drink(self):
print("小猫在喝水")

tom = Cat()
tom.drink()
tom.eat()

引用概念的强调

在面向对象开发中，引用的概念是同样适用的！

在 Python 中使用类创建对象之后，tom 变量中仍然记录的是对象在内存中的地址
也就是 tom 变量引用了新建的猫对象
使用 print 输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址（十六进制表示）

提示：在计算机中，通常使用十六进制表示内存地址

十进制和十六进制都是用来表达数字的，只是表示的方式不一样
十进制和十六进制的数字之间可以来回转换
%d 可以以 10 进制输出数字
%x 可以以 16 进制输出数字
案例进阶 —— 使用 Cat 类再创建一个对象

lazy_cat = Cat()
lazy_cat.eat()
lazy_cat.drink()

提问：tom 和 lazy_cat 是同一个对象吗？
03. 方法中的 self 参数3.1 案例改造 —— 给对象增加属性
在 Python 中，要给对象设置属性，非常的容易，但是不推荐使用
因为：对象属性的封装应该封装在类的内部
只需要在类的外部的代码中直接通过 . 设置一个属性即可

注意：这种方式虽然简单，但是不推荐使用！

tom.name = "Tom"
...

lazy_cat.name = "大懒猫"

3.2 使用 self 在方法内部输出每一只猫的名字
由哪一个对象调用的方法，方法内的 self 就是哪一个对象的引用
在类封装的方法内部，self 就表示当前调用方法的对象自己
调用方法时，程序员不需要传递 self 参数
在方法内部
可以通过 self. 访问对象的属性
也可以通过 self. 调用其他的对象方法
改造代码如下：

class Cat:

def eat(self):
print("%s 爱吃鱼" % self.name)

tom = Cat()
tom.name = "Tom"
tom.eat()

lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()

文章图片
?
在类的外部，通过变量名. 访问对象的属性和方法
在类封装的方法中，通过 self. 访问对象的属性和方法
04. 初始化方法4.1 之前代码存在的问题 —— 在类的外部给对象增加属性
将案例代码进行调整，先调用方法再设置属性，观察一下执行效果

tom = Cat()
tom.drink()
tom.eat()
tom.name = "Tom"
print(tom)

程序执行报错如下：

AttributeError: \'Cat\' object has no attribute \'name\'
属性错误：\'Cat\' 对象没有 \'name\' 属性

提示
在日常开发中，不推荐在类的外部给对象增加属性
如果在运行时，没有找到属性，程序会报错
对象应该包含有哪些属性，应该封装在类的内部
4.2 初始化方法
当使用类名() 创建对象时，会自动执行以下操作：
为对象在内存中分配空间 —— 创建对象
为对象的属性设置初始值 —— 初始化方法(init)
这个初始化方法就是 init 方法，init 是对象的内置方法
init 方法是专门用来定义一个类具有哪些属性的方法！
在 Cat 中增加 init 方法，验证该方法在创建对象时会被自动调用

class Cat:
"""这是一个猫类"""

def __init__(self):
print("初始化方法")

4.3 在初始化方法内部定义属性
在 init 方法内部使用 self.属性名 = 属性的初始值就可以定义属性
定义属性之后，再使用 Cat 类创建的对象，都会拥有该属性

【?超级详细万文零基础也能学的面向对象—没对象（new一个！）】

class Cat:

def __init__(self):

print("这是一个初始化方法")

# 定义用 Cat 类创建的猫对象都有一个 name 的属性
self.name = "Tom"

def eat(self):
print("%s 爱吃鱼" % self.name)

# 使用类名()创建对象的时候，会自动调用初始化方法 __init__
tom = Cat()

tom.eat()

4.4 改造初始化方法 —— 初始化的同时设置初始值
在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对 init 方法进行改造
把希望设置的属性值，定义成 init 方法的参数
在方法内部使用 self.属性 = 形参接收外部传递的参数
在创建对象时，使用类名(属性1, 属性2…) 调用

class Cat:

def __init__(self, name):
print("初始化方法 %s" % name)
self.name = name
...

tom = Cat("Tom")
...

lazy_cat = Cat("大懒猫")
...

05. 内置方法和属性

文章图片
?
5.1 del 方法（知道）
在 Python 中
当使用类名() 创建对象时，为对象分配完空间后，自动调用 init 方法
当一个对象被从内存中销毁前，会自动调用 del 方法
应用场景
init 改造初始化方法，可以让创建对象更加灵活
del 如果希望在对象被销毁前，再做一些事情，可以考虑一下 del 方法
生命周期
一个对象从调用类名() 创建，生命周期开始
一个对象的 del 方法一旦被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法

class Cat:

def __init__(self, new_name):

self.name = new_name

print("%s 来了" % self.name)

def __del__(self):

print("%s 去了" % self.name)

# tom 是一个全局变量
tom = Cat("Tom")
print(tom.name)

# del 关键字可以删除一个对象
del tom

print("-" * 50)

5.2 str 方法
在 Python 中，使用 print 输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址（十六进制表示）
如果在开发中，希望使用 print 输出对象变量时，能够打印自定义的内容，就可以利用 str 这个内置方法了
注意：str 方法必须返回一个字符串

class Cat:

def __init__(self, new_name):

self.name = new_name

print("%s 来了" % self.name)

def __del__(self):

print("%s 去了" % self.name)

def __str__(self):
return "我是小猫：%s" % self.name

tom = Cat("Tom")
print(tom)

面向对象封装案例目标

封装
小明爱跑步
存放家具

01. 封装封装是面向对象编程的一大特点
面向对象编程的第一步 —— 将属性和方法封装到一个抽象的类中
外界使用类创建对象，然后让对象调用方法
对象方法的细节都被封装在类的内部
02. 小明爱跑步需求
小明体重 75.0 公斤
小明每次跑步会减肥 0.5 公斤
小明每次吃东西体重增加 1 公斤
007_小明爱跑步

文章图片
?
提示：在对象的方法内部，是可以直接访问对象的属性的！
代码实现：

class Person:
"""人类"""

def __init__(self, name, weight):

self.name = name
self.weight = weight

def __str__(self):

return "我的名字叫 %s 体重 %.2f 公斤" % (self.name, self.weight)

def run(self):
"""跑步"""

print("%s 爱跑步，跑步锻炼身体" % self.name)
self.weight -= 0.5

def eat(self):
"""吃东西"""

print("%s 是吃货，吃完这顿再减肥" % self.name)
self.weight += 1

xiaoming = Person("小明", 75)

xiaoming.run()
xiaoming.eat()
xiaoming.eat()

print(xiaoming)

2.1 小明爱跑步扩展 —— 小美也爱跑步
需求
小明和小美都爱跑步
小明体重 75.0 公斤
小美体重 45.0 公斤
每次跑步都会减少 0.5 公斤
每次吃东西都会增加 1 公斤

文章图片
?
提示
在对象的方法内部，是可以直接访问对象的属性的
同一个类创建的多个对象之间，属性互不干扰！

文章图片
?
03. 摆放家具需求
房子(House) 有户型、总面积和家具名称列表
新房子没有任何的家具
家具(HouseItem) 有名字和占地面积，其中
席梦思(bed) 占地 4 平米
衣柜(chest) 占地 2 平米
餐桌(table) 占地 1.5 平米
将以上三件家具添加到房子中
打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

文章图片
?
剩余面积
在创建房子对象时，定义一个剩余面积的属性，初始值和总面积相等
当调用 add_item 方法，向房间添加家具时，让剩余面积 -= 家具面积
思考：应该先开发哪一个类？
答案 —— 家具类
家具简单
房子要使用到家具，被使用的类，通常应该先开发
3.1 创建家具

class HouseItem:

def __init__(self, name, area):
"""

:param name: 家具名称
:param area: 占地面积
"""
self.name = name
self.area = area

def __str__(self):
return "[%s] 占地面积 %.2f" % (self.name, self.area)

# 1. 创建家具
bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

小结
创建了一个家具类，使用到 init 和 str 两个内置方法
使用家具类创建了三个家具对象，并且输出家具信息

class House:

def __init__(self, house_type, area):
"""

:param house_type: 户型
:param area: 总面积
"""
self.house_type = house_type
self.area = area

# 剩余面积默认和总面积一致
self.free_area = area
# 默认没有任何的家具
self.item_list = []

def __str__(self):

# Python 能够自动的将一对括号内部的代码连接在一起
return ("户型：%s\\n总面积：%.2f[剩余：%.2f]\\n家具：%s"
% (self.house_type, self.area,
self.free_area, self.item_list))

def add_item(self, item):

print("要添加 %s" % item)

...

# 2. 创建房子对象
my_home = House("两室一厅", 60)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

小结
创建了一个房子类，使用到 init 和 str 两个内置方法
准备了一个 add_item 方法准备添加家具
使用房子类创建了一个房子对象
让房子对象调用了三次 add_item 方法，将三件家具以实参传递到 add_item 内部
3.3 添加家具
需求
1> 判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
2> 将家具的名称追加到家具名称列表中
3> 用房子的剩余面积 - 家具面积

def add_item(self, item):

print("要添加 %s" % item)
# 1. 判断家具面积是否大于剩余面积
if item.area > self.free_area:
print("%s 的面积太大，不能添加到房子中" % item.name)

return

# 2. 将家具的名称追加到名称列表中
self.item_list.append(item.name)

# 3. 计算剩余面积
self.free_area -= item.area

3.4 小结