Python面向对象基础

什么是面向对象？

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

# 学生：姓名、年龄；  玩、学习
# 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. 类：包含两部分: 变量、方法

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

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

说明：面向对象听起来很抽象、模糊、不理解，暂时没关系，记住五个字：一切皆对象。

面向对象思想优势：

（1）在现实生活中，所有事物都被看作是对象；

（2）面向对象的宗旨：模拟现实世界中的一切事物；

（3）贴近实际生活，给所有对象都赋予属性和方法，更加人性化。

例如，一起来完成：

（1）举两个现实生活中的案例；

（2）以面向过程思想分析；

（3）以面向对象思想分析。

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

打水
面向过程: 拿水杯、去清洗、装水、盖盖子、拿到教室
面向对象: 叫方哥给你打杯水.

玩游戏
面向过程: [我]开机、打游戏、打、xxx、关机;  -我玩游戏
面向对象: 我叫人帮我玩游戏. [关注结果]

面向对象的三大特性：

（1）封装

（2）继承

（3）多态

在现实生活中，也有很多与封装的案例。

比如，小明是一个IT公司的程序员。

小明身边的人	了解小明的隐私内容项
银行柜员	身份证号、联系方式、银行卡号等。
同事	姓名、职位、性别、年龄等。
爸妈	血型、身份证号、女朋友姓名、性别等。

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

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

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

面向对象的概念

 

类是抽象的概念，指的是：对某些事物的描述。

对象是具体的概念，指的是：实实在在存在的个体

例如，请判断以下哪些是类，哪些是对象？

（1）员工；类
（2）《陈翔六点半》里的演员妹爷；
（3）手机；类
（4）被8分钟残忍嘎腰子的那只羊；
（5）银行卡；类
（6）昆虫；类
（7）动物；类
（8）老王买的最新款iPhone 14 Pro，商品编号为：874875487的手机
（9）在对面马路上快速奔跑的Tank 300。

类

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

定义Python类语法：

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

例如，一起来完成：

（1）定义一个汽车类；

（2）让汽车类能跑起来；

（3）执行程序，观察效果。

class Car:
    def run(self):
        print("汽车能跑起来..."  )
# 当仅定义了后,执行程序没有效果

对象

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

创建对象语法：

 对象名 = 类名()

调用方法语法：

对象名.方法名()

例如，一起来完成：

（1）用对象模拟制造出一台小轿车；

（2）小轿车能跑起来；

（3）执行程序，观察效果。

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

# 1.创建对象
# 对象名 = 类名()
car = Car()
# 2.调用方法
# 对象名.方法名()
car.run()   # 不需要给self传递值

self关键字

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

# 定义类
class Student:
    pass

# 创建对象
student = Student()

例如，一起来完成：

（1）定义一个学生类，且学生在努力学习；

（2）创建一个对象，同时输出对象名、self，了解self的含义；

（3）再到学生类中，定义一个学生睡觉的行为，并分别通过对象名、self调用方法；

（4）执行程序，观察self的效果。

# 1、定义汽车类
# 类中的self只是一个模版，创建对象之后，self是指向本对象
# 如果你创建了2个对象，每个对象中都有self，每个self都指向自己的对象
class Student():
    def study(self):
        print(self)   # <__main__.Student object at 0x0000021AB977F048>
        print('学生在努力学习!')

    def sleep(self):
        print(self)  # <__main__.Student object at 0x0000021AB977F048>
        self.study()   # 同一个类中，要调用其他方法，需要使用self，self表示本对象
        print('学生要好好睡觉！')


# 2、创建学生对象
s = Student()
print(s)  # <__main__.Student object at 0x0000021AB977F048>
s.study()
s.sleep()

print('--------------下边又是创建一个新的对象----------------')

s2 = Student()
print(s2)
s2.study()
s2.sleep()

对象属性

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

（1）属性在面向对象中，可以使用变量来表示；

（2）注意：属性可以在类内部、类外部都进行获取与使用。

类外面访问属性

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

（1）添加属性

（2）获取属性

 

添加属性语法： 对象名.属性名 = 值

获取属性语法： 对象名.属性名

例如，一起来完成：

（1）在车类外设置车的颜色为红色、有4个轮胎；

（2）获取属性值并输出结果。

# 1、定义汽车类
class Car:
    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象------------------------')
# 2、创建Car类对象
car = Car()
# 3、通过对象来调用方法
car.run()

# 4、添加属性
car.color = 'red'
car.number = 4

# 5、获取属性
print(f'车的颜色{car.color}')  # .就是的
print(f'车的轮胎数量{car.number}')  # .就是的

print('--------------造第二个对象------------------------')
# 1、创建对象
car2 = Car()
car2.run()

# 2、添加属性
car2.brand = '宝马'


