Python面向对象设计

一、面向对象思想

1.面向对象思想设计

基于哲学观点:万物皆对象

举例说明:

案例一:我想吃大盘鸡

面向过程 面向对象

1.自己去买菜 1.委托一个人帮忙买菜

2.自己择菜 2.委托一个人帮忙择菜

3.自己做菜 3.委托一个人厨师做菜

4.自己吃 4.自己吃

案例二:小明是一个电脑小白,想要配置一台电脑

面向过程 面向对象

1.小明补充电脑知识 1.委托一个懂电脑的人买零件

2.小明去买零件 2.委托一个人组装

3.小明把零件运回来 3.小明打开玩游戏

4.小明组装

5.小明打开玩游戏

案例三:一辆红色的法拉利在京藏高速上奔驰

法拉利 京藏高速

面向过程:狗吃屎 面向对象:吃狗屎

面向过程:蛋炒饭 面向对象:盖浇饭

2.面向过程和面向对象的区别

2.1面向过程

process:处理

在生活案例中:

​ 一种看待问题的思维方式,在解决问题的时候,侧重于问题是怎样一步一步解决的,然后亲力亲为的去解决

在程序中:

​ 代码从上往下依次执行

​ 各个模块之间的关系尽可能的独立的,当import的时候,加载的顺序也是从上往下依次加载

​ 每个模块中的语句结构:顺序,分支,循环

2.2面向对象

在生活案例中:

​ 一种看待问题的思维方式,侧重于找到一个具有特殊功能的个体,然后委托这个个体帮忙完成某件事情,这个个体就被称为对象

​ 好处:可以将复杂的问题简单化,将程序员从执行者变成了指挥者

在程序中:

​ 根据不同的需求执行代码【代码执行顺序不一定】

​ 程序的流程完全由需求决定【对象】

​ 思想:如果对象存在,则直接使用;如果对象不存在,则创建对象

注意:面向对象只是一种思想,并不是一门编程语言

Python是一门面向对象的编程语言,类和对象是 面向对象的核心

示例: 小狗吃食(闻一闻smell、舔一舔lick、咬一咬bite)
    分别采用面向过程和面向对象来分析

面向过程 :  先闻一闻, 然后再舔一舔, 最后再咬一咬 (注重过程) 
面向对象 :  小狗是一个对象, 它可以闻一闻食物, 可以舔一舔食物, 可以咬一咬食物.      (不注重过程, 注重对象)

二、类和对象【掌握】

1.类和对象的概念

类:多个具有特殊功能的个体的集合

对象:在一个类中,一个具有特殊功能的个体,能够帮忙解决某件特定的事情,也被称为实例【instance】

两者之间的关系:类用于描述某一类对象的共同特征,而对象是类的具体的存在【包含关系】

思考问题:先有类还是先有对象?

【不好说,但是,在程序中使用的时候,一般是先定义类,然后创建对象】

举例:

​ 类 对象

​ 人 王麻子,李四,尼古拉斯.赵四。。。。

​ 快递 韵达,中通,圆通。。。。。

​ SupreHero 蝙蝠侠,蜘蛛侠,美国队长,猪猪侠。。。

帮忙理解:类其实也是一种数据类型,只不过一般情况下是自定义的,所以可以将类认为是自定义的数据类型,用法和整型,string,list等基本是相同的【定义变量,传参】

2.类的定义

语法:

class 类名():

​ 类体

说明:

​ a.Python中使用class关键字定义类

​ b.类名只要是一个合法的标识符即可,但是要求:遵循大驼峰命名法则【首单词的首字母大写,不同单词之间首字母大写】

​ c.通过缩进区分类体

​ d.类体一般包含两部分内容:对类的特征的描述、对类的行为的描述

代码演示:

#类的定义
#类的声明
class MyClass():
    #类的实现
    #类体
    #print("hello")   #一般不会这么书写
    pass

#注意:在同一个py文件中可以同时定义多个类,但是,为了提高代码的可读性,结合模块的使用,最好是一个文件一个类
class MyClass1():
    pass

