python基础知识（十一）面向过程，面向对象，对象属性，魔法方法，继承，私有权限

面向过程是什么

什么是面向对象？

面向对象的三大特性：

继承

多态

类

对象

self关键字

对象属性

类外面访问属性

类内部获取属性

魔法方法

无参init()方法

有参init()方法

str()方法

del()方法

继承基础

什么是继承

单继承

多继承

继承进阶

方法重写

调用父类方法

多层继承

私有权限

私有方法

面向对象综合案例

常见的编程思想有：

（1）面向过程

面向过程强调的是过程，关注操作步骤、动作。

（2）面向对象

Python是同时支持面向过程和面向对象的编程语言！

面向过程是什么

面向过程是一种以过程为中心的编程思想。

通俗地说，在解决编程问题时，我们会把需要的操作步骤都列出来，然后按照操作步骤写代码，这种思维就是面向过程思想。

说明：

比如，要产生一个随机数，步骤：（1）导入random模块；（2）产生随机数；（3）输出结果。

在实际生活中，为了更好理解面向过程。

使用面向过程思维来了解：使用ATM机取钱的过程。

（1）带上银行卡，去ATM机所在的地方；

（2）排队等待；

（3）轮到自己了，把银行卡插入ATM机；

（4）输入密码，取钱；

（5）取钱成功，准备回家把钱上交媳妇儿把钱。

什么是面向对象？

面向对象是软件开发方法，一种编程范式。面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

# 学生：姓名、年龄；  玩、学习
# a.先定义
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def play(self):
        print(f"{self.age}岁的{self.name}还在玩泥巴...")

    def study(self):
        print("好好学习,天天向上!!")

# b.后调用
stu = Student("张三",16)
print(stu.name)
print(stu.age)
# 调用
stu.play()
stu.study()

通俗地说，面向对象思想就是：当解决问题的视角不再是详细的操作步骤，而是另一个视角：操作对象。比如，操作手机打电话、操作电脑来看电影、操作冰箱来存储新鲜水果等。

【对象】可以理解为冰箱、手机、电脑等一切事物。

吃饭面向过程: 买菜、洗菜、做饭菜、吃面向对象: 点外卖 [厨师、外卖员]

打水

面向过程: 拿水杯、去清洗、装水、盖盖子、拿到教室

面向对象: 叫方哥给你打杯水.

面向对象的三大特性：

（1）封装

（2）继承

（3）多态

类似的，在Python面向对象中也有封装。

简单地说，封装就是把对象的属性和方法放在一个整体中，并限制对属性和方法的访问操作。而这里说的整体，就是【类】。

class 类名:
    def 方法名():
        属性1 = 值1
        属性2 = 值2
        ...
    def 方法名2():
        执行代码1
        执行代码2
        ...

面向对象里的封装，就是把属性和方法都存放到一个Python类中；

继承

在现实生活中，继承一般指的是子女继承父辈的财产，比如：子承父业等。

类似的，面向对象继承也有继承父类的意思。

通俗地说，当子类继承了父类后，子类就具有父类的属性和方法。

继承可以让程序更加简洁。

多态

多态指的是：不同类的对象对同一消息做出不同的响应。

这里的发送消息，通常是指调用方法。

通过生活案例来说明什么是多态，比如：电脑键盘上的F12功能键是固定不变的，但完成功能不同。

类

类是抽象的概念，指的是：对某些事物的描述。简单地说，类就是一个模板。

定义Python类语法：

class 类名:
    def 方法名(self):
        代码1
        代码2
        ...
    # 其他方法...

对象

对象是具体的概念，指的是：实实在在存在的个体。简单的说，对象就是通过类创建出来的实体。

创建对象语法：

对象名 = 类名()

调用方法语法：

对象名.方法名()

self关键字

self是一个Python关键字，在面向对象中，self指向了对象本身。比如，创建了一个学生对象。

定义类
class Student:
    pass

创建对象
student = Student()

说明：self表示当前的，当前的对象

对象属性

什么是属性

