首页 > 代码库 > 面向对象进阶

面向对象进阶

2024-09-17 13:43:01   208人阅读

成员

      类，对象=》静态字段，静态方法，普通字段，普通方法

      通过类访问有：静态字段，静态方法

      通过对象访问：普通字段，普通方法

成员修饰符

面向对象中一些常用特殊方法  __init__     __call__     __delitem__

 

反射查找类的成员

 1 #-*- coding:utf-8 -*-
 2 class abc(object):
 3    def __init__(self,name):
 4        self.name=name
 5    def a1(self):
 6        pass
 7 
 8 
 9 
10 f1=abc.__dict__
11 #查看类中方法
12 #print(f1)
13 
14 #反射：找类中的方法，__init__和a1
15 print(hasattr(abc,‘a1‘))
16 
17 #反射：对象，既可以找对象还可以找类中的方法
18 f1=abc(‘zhangs‘)
19 print(hasattr(f1,‘name‘))
20 print(hasattr(f1,‘a1‘))

 

反射：

反射导入模块，在找类然后初始化对象，最后根据对象知道对应的方法

技术分享 
 1 #-*- coding:utf-8 -*-
 2 
 3 #导入模块
 4 f1=__import__(‘f2‘,fromlist=True)
 5 
 6 #获取f1的类
 7 class_name=getattr(f1,‘F1‘)
 8 
 9 #创建对象
10 obj=class_name("zhangs")
11 
12 #获取对象中的方法
13 result=getattr(obj,‘name‘)
14 print(result)
15 
16 
17 结果：
18 zhangs
反射模块

 

 

类静态字段

 1 #-*- coding:utf-8 -*-
 2 
 3 class F1(object):
       #类静态字段
 4     country = ‘中国‘
 5     def __init__(self,name):
 6         #对象方法
 7         self.name=name
 8         #self.country="中国"  这样写的缺点就是浪费内存，每一个对象都会有这个这个属性
 9     def fun(self):
10         pass
11 
12 a1=F1("黑龙江")
13 a2=F1("湖北")
14 a3=F1("湖南")

其实带self定义的就是对象方法，每生成一个对象都会有这个方法

 

 

类静态方法

staticmethod

技术分享 
 1 class F1(object):
 2 
 3     def __init__(self):
 4         pass
 5     #静态方法必须加这个装饰器
 6     @staticmethod
 7     def static_func(x):
 8         print(x)
 9 
10 a1=F1()
11 #通过对象访问类的静态方法，原则上尽量不使用。要想使用也是用类的方法去访问
12 a1.static_func(1)
13 #通过类访问静态方法
14 F1.static_func(12)
静态方法

实际静态方法的意思

 

类方法

技术分享 
 1 #-*- coding:utf-8 -*-
 2 
 3 class F1(object):
 4 
 5     def __init__(self):
 6         pass
 7     #静态方法必须加这个装饰器
 8     @staticmethod
 9     def static_func(x):
10         print(x)
11 
12     #类方法会自动加一个类名，必须定义cls
13     @classmethod
14     def classfunc(cls):
15         print(cls)
16 
17 F1.classfunc()
18 
19 结果:
20 <class ‘__main__.F1‘>
类方法

类方法比静态方法多一个功能就是传递一个类名

 

面向对象进阶


联系
我们