一、面向对象简介
概念：
- 面向对象编程【简称：OOP】
开发程序模式
- 面向过程：
- 程序得开发过程是根据业务逻辑走【根据要求写语句】
- 如何达成目标
- 面向对象：
- 程序得开发过程是围绕数据走
- 操作将会影响谁
案例：打印tom、jerry、jack三个学员的信息，信息包括姓名、年龄、地址
# ================ 面向过程 ===================
# 定义第一个学员
stu1 = {
"name":"tom",
"age":"18",
"addr":"hebei"
}
# 定义第一个学员
stu2 = {
"name":"jerry",
"age":"18",
"addr":"tianjin"
}
# 定义第一个学员
stu3 = {
"name":"jack",
"age":"18",
"addr":"beijing"
}def showStu(**stuInfo):
print("%s 的 年龄是 %s, 地址是%s"%(stuInfo["name"],stuInfo["age"],stuInfo["addr"]))showStu(**stu1)
showStu(**stu2)
showStu(**stu3)面试问题：你如何理解面向对象和面向过程
- 面向过程主要是需要关注具体的过程
- 面向对象主要是着眼点是如何达到最终效果
类
- 这是一个抽象概念，统指一类事物，比如人、动物、狗
- 类是无法直接使用，必须将类实例化一个对象以后，基于这个对象才能使用
实例化
- 将一个抽象的类具体化到某一个具体的对象，这个过程实例化
对象
- 实例化的结果就是对象
案例：
汽车 类
奥迪 类
奥迪a6 类
我的奥迪a6 对象狗 类
大黄狗 类
小伙家门口的哪个日本 对象水果
苹果
我吃了一块的苹果灯 类
我家客厅灯 对象
面向对象编程的特点
- 一切皆为对象，列表、字典、字符串、元组
- 例如：列表就是一个对象，列表中的每个元素也都是对象
- python就是一堆对象集合
- 每个对象都是实例化的结果
- 每一类对象都具有自己特定的属性和方法
# 列表是一个类
# 创建一个列表对象【类的实例化】
li1 = [1,2,3]# 列表类的方法
li.pop()
li.append()# 字符串是一个类
# 创建字符串对象
str1 = "123"注意：所有的对象，都是由类生成的，类具有的方法，其所有生成的对象都会具有
类的组成
- 类名
- 类方法：
- 类的方法其实就是类里面的函数
- 方法其实就是能做的事情
- 类属性：
- 类的属性其实就是类里面的一个变量
- 属性其实就是这一类事物具有的特点、特性
案例：以狗类为例
类名：狗
类属性：品种、性别、毛色、体重、身高、年龄
类方法：叫、咬、吃、喝、拉、撒、跑
面向对象的三个原则
- 封装：
- 隐藏具体的实现细节
- 继承：
- 子类会继承父类所有的属性和方法
- 类
- 上级类：父类、基类、超类
- 下级类：子类、派生类
- 多态：
- 传递不同的数据，会返回不同的结果
2、面向对象简单实现
定义类的格式
# 定义经典类
class 类名():
属性
方法# 定义新式类
class 类名(父类名):
属性
方法说明
- 函数名：第二个单词首字母大写
- 类名：每个单词首字母大写
案例：
# 定义一个类
class StuInfo():
# 定义属性
age = "10"
addr = "hebei"
name = "tom" # 定义方法
def showInfo(self): # 类中的方法的第一个形参必须是self
#print("%s的年龄是%s, 地址在%s"%(name, age, addr)) # 此时这三个变量是去全局段找
print("%s的年龄是%s, 地址在%s"%(self.name, self.age, self.addr)) # 加上self是去类内部找变量# 进行实例化，将实例化结果赋值给stu1变量
# stu1是一个对象
stu1 = StuInfo()# 显示类属性
print(stu1.age)
print(stu1.addr)
print(stu1.name)# 调用类方法
stu1.showInfo()案例：
class Car():
def Start(self):
print("汽车启动...") def Run(self):
print("汽车在行驶...") def Stop(self):
print("汽车停止...")myCar = Car()
myCar.Start()
myCar.Run()
myCar.Stop()给类添加属性
# 定义一个类
class Car():
# 定义一个属性
speed = "30" # 定义一个方法
def Start(self):
print("汽车启动...")
# 定义一个方法
def Run(self):
print("品牌是%s, 车型是%s，汽车在行驶，速度是%s "%(myCar.carPai, myCar.carType, self.speed))
# 定义一个方法
def Stop(self):
print("汽车停止...")# 将类实例化成对象，将对象赋值给myCar
myCar = Car()# 修改类中的属性
myCar.speed = "80"
# 给类添加属性
myCar.carType = "SUV"
myCar.carPai = "领克"# 调用类方法
myCar.Start()
myCar.Run()
myCar.Stop()类多次实例化的问题
# 定义一个类
class Car():
carType = "SUV"
carPai = "领克"
# 定义一个方法
def Run(self):
print("品牌是%s, 车型是%s，汽车在行驶"%(self.carPai, self.carType))# 将类实例化成对象，将对象赋值给myCar
myCar = Car()
# 给类添加属性
myCar.carType = "SUV"
myCar.carPai = "领克"
# 调用类方法
myCar.Run()# 将类实例化成对象，将对象赋值给yourCar
yourCar = Car()
# 给类添加属性【因为上面已经添加过carType和carPai两个属性了，因此这里其实是在修改属性】
yourCar.carType = "轿车"
yourCar.carPai = "宝马"
# 调用类方法
yourCar.Run()3、两个内置方法
__init__
不需要调用，可以自动执行，也就是当实例化的时候，就自动执行
主要的作用是用于初始化一些变量__str__
不需要调用，可以自动执行，也就是当实例化的时候，就自动执行
主要的作用是用于输出一些提示信息
定义属性的时候，有两种方法
- 方法1：在类中直接进行定义，和之前定义变量完全一样
- 方法2：在类的方法中进行定义，定义格式 self.变量名 = 值
- 如果在类的方法中定义变量的时候，如果没有加self，那么这个变量就是局部变量
案例
# 定义一个类
class Car():
# init 方法
def __init__(self,carType, carSpeed):
# 定义类属性
self.speed = carSpeed
self.type = carType
print("haha,初始化成功")# str 方法
def __str__(self):
return "这是我们的第一个类的练习" # 定义一个方法
def Run(self):
print("车型是%s，速度是%s"%(self.type, self.speed))# 将类实例化成对象，将对象赋值给myCar
myCar = Car("suv","50")
print(myCar)
myCar.Run()4、类的内置属性和方法
python的变量
- 直接用 变量名 = 变量值 定义
- 用 双下划线加上变量名进行定义，类中的私有属性，只有类内部可以使用，子类无法使用
- 单下划线加上变量名进行定义，这是特殊的属性，无法直接访问，需要提供特殊接口才能访问
- 用 双下划线加上变量名再加双下划线进行定义
# 常规变量
name = "tom"# 类的私有属性
__name = "tom"# 特殊属性，无法直接访问
_name = "tom"# pyhton中特殊方法的专用标识
__name__ = "tom"__dict__ 获取类中的全部的属性
dir() 获取类中的全部的属性
__name__ 获取类的名字
__doc__ 获取类的说明文档
__base__ 获取当前这个类的父类信息案例：
# 定义一个类
class MyClass():
"""
这是我的测试类
你听懂了吗
"""
name = "python开发"
def __init__(self):
self.height = "175"
def show(self):
age = "20"
print("%s 的年龄是 %s, 身高是%s"%(selfname, age, self.height))# 通过 __dict__ 可以显示类的全部的属性
print(MyClass.__dict__) # 即可以显示属性，也可以显示属性的值
print(dir(MyClass)) # 仅仅显示属性，不可以显示属性的值
print(MyClass.__name__)
print(MyClass.__doc__)
print(MyClass.__base__)可用的变量
- 全局变量：定义在主程序【类外面】
- 类变量：定义在类内部，但是不是类的方法里
- 局部变量：定义在类的方法中的变量，而且定义变量的时候没有加self
5、案例：烤地瓜
让用户输入烘烤时间
- 烘烤时间在0-3分钟，表示生
- 烘烤时间在4分钟，表示夹生
- 烘烤时间在5-8分钟，表示熟
- 烘烤时间超过8分钟，表示糊了
版本1：面向过程
import sys
def cooke(cTime):
try:
cTime = int(cTime)
except Exception:
print("时间格式不对")
sys.exit() if cTime>=0 and cTime<=3:
str = "地瓜还是生的"
elif cTime == 4:
str = "地瓜还是夹生的"
elif cTime>=5 and cTime<=8:
str = "地瓜是熟的"
elif cTime>8:
str = "糊了"
else:
print("时长错误")
sys.exit(3) print(str)
userInput = input("请输入烹饪时长：")
cooke(userInput)版本2：面向对象
分析和规划
属性：
- cTime 表示的是烹饪时间长度
- str 表示定义字符串，描述地瓜的生疏程度
方法：
- init：初始化变量
- str：让输出结果更美观
- cooke：烘烤地瓜的方法
import sys
class DiGua():
# 初始化变量
def __init__(self, t1):
self.cTime = t1
self.str = ""
# 烹饪
def cooke(self):
if self.cTime>=0 and self.cTime<=3:
self.str = "地瓜还是生的"
elif self.cTime == 4:
self.str = "地瓜还是夹生的"
elif self.cTime>=5 and self.cTime<=8:
self.str = "地瓜是熟的"
elif self.cTime>8:
self.str = "糊了"
else:
print("时长错误")
sys.exit(3) print(self.str)
try:
userInput = int(input("请输入烹饪时长："))
except Exception:
print("时间错误")
sys.exit(3)
# 实例化
digua = DiGua(userInput)# 调用方法去烹饪
digua.cooke()本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