在现实生活中，属性就表示固有特征，比如：一辆小轿车的属性有轮胎数、颜色、品牌等。

仔细观察后会发现，属性可以简单理解为与生俱来的特征，比如一个人的姓名、年龄、身高、体重等都是属性。

而属性在Python面向对象中，直接使用变量来表示。属性可以在类内部、类外部都进行获取与使用。需要注意的是，一个对象通常包含两部分：方法、属性。

类外面访问属性

在类外面访问属性，分为：

（1）添加属性

（2）获取属性

说明：要访问对象中的属性，需要使用.点来操作。

添加属性语法：

对象名.属性名 = 值

获取属性语法：

对象名.属性名

class Car:
    def run(self):
        print("汽车能跑起来...")

# 1.创建对象
car = Car()
# 2.添加属性
car.color = "红色"
car.number = 4
# 3.获取属性
print(f"颜色:{car.color}")
print(f"轮胎数:{car.number}")

类内部获取属性

在类内部，获取属性语法：

self.属性

说明：可以简单的把self理解为对象本身。

class Car:
    def run(self):
        print("汽车能跑起来...")
    # 定义方法
    def show(self):
        print(f"车颜色:{self.color}")
        print(f"车的品牌:{self.brand}")
        # self.属性没有任何提示, 如果要显示出提示,该怎么办??
        # 为什么会有警告?


car = Car()
# 外部设定值
car.color = "黑色"
car.brand = "BWM"
# 内部获取值
# 调用方法
car.show()

总结：

（1）在类内部获取属性可以使用【self.属性名】方式；

（2）注意：当没有在init()中初始化属性时，直接在方法中调用，则会报警告信息。

魔法方法

魔法方法指的是：可以给Python类增加魔力的特殊方法。有两个特点：

（1）总是被双下划线所包围；

（2）在特殊时刻会被自动调用，不需要开发者手动去调用。

魔法方法语法：

__魔法方法名__()

在Python中，常用的魔法方法有：

魔法方法名	描述信息
__init__(self [, ...])	构造器，当一个对象被初始化创建时，会被自动调用。
__str__(self)	输出对象名时，若不想直接输出内存地址值，可重写str()方法。
__del__(self)	当一个对象被删除或销毁时，会被自动调用。

无参`init()`方法

在Python中，当新创建一个对象时，则会自动触发init()魔法方法。

魔法方法名	描述信息
__init__(self [, ...])	构造器，当一个对象被初始化创建时，会被自动调用。

根据是否给init()魔法方法传递参数值，可分为：

（1）无参init()方法

（2）有参init()方法

无参init()方法语法：

class 类名:
    def __init__(self):
        代码
        ...

说明：当仅需在类内部使用与初始化属性时，可以使用该方法。

# 1.定义类: 默认设置属性
class MyCar:
    def __init__(self):
        # 默认设定
        self.color = "黑色"
        self.number = 3

    def func(self):
        print("============================")
        print(f"颜色:{self.color}")
        print(f"轮胎数:{self.number}")
        print("============================")

# 2.在类的外部访问属性
my_car = MyCar()
print(my_car.color)
print(my_car.number)

# 3.类内部访问属性
my_car.func()

有参`init()`方法

当想要在创建对象时，就设定属性值时，可以使用有参init()方法。语法：

class 类名:
    def __init__(self, 参数1, 参数2,...):
        代码
        ...

说明：

（1）不需要给self传递参数值；

（2）传递参数个数的计算公式为【传递参数个数 = 定义方法后的参数总个数 - 1】。

# 1.定义类、方法
class Car:
    def __init__(self,color,number):   # 属性名会与传递的参数名名称保持一致
        self.color = color
        self.number = number


# 2.创建对象
car = Car("黑色",4)
# 3.获取值
print(f"颜色:{car.color}")
print(f"轮胎个数:{car.number}")

总结：

（1）init()方法可以用来设置属性的默认值；

（2）注意：当要在创建对象时，直接设定属性值，则可以通过有参init()方法传递参数值来处理。

`str()`方法

内存地址值，也称为引用。表现形式有两种：

