7-2 封装和反射

封装

1 【封装是什么】

隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2【好处】

1. 将变化隔离；

2. 便于使用；

3. 提高复用性；

4. 提高安全性；

【封装原则】

1. 将不需要对外提供的内容都隐藏起来；

2. 把属性都隐藏，提供公共方法对其访问。

二私有变量和私有方法

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

三实例

1 私有变量

#私有属性
# class Person():
#     __country='中国'
#     print(__country)
# print(Person.__dict__)
# print(Person._Person__country) # 不能使用这种方式去调用私有的变量
# #私有的名字，只能在类的内部使用，不能在类的外部使用
# Person.__name='XXX' #在类的外部不能定义私有变量
# print(Person.__name)
# print(Person.__dict__)

2私有方法

 1 # 在类的内部 如果使用__变量的形式会发生变形，python会自动的为你加上_类名
 2 # class Person():
 3 #     __country='中国' #私有的静态属性
 4 #     def __init__(self,name,pwd):
 5 #         self.name=name
 6 #         self.__pwd=pwd #私有的对象属性
 7 #     def login(self):
 8 #         print(self.__dict__)
 9 #         if self.name=='alex' and self.__pwd=='alex3714':
10 #             print('登录成功')
11 # alex=Person('alex','alex3714')
12 # alex.login()
13 # print(alex.__dict__)

总结

# 静态属性、对象属性、方法（动态属性）前面加上双下划綫都会变成私有的
# 私有的特点就是只能在类的内部调用，不能在类的外部使用

反射


一 概念

# 什么叫反射
# 通过字符串数据类型的变量名来访问变量的值

2 反射的四种类型

# 类名反射静态属性
# 对象名反射对象属性和方法
# 模块反射模块中的名字
# 反射自己所在文件中的名字
# x.y 这样的形式都可以用反射

3实例

1）类名反射静态属性

 1 # class Person:
 2 #     role='Person'
 3 #     def __init__(self,name):
 4 #         self.name=name
 5 #     def eat(self):print('eating')
 6 #     def drink(self):print('drinking')
 7 #
 8 # alex=Person('alex')
 9 # print(alex.name) #正常的获取
10 # #
11 # # print(getattr(alex,'name')) #利用反射获取 对象反射对象属性
12 # #
13 # # print(getattr(Person,'role')) #类名反射静态属性

2）

1 # 模块 反射 模块中的名字
2 #自己先建个一个py文件即模块 mymodules.py

3 
4 # import mymodules
5 # mymodules.func1()
6 # getattr(mymodules,'func1')() #反射模块中的方法
7 # # print(mymodules.money)
8 # print(getattr(mymodules,'money')) #反射模块中的静态属性

3）

#调用模块中的类方法
# Manager=getattr(mymodules,'Manager')
# a=Manager()
# a.eat()

4）

1 # 反射 自己所在文件中的名字
2 import sys
3 # value='123'
4 # print(sys.modules['__main__']) #打印自己文件所在的路径
5 # print(getattr(sys.modules['__main__'],'value'))

#总结：
# 首先使用getattr取获取一个名字，如果在这个对象的命名空间中没有这个名字会报错
# getattr的反射好伴侣 hasattr
# 如果使用getattr取获取一个方法，那么只能拿到这个方法的内存地址加上括号就是执行，当然，括号里的参数可以照传不误
# 如果getattr获取一个属性，那么直接使用反射就可以获取到值如：print(getattr(alex,'name'))

三 __new__ 构造方法，创建一个对象

1 # class Foo:
2 #     def __new__(cls,*args,**kwargs):#cls是类，因为这时候self还么有
3 #         print('执行我了')
4 #         obj=object.__new__(cls) #这个就是self
5 #         print(obj)
6 #         return obj
7 #     def __init__(self):
8 #         print('2222222',self)
9 # Foo()

#总结
# 先执行new方法，object.new()
# 再执行init

#具体的执行过程
# Foo()  --> python解释器接收到你的python代码
# python解释器替你去做了很多操作
# 包括 主动帮助你 调用 new方法 去创造一个对象 —— 开辟内存空间 —— python语言封装了开辟内存的工作
# object的new方法里 —— 帮你创造了对象
# 调用init用到的self参数 就是new帮你创造的对象