day 23 封装之如何隐藏、封装之隐藏属性的底层原理、封装的真正意义、property特性、绑定方法与非绑定方法

1、什么是封装

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

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

为什么要封装

　　封装数据属性的目的，首先定义属性的目的就是为了给类外部的使用而使用的。

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

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

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

封装函数属性

　　首先定义函数的目的就是为了给类的外部来使用，

　　隐藏函数属性是为了不让外部直接使用，需要类内部开辟一个借口

　　然后再接口内去调用隐藏的功能

　　精髓在于:隔离了复杂度

#如何隐藏?:在属性前加上__开头
#这种隐藏是对外不对内的，即在类的内部可以直接访问，而在类的外部无法直接访问
class people:#只有装的概念没有封的概念
    __country='china'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def eat(self):
        print('eat...')
        print(people.__country)
# print(people.eat(123))
#如何隐藏一个属性，对外隐藏对内开放？

# people.eat(123)#对内是开放的
# print(people.__country) #对外是封闭的
peo1=people('egon',18,'male')
peo1.eat()
# print(peo1.name) 

封装之隐藏属性的底层原理

class people:
    __country='china'
    __n=100
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def eat(self):
        print('eat...')
        print(people.__country)
        print(self.__name)

print(people.__dict__)
#print(people._people__country) 属性名变成了__people__country

'''
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__)

# 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')
#
# obj=Bar()
# obj.f2()

 函数的封装

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

封装的真正意义

pass

property特性

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

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property #把bim技能伪装成特征
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)      #原本print(peo1.bmi())

 详细理解的地方

property装饰器用于将被装饰的方法伪装成一个数据属性，在使用时可以不用加括号而直接引用
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

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

peo1=People('egon',75,1.8)

peo1.height=1.85
print(peo1.bmi)


#关于改技能的属性
'''
class People:
    def __init__(self,name):
        self.__name=name

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

    @name.setter #修改obj.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):
        # raise PermissionError('不让删')
        print('不让删除傻叉')
        # del self.__name

peo1=People('egon')
# print(peo1.name)

# print(peo1.name)

# peo1.name='EGON'
# print(peo1.name)

del peo1.name

'''


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


    def tell_name(self):
        return '<名字是：%s>' %self.__name

    def set_name(self,name):
        if type(name) is not str:
            raise TypeError('名字必须是str类型傻叉')
        self.__name=name

    def del_name(self):
        print('不让删除傻叉')

    name=property(tell_name,set_name,del_name)


peo1=People('egon')

print(peo1.name)
peo1.name='EGON'
print(peo1.name)
del peo1.name

定位到属性操作三个点，查看 修改 删除

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

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

    @name.setter #修改obj.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):
        # raise PermissionError('不让删')
        print('不让删除傻叉')
        # del self.__name

peo1=People('egon')
# print(peo1.name)

# print(peo1.name)

# peo1.name='EGON'
# print(peo1.name)

del peo1.name

　　

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

    绑定方法分为两类:
        1.1 绑定给对象方法
            在类内部定义的函数（没有被任何装饰器修饰的），默认就是绑定给对象用的
        1.2 绑定给类的方法：
            在类内部定义的函数如果被装饰器@classmethod装饰，
            那么则是绑定给类的，应该由类来调用，类来调用就自动将类当作第一个参数自动传入



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

非绑定方法其实就是一个函数


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


'''

class Foo:
    @classmethod
    def f1(cls):  #绑定给类的
        print(cls)

    def f2(self):#b绑定给对象的
        print(self)


obj=Foo()
# print(obj.f2)#绑定给对象
# print(Foo.f1)#绑定给类的   不加@classmethod就是访问一个普通的函数

#绑定一共分为两类，一类是绑定给类的，一类是绑定给对象的

# Foo.f1()
# print(Foo)


# 1、f1绑定给类的
# 了解：绑定给类的应该由类来调用，但对象其实也可以使用，只不过自动传入的仍然是类
# print(Foo.f1)
# print(obj.f1)
# Foo.f1()
# obj.f1()
#
# 2、f2是绑定给对象的
# obj.f2()
# Foo.f2(obj)
#
import setting
# 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)

视频最后有老师总结