# 3、获取属性
print(f'车的品牌:{car2.brand}')  # .就是的

# 以上代码两辆车的属性都不同

魔法方法

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

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

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

魔法方法语法：__魔法方法名__()

无参__init__()方法

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

__init__(self [, ...])

构造器，当一个对象被初始化创建时，会被自动调用。

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

（1）无参__init__()方法

（2）有参__init__()方法

无参__init__()方法语法：

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

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

例如，一起来完成：

（1）给小轿车这个对象默认设置颜色和轮胎数为：黑色、3个轮胎；

（2）创建对象后，直接获取属性结果。

# 1、定义汽车类
class Car:
    def __init__(self):
        print('init方法执行了！')
        self.color = '白色'  # 所有对象的属性变量
        self.number = 4     # 所有对象的属性变量
        brand = '宝马'       # init方法中的局部变量，只能在方法内部使用，和对象关系不大

    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象：使用默认的属性------------------------')
car = Car()  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')
print(f'车的品牌:{car.brand}')

print('--------------造第二个对象：使用默认的属性------------------------')
car2 = Car()  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')

print('--------------造第三个对象：修改默认属性------------------------')
# 修改了对象的属性之后，只是修改本对象的属性，默认属性并不会修改
car3 = Car()
car3.color = '黑色'
car3.number = 3

print(f'车的颜色:{car3.color}')
print(f'车的轮胎数量:{car3.number}')

print('--------------造第四个对象：使用默认的属性------------------------')
# 这里输出的还是默认属性
car4 = Car()  # 自动执行init方法
print(f'车的颜色:{car4.color}')
print(f'车的轮胎数量:{car4.number}')

有参__init__()方法

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

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

说明：

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

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

例如，一起来完成：

（1）直接在创建车对象时，初始化设定颜色、轮胎数值；

（2）在类外部直接获取对象属性值。

# 1、定义汽车类
class Car:
    def __init__(self,color,number):
        self.color = color       # 所有对象的属性变量
        self.number = number     # 所有对象的属性变量

    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象：传入自定义属性------------------------')
car = Car('白色',number=4)  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')

print('--------------造第二个对象：传入自定义属性------------------------')
car2 = Car(color='黑色',number=3)  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')

# 1、定义学生类
class Student:
    # 类属性，这个属性是所有对象共享属性,不独属于任何一个对象
    #当你修改了类属性school_name后，这个改变会影响到所有通过该类创建的实例。
    #这是因为类属性是共享的，一旦你在类的定义外部修改了它，所有对该类属性的引用（包括已经创建的实例）都会看到新的值。
    school_name = '黑马程序员'
    # 属性
    def __init__(self, id,name, age,sex):  # 对象属性
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex

    # 学习行为
    def study(self):
        print(f'{self.name}学生要好好学习!')
    # 睡觉行为
    def sleep(self):
        print(f'{self.name}学生要好好睡觉!')


# 2、创建学生对象1
print('---------------造对象1--------------------------')
stu1 = Student(1001,'刘备',23,'M')
stu1.study()
stu1.sleep()
# 访问对象属性
print(f'学号:{stu1.id},名字:{stu1.name}')
# 访问类属性
print(f'学校:{Student.school_name}')

Student.school_name = '传智播客'

print('---------------造对象2--------------------------')
# 2、创建学生对象
stu2 = Student(1002,'关羽',24,'W')
stu2.study()
stu2.sleep()

# 访问对象属性
print(f'学号:{stu1.id},名字:{stu1.name}')
# 访问类属性
print(f'学校:{Student.school_name}')

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

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

__str__()方法

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

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

（2）十六进制数 0x45AC6

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

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

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

__str__方法语法：

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

例如，一起来完成：

（1）创建一个有两个参数的小轿车对象，直接输出对象名，观察结果；

（2）思考：在输出小轿车对象名时，如何把颜色、轮胎数显示出来？

# 1、定义学生类
class Student:
    school_name = '黑马程序员'
    # 属性
    def __init__(self, id,name, age,sex):  # 对象属性
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex

    # 重写系统的__str__方法,打印对象时，会自动调用该方法
    def __str__(self):
       return f'{self.id},{self.name},{self.age},{self.sex}'


# 2、创建学生对象1
print('---------------造对象1--------------------------')
stu1 = Student(1001,'刘备',23,'M')

# 你直接打印对象时，默认调用的时__str__方法，但是系统中的该方法返回的对象地址,我们重新定义__str__方法，当打印对象时，就可以调用我们自定义的__str__方法
print(stu1)

__del__()方法

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

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

__del__()方法语法：

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

例如，一起来完成：

（1）定义一个有品牌属性的车类；

（2）创建对象后，输出属性值；

