Python封装与隐藏

 

今日内容：

1.封装与隐藏
2.property
3.绑定方法与非绑定方法

知识点一：封装与隐藏

　　

　　1、什么封装：
  　　　　封：属性对外是隐藏的，但对内是开放的
  　　　　装：申请一个名称空间，往里装入一系列名字/属性

 　   2、为什么要封装：
  　　　封装数据属性的目的
   　　　　首先定义属性的目的就是为了给类外部的使用者使用的，
   　　　　隐藏之后是为了不让外部使用者直接使用，需要类内部开辟一个接口
   　　　　然后让类外部的使用通过接口来间接地操作隐藏的属性。
   　　　　精髓在于：我们可以在接口之上附加任意逻辑，从而严格控制使用者对属性的操作

  　　　封装函数属性：
   　　　　首先定义属性的目的就是为了给类外部的使用使用的，
   　　　　隐藏函数属性是为了不让外不直接使用，需要类内部开辟一个接口
   　　　　然后在接口内去调用隐藏的功能
   　　精髓在于：隔离了复杂度

　　3、如何隐藏：

　　　　1、 这种隐藏仅仅只是一种语法上的变形操作
 　　　  2、 这种语法上的变形只在类定义阶段发生一次，因为类体代码仅仅只在类定义阶段检测一次
 　　　  3、 这种隐藏是对外不对内的，即在类的内部可以直接访问，而在类的外则无法直接访问，原因是
     　　　　在类定义阶段，类体内代码统一发生了一次变形

 　　　  4、 如果不想让子类的方法覆盖父类的，可以将该方法名前加一个__开头

 

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

    def tell_info(self):
        print('%s:%s' %(self.__name,self.__age))

    def set_info(self,name,age):
        if type(name) is not str:
            # print('用户名必须为str类型')
            # return
            raise TypeError('用户名必须为str类型')

        if type(age) is not int:
            # print('年龄必须为int类型')
            # return
            raise TypeError('年龄必须为int类型')
        self.__name=name
        self.__age=age

peo1=People('张三',34)
# peo1.name=123
# peo1.age
peo1.tell_info()

peo1.set_info('李四',19)
peo1.tell_info()

 

 知识点二：property装饰

　　property装饰器用于将被装饰的方法伪装成一个数据属性，
　　在使用时可以不用加括号而直接引用

》》》@propertyde思路演变的过程
版本1：正常版本
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    def bmi(self):
        return self.weight / (self.height**2)

peo=People('张三',130,1.65)
print(peo.name)   #张三
print(peo.bmi())   #47.75022956841139

问题：发现bmi的访问方式比访问对象属性多了个（）
思路变化1：正常情况下我们访问对象里面属性和类里面的函数方式为：
思路变化2：为了方便用户调用，能不能让用户已访问对象属性的方式去访问bmi print（peo.bmi）

》》》》》》版本2：@property初始版本
#思考：如何实现改变访问bmi的方式为》》》print(peo.bmi)
#      使用@property:作用是将本装饰的方法伪装成一个数据类型，在使用时可以不用加括号而直接使用

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

    @property        #将bmi伪装成一个数据类型
    def bmi(self):
        return self.weight / (self.height**2)

peo=People('张三',130,1.65)
print(peo.name)   #张三
print(peo.bmi)    #这样可以直接调用而不用加括号

 

》》》》》完整版：@property
#property装饰器
#是一种封装思想的体现，方便了查 删 改

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

    @property
    def name(self):            #查看obj.name
        return '名字是：%s'%self.__name

    @name.setter              #更改obj.name=name
    def name(self,name):
        if type(name) is not str:
            raise TypeError('名字必须是str类型')
        self.__name=name
    @name.deleter           #删除 del obj.name
    def name(self):
        print('不让删除')  #里面可以设定提示
        # del self.__name      #也可以设定直接删除功能

peo=people('张三')
#默认不加@property调用方法为:

peo.name='李四'  #@name.setter 调用了更改
print(peo.name)    #@property 调用了查看                  输出结果：名字是：李四
del peo.name       #@name.deleter  调用了产出的需求       输出结果：不让删除

 

