面向对象进阶一

一、利用反射查看面向对象成员归属

反射：以字符串的形式去对象（模块）中操作成员

记住点：

1）反射如果查看对象：可以找对象，也可以找类的成员

2）反射查看类：只能找类的成员

如下代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
    def __init__(self,name):
        self.name = name
    def show(self):
        print("show")
obj = Foo("a")
F = hasattr(obj,"name")
print(F)
F = hasattr(obj,"show")
print(F)
r = hasattr(Foo,"name")
print(r)
F = hasattr(obj,"name")
print(F) 

aa

执行True True False True

二、利用反射导入模块、查找类、创建对象、查找相应的字段

问题：如何去一个模块中调用或者查看成员？

下面就是例子

#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
    def __init__(self,name):
        print("xxx")
        self.name = name
    def show(self):
        print("show")

BB

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#导入模块
m = __import__("BB",fromlist=True)
#利用反射去模块中找类
class_name = getattr(m,"Foo")
#根据类创建对象
obj = class_name("hello")
#根据反射去对象中找到相应的值
val = getattr(obj,"name")
print(val)

CC

上述流程：首先找到m模块，之后找到Foo这个类，创建一个class_name这个对象，然后利用反射找到对应的值

三、静态字段、普通字段、静态方法、类方法、特性

静态字段的意义：将对象中保存的重复的数据存放在类中

静态字段封装的是类的数据

普通字段封装的是对象的数据

所以类调用静态字段

对象调用普通字段

 1 class Provice1:
 2     #静态字段
 3     country = "中国"
 4     #这是对象里面的东西
 5     def __init__(self,name):
 6         #普通字段
 7         self.name = name
 8     def show(self):
 9         print( "show")
10     #类方法：特点参数传递的是类名
11     @classmethod
12     def xxoo(cls):
13         print(‘xxoo‘,cls)
14     #静态方法
15     @staticmethod
16     def xo(arg1,arg2):
17         print("xo")
18 obj = Provice("a")
19 Provice1.xo(1,2)
20 Provice1.xxoo()
21 obj.xo(1,2)

@staticmethod  装饰函数就是静态方法

@classmethod  装饰函数 叫做类方法，类方法中参数必须有cls（cls参数传递的就是类名）

Python的静态方法和类成员方法都可以被类或实例访问，两者概念不容易理清，但还是有区别的：

1）静态方法无需传入self参数，类成员方法需传入代表本类的cls参数；

2）从第1条，静态方法是无法访问实例变量的，而类成员方法也同样无法访问实例变量，但可以访问类变量；

3）静态方法有点像函数工具库的作用，而类成员方法则更接近类似Java面向对象概念中的静态方法。

特性：

1、@property   将方法为造成一种字段

2、和1中的方法名一样的函数名.setter 获取上面的字段，然后修改内存中的数据

那怎么用呢？

下面代码：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 class Provice1:
 4     #静态字段
 5     country = "中国"
 6     #这是对象里面的东西
 7     def __init__(self,name):
 8         #普通字段
 9         self.name = name
10     @property #特性：将方法伪造成一种字段
11     #获取字段
12     def end(self):
13         tmp = "%s sb"%self.name
14         return tmp
15     #设置字段
16     @end.setter
17     def end(self,value):
18         print(value)
19         self.name = value
20 obj = Provice1("a")
21 #获取字段
22 print(obj.end)
23 #设置字段
24 obj.end = "123"
25 print(obj.end)

上面执行顺序：

首先执行end函数，设置end函数为123，也就是把123传入给value，然后执行17行的end函数输出123.sb