（1）十进制数 5040624，id()函数

（2）十六进制数 0x45AC6

说明：当直接输出对象名时，默认输出的是对象的内存地址值。

当在类中定义了str方法，则获取的是该方法返回的数据结果。

魔法方法名	描述信息
__str__(self)	输出对象名时，若不想直接输出内存地址值，可重写str()方法。

class 类名:

class 类名:
        def __str__(self):
        代码
        ...
        return 字符串型的结果

# 1.定义类
class Car:
    def __init__(self,color,number):
        self.color = color
        self.number = number

    def __str__(self):
        # return "颜色:"+self.color
        return "颜色:"+self.color+",轮胎数:"+str(self.number)

# 2.输出对象名  -内存地址值
car = Car("白色",4)
# print(car)  # <__main__.Car object at 0x000001FBBCA72DF0>
# 3.如何显示
print(car)
# 总结
# 1.当直接输出对象名时,输出内存地址值,则表示没有重写str方法
# 2.当输出对象名不显示内存地址值, 重写了str方法

`del()`方法

当删除对象时，会自动调用del()方法。

魔法方法名	描述信息
__del__(self)	当一个对象被删除或销毁时，会被自动调用。

class 类名:
    def __del__(self):
        代码
        ...

# 1.定义类
class Car:
    def __init__(self,brand):
        self.brand = brand

    def __del__(self):
        print("=========__del__===========")

# 2.创建对象
car = Car("BMW")
# 删除 -内存
# del car   # 注释
print(car.brand)
# 3.查看del
# 注意: 为了能更方便的查看del效果, 建议使用 del xx语法

总结：

（1）当使用【del 对象名】时，自动调用了del()方法；

（2）注意：当程序执行结束时，Python垃圾回收器会自动销毁内存垃圾，此时会自动调用del()方法。

继承基础

我们知道，可以使用class关键字定义类。

在类的使用中，定义方式有三种：

（1）【类名】

（2）【类名()】

（3）【类名(object)】

说明：区别在于类名后面是否加其他内容。

方式1语法：

class 类名:
    代码
    ...

方式2语法：

class 类名():
    代码
    ...

方式3语法：

class 类名(object):   # 推荐
    代码
    ...

说明：方式3是定义类最常见的语法。

# 1.类名
# class Teacher:
class Teacher:
    pass


# 2.类名()
class Student():  # 删除()
    pass


# 3.类名(object)
class Phone(object):   # 标准
    pass

什么是继承

类似的，在面向对象中，当子类继承父类后，则：子类拥有了父类的属性和方法。

继承语法：

class 父类名(object):
    代码
    ...
class 子类名(父类名):
    代码
    ...

说明：

（1）建议在定义父类时，都采用【类名(object)】语法；

（2）当子类拥有了父类的属性和方法后，能提升代码的复用性。

# 1.定义父类
class Father(object):
    def __init__(self):
        self.sex = "男"

    def run(self):
        print("跑步很快...")

# 2.定义子类
# class Son(object):
#     def __init__(self):
#         self.sex = "男"
#
#     def run(self):
#         print("跑步很快...")

# 3.改进
class Son(Father):
    pass

# 4.输出
son = Son()
print(f"属性:{son.sex}")
son.run()

单继承

单继承指的是：一个子类继承一个父类。语法：

class 子类名(父类名):
    代码
    ...

# 1.定义父类：老师傅
# 配方
# 摊煎饼
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")

# 2.定义子类：徒弟
class TuDi(Master):
    pass

# 3.创建对象
fang_ge = TuDi()
print(fang_ge.pei_fang)
fang_ge.make_cake()

总结：

（1）单继承就是一个子类继承了一个父类，语法：class 子类名(父类名): ...；

（2）注意：当子类继承了父类后，子类可以拥有父类的属性和方法。

多继承

多继承指的是：一个类同时继承了多个父类。语法：

class 子类名(父类名1, 父类名2, ...):
    代码
    ...

继续，回到摊煎饼的故事主线。

例如，一起来完成：

（1）徒弟是个爱学习的好孩子，想学习更多的摊煎饼技术；

