成员
类，对象=》静态字段，静态方法，普通字段，普通方法
通过类访问有：静态字段，静态方法
通过对象访问：普通字段，普通方法
成员修饰符
面向对象中一些常用特殊方法 __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)
静态方法和函数差不多，直接调用。不愿意写函数的就是用这个方法。这个方法在c#或java 中就可以实现函数的方式
类方法classmethod
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'>
类方法比静态方法多一个功能就是传递一个类名
特性property
1 #-*- coding:utf-8 -*- 2 3 class F1(object): 4 #普通方法 5 def s1(self): 6 print("s1") 7 8 @property 9 def s2(self): 10 print("s2") 11 12 obj1=F1() 13 #执行普通方法 14 obj1.s1() 15 #执行特性方法，特性方法不需要写()，但是也无法加参数 16 obj1.s2
将方法伪造成字段
给property赋值方法，property中还是很少用到的知道就好了
1 #-*- coding:utf-8 -*- 2 3 class F1(object): 4 @property 5 def s2(self): 6 print("s2") 7 #给特性方法赋值就必须这么写，下面的方法名必须和上面一样 8 @s2.setter 9 def s2(self,value): 10 print(value) 11 obj1=F1() 12 #执行特性方法 13 obj1.s2 14 #给特性方法赋值 15 obj1.s2=123 16 17 18 结果： 19 s2 20 123
成员修饰符(公开或私有)
1 class F1(object): 2 abc=123 3 __aaa=4565 4 def __init__(self): 5 self.__name="zhangs" 6 #类的内部可以正常访问私有修饰符成员 7 def s2(self): 8 print(F1.__aaa) 9 print(self.__name) 10 11 12 obj1=F1() 13 #静态方法或普通方法都不能直接访问私有修饰符成员 14 #obj1.__aaa 15 #obj1.__name 私有修饰符的普通方法也无法访问 16 17 18 #可以访问类公共修饰符变量 19 print(obj1.abc) 20 21 #内部可以正常访问私有修饰符方法 22 print(obj1.s2())
私有对象修饰符和派生类测试
1 #-*- coding:utf-8 -*- 2 3 class F1(object): 4 abc=123 5 __aaa=4565 6 def __init__(self): 7 self.__name="zhangs" 8 def __test(self): 9 print("test") 10 def demo(self): 11 #内部可以调用私有修饰符成员对象 12 print self.__test() 13 14 class F2(F1): 15 def abc(self): 16 print(self.__name) 17 18 f2=F2() 19 #私有修饰符对象方法也不能直接调用，派生类也无法调用 20 # f2.abc() 21 # f2.__test() 22 f2.demo()
访问私有方法,知道就可以基本没人这么用
class f:
__name=12
f1=f()
f1_f__name
__call__方法
1 class f1: 2 def __init__(self): 3 print("__init__") 4 5 def __call__(self, *args, **kwargs): 6 print("__call__") 7 return 1 8 9 #很特殊的call方法调用 10 f=f1()() 11 12 #上面的方法就是下面方法的简写，在看源码的时候要注意就这样写的 13 #实际上是调用的call方法 14 #f=f1() 15 #f() 16 17 print(f) 18 19 结果： 20 __init__ 21 __call__ 22 1
类成员魔法参数 __getitem__ __setitem__ __delitem__
1 #-*- coding:utf-8 -*- 2 class f1: 3 def __init__(self): 4 self.dick={} 5 def __getitem__(self, item): 6 if type(item) == dict: 7 if self.dick.has_key(item):print(self.dick[item]) 8 else:print("{}") 9 else: 10 print(item) 11 12 def __setitem__(self, key, value): 13 self.dick[key]=value 14 print(key,value) 15 16 def __delitem__(self, key): 17 del self.dick[key] 18 print(key) 19 20 def __delslice__(self, i, j): 21 print("__delslice__") 22 23 def __setslice__(self, i, j, sequence): 24 print("__setslice__") 25 26 27 28 f=f1() 29 #查找 30 f['aa'] 31 32 #设置 33 f['key']="value" 34 35 #删除 36 del f['key'] 37 38 #切片 39 f[1:2] 40 41 #设置切片 42 f[1:2]=[3,6] 43 44 #删除切片 45 del f[1:2] 46 47 48 结果： 49 aa 50 ('key', 'value') 51 key 52 slice(1, 2, None) 53 __setslice__ 54 __delslice__
__iter__为什么for可以循环某些对象？
1 #-*- coding:utf-8 -*- 2 class f1: 3 #对象中包含这个方法就是说明这个对象可以被迭代了 4 def __iter__(self): 5 yield 1 6 yield 2 7 yield 3 8 9 10 11 f=f1() 12 #循环可迭代的对象 13 for i in f: 14 print(i)