Python 私有化属性

#   对象的基本理论
#   什么事对象？
#   万物皆对象
#       对象是具体物体
#                       拥有属性
#                       拥有行为
#                       把很多零散的东西，封装成为一个整体
#       举例：王二小
#                   属性
#                           姓名
#                           年龄
#                           身高
#                           体重
#                   行为
#                           走路
#                           吃饭
#                           放羊
#       Python中的体现
#                      是一门特别彻底的面向对象编程(OOP)的语言
#                                                               其他语言:基本数据类型，对象类型
#                                                               python全部类型都是对象类型
#   面向对象是面向过程的封装
#   对象和类的关系：对象 可以抽象为类 类可以实例化为对象

class Money:
    pass

print(Money)    #<class '__main__.Money'>
one = Money()
print(one, type(one))   #<__main__.Money object at 0x030CFBB0> <class '__main__.Money'>

class Person:
    pass

#   对象的操作：增
p = Person()
#   查看对象的所有属性
print(p.__dict__)   #{}
p.age = 18
p.height = 180
print(p.__dict__)   #{'age': 18, 'height': 180}

#   对象的操作：删
del p.age

#   对象的操作：改
p.height = 185  #   对象里面如果有这个属性，就是修改，否则就是增加这个属性

#   类里面的 __dict__ 不可以修改，只读的
#   对象里的 __dict__ 可以修改
class Test:
    age = 18

#Test.__dict__["age"] = 20   #TypeError: 'mappingproxy' object does not support item assignment

one = Test()

one.__dict__ = {"name":"abc", "height":180} #就是说__dict__字典里面生存储属性的变量
print(one.__dict__)     #{'name': 'abc', 'height': 180}

#   理解下面的内容
class Person:
    age = 10

p = Person()

print(Person.age) #
print(p.age)      #

p.age += 5 #    p.age = p.age + 5
#   要理解这个在对象和类的操作方法：首先是计算右边的值，p.age 在对象p中没有，所以他要到类中去取age = 10
#   然后变成10+5 = 15, 然后在p对象中新增加个age属性（以前说过，对象没有就是新增，有的话就是修改)

print(Person.age) #
print(p.age)      #

#   __slot__
class Person:
    __slots__ = {"age"} #只可以加入age的属性

p1 = Person()
p1.age = 18
print(p1.age)

#   方法：实例方法，类方法，静态方法

class Person:
    def eat(self):
        print("这是个实例方法", self)

    @classmethod
    def eat2(cls):
        print("这是个类方法", cls)

    @staticmethod
    def eat3():
        print("这是个静态方法")

p = Person()
print(p)
p.eat()
p.eat2()
p.eat3()
# <__main__.Person object at 0x032F54F0>
# 这是个实例方法 <__main__.Person object at 0x032F54F0>
# 这是个类方法 <class '__main__.Person'>
# 这是个静态方法
print("-" * 30)
#另外的调用方式：
Person.eat("")  #这里必须要有个参数，才能调用成功
Person.eat2()
Person.eat3()

print("-" * 30)
#   实例方法，类方法，静态方法的访问权限问题（包括类属性，实例属性）
class Person:
    age = 10
    #   实例方法
    def shilie(self):
        print(self)
        print(self.age)
        print(self.num)

    #   类方法
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
        print(cls.num)  #   不可以使用实例属性

    #   静态方法
    @staticmethod
    def jingtai():
        print(Person.age)   #   能使用类里面的属性，但很少这样去调用的

p = Person()
p.num = 11

p.shilie()  #   实例方法：可以调用实例属性和类属性
#p.leifangfa()   #   类方法：不可以使用实例属性
p.jingtai() #   静态方法：可以使用类属性，不可以使用实例属性

#   元类
num = 123
str = "abc"
print(num.__class__.__class__)  #   <class 'type'>
print(str.__class__.__class__)  #   <class 'type'>
print(Person.__class__)         #   <class 'type'>
print(Person.__class__.__class__)#   <class 'type'>
print(p.__class__.__class__)    #   <class 'type'>

#   ----------------------------另外一种创建类的方式-------------------------
def run(self):
    print(self)

dog = type("Dog",(),{"name":"abc","run":run}) #字典里面可以是类属性，或者类方法
print(dog.name) #abc
print(dog.run)  #<function run at 0x02B56C90>

#   ---------------------------类的创建流程----------------------------------

class Animal:
    # __metaclass__ = xxx
    pass

class Person(Animal):
    # __metaclass__ = xxx
    pass

#   -------------------------类的描述, pydoc 模块---------------------------------------
class Person:
    """
    关于类的描述，类的左右，类的构造函数
    Attribute:
        属性的描述
    """
    def run(self, distence, step):
        """
        函数的作用
        :param distence:参数含义，数据类型，默认值
        :param step:
        :return:    返回值类型
        """
        return distence / step

#   help(Person) #  可以这样看帮助文档

#   ------------------------    私有化属性（类的内部，子类内部，模块内部，模块外部）4大块   -------

class Animal:
    x = 10
    _y = 20
    __z = 30
    def test(self):
        print(Animal.x)
        print(self.x)
        print(Animal._y)
        print(self._y)
        print(Animal.__z)
        print(self.__z)
        print("-" * 30)

class Dog(Animal):
    def test2(self):
        print(Dog.x)
        print(self.x)
        print(Dog._y)
        print(self._y)
        # print(Dog.__z)  #   错误
        # print(self.__z) #   错误
        print("-" * 30)

#   类的内部访问
a = Animal()
a.test()    #   成功打印x

#   子类的内部访问
d = Dog()
d.test2()   #   成功打印x

#   模块内部访问
# print(Animal.x) #   成功打印x
# print(Dog.x)    #   成功打印x
# print(a.x)      #   成功打印x
# print(d.x)      #   成功打印x
#   print(a.__z)    #   有错误
#
# print(Animal._y) #   成功打印_y，但有警告
# print(Dog._y)    #   成功打印_y，但有警告
# print(a._y)      #   成功打印_y，但有警告
# print(d._y)      #   成功打印_y，但有警告
# print(a.__z)      #   有错误
# print(d.__z)      #   有错误

print(Animal.__dict__)
print(Animal._Animal__z)    #  伪私有 30
#   模块外的访问
import public
print(public.num)   #   成功打印num
print(public._num2)

#   另外一种模块导入方法
from public import *
#   直接写public 模块中的变量
print(num)          #   成功打印num
#   print(_num2)    #   有错误