（3）再使用__del__()方法删除对象查看效果；

（4）思考：当不调用【del 对象名】，__del__()方法会自动调用执行吗？

# 1、定义学生类
class Student:
    school_name = '黑马程序员'
    # 属性
    def __init__(self, id,name, age,sex):  # 对象属性
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex

    # 重新系统的__del__方法，当删除对象时，自动调用该方法
    def __del__(self):
        print(f'请注意，{self.name}学生对象被删除了！')


print('---------------删对象-------------------------')
del stu1     #  当删除对象时，自动调用__del__该方法

print(stu1)  # 删除之后是不能再打印对象的

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

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

继承基础

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

（1）【类名】

（2）【类名()】

（3）【类名(object)】

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

例如，一起来完成：

（1）使用方式1/2/3分别定义老师类、学生类、手机类；

（2）当成功定义后，观察类的效果。

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


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


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

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

说明：

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

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

例如，一起来完成：

（1）Father类有一个性别属性，默认为男，同时，Father跑步速度快；

（2）如果Son类也想要拥有这些属性和方法，该怎么做呢？

（3）执行程序，观察程序效果。

# 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 子类名(父类名):
    代码
    ...

# 定义父类
class Person(object):
    def __init__(self, name,age,sex):
        print('父类的init方法')
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('人必须要吃饭!')

    def sleep(self):
        print('要必须要睡觉!')

# 2、定义子类：Student类
class Student(Person):
    #子类有特殊的对象属性：sid
    print('-------------调用父类的初始化--------------------')
    def __init__(self,name,age,sex,sid):
        super().__init__(name,age,sex)  # 调用父类的init方法进行初始化
        self.sid = sid    # 给自己特有的属性进行初始化

    # print('-------------自己进行初始化--------------------')
    # def __init__(self,name,age,sex,sid):
    #     self.name = name
    #     self.age = age
    #     self.sex = sex
    #     self.sid = sid    # 给自己特有的属性进行初始化


    #特殊的行为：study
    def study(self):
        print('每个学生都要好好学习!')

    def __str__(self):  # 使用父类的属性就像自己的一样，直接使用self来调用
        return f'{self.name},{self.age},{self.sex},{self.sid}'



# print('------------测试----------------')
# 1、创建父类对象
person = Person('刘备',18,'男')
person.eat()
person.sleep()

print('----------------子类对象-----------------')
# 2、创建子类对象
student = Student('刘备',18,'男','1001')  # 创建子类对象时，会先创建父类对象
student.eat()    # 调用父类方法
student.sleep()  # 调用父类方法

student.study()  # 调用子类特有方法

print(student)   # 打印子类对象

例如，一起来完成：

（1）从前，有个摊煎饼的老师傅[Master]，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼技术；

（2）渐渐地，老师傅老了，就想着把这套技术传授给他唯一的最得意的徒弟[TuDi]；

（3）试着通过初始化、无参、定义方法与单继承来模拟程序。

# 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__

例如，一起来完成：

（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("===========采用黑马配方制作煎饼果子!!")

# 3.定义子类：徒弟
# 如果父类出现同名的方法，调用顺序和这里继承父类的书写顺序相同，先调用Master的make_cake，再调用School的make_cake
class TuDi(Master,School):
    def programming(self):   # 子类的特有方法，加上父类继承的方法，子类一共有三个方法
        print("====培训大数据开发!")


# 4、创建子类对象
tudi = TuDi()
# 调用方法时：
# a.先去子类中去查找该方法,若存在,则直接使用
# b.如果子类没有，则去第1个父类中查找Master
# c.如果第一个父类没有，则去第2个父类中找School
# d.如果所有父类都没有，则取object找
# e.如果都没有，则报错
tudi.make_cake()
tudi.programming()

print('-------mro()查看父类方法调用顺序----------')
print(TuDi.__mro__)

继承进阶

方法重写

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

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

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

例如，一起来完成：

（1）徒弟非常认真学习，终于掌握了老师傅的技术；

（2）接着，自己潜心钻研出类独门配方的全新摊煎饼技术；

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

# 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())

调用父类方法

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

super()语法：

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

例如，一起来完成：

（1）徒弟在培训学校学习努力，不仅掌握了黑马摊煎饼配方、还创办了自己煎饼果子的品牌；[配方、品牌]

（2）配合着一起摊煎饼，做出了更加美味的煎饼果子；

（3）使用调用父类方法在__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）N年后，当初的徒弟也老了；

（2）因此，徒弟想要把"有自己品牌，也有黑马配方的煎饼果子"的所有技术传授给自己的小徒弟；

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

# 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


#------------------
tusun = TuSun()
tusun.make_cake()  #调用的时直接父类的方法，如果父类没有，则调用祖父类，否则就一直向上追溯