知识点三：绑定方法

　　1.绑定方法
　　　　特性：绑定给谁就应该由谁来调用，谁来调用就会将谁当做第一个参数自动传入
　　　　精髓：是在于自动传值

　　　　　　1.1绑定对象的方法
　　　　　　　　在类内部定义的函数（没有被任何装饰器修饰的），默认是绑定给对象用的

　　　　　　1.2绑定给类的方法
　　　　　　　　在类内部定义的函数如果被装饰器@classmethod装饰，
　　　　　　　　那么则是绑定给类的，应该由类来调用，类来调用就自动将类当做第一个参数自动传入

　　　　绑定给类的：自动传的是类的值
　　　　绑定给对象的：自动传的是对象的值

　　2.非绑定方法

　　　　类中定义的函数如果被装饰器@staticmethod装饰，那么该函数就变成非绑定方法
　　　　既不与类绑定，又不与对象绑定，意味着类与对象都可以来调用
　　　　但是无论谁来调用，都没有任何自动化传值的效果，就是一个普通函数

　　

　　3.应用
　　　　什么时候绑定给类？ 什么时候绑定给对象？
　　　　取决于函数体代码
　　　　如果函数体代码需要用外部传入的类，则应该将该函数定义成绑定类的方法
　　　　如果函数体代码需要用外部传入的对象，则应该将该函数定义成绑定给对象的方法
　　　　如果函数体代码既不需要外部传入的类也不需要外部传入的对象，则应该将该函数定义成非绑定方法对象，则应该将该函数定义成非绑定方法

　　

#绑定方法初始实例：绑定给类@classmethod

class Foo:
    @classmethod
    def f1(cls):
        print('Foo.f1')
        print(cls)

    def f2(self):
        print(self)
obj=Foo()
# print(obj.f2)   #默认绑定给对象用#<bound method Foo.f2 of <__main__.Foo object at 0x04BACD10>>
# print(Foo.f1)   #绑定给类用 <bound method Foo.f1 of <class '__main__.Foo'>>
Foo.f1()     #类调用
print(Foo)   #所以传入的值就是类的值 <class '__main__.Foo'>

obj.f2()    #对象调用，
print(obj)  #所以传入的值就是对象的值 <__main__.Foo object at 0x04C50EB0>

# f1绑定给类的应该由类来调用，但对象其实也可以使用，只不过自动传入的任然是类
#f2绑定给对象的应该由对象来调用，但是类其实也可以使用

 

 

# 绑定方法进阶实例2：新的实例化方式，绑定给类
"""
将需要传入的信息写到settings.py文件里面，调用更加灵活方便
IP='192.168.11.3'
PORT=3306
"""
import settings

class Mysql:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port
    def tell_info(self):
        print('%s:%s'%(self.ip,self.port))
        # print(self)

    @classmethod
    def from_conf(cls):
        return cls(settings.IP,settings.PORT) #可以理解为 Mysql('1.1.1.1',23)即调用了init方法，给其传参数 cls名字可以随便起
    # print(settings.IP)

#默认的实例化方式：类名（..）（实质给tell_info(self)里的self传的是对象res的值）
res=Mysql('1.1.1.1',23)
print(res)  #<__main__.Mysql object at 0x05717410>即为对象res也就是tell_info(self)的值
res.tell_info()

# 一种新的实例化方式，从配置文件中读取配置完成实例化（这里实质给cls传的是类Mysql的值）
res=Mysql.from_conf()
res.tell_info()
print(res.ip)

 

 非绑定方法应用实例：

#非绑定方法应用实例：uuid获取随机id值

import uuid
class UserInfo:
    def __init__(self,name,age):

        self.name=name
        self.age=age
        self.uid = self.create_uid()
    def tell_info(self):
        print('姓名:%s,年龄：%s,ID:%s'%(self.name,self.age,self.uid))
        # print(self)

    @staticmethod          #因为不需要传任何参数所以定义为非绑定方法，类和对象都可以取调用
    def create_uid():
        return uuid.uuid1()

res=UserInfo('张三',23,)
res.tell_info()
print(res.uid)