封装

原文链接：http://www.meng1.top/%E5%B0%81%E8%A3%85/

私有的

python ：public 公有的​ private 私有的

java完全面向对象的语言​ public 公有的​ protect 保护的​ private 私有的

定义一个私有的名字：就是在私有的名字前面加上两条下划线 __N = "aaa"

所谓私有就是不能在类的外面去引用它

  class A:
      __N = 'aaaa'   #定义一个私有变量
      def func(self)
          print(A.__N)  #在内部引用
  a = A()
  a.func()  #这样才可以在外部打印出全局变量
  print(A._A__N)  #python就是把__名字当成私有变量来定义

一个私有的属性/名字，在存储的过程中任然会出现在A.__dict__中，所以我们还可以调用的到

只不过python对其名字 进行了修改：_类名__名字

只不过在类的外部调用需要“_类名__名字”去使用

在类的内部可以正常使用名字

在类内只要代码遇到双下滑线名字，就会被python解释器自动的转化成 _类名__名字 的方式

私有属性

  class B(object):
      def __init__(self,name):
          self.__name = name
       def func(self):
          print("in func:%s" %self.__name)
  ​
  b = B()
  print(b._B__name)
  b.func()

 

私有方法

 class C:
      def __func(self):
  c = C()
  c._f__func()

 

在类中，静态属性，方法，对象属性都可以变成私有的，需要在这些名字之前加上__

 class D:
      def __func(self):
          print("in func")    #"_D__func()"
  class E(D):
      def __init__(self):
          self.__func()   #‘_E__func()’
          
  e = E()#__func不能被调用
  #私有的名字不能被子类继承
  
  class F:
      def __init__(self):
          self.__func()
      def __func(self):
          print("in func F")
  class G(F):     
      def __func(self):
          print("in func G")
          
  g = G()
  输出结果：in func F

 

私有的名字在类内中使用的时候，就是会变成_该类名__方法名

以此为例，没有双下划线会先找E中的__func

但是有了双下划线，会在调用这个名字的类D中直接找_D__func

 class F:pass
  F.__name = "kuoiea"
  print(F.__name)
  ​
  输出内容为：kuoiea
  #变形只会在在类的内部发生不会在类的外部发生

 

于Java中的对比：

public 公有的 在类的内部可以使用，子类可以使用，外部可以使用 python中所有正常的名字

protect 保护的 在类的内部可以调用，子类可以使用，外部不可以使用 python中没有

private 私有的 只能在类的内部使用，子类的外部都不可以使用 python中的 __名字

私有的用法：

当一个方法不想被子类继承的时候

当有些属性或方法不希望从外部被调用，只想提供给内部的方法使用

 

#property

property：是一种特殊的属性，访问它时就会执行一段功能(函数)然后返回值。

class Foo(object):
    @property
    def func(self):
        print("hello")

f = Foo()
f.func
这样可以像调用一个对象一样，也可以调用这个方法

将一个方法伪装成一个属性：​ 这样并不会让你的代码上有什么逻辑上的提高​ 只是从调用者的角度上换了一种方式，使之看起来更合理

@func.setter--->func 对伪装的属性进行赋值的时候调用这个方法，一般情况下用来修改

class Googs(object):
    def __init__(self,name,price,discount):
        self.name = name
        self.__price = price
        self.__discount = discount
    @propetry
    def discount_price(self):
        return self.__price *self.__discount

    @discount_price.setter
    def discount_price(self,new_price):
        self.__price = new_price



g = Googs("裤子",2000,0.8)
g.discount_price = 500   #这块调用的说discount_price.setter这块的代码，给self.__price重新进行赋值
print(g.discount_price)  #这里调用的是@property之下的代码，执行运算操作

 

@func.deleter--->func 需要对伪装的属性进行删除操作的时候调用这个方法，一般情况下用来删除

class A(object):
    @property
    def name(self):
        print("A")
    @name.deleter
    def name(self):
        print("被删除了")


a = A()
del a.name  #如果我们不给函数加上装饰器@name.deleter，那么del方法是不能对这个函数进行删除的，只有我们对这个方法加上装饰器，del方法才会有作用

 

将一些需要随着一部分属性的变化而变化的值的计算过程 从方法伪装成属性

将私有的属性保护起来，让修改的部分保护起来，让修改的部分增加一些约束，来提高程序的稳定性和数据的安全性

#classmethod

class A(object):
    __N = 11

    @classmethod
    def n(self):
        self.__N = 12
        return self.__N


print(A.n())#如果不加上@classmethod这个装饰器的话，类是不能直接调用这个函数，来对__N改名的

 

类方法，可以直接被类调用 不需要默认传对象参数 只需要传一个参数就可以

#staticmethod

当一个方法要使用对象的属性时，就使用普通的方法当一个方法要使用类中的静态属性时，就使用类的方法当一个方法即不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法