3.类的设计【类体的实现】

三要素:

​ 事物名称【类名】:举例:人

​ 事物的特征【变量】:名词,举例:姓名,年龄。。。。

​ 事物的行为【函数/方法】:动词,举例:吃,跑。。。。

三、类中的方法和变量【掌握】

1.类中的方法和变量的定义

类中的方法和变量是为了描述事物的行为和特征

类中定义的方法被称为成员方法

类中定义的变量被称为成员变量,也被称为属性 [os.name]

成员变量:类具有的特征

成员方法:类具有的行为

类存在的意义:拥有相同特征和行为的对象可以抽取出来一个类,类的存在是为了创建一个具体的对象

代码演示:

#定义类
#1.事物的名称:类名
class Person():
    #2.事物的特征:成员变量、属性
    name = ""
    age = 0
    height = 0.0

    #3.事物的行为:成员方法【函数】
    #注意:类中的成员方法区别于普通方法:参数部分一定包含self,而且最好self出现在参数列表的第一个
    #调用函数的时候,self不需要被传参
    #初次之外,成员方法的用法和普通方法的使用完全相同,也可以设置默认参数或者关键字参数,不定长参数

    #注意:self:自己,代表类的实例【对象】
    #此处的self可以是任意的标识符,只不过为了结合其他编程的使用,习惯上使用self
    def eat(self,food):
        print("eating",food)
    def run(self):
        print("running")

2.类中方法和属性的使用

2.1创建对象【实例化对象】

已知类,通过类创建对象

对象的创建过程被对象的实例化过程

语法:变量名 = 值

​ 对象名 = 类名()

代码演示:

#定义类
#1.事物的名称:类名
class Person():
    #2.事物的特征:成员变量、属性
    name = ""
    age = 0
    height = 0.0

    #3.事物的行为:成员方法【函数】
    #注意:类中的成员方法区别于普通方法:参数部分一定包含self,而且最好self出现在参数列表的第一个
    #调用函数的时候,self不需要被传参
    #初次之外,成员方法的用法和普通方法的使用完全相同,也可以设置默认参数或者关键字参数,不定长参数

    #注意:self:自己,代表类的实例【对象】
    #此处的self可以是任意的标识符,只不过为了结合其他编程的使用,习惯上使用self
    def eat(self,food):
        print("eating",food)
    def run(self):
        print("running")
        print("self的地址:", id(self))


#对象的创建
p1 = Person()
print(p1)

p2 = Person()
print(p2)

#p1和p2被称为对象,变量名,引用,指向了真正的对象
#p1和p2在栈空间中开辟了空间,真正的对象的被存储在堆空间中

#通过对象调用类中的成员方法和访问类中的成员变量
#1.访问属性
#语法:对象.属性名
#赋值:对象.属性 = 值
per = Person()
print(per.name)
per.name = "小姐姐"
print(per.name)
per.age = 18
print(per.age)
per.height = 1.70
print(per.height)

#2.调用方法
#语法:对象.函数名(参数列表)
#注意:self不需要被传参,传参的时候注意区分参数的类型【默认参数,不定长参数,关键字参数】
per.run()
print("per的地址:",id(per))
"""
self的地址: 2687721120880
per的地址: 2687721120880
"""
per.eat("apple")

person = Person()
person.name = "张三"
person.age = 20
print(person.name,person.age)
person.run()
person.eat("")

#结论:类中的成员变量和成员方法随着对象的出现而出现

总结:

​ 访问变量采用:对象名.属性名

​ 访问方法采用:对象名.方法名(参数列表)

3.内存中的对象

per = Person()

说明:

a.程序中定义的Person类型的变量per实际上是一个变量名,它被存放在栈内存中,他指向实际的Person对象,而真正的Person对象则存放于堆内存中

b.类中的成员变量随着对象的出现而出现,随着对象的消失而消失

c.每个对象的成员变量会在堆空间中开辟一份自己的空间,相互之间互不影响

4.动态绑定属性和限制绑定