（2）于是，在百度搜索到培训学校[School]，报班来培训学习如何摊煎饼；

（3）使用多继承形式模拟程序。

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之配方】"

    def make_cake(self):
        print("===========采用配方制作煎饼果子!!")

# 3.定义子类：徒弟
class TuDi(Master,School):
    pass

注意：在Python面向对象中，继承包含：单继承、多继承、多层继承。

当子类同时继承多个父类，并调用多个父类同名方法的顺序，查看时使用：

类名.__mro__
类名.mro()

例如，一起来完成：

（1）可以发现老师傅[Master]、培训学校[School]都有摊煎饼方法；

（2）在徒弟对象中调用摊煎饼方法，会执行哪个父类的方法呢？

（3）思考：当给父类培训学校[School]新增编程方法后，子类能调用方法吗？

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之配方】"

    def make_cake(self):
        print("===========采用配方制作煎饼果子!!")

    def programming(self):
        print("====培训开发!")

# 3.定义子类：徒弟
class TuDi(Master,School):
    pass

# 创建对象、调用方法
fang_ge = TuDi()
# a.先去子类中去查找该方法,若存在,则直接使用
# b.去第1个父类中查找TuDi(【Master】,School)
# c.去第2个父类中找
# d.object找
print(TuDi.__mro__)
print(TuDi.mro())
fang_ge.make_cake()
fang_ge.programming()

总结：

（1）当子类继承父类后，可以给子类添加新的扩展方法；

（2）当要查看子类调用父类方法的顺序时，可以使用子类名.__mro__或mro()。

继承进阶

方法重写

当父类的同名方法达不到子类的要求，则可以在子类中对方法进行重写。语法：

class 父类名(object):
    def 方法A(self):
        代码
        ...

class 子类名(父类名):
    def 方法A(self):
        代码
        ...

例如，一起来完成：

使用方法重写对摊煎饼方法进行处理。

# 1.老师傅: 父类
class Master(object):
    def make_cake(self):
        print("使用古法配方摊煎饼果子...")


# 2.徒弟：子类  -父类方法达不到要求
class TuDi(Master):
    # 重写
    def make_cake(self):
        print("======潜心学习,专研了新的配方制作煎饼果子...")


# 3.调用使用
tudi = TuDi()
tudi.make_cake()
print(TuDi.mro())

总结：

（1）当子类中出现与父类中同名方法且参数内容保持一致时，称为（方法重写）

（2）当子类重写了父类方法后，子类对象优先调用执行子类方法，可以通过【子类名.mro()】查看执行顺序。

调用父类方法

当子类要在父类同名方法的基础上，再新增功能且要求在子类中调用同名方法时，就可以使用super()。

super()语法：

super().方法名([参数1, 参数2, ...])

说明：

（1）super()表示父类；

（2）.点表示的。

使用调用父类方法在init()和摊煎饼方法中处理。

# 1.定义父类 [属性、方法]
class School(object):
    def __init__(self, pei_fang):
        self.pei_fang = pei_fang

    def make_cake(self):
        print("父类,制作了美味的煎饼果子!!")

# 2.定义子类
class TuDi(School):
    # 属性: 配方、品牌
    def __init__(self,pei_fange,brand):
        # self.pei_fang = pei_fange   # 提升代码的复用性
        super().__init__(pei_fange)
        self.brand = brand

    def make_cake(self):
        # 调用父类的方法
        super().make_cake()
        print("===========子类制作煎饼果子!!")

# 3.创建对象、调用
tudi = TuDi("黑马","方哥")
tudi.make_cake()

多层继承

多层继承指的是：多级继承的关系，比如：子类继承父类C、继续继承父类B、继续继承父类A等。

为了区分单继承、多继承和多层继承，看下图：

请试着使用多层继承的方式完成案例

# 1.A父类 学校
class School(object):
    def make_cake(self):
        print("----1-----学校:父类")

# 2.B父类 徒弟
class TuDi(School):
    def make_cake(self):
        print("=====2======徒弟: 子、父类")

