python---面向对象高级进阶

静态方法，调用静态方法后，该方法将无法访问类变量和实例变量

 1 class Dog(object):
 2     def __init__(self,name):
 3         self.name = name
 4
 5     def eat(self,food):
 6         print("%s is eating %s"%(self.name,food))
 7
 8 d = Dog("Jack")
 9 d.eat("banana")
10
11 #静态方法写法
12 class Dog(object):
13     def __init__(self,name):
14         self.name = name
15     @staticmethod       #静态类后，则无法调用类变量和实例变量
16     def eat(self):  #需要传进来的是实例了，而不能调用类本身的属性
17         print("%s is eating %s"%(self.name,"banana"))
18
19 d = Dog("Alex")
20 d.eat(d)        #传入实例化后的一个实例

类方法，类方法后，可以访问类变量，但无法访问实例变量

 1 class Dog(object):
 2     name = "Mark"
 3     def __init__(self,name):
 4         self.name = name
 5     @classmethod
 6     def eat(self):
 7         print("%s is eating %s"%(self.name,"banana"))   #name为类变量，而非实例变量
 8
 9 d = Dog("Alex")
10 d.eat()
11 #运行结果：Mark is eating banana

属性方法，@property 调用属性方法后，该方法将是静态属性，调用不需要加()，直接调用即可

 1 class Dog(object):
 2     def __init__(self,name):
 3         self.name = name
 4         self.__food = None
 5     @property
 6     def eat(self):
 7         print("%s is eating %s"%(self.name,"banana"))
 8     @eat.setter
 9     def eat(self,food):
10         print("set food:",food)
11         self.__food = food
12
13 d = Dog("Alex")
14 d.eat       #属性方法输出的是属性，不需要动态调用，即不需要d.eat()

属性方法修改，删除

class Dog(object):
    def __init__(self,name):
        self.name = name
        self.__food = None
    @property
    def eat(self):
        print("%s is eating %s"%(self.name,self.__food))
    @eat.setter
    def eat(self,food):             #修改属性方法的参数
        print("set food:",food)
        self.__food = food
    @eat.deleter        #删除属性方法的参数
    def eat(self):
        del self.__food
        print("deleted!!!!!")

d = Dog("Mark")
d.eat
d.eat = "apple"         #向属性方法种传递参数
d.eat
del d.eat               #删除属性方法种的参数
d.eat

__metaclass__,__init___,__call__,__new__方法调用

 1 # -*- coding:utf-8 -*-
 2 # LC
 3
 4 class MyType(type):
 5     def __init__(self,*args,**kwargs):
 6         print("Mytype init",args,kwargs)
 7     def __call__(self, *args, **kwargs):
 8         print("Mytype call",args,kwargs)
 9         obj = self.__new__(self)
10         self.__init__(obj,args,kwargs)
11
12 class Foo(object):
13     __metaclass__ = MyType      #表示该类是由谁来实例化自己的（即Foo类）
14     def __init__(self):
15         print("foo init")
16     def __new__(cls, *args, **kwargs):
17         print("foo new")
18         return object.__new__(cls)
19
20 f = Foo()
21 #在python2或者3中，执行顺序为：__new__ ,  __init__,  __call__、
22 #__new__优于__init__执行
23 #__call__用于创建__new__

反射，类的反射

 1 class Dog(object):
 2     def __init__(self,name):
 3         self.name = name
 4
 5     def eat(self):
 6         print("%s is eating"%self.name)
 7
 8 def bulk(self):
 9     print("%s is yelling"%self.name)
10
11
12 d = Dog("Jack")
13
14 choice = input(">>:").strip()
15 print(hasattr(d,choice))            #表示对象中是否含有choice的属性，包含变量，方法等
16
17 if hasattr(d,choice):
18     print(getattr(d,choice))        #获取对象中的choice属性，如果是变量，则获取变量值，如果是方法，可以通过加()进行执行
19     getattr(d,choice)()
20 else:
21     setattr(d,choice,bulk)          #设置对象中的choice属性，如可以新增一个变量或方法
22     getattr(d,choice)(d)        #func = get(d,choice), func(d)
23 d.talk(d)
24
25 delattr(d,choice)               #删除对象中的choice属性，可以是变量，也可以是方法
26 d.talk(d)

