1、封装

（1）什么是封装？

封：属性对外是隐藏的，但对内是开放的；

装：申请一个名称空间，往里面装入一系列名字/属性

（2）为什么要封装？

封装数据属性的目的

首先定义属性的目的就是为了给类外部的使用者使用的

隐藏之后是为了不让外部使用直接使用，需要类内部开辟一个接口

然后让类外部的使用通过接口来间接的操作隐蔽的属性

精髓在于：我们可以在接口之上附加任意逻辑，从而严格严格控制使用者对属性的操作；

封装函数属性

首先定义属性的目的就是为了给类外部的使用使用的

隐藏函数属性是为了让使用者不直接使用，在类内部开辟一个接口，在接口内部调用隐蔽的功能

精髓在于：隔离了复杂度

（3）如何封装

如何隐藏：在属性前加上__开头

1、这种隐藏仅仅只是一种语法上的变形操作；

2、这种语法上的变形只是在类定义阶段发生一次，因为类体代码仅仅只在类定义阶段检测一次；

3、这种隐藏是对外不对内的，即在类的内部可以直接访问

，而在类的外部则无法直接访问，原因是在类定义阶段，类体代码统一发生了一次变形

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

如何隐藏
# class people:
#     __country= 'china' # 在要隐藏的属性前加上__
#     def __init__(self,name,age,sex):
#         self.__name= name  #在定义阶段代码发生了变形 self._people__name= name
#         self .age= age
#         self .sex= sex
#
#     def eat(self):
#         print('eat....')
#         print(people .__country )  #在类内部可以访问

# peo= people('egon',18,'male')
#people .__country #在类外部无法访问
# print(people.__dict__ )
#隐藏的原理：在类定义阶段属性名__country 变成了_people__country
# print(people._people__country) #这样是可以访问到隐藏后的属性的

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

class Foo:
    def __f1(self): #_Foo_f1
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self .__f1()  #self._Foo_f1

class Bar(Foo):
    def __f1(self):  #_Bar_f1
        print('Bar.f1')
#print(Bar.mro())
obj = Bar()
obj.f2()

2、Property 装饰器

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

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

    @property  #伪装成数据属性查看
    def name(self):
        return self .__name

    @name.setter    #在原来函数name上进行修改操作
    def name(self,name):
        if type(name) is not str:
            print('名字必须是str类型')
        self .__name= name  #把原来的属性self.__name改成name

    @name.deleter   #删去操作
    def name(self):
        #print('不让删')
        del  self.__name

peo= people ('qqc') #建对象

# print(peo.name)  #查看
peo.name= 'QQC'  #修改操作
print(peo.name)
# del peo.name   #删除操作
# print(peo.__dict__ )

3、绑定方法与非绑定方法

（1）绑定方法

特性：绑定给谁就应该由谁来调用，谁里啊调用就会将谁当做第一个参数自定传入

注：自动传值

绑定方法分为两类：

1.1 绑定给对象的方法

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

1.2 绑定给类的方法

在类内部定义的函数如果被装饰器@classmethod装饰，

那么则是绑定给类的，应该由类来调用，类来调用就自动将类当做第一个参数自动传入

（2）非绑定方法

类中定义的函数如果被装饰器@staticmethod装饰，那么该函数就变成非绑定方法

即不与类绑定，又不与对象绑定，意味着类与对象都可以来调用

但是无论谁来调用，都没有任何自动传值的效果，就是一个普通函数

应用：

函数体代码需要用外部传入的类，则应该将该函数定义成绑定给类的方法；

函数体代码需要用外部传入的对象，则应该将该函数定义成绑定给对象的方法；

如果函数体代码即不需要外部传入的类也不需要外部传入的对象，则应该将该函数定义成非绑定方法/普通函数

#绑定方法
class Foo:
    @classmethod
    def f1(cls):
        print(cls)
    def f2(self):
        print(self)

obj = Foo()
# print(obj.f2)
#1、f1是绑定给类的，应该由类来调用，但其实对象也可以调用,但自动传入的参数仍然是类
# Foo.f1()
#2、f2是绑定给对象的
# obj.f2()

例子：从配置文件中实例化

import settings
class mysql:
    def __init__(self,ip,port):
        self.ip= ip
        self.port= port

    def tell_info(self):
        print(self.ip ,self .port)

    @classmethod
    def from_conf(cls):  #与类绑定，自动传入类
       return  mysql(settings.IP,settings.PORT)

    @staticmethod   #非绑定方法，无自动传值
    def func():
        print('不与任何人绑定')

#默认实例化方式：类名（。。。）
obj= mysql('10.10.0.9',3307)

#一种新的实例化方式，从配置文件中读取配置完成实例化
obj1= mysql.from_conf()
obj1.tell_info()
obj1.func()