Python类的封装教程

Posted 2023-04-05 Python热爱者

一、什么是封装

封装的本身意思其实就和闭包函数一样，就是把一个函数和变量全都包在一起，但其实这样的说法不是很具体，就是一种很片面的解释

二、为什么要封装

封装数据的主要原因是：保护隐私

封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了，只提供了一个快门键，就可以直接拍照）

提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），就是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。

三、如何封装

1.在类里面封装其实就是：

• 隐藏属性：通过 __变量名来隐藏
• 隐藏方法：通过 __方法名来隐藏

2.隐藏属性：是为了数据的安全

• 隐藏nmae属性的例子

class Person:
    def __init__(self,name,age):
        self.__name=name
        self.age=age

p=Person('xichen',18)
print(p.age)# 这个时候我们实例化出来的对象是访问不到类init里的__name属性的，

如何访问被隐藏的属性

通过在列里面写一个访问被隐藏的属性的接口

class Person:
    def __init__(self,name,age):
        self.__name=name
        self.age=age
    def get_name(self):
        # print(self.__name)
        return '[----%s-----]'%self.__name

p=Person('xichen',18)
print(p.age)

p=Person('xichen',18)
print(p.get_name())

通过对象名._类名_被隐藏的属性名

print(p._Person__name)

3.隐藏方法：为了隔离复杂度

• 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

• 方法的隐藏和属性的隐藏式一样的

• 这里的隐藏的方法不想我们的隐藏的属性一样可以有方法去用，隐藏的方法是用不了的

class Person:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def __speak(self):
        print('6666')

四、property装饰器

1 property装饰器有什么用

它可以把方法包装成数据属性

class Person:
    def __init__(self,name,height,weight):
        self.name=name
        self.height=height
        self.weight=weight
    @property	# 使用语法糖的方式 通过property装饰器进行装饰
    def bmi(self):
        return self.weight/(self.height**2)
    
p=Person('xc',1.82,75)
print(p.bmi)	# 使用查看对象属性的方式  查看方法的返回值
# print(p.bmi())	# 错误的使用方法
# p.bmi = 123   # 只能查看，不能进行修改

22.6421929718633

2 property之setter和deleter

使用property装饰器将方法包装成数据属性后，是无法进行修改的

只要通过property装饰器中的方法 .setter，这样就可以修改了

class Person:
    def __init__(self,name,height,weight):
        self.__name=name
        self.__height=height
        self.__weight=weight
    @property
    def name(self):
        return '[我的名字是：%s]'%self.__name

    #用property装饰的方法名.setter，这样就可以修改了
    @name.setter
    def name(self,new_name):
        # if not isinstance(new_name,str):
        if type(new_name) is not str:
            raise Exception('改不了')
        if new_name.startswith('sb'):
            raise Exception('不能以sb开头')
        self.__name=new_name
        
p=Person('xc',1.82,70)
# 按照属性进行调用
print(p.name)	# 调用property装饰器后的方法 name，变为一个属性
# 按照属性进行调用，并修改
p.name='pppp'	# 调用property.setter装饰器后的方法，可以进行修改

# 改不了，直接抛异常
# p.name=999
# p.name='sb_xxx'

只要通过property装饰器中的方法 .deleter，就可以删除了

一般没有这个需求。

class Person:
    def __init__(self, name, height, weight):
        self.__name = name
        self.__height = height
        self.__weight = weight

    @property
    def name(self):
        return '[我的名字是：%s]' % self.__name

    # 用property装饰的方法名.setter，这样就可以修改了
    @name.setter
    def name(self, new_name):
        # if not isinstance(new_name,str):
        if type(new_name) is not str:
            raise Exception('改不了')
        if new_name.startswith('sb'):
            raise Exception('不能以sb开头')
        self.__name = new_name


p = Person('xc', 1.82, 70)
# python学习交流群：711312441
# 按照属性进行调用
print(p.name)  # 调用property装饰器后的方法 name，变为一个属性
# 按照属性进行调用，并修改
p.name = 'pppp'  # 调用property.setter装饰器后的方法，可以进行修改
# 改不了，直接抛一异常
# p.name=999
# p.name='sb_xxx'

# 删除name，会调用property.deleter装饰的方法
del p.name

Python教程8

Python教程8

　　1.多态

# -*-coding:utf-8-*-
"""
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码重用，相同的代码不需要重复编写
3.多态：不同的子类对象调用相同的父类方法，产生不同的执行结果
（多态可以增加代码的灵活度，以继承和重写父类方法为前提，是调用方法的技巧
不影响到类的内部设计）

"""


class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print("%s 蹦蹦跳跳的玩耍" % self.name)


class XiaoTianDog(Dog):
    def game(self):
        print("%s 飞到天上去玩耍" % self.name)


class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print("%s 和%s 一起玩耍----" % (self.name, dog.name))
        dog.game()


# 创建狗对象
# waicai =Dog("旺财")
waicai = XiaoTianDog("旺财1")
# 创建人对象
xm = Person("小明")
# 调用和人玩的方法
xm.game_with_dog(waicai)

"""
术语：
创建出来的对象叫做类的实列
创建对象的动作叫实例化
对象的属性叫做实例属性
对象的调用方法叫做实例方法
两个说明：
1.每个对象都有自己独立的内存空间，保存各种不同的属性
2.每个对象的方法，在内存中只有一份，
在调用方法时，需要把对象的引用传递到方法的内部
"""

# 类对象
"""
类时一个特殊的对象，程序运行时，类同样会加载到内存。类对象在内存中只有一份，
使用一个类可以创建很多个对象实例，类对象还可以拥有自己的属性和方法。
类属性就是给类对象中定义的属性，通常用来记录这个类的相关特征，类属性不会用于记录剧吐的对象特征
"""


# 实例，定义一个工具类，每件工具都有自己的name，需求，指定使用这个类，创建多少个工具对象
class Tool(object):
    # 使用赋值语句定义类的属性
    count = 0

    def __init__(self, name):
        self.name = name
        Tool.count += 1  # 每次调用初始化方法都加1


tool1 = Tool("斧头")
print(Tool.count)
tool2 = Tool("榔头")
tool3 = Tool("扳手")
print(Tool.count)
print("----属性获取机制----")
print(Tool.count)  # 推荐
print("工具对象的总数: %d" % tool1.count)  # (不推荐)
print("工具对象的总数: %d" % tool3.count)  # （不推荐）
#  注意下三行
tool3.count = 99  # 在对象中找不到count属性，则会自动添加一个。和类属性不一样
print("工具对象的总数: %d" % tool3.count)
print("=====> %d" % Tool.count)

"""
类方法:
类方法需要修饰器@classmethod来标识
类方法的第一个参数是cls
"""


class Tool1(object):
    count1 = 10

    @classmethod  # 创建类方法,方法上方使用@classmethod
    def show_tool_count(cls):
        print("工具对象的数量%d" % cls.count1)

    def __init__(self, name):
        self.name1 = name
        Tool1.count1 += 1


toola = Tool1("斧头")
toola = Tool1("斧头1")
Tool1.show_tool_count()  # 调用类方法

"""
静态方法：
在开发时，如果需要在类中封装一个方法：
1.不需要访问实列属性或者调用实例方法
2.不需要访问类的属性或者调用类的方法
可以把方法封装成一个静态的方法

"""


class Dog1(object):
    @staticmethod  # 定义静态方法，在方法上使用@staticmethod
    def run():  # 注意静态方法没有参数
        print("小狗要跑跑....")


# dog1 = Dog1() #调用静态方法可以不创建对象
Dog1.run()