python 面向对象之class和封装

# 封装
# Python并没有真正的私有化支持,但可用下划线得到伪私有 访问私有变量:实例._类名__变量名 访问私有方法:实例._类名__方法名()
class Wife02():
    def __init__(self,name,age,sex):  # 负责对象的初始化
        self.set_name(name)
        self.set_age(age)
        self.set_sex(sex)
   def set_name(self,value):
        if isinstance(value,str):  # 数据类型是否是字符串
            if '\u4e00' <= value <= '\u9fff':  # 是否是正文
                self.__name = value
            else:
                raise ValueError("不是中国人")  # 抛出异常
        else:
            raise ValueError("数据类型错误")
   def set_age(self,value):
        if 18 <= value <= 100:
            self.__age = value  # 私有化实例变量:在变量名称前,加入双下划线。
        else:
            raise ValueError("年龄不符,请重新创建对象")
   def set_sex(self,value):
        if value == "女":
            self.__sex = value
        else:
            raise ValueError("性别错误")
   def get_name(self):
        return self.__name  # 返回私有变量的值
   def get_age(self):
        return self.__age
   def get_sex(self):
        return self.__sex

# w01 = Wife02("zs",20,"女")  # ValueError: 不是中国人
# w02 = Wife02("张三",8,"女")  # ValueError: 年龄不符,请重新创建对象
# w03 = Wife02("张三",8,"男")  # ValueError: 年龄不符,请重新创建对象
w04 = Wife02("张三",20,"女")
print(w04._Wife02__age)  # 访问私有变量
print(w04.get_age())  # 访问私有变量
print(w04.__dict__)  # {'_Wife02__name': '张三', '_Wife02__age': 20, '_Wife02__sex': '女'}
w04.set_age(30)  # 修改私有变量的值
print(w04.__dict__)  # {'_Wife02__name': '张三', '_Wife02__age': 30, '_Wife02__sex': '女'}
w04.sex = "男"  # 增加非私有化属性
print(w04.__dict__)  # {'_Wife02__name': '张三', '_Wife02__age': 30, '_Wife02__sex': '女', 'sex': '男'}
class Wife03():
    # 类的设计者,限制该类对象只能有如下的实例变量
    __slots__ = ("__age","sex")  # 该类只有这两个属性
    def __init__(self,age,sex = ""):
        self.age = age  # 属性
        self.sex = sex  # 实例变量
   @property  # 负责age属性的读取操作 装饰器
    def age(self):
        return self.__age
   @age.setter  # 负责age属性的写入操作
    def age(self,value):
        if 18 <= value <= 100:
            self.__age = value  # 私有化实例变量:在变量名称前,加入双下划线。
        else:
            raise ValueError("年龄不符,请重新创建对象")

w05 = Wife03(30)  # 调用的@age.setter下函数
print(w05.age)  # 调用的@property下函数
w05 = Wife03(20)  # 调用的@age.setter下函数
print(w05.age)  # 调用的@property下函数
# print(w05.__dict__)  # 报错 当定义了__slots__属性之后,Python对象将不再拥有__dict__属性和__weakref__属性
print(w05.__slots__)  # ('__age', 'sex')
print(w05._Wife03__age)
print(dir(w05))  # 属性列表['_Wife03__age', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'age', 'sex']
# 核心思想:分而治之   封装变化
class Person:
    def __init__(self, name):
        self.name = name
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value):
        self.__name = value
    def go_home(self, car):
        print(self.name, end="")
        car.run("家")
class Car:
    def run(self, pos):
        print("移动到" + pos)