私有权限

私有属性

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

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

定义私有属性语法：

self.__属性名

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

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

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

例如，一起来完成：

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

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

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

#  ---------隐藏该隐藏的，暴露该暴露的--------------------------
# 1、定义父类
class Master(object):
    def __init__(self):
        self.__money = 0  # 私有属性

    # 对外提供修改私有属性的方法
    def set_money(self,money):
        self.__money = money

    # 对外提供一个获取私有属性的方法
    def get_money(self):
        return self.__money


class TuDi(Master):
    def method(self):
        print(self.__money)  # 子类不能直接访问父类的私有属性，但是可以调用父类的get方法来获取私有属性

print('----------------测试父类--------------------')

master = Master()
# master.__money = 100  # 对象又自己添加了一个属性，不是私有属性

# 修改私有属性
master.set_money(8000)

# 获取私有属性
print(master.get_money())

print('----------------测试子类--------------------')
tudi = TuDi()
tudi.method()  # 子类不能直接访问父类的私有属性，但是可以调用父类的get方法来获取私有属性

# 升级:
# 1.当子类继承了父类后, 子类就拥有了父类的属性和方法
# 2.当子类继承了父类后, 子类就拥有了父类的【非私有】属性和【非私有】方法

私有方法

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

定义私有方法语法：

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

例如，一起来完成：

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

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

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

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

    # 间接,我们可以封装一个方法，只有满足我的条件，才能调用私有方法，否则不能访问
    def use(self,info):
        if info == '衷心的徒弟':
           self.__make_secret()
        else:
            print('龟蛋!!!!!')


print('--------------------------------')
master = Master()
# master.__make_secret()  # 不能在类外部调用私有方法

master.use('衷心的徒弟')  # 不能在类外部调用私有方法

面向对象综合案例

例如，一起来完成：

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

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

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

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

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

class lose_weight():
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight

    def run(self,num1):
        self.num1=num1
        self.weight -=self.num1 * 0.5
    def eat(self,num2):
        self.num2=num2
        self.weight +=self.num2 * 2

    def __str__(self):
        return f'{self.name},运动了{self.num1}次,大吃大喝了{self.num2}次,当前体重{self.weight}'
        
z = lose_weight('小芳',100)
z.run(10)
z.eat(1)
print(z)# 小芳,运动了10次,大吃大喝了1次,当前体重97.0

对象属性和类属性

对象属性

例如，一起来完成：

（1）定义一个手机类，属性有品牌、颜色；

（2）分别试着在类内部和类外部访问属性。

# 1.定义手机类
# 2.内部访问
class Phone(object):
    def __init__(self,color,brand):
        # 对象名.属性名
        self.color = color   # 对象属性
        self.brand = brand   # 对象属性

    def show(self):
        print(f"访问车的颜色:{self.color}")

# 3.外部访问
phone = Phone("黑色","Audi")
print(f"颜色:{phone.color}")
print(f"品牌:{phone.brand}")

类属性

类属性指的是：类所拥有的属性，在整个类中都可以直接使用。

定义类属性语法：

​​​​​​​class 类名(object):
    类属性名 = 值

调用类属性语法： 类名.类属性名

例如，一起来完成：

（1）在Student类中,定义一个名为school_name的类属性；

（2）调用使用类属性，观察效果

class Student:          # 公共属性就定义成类属性
    school_name = '黑马程序员'   #类属性，所有对象共享，不输入任何一个对象，属于整个类，用类名访问，用对象访问可以可以
    # 属性
    def __init__(self, id,name, age,sex):
        self.id = id    # 对象属性，属于某个对象的，使用对象访问
        self.name = name
        self.age = age
        self.sex = sex

    # 学习行为
    def study(self):
        print(f'{self.name}学生要好好学习!')
    # 睡觉行为
    def sleep(self):
        print(f'{self.name}学生要好好睡觉!')


print('-----------------------')
stu = Student(1001,'刘备',18,'M')

# 访问类属性
print('-----------访问类属性-----------------')
print(Student.school_name)  # 使用类名来访问类属性
print(stu.school_name)      # 类属性也可以使用对象访问，但是不建议

# 访问对象属性
print('-----------访问对象属性-----------------')
print(stu.id)   # 使用对象来访问对象属性
print(stu.name) # 使用对象来访问对象属性
print(stu.age)  # 使用对象来访问对象属性
print(stu.sex)  # 使用对象来访问对象属性# 1.定义类 -类属性  [方法]
class People(object):
    # 类属性
    count = 100

    def show(self):
        print("森林防火,人人有责.")

# 2.调用使用
# print(People.count)
# 扩展   了解
# p = People()
# print(p.count)
# 思考: 类属性名可以私有化吗？如何访问？