Python—面向对象小解(2)

一、面向对象开发的基本使用

根据需求定义类

• 关键字class

• 属性

  • 变量

• 方法

  • 函数

  • 默认函数中必须有个self参数

  • self(自己)代表当前对象

如何将一项物品放入一个空间内?

# 类的定义创建
class itcast:
    # 指定属性
    name = '大象'
    container = '冰箱'

    # 指定数据的处理方法
    def open_container(self):
        # self代表当前兑现本身，可以使用self调用类中的属性和方法
        print(f'打开{self.container}')

    def add_func(self):
        print(f'将{self.name}放入{self.container}')

    def close_container(self):
        print(f'关闭{self.container}')

# 使用类创建对象
obj = itcast()
# 调用对象方法
obj.open_container()
obj.add_func()
obj.close_container()

二、类的属性

类属性说明：

本质就是保存数据，属性有两种：类属性、对象属性

类属性：在方法的外部，类的下方定义的叫做类属性

class A:
    data = 10  # 类属性

    def func(self):

对象属性：在方法内使用self定义的数据

class A:

    def func(self):
        self.data = 20 # 对象属性

两种属性区别：

1-类属性可以使用类名获取也可以使用对象获取

2-对象属性只能使用对象获取

# 属性说明
class itcast:

    name = '张三'  # 类型属性

    def func(self):
        self.age = 20 # 对象属性

    def func2(self):
        # self就是一个对象
        print(self)
        print(self.name)
        print(self.age)

# 属性值的获取调用
# 类属性获取
# 类名获取类属性值
print(itcast.name)
# 使用类创建对象
obj = itcast()
# 对象获取类属性值
print(obj.name)


# 对象属性
# 先使用方法，执行对象属性的创建
obj.func()
# print(itcast.age) # 类名无法获取对象属性值
print(obj.age) # 使用对象可以获取对象属性

# 调用func2方法
print(obj)
obj.func2()

self的说明：

self代表当前对象本身，是一个对象

# self的演示
class A:

    def func(self):
        print(self)


# 使用类创建对象
# 创建对象a1
a1  = A()
print(a1)
# 使用对象调用方法
a1.func() # self输出信息和a1输出信息一样，self现在代表的是a1

# 创建对象a2
print('---------------------------------------------------')
a2 = A()
print(a2)
a2.func() # 方法是哪个对象调用，self代表的就是当前对象

三、类的方法

3.1-魔法方法

魔法方法

• 类中自带的方法

• __init__()

  • 在创建类对象时会调用的方法

• __str__()

  • 在对对象进行print输出时调用

• __del__()

  • 在删除对象时会被调用

3.2-自定义方法

自己编写分方法

# init魔法方法的使用
class A:

    # 魔法方法
    def __init__(self):
        print('创建对象调用')

    # 自定义方法
    def func(self):
        print('自定义方法，需要创建对象后，使用对象调用才会执行')

# 创建对象会调用init方法
a1 = A()

# 使用对象调用func方法
a1.func()

3.3-魔法方法使用

class A:
    # 魔法方法
    # init方法常用
    def __init__(self):
        # 初始化方法  在创建兑现时调用
        print('init')

    def __str__(self):
        # 输出方法  在对对象进行print输出时调用
        print('str')
        return '调用了str方法'

    def __del__(self):
        # 删除对象时调用
        print('del')
# 创建对象 调用初始化方法
a = A()

# 在print输出对象会调用str
print(a) # 将str的返回值输出

# 可以手动删除对象
del a

# 程序结束后需要 会自动删除对象
for i in range(100000):
    print(i)

3.4-方法的传参

方法本质其实就是函数，可以将数据通过参数传递到方法内

• 形参

  • 缺省参数

  • 不定长参数

• 实参

  • 位置参数 按照形参的位置和个数传递数据

  • 关键字参数 形参名=值​​​

3.4.1-init方法传参