# 3.子类 徒孙
class TuSun(TuDi):
    pass

总结：

（1）简单地说，多层继承表示有多级父类；

（2）请问：Python同时支持单继承、多继承和多层继承

私有权限

为了更好的限制属性的访问和包含隐私，可以给属性设置私有权限。

当把属性设置为私有属性后，则该属性只能被本类直接访问。

私有属性

定义私有属性语法：

self.__属性名

设置和获取私有属性值语法：

class 类名(xxx):
    # 设置私有属性值[set]
    def set_私有属性名(self,参数):
        self.私有属性 = 参数

    # 获取私有属性值[get]
    def get_私有属性名(self):
        return self.私有属性

例如，一起来完成：

（1）FangGe把技术传承给小徒弟时，不想把自己的私房钱（￥6000000）继承给徒弟；

（2）这时，就要为私房钱这个属性设置私有权限；

（3）思考：若想要来访问私有属性，该怎么做呢？

# 1.父类：Master
class Master(object):
    def __init__(self):
        self.__money = 6000000

    # 设置
    def set_money(self,money):
        self.__money = money
    # 获取
    def get_money(self):
        return self.__money

# 2.子类
class TuDi(Master):
    pass

# 3.能否访问？
# xiao_fang = TuDi()
# print(xiao_fang.__money)   # 不能访问？

master = Master()
master.set_money(5000000)
print(master.get_money())
# 升级:
# 1.当子类继承了父类后, 子类就拥有了父类的属性和方法
# 2.当子类继承了父类后, 子类就拥有了父类的【非私有】属性和【非私有】方法

总结：

（1）当要定义私有属性时，仅需要在属性名前添加（双下划线==）

（2）注意：如果要从外部访问私有属性值，建议要在类中定义set/get方法。

私有方法

当把方法设置为私有方法后，则该方法只能被本类直接访问。

定义私有方法语法：

def __方法名(self):
     ...

例如，一起来完成：

（1）FangGe把技术传承给小徒弟时，不想把自己独创配方的制作过程继承给徒弟；

（2）这时，就要为制作独创配方这个方法设置私有权限；

（3）思考：该怎么访问私有方法呢？

# 1.定义父类
class Master(object):
    def __make_secret(self):
        print("===================")
        print("加葱姜蒜...")
        print("加酱油,加白醋")
        print("辣椒面...")
        print("制作好卖给我的学生!!")
        print("===================")

    # 间接
    def use(self):
        self.__make_secret()


# 2.子类？？
# 3.直接访问
master = Master()
# master.__make_secret()  # 不能?
master.use()

总结：

（1）当把方法设定为私有权限后，则该方法不会被继承给子类；

（2）注意：当子类继承了父类后，子类拥有父类的（非私有属性和非私有方法）。

面向对象综合案例

案例：减肥

例如，一起来完成：

（1）小方同学当前体重是100kg；

（2）每当他跑步一次时，则会减少0.5kg；

（3）每当他大吃大喝一次时，则会增加2kg；

（4）假如跑步5次后，再大吃大喝一次，体重如何？

（5）请试着采用面向对象思想来编写案例。

# 1.定义类：属性[变量]、行为[方法]
class Student(object):
    def __init__(self):
        # 默认
        self.weight = 100

    def run(self):
        self.weight = self.weight - 0.5
        print(f"跑步一次,减肥0.5kg,当前体重为:{self.weight}kg")

    def eat(self):
        self.weight += 2
        print(f"=====大吃大喝一顿,增重2kg,当前体重为:{self.weight}kg")

# 2.创建对象
student = Student()
print(f"当前体重为:{student.weight}")
student.run()
student.run()
student.run()
student.run()
student.run()
student.eat()

总结：

（1）在类内部调用或获取属性时，可以使用 self.属性名方式；

（2）当通过对象来调用方法时，可以使用【self.方法名()】方式。

（3）我们会发现，对于魔法方法的使用，会在某些特殊时刻自动被调用；

（4）在学习面向对象知识时，我们会发现总结起来就是五个字：一切皆对象。