__slots__变量的作用:限制一个类中的成员变量【程序在运行的过程中,就不能随意的动态绑定属性】
语法:__slots__ = (属性的名称)

代码演示:

#1.类的定义
class MyClass():
    #2.成员变量
    """
    num1 = 0
    num2 = 10
    """
    #限制属性
    #注意:被限制的属性的名称通过字符串的方式出现在元组的元素中
    __slots__ = ("num1","num2")

    #3.成员方法
    def fun1(self):
        print("fun1")
    def fun2(self,num):
        print(num)

#4.创建对象
my = MyClass()
#5.访问类中的成员变量
my.num1 = 11
my.num2 = 22
print(my.num1,my.num2)

#6.调用类中的成员方法
my.fun1()
my.fun2(30)

#成员变量随着对象的出现而出现的
#属性的动态绑定【Python是一门动态语言】
my.n = 100
print(my.n)

my1 = MyClass()
#print(my1.n)

5.综合案例一

代码演示:

practiceDemo01.py文件【测试模块】

"""
需求:使用面向对象的思想描述下面这个情景
开学了,王老师让小明,小花,小丽分别做自我介绍
需要介绍姓名,年龄,爱好,来一段才艺展示
"""
"""
分析:
老师类
    特性:姓名
    行为:让学生做自我介绍

学生类
    特征:姓名,年龄,爱好
    行为:一段才艺展示
"""
#导入
"""
import  practice01.teacher
import  practice01.student
"""
from practice01.teacher import  Teacher
from practice01.student import Student

#1.创建一个老师的对象
wang = Teacher()
wang.name = "王老师"

#2.创建一个学生的对象
xiaohua = Student()
xiaohua.name = "小花"
xiaohua.age = 18
xiaohua.hobby = "唱歌"

#3.让老师执行自己的行为
wang.letStudentIntroduce(wang.name,xiaohua)   #stu = xiaohua

xiaoli = Student()
xiaoli.name = "小丽"
xiaoli.age = 20
xiaoli.hobby = "跳舞"
wang.letStudentIntroduce(wang.name,xiaoli)

xiaoming = Student()
xiaoming.name = "小明"
xiaoming.age = 25
xiaoming.hobby = "吹牛逼"
wang.letStudentIntroduce(wang.name,xiaoming)

teacher.py文件【实体类】

#老师类
class Teacher():
    #特征:成员变量
    name = ""

    #行为:成员方法
    def letStudentIntroduce(self,name,stu):
        #老师发出指令
        print(name + "让" + stu.name + "做自我介绍")

        #执行指令
        stu.introduce(stu.name,stu.age,stu.hobby)

        #不同的学生展示不同的才艺
        if stu.name == "小花":
            stu.singSong()
        elif stu.name == "小丽":
            stu.dance()
        else:
            stu.lie()

student.py文件【实体类】

#学生类
class Student():
    #特征:成员变量
    name = ""
    age = 0
    hobby = ""

    #行为:成员方法
    def introduce(self,name,age,hobby):
        print("大家好,我是%s,今年%d,爱好%s"%(name,age,hobby))

    #唱歌
    def singSong(self):
        print("娘子~啊哈")

    #跳舞
    def dance(self):
        print("广场舞")

    #吹牛逼
    def lie(self):
        print("我家可穷了,就养了几百头牛")

四、构造函数和析构函数

1.构造函数【掌握】

采用上面的方式创建对象【直接给成员变量赋值】,很多的类一般倾向于创建成有初始状态的
__init__:构造函数【作用:创建对象,给对象的成员变量赋初始值】
构造函数:构造器
调用的时机:当一个对象被创建的时候,第一个被自动调用的函数
per = Person()

语法:
  def __init__(self,args1,args2....)
      函数体
说明:
  a.之前的写法中并没有显式的定义__init__函数,说明系统默认提供了一个无参的构造函数
  b.args1,args2...一般设置的形参列表和成员变量有关

代码演示:

