封装，绑定方法与非绑定方法

一：封装

           1，什么是封装：

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

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

            2，为什么要封装？

            封装数据属性的目的

                    首先定义属性的目的就是为了给类外部的使用的，隐藏之后是为了不让外部直接使用，需要类内部开辟一个接口。然后让类外部的使用通过接口来间接地操作隐藏的属性。

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

             封装函数的属性

                      首先定义函数的目的就是为了让类的外部使用的    ，隐藏函数属性是为了不让外部直接使用，需要类内部开辟一个接口，然后在接口内去调用隐藏的功能

                        精髓在于：隔离了复杂度

             3，如何隐藏属性？

                       在属性钱加上__(双下划线）开头

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

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

                       3，这种隐藏是对外不对内的，即在类的内部的可以直接访问，而在类的外部则无法直接访问。原因是：在类的定义阶段，类体内的代码统一发生了一次形变

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

                        # class People:
                        #     __country='China' #_People__country='China'#发生变形
                        #     __n=100 #_People__n=100
                        #     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) #People._People__country#变形
                        #         print(self.__name) #self._People__name#变形
                        # People.eat(123)
                        # print(People.__country)
                        # peo1=People('egon',18,'male')
                        # peo1.eat()
                        # print(peo1.__name)
                        # print(People.__dict__)
                        # print(People.__country)
                        # print(People._People__country)
                        # People.__x=11

                        # print(People.__dict__)

                        # peo1=People('egon',18,'male')
                        # print(peo1.__dict__)
                        # peo1.__x=111

                        # print(peo1.__dict__)

二：绑定方法？

         1，绑定方法：

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

                           精髓在于自动传值

                绑定方法分为两类：

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

                          1.2 绑定给类的方法：

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

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

               3，应用

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

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

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

                # class Foo:
                #     @classmethod
                #     def f1(cls):
                #         print(cls)
                #     def f2(self):
                #         print(self)
                # obj=Foo()
                # print(obj.f2)
                # print(Foo.f1)
                # Foo.f1()
                # print(Foo)
                #1、f1绑定给类的
                # 了解：绑定给类的应该由类来调用，但对象其实也可以使用，只不过自动传入的仍然是类
                # print(Foo.f1)
                # print(obj.f1)
                # Foo.f1()
                # obj.f1()
                #2、f2是绑定给对象的
                # obj.f2()

                # Foo.f2(obj)

              绑定类方法，绑定对象方法，非绑定方法

                import settings
                import uuid
                class Mysql:
                    def __init__(self,ip,port):
                        self.uid=self.create_uid()
                        self.ip=ip
                        self.port=port
                    def tell_info(self):
                        print('%s:%s' %(self.ip,self.port))
                    @classmethod
                    def from_conf(cls):
                        return cls(settings.IP, settings.PORT)
                    @staticmethod
                    def func(x,y):
                        print('不与任何人绑定')
                    @staticmethod
                    def create_uid():
                        return uuid.uuid1()
                # 默认的实例化方式：类名(..)
                obj=Mysql('10.10.0.9',3307)
                # 一种新的实例化方式：从配置文件中读取配置完成实例化
                # obj1=Mysql.from_conf()
                # obj1.tell_info()
                # obj.func(1,2)
                # Mysql.func(3,4)
                # print(obj.func)
                # print(Mysql.func)
                print(obj.uid)