概念

广义的封装：函数和类的定义本身，就是封装的体现

狭义的封装【在面向对象中的封装】：一个类的某些属性，在使用的过程中，如果不希望被外界直接访问，就可以将该属性作为私有的【private，只有当前类持有】，然后暴露给外界一个访问的函数即可【间接的访问属性】

封装的本质：就是属性的私有化

封装的好处：提高了数据的安全性，提高了数据的复用性

举例说明：插排【不需要关心属性在类的内部做了什么样的操作，只需要关心将值传进去，将结果取出来】

 属性私有化

如果想要属性不能被外界直接访问，则可以在属性的前面添加两个下划线__，此时称该属性为私有属性【私有成员变量】

私有属性的特点：只能在类的内部被直接访问，在外界不能直接访问

属性不被私有化情况：

#1.属性不私有化的时候
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def myPrint(self):
        print(self.name,self.age)
#创建对象
p = Person("lisi",10)
#通过对象.属性，访问属性
print(p.name,p.age)     #lisi 10

#通过对象.成员函数，调用函数
p.myPrint()     #lisi 10

#通过对象直接访问属性，并给属性赋值
p.name = "jack"
print(p.name)    #jack

属性被私有化情况：

#2.属性私有化的时候，需要在被私有化的属性前面加__
class Person1():
    def __init__(self,name,age):
        self.name = name
        self.__age = age          #私有化属性

    def myPrint(self):
        print(self.name,self.__age)      #私有化属性，在类的内部可以直接访问私有化属性

p1 = Person1("aaa",5)
print(p1.name)     #aaa

p1.myPrint()     #aaa 5

p1.name = "jack"
print(p1.name)    #jack  

注意：

1. 属性被私有化之后，将不能再直接访问
2. 在类的外部，不能通过对象直接访问属性
3. 属性的动态绑定，age和__age其实属于不同的两个变量，所以重新创建一个对象，该对象仍然不能直接访问__age

 get函数和set函数

get函数和set函数并不是系统内置的函数，而是自定义的，为了和封装的概念相吻合，命名为getXxx（）和setXxx（）

get函数：获取值【p.name】

set函数：赋值【p.name=值】

说明：getXxx（）和setXxx（）中Xxx代表的是被私有化的属性的名称

语法：

get函数：def getXxx（self）：

                       return 私有化属性

set函数：def setXxx（self，私有化属性的名称）：

                       私有化属性 = 私有化属性的名称

  @property装饰器

作用：可以给函数动态的添加新的功能，对于类的成员函数，装饰器同样起作用

Python的内置装饰器@property的作用：将一个函数转换为属性进行使用【简化get函数和set函数】

使用：@property装饰器的作用相当于get函数，同时，会自动生成一个新的装饰器

           @属性名.setter相当于set函数

注意：使用在类的成员函数中，可以简化代码，同时保证对参数的校验

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print("构造函数被调用")        
    def myPrint(self):
        #在类的内部可以访问私有化属性
        print(self.name,self.__age)
    #注意：函数的命名方式：被私有化的属性的名称，举例self.__age--->age
    #函数的命名并不是固定的，只要是一个合法的标识符即可，但是，一般情况下，使用变量名命名，方便区分
    #相当于get函数，设置返回值，将被私有化的属性值返回
    @property
    def age(self):
        return self.__age
    #注意：函数的命名方式：和@property作用的函数名保持一致，装饰器的命名方式：@属性名.setter
    #相当于是set函数，设置参数，给私有化属性进行赋值
    @age.setter
    def age(self,age):
        if age < 0:
            age = 0
        self.__age = age
        print(self.__age)
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,name):
        self.__name = name
        print(self.__name)

P = Person("jack",4)    #jack
                        #4

@property本质：将函数在转换为属性使用

获取值：print(P.age)             #相当于调用了get函数【@property修饰的函数】，将被私有化的属性的值返回。

设置：P.age = 12       print(P.age)           #相当于调用了set函数【@age.setter修饰的函数】，将12作为参数传值。

 属性的不同形式

属性私有化工作原理：

class Person5():
    def __init__(self,name,age):
        self.name = name
        self.__age = age   #私有化属性
        
    def myPrint(self):
        print(self.name,self.__age)
        
per = Person5("jack",55)
#per.__age:Python解释器将__age变成了Person5__age
#可以通过对象._Person5__age去访问，但不建议使用，不同的解释器可能存在解释的斌量不一致
print(per._Person5__age)


class Person6():
  def __init__(self,name,age,height):
        self._name = name    #在变量的前面添加一个下划线，属于特殊变量，则认为该变量受保护的
        #特点：在类的外面也可以直接访问，但不建议使用
        self.__age = age
        self.__height__ = height  #在变量的前后各添加两个下划线，属于特殊变量，一般认为这种变量都是系统的内置变量或者内置函数
        #【__name__、__init__、__del__】
        #特点：在类的外面也可以直接访问，但不建议使用
p = Person6("tom",10,5.0)
print(p._name)
print(p.__height__)

说明：

xxx：普通变量

_xxx：受保护的变量，自定义变量不建议使用

__xxx：私有变量，在外界不能直接被访问

__xxx__：系统的内置变量，自定义变量不建议使用

 私有函数（类中的成员函数也可以被私有化）

写法：在函数名的前面添加两个下划线【函数名就是一个变量名】，此时，该函数被称为私有函数

特点：只能在当前类中被直接调用

#私有函数
class Site():
    def __init__(self,name):
        self.name = name

    def func(self):
        print("这是一个普通【公共】函数")

        #在公共函数中将私有函数调用，调用格式：self.__私有的函数名称（参数列表）
        self.__func1()

    def __func1(self):
        print("这是一个私有函数")
s = Site("临潼")
s.func()