#1.构造函数被调用的时机
class Check():
    num1 = 0
    str1 = ""

    #构造函数
    def __init__(self):
        print("jfahj")

    def show(self):
        print("show")
#注意:当创建对象的时候,默认调用了系统提供的无参的构造函数
c = Check()
c.show()

#2.给构造函数添加参数
class Check1():
    name = ""
    age = 0
    """
    def __init__(self,n,a):
        print("fajkgak")
    """
    #注意2:当使用构造函数的时候,可以使用无参的,也可以使用有参的,在Python中的解决办法:设置不定长参数
    #注意3:Python中,一个类中只能有一个构造函数
    def __init__(self, *n):
        print("fajkgak")


#注意1:当手动头添加了有参的构造函数之后,系统将不再提供无参的构造函数
c1 = Check1()
c11 = Check1("fsiugh")

#3.有参构造函数的使用
class Check2():
    name = ""
    age = 0

    #构造函数的形参列表:和成员变量有关
    def __init__(self,n,a):
       print(n,a)
       name = n
       age = a

#注意1:当手动头添加了有参的构造函数之后,系统将不再提供无参的构造函数
c2 = Check2("zhangsan",10)
print(c2.name,c2.age)   #0


#4.self的使用
class Check3():
    name = ""
    age = 0

    #构造函数的形参列表:和成员变量有关
    def __init__(self,n,a):
       print(n,a)
       #self的使用:通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
       self.name = n
       self.age = a

c3 = Check3("zhangsan",10)
print(c3.name,c3.age)  #10

#5.使用self之后,可以省略成员变量的定义【掌握】
#self只是一个标识符,可以替换成任意的标识符
class Check4():

    #构造函数的形参列表:和成员变量有关
    def __init__(self,name,age):
       print(name,age)
       #self的使用:通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
       self.name = name
       self.age = age

    def show(self):
        print("showing")

c4 = Check4("lisi",20)
print(c4.name,c4.age)
c4.show()

2.析构函数

与构造函数正好相反,当对象被销毁的时候自动调用的函数,被称为析构函数
__del__:

删除变量:   del  变量名,此时可以触发析构函数的调用

使用情景:清理工作,比如关闭数据库,关闭文件等

代码演示:

import  time

class Pig():
    def __init__(self,name,age):
        self.name  = name
        self.age = age
        print("构造函数被执行")


    def show(self):
        print("show")

    #析构函数
    def __del__(self):
        print("~析构函数被调用")


#析构函数被调用的时机:1:当程序运行完成的时候    2:使用del删除变量
p = Pig("abc",10)

del p

#注意:对象释放以后就不能再访问了【相当于根本未创建过这个对象】
#print(p.age)

time.sleep(5)

#在函数里定义的对象,会在函数结束时自动释放,这样可以用来减少内存空间的浪费
#其实就是作用域的问题
def func():
    per2 = Person("aa", 1, 1, 1)

func()

3.综合案例二

practiceDemo02.py文件【测试模块】

"""
需求:富二代王思聪开着豪车,很自豪的向他的新女友炫耀

富二代类
特征:姓名
行为:开车,炫耀

汽车类
特征:品牌,颜色
行为:奔驰
"""
#测试模块
from  practice02.car import Car
from practice02.richMan import RichMan

#1.创建一个富二代的对象
wang = RichMan("王思聪")

#2.创建一个汽车的对象
c = Car("玛莎拉蒂","闷骚红")
c.run()

#3.让富二代执行自己的行为
wang.driveCar(c)
wang.showCar(c)

richMan.py文件【实体类】

class RichMan():
    #构造函数
    def __init__(self,name):
        self.name = name

    #成员函数
    def driveCar(self,car):
        print("富二代%s开着他的豪车%s"%(self.name,car.brand))
    def showCar(self,car):
        print(car.brand,car.color)

car.py文件【实体类】

class Car():
    #构造函数
    def __init__(self,brand,color):
        self.brand = brand
        self.color = color

    #成员函数
    def run(self):
        print("%s在马路上奔驰"%(self.brand))

你可能感兴趣的:(Python面向对象设计)