# init魔法方法的传参
class A:

    def __init__(self, name, age=0):
        # 接收参数数据，使用self创建对象属性保存数据
        self.name = name
        self.age = age

    # 自定义方法
    def func(self):
        # 方法内使用定义的属性值
        print(f'姓名:{self.name},年龄{self.age}')

# 传递参数数据  init方法的参数在创建对象时传递
a = A('张三',age=20)
# 直接获取属性值
print(a.name) # 使用对象获取对象属性值
# 调用自定义方法输出
a.func()

3.4.2-自定义方法传参

class A:

    # 自定义方法接收参数
    def func(self,name,age=10):
        # 使用属性保存
        self.name = name
        self.age = age

    # 自定义函数2
    def func2(self):
        # 通过self获取属性值
        print(f'姓名:{self.name},年龄:{self.age}')

# 初始化创建对象
a = A()

# 调用自定义方法传递参数数据
a.func('张三')

# 获取属性值
print(a.name)
print(a.age)

# 谁调用方法，方法中self就是谁
a.func2()

# 第二个对象
a2 = A()
# 使用a2对象调用方法
a2.func('李四',50)
print(a2.name)

print(a.name)

四、封装

        封装是面向对象编程的基本概念之一，指的是将数据（属性）和操作（方法）封装在类中，并限制对这些数据的直接访问。通过封装，可以隐藏对象的内部实现细节，提供一个受控的接口来访问和修改数据。这样做的好处是提高了代码的安全性和可维护性。

class 类名:
	属性
    方法
    
# 类继承
class 类名():
     属性
     方法

# 继承Python的顶级类 ，默认不写自动继承
class 类名(object):

建议定义类名的时，使用大驼峰命名,首字母大写：

# 不同定义类的方式
# 定义一个学生类
class Student:
    name = '张三'


# 定义教师类  继承使用
class Teacher():
    name = '李四'

# 定义学校类
class School(object):
    name = '长安大学'


# 使用类创建对象
stu = Student()
print(stu.name)

teacher = Teacher()
print(teacher.name)

school  = School()
print(school.name)

五、继承

        继承是面向对象编程的另一个基本概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以重用父类的代码，同时还可以添加新的属性和方法，或者修改父类的方法。这有助于减少代码的重复，提高代码的可维护性和可扩展性。

5.1单继承

一次继承一个类

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

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

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

# 单继承
class Father:
    gender = '男'

    def run(self):
        print('跑步速度快')

# 定义son 使用Father的属性和方法，就通过继承
# 一但继承后  Father叫做父类  Son叫子类 派生类
class Son(Father):

    def play(self):
        print('玩游戏')


son = Son()

# 在子类对象中调用父类的属性和方法
print(son.gender)
son.run()
son.play()

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

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

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

class Master:

    def __init__(self):
        self.name = '师傅'

    def jianbin(self):
        print('摊煎饼')


class TuDi(Master):
    # 子类中没有要新增的方法或属性
    pass

# 初始化对象
t = TuDi()
t.jianbin()

5.2多继承

继承多个类

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

（2）于是，在百度搜索煎饼学校[School]，学习如何摊煎饼；

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

class Master:

    def __init__(self):
        self.name = '师傅'
    def jianbin(self):
        print('摊煎饼')

class School:

    def __init__(self):
        self.name ='学校'

    def jianbin(self):
        print('摊煎饼2')

class TuDi(Master,School):
    # 子类中没有要新增的方法或属性
    pass

# 初始化对象
t = TuDi()
t.jianbin()

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

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

调用第一个父类的方法，print(TuDi.mro) # 查看类的继承执行顺序

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

可以调用

class Master:

    def __init__(self):
        self.name = '师傅'
    def jianbin(self):
        print('摊煎饼')

class School:

    def __init__(self):
        self.name ='学校'

    def jianbin(self):
        print('摊煎饼2')

    def baozi(self):
        print('蒸包子')

class TuDi(Master,School):
    # 子类中没有要新增的方法或属性
    pass

# 初始化对象
t = TuDi()
t.jianbin()

print(TuDi.__mro__) # 查看类的继承执行顺序

t.baozi()