python第十次课 面向对象及案例

一、面向对象简介

概念：

• 面向对象编程【简称：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()

---