zs = Person("张三")
car = Car()
zs.go_home(car)

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Python基于class()实现面向对象原理详解

    首先,类是一个集合,包含了数据,操作描述的一个抽象集合 你可以首先只把类当做一个容器来使用 class Cycle: def __init__(self,r): self.pi=3.14 self.r=r a=Cycle(4) b=Cycle(7) 你看,我们定义了一个 Cycle 类,我们现在只是将它当做一个数据集合来用,我们利用其实例之间彼此数据隔离的特性来保证具体的实例数据彼此不污染.好了你现在想问,为什么我们要用数据集合来放数据 好了,我们来看看没有类之前我们会怎么样,假设我们现在要计算

  • Python面向对象之类的封装操作示例

    本文实例讲述了Python面向对象之类的封装操作.分享给大家供大家参考,具体如下: 承接上一节<Python面向对象之类和实例>,学了Student类的定义及实例化,每个实例都拥有各自的name和score.现在若需要打印一个学生的成绩,可定义函数 print_score() 该函数为类外的函数,如下: class Student(object): def __init__(self, name, score): self.name = name self.score = score May

  • Python面向对象编程之类的封装

    目录 1.封装的理解 2.私有类属性.公开类属性.私有实例属性和公开实例属性 2.1 公开类属性 2.2 私有类属性 2.3 公开实例属性 2.4 私有实例属性 2.5 私有属性不一定真的私有 3.私有方法和公开方法 4.类的保留属性 5.类的保留方法 1.封装的理解 封装(Encapsulation):属性和方法的抽象 属性的抽象:对类的属性(变量)进行定义.隔离和保护 分为私有属性和公开属性: 私有属性:只能在类内部访问 公开属性:可以通过类.对象名访问 可以选择公开或隐藏属性,隐藏属性的内

  • Python面向对象中类(class)的简单理解与用法分析

    本文实例讲述了Python面向对象中类(class)的简单理解与用法.分享给大家供大家参考,具体如下: 我们先来创建一个简单的类 class Fish(object): pass xiaoming = Fish() 一个基础类(base class) Fish(鱼)类就创建好了.class Fish(object)等同于class Fish() caoyu = Fish() 语句创建了一个对象:xiaoming(小明).变量名 = 类名+() 实例化 类 下面对Fish类进行扩充 class F

  • Python面向对象三大特征 封装、继承、多态

    目录 1.封装 1.1 私有属性和私有方法 2.继承 2.1 方法的重写 2.2 在子类方法中调用父类方法 2.3 多继承 2.4 新式类和经典类 3.多态 1.封装 封装: 根据 职责 将 属性 和 方法 封装到一个 抽象的类 中将数据(属性)和行为(方法)包装到类对象中.在方法内部对属性进行操作,在类对象的外部调用方法.这样无需关心方法 内部的具体实现,从而隔离了复杂度 封装是面向对象编程的一大特点 面向对象编程的第一步.将属性和方法封装到一个抽象的类中 外界使用类创建对象,然后让对象调用方

  • Python面向对象程序设计类的封装与继承用法示例

    本文实例讲述了Python面向对象程序设计类的封装与继承用法.分享给大家供大家参考,具体如下: 访问限制(封装) 1.概念 面向对象语言的三大特征:封装, 继承, 多态. 广义的封装: 类和函数的定义本身就是封装的体现. 狭义的封装:一个类的某些属性,不希望外界直接访问,而是把这个属性私有化[只有当前类持有],然后暴露给外界一个访问的方法. 封装的本质:就是属性私有化的过程. 封装的好处:提供了数据的复用性,保证了数据的安全性. 举例:插排 2.使用 class Person(object):

  • Python面向对象的三大特性封装、继承、多态

    Python是一门面向对象的语言.面向对象都有三大特性:封装.继承.多态. 下面分别来说说这三大特性: 1.封装 隐藏对象的属性和实现细节,仅对外提供公共访问方式.在python中用双下划线开头的方式将属性设置成私有的 . 好处: 1. 将变化隔离: 2. 便于使用: 3. 提高复用性: 4. 提高安全性. 2.继承 继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类. 即一个派生类继承基类的字段和方法.继承也允许把一个派

  • python 面向对象之class和封装

    # 封装 # Python并没有真正的私有化支持,但可用下划线得到伪私有 访问私有变量:实例._类名__变量名 访问私有方法:实例._类名__方法名() class Wife02(): def __init__(self,name,age,sex): # 负责对象的初始化 self.set_name(name) self.set_age(age) self.set_sex(sex) def set_name(self,value): if isinstance(value,str): # 数据类

  • Python 面向对象之封装、继承、多态操作实例分析

    本文实例讲述了Python 面向对象之封装.继承.多态操作.分享给大家供大家参考,具体如下: 封装.继承.多态 是面向对象的3大特性 为啥要封装 好处 在使用面向过程编程时,当需要对数据处理时,需要考虑用哪个模板中哪个函数来进行操作,但是当用面向对象编程时,因为已经将数据存储到了这个独立的空间中,这个独立的空间(即对象)中通过一个特殊的变量(class)能够获取到类(模板),而且这个类中的方法是有一定数量的,与此类无关的将不会出现在本类中,因此需要对数据处理时,可以很快速的定位到需要的方法是谁

  • Python面向对象程序设计中类的定义、实例化、封装及私有变量/方法详解

    本文实例讲述了Python面向对象程序设计中类的定义.实例化.封装及私有变量/方法.分享给大家供大家参考,具体如下: 1. 定义类 python中定义一个类的格式如下: class MyClass(object): def __init__(self,data1,data2): self.__data1=data1 self.data2=data2 def __func1(self): print("MyClass类的私有方法被调用!") def print_data(self): s

  • Python面向对象封装操作案例详解

    本文实例讲述了Python面向对象封装操作.分享给大家供大家参考,具体如下: 目标 封装 小明爱跑步 存放家具 01. 封装 封装 是面向对象编程的一大特点 面向对象编程的 第一步 -- 将 属性 和 方法 封装 到一个抽象的 类 中 外界 使用 类 创建 对象,然后 让对象调用方法 对象方法的细节 都被 封装 在 类的内部 02. 小明爱跑步 需求 小明 体重 75.0 公斤 小明每次 跑步 会减肥 0.5 公斤 小明每次 吃东西 体重增加 1 公斤 提示:在 对象的方法内部,是可以 直接访问

  • Python面向对象封装操作案例详解 II

    本文实例讲述了Python面向对象封装操作.分享给大家供大家参考,具体如下: 目标 士兵突击案例 身份运算符 封装 封装 是面向对象编程的一大特点 面向对象编程的 第一步 -- 将 属性 和 方法 封装 到一个抽象的 类 中 外界 使用 类 创建 对象,然后 让对象调用方法 对象方法的细节 都被 封装 在 类的内部 一个对象的 属性 可以是 另外一个类创建的对象 01. 士兵突击 需求 士兵 许三多 有一把 AK47 士兵 可以 开火 枪 能够 发射 子弹 枪 装填 装填子弹 -- 增加子弹数量

随机推荐