类的特殊方法：

 1 # -*- coding:utf-8 -*-
 2 # LC
 3
 4 #__doc__ 输出类的描述信息
 5 class Foo:
 6     ‘‘‘
 7     类的描述信息
 8     ‘‘‘
 9     def func(self):
10         pass
11
12 print(Foo.__doc__)
13
14
15 #__module__ 输出当前操作的对象在那个模块
16 #__class__  输出当前操作的对象的类是什么
17
18 from lib.aa import C
19 obj = C()
20 print(obj.__module__)
21 print(obj.__class__)
22
23 #__call__ 对象后加括号，触发执行
24 #构造方法的执行是由创建对象触发的，即：对象=类名();而对于__call__方法的执行是由对象加括号触发的，即对象()或类()()
25 class Dog(object):
26     def __init__(self,name):
27         self.name = name
28
29     def __call__(self, *args, **kwargs):
30         print("%s running call"%self.name,args,kwargs)
31
32 obj2 = Dog("alex")
33 obj2("wawawa",sex="F")
34
35
36 #__dict__ 查看类或者对象中的成员
37
38 print(Dog.__dict__)
39 print(obj2.__dict__)
40
41 #__str__  如果一个类中定义了__str__方法，则在打印对象的时候，默认输出该方法（__str__）的值
42 class Cat(object):
43     def __str__(self):
44         return "str method"
45
46 obj3 = Cat()
47 print(obj3)
48
49 #__getitem__,__setitem__,__delitem__  用于索引操作，如字典，分别进行获取，设置，删除数据
50
51 class apple(object):
52     def __init__(self):
53         self.data = {}
54     def __getitem__(self, key):
55         print("get apple %s"%key)
56         return self.data.get(key)
57     def __setitem__(self, key, value):
58         print("setting apple,%s,%s"%(key,value))
59         self.data[key] = value
60     def __delitem__(self, key):
61         print("deleting apple %s"%key)
62         del self.data[key]
63
64 obj4 = apple()
65 obj4["apple1"] = "red"
66 obj4["apple2"] = "green"
67
68 res = obj4["apple1"]
69 print(‘---‘,res)
70 print(obj4.data)
71 del obj4["apple1"]
72 res = obj4["apple2"]        #删除后则没有了。输出为None，具体是否删除，也是由__delitem__方法定义的
73 print(‘---‘,res)
74
75
76 #__new__
77 class Foo(object):
78     def __init__(self,name):
79         self.name = name
80
81 f = Foo("Jack")
82 print(type(f))
83 print(type(Foo))

异常处理

 1 names = ["Alex","Jack"]
 2 dict = {}
 3
 4 try:
 5     names[3]
 6 except IndexError as e:         #抓具体的错误类型
 7     print("ERROR !!!",e)
 8
 9 try:
10     names[3]
11 except Exception as e:          #包含所有的错误类型，不建议使用，建议使用在最后抓未知错误
12     print("ERROR !!!",e)
13
14
15
16 try:
17     dict["age"]
18 except KeyError as e:         #抓具体的错误类型
19     print("ERROR !!!",e)
20
21 try:
22     #dict["age"]
23     #names[3]
24     print(names[3])
25 except (IndexError,KeyError) as e:  #抓取两个错误中的任意一个，代码谁先出错则执行谁
26     print("ERROR",e)
27 else:                           #没有错的时候执行
28     print("all is well")
29
30 finally:                        #不管有没有错，都执行
31     print("不管有你没有错，都执行")
32
33
34 class TestException(Exception):     #自定义异常
35     def __init__(self,msg):
36         self.msg = msg
37
38 try:
39     raise TestException(‘自定义异常‘)
40 except TestException as e:
41     print(e)