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

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

 class Dog(object):
     def __init__(self,name):
         self.name = name

     def eat(self,food):
         print("%s is eating %s"%(self.name,food))

 d = Dog("Jack")
 d.eat("banana")

 #静态方法写法
 class Dog(object):
     def __init__(self,name):
         self.name = name
     @staticmethod       #静态类后，则无法调用类变量和实例变量
     def eat(self):  #需要传进来的是实例了，而不能调用类本身的属性
         print("%s is eating %s"%(self.name,"banana"))

 d = Dog("Alex")
 d.eat(d)        #传入实例化后的一个实例

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

 class Dog(object):
     name = "Mark"
     def __init__(self,name):
         self.name = name
     @classmethod
     def eat(self):
         print("%s is eating %s"%(self.name,"banana"))   #name为类变量，而非实例变量

 d = Dog("Alex")
 d.eat()
 #运行结果：Mark is eating banana

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

 class Dog(object):
     def __init__(self,name):
         self.name = name
         self.__food = None
     @property
     def eat(self):
         print("%s is eating %s"%(self.name,"banana"))
     @eat.setter
     def eat(self,food):
         print("set food:",food)
         self.__food = food

 d = Dog("Alex")
 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__方法调用

 # -*- coding:utf-8 -*-
 # LC

 class MyType(type):
     def __init__(self,*args,**kwargs):
         print("Mytype init",args,kwargs)
     def __call__(self, *args, **kwargs):
         print("Mytype call",args,kwargs)
         obj = self.__new__(self)
         self.__init__(obj,args,kwargs)

 class Foo(object):
     __metaclass__ = MyType      #表示该类是由谁来实例化自己的（即Foo类）
     def __init__(self):
         print("foo init")
     def __new__(cls, *args, **kwargs):
         print("foo new")
         return object.__new__(cls)

 f = Foo()
 #在python2或者3中，执行顺序为：__new__ ,  __init__,  __call__、
 #__new__优于__init__执行
 #__call__用于创建__new__

反射，类的反射

 class Dog(object):
     def __init__(self,name):
         self.name = name

     def eat(self):
         print("%s is eating"%self.name)

 def bulk(self):
     print("%s is yelling"%self.name)

 d = Dog("Jack")

 choice = input(">>:").strip()
 print(hasattr(d,choice))            #表示对象中是否含有choice的属性，包含变量，方法等

 if hasattr(d,choice):
     print(getattr(d,choice))        #获取对象中的choice属性，如果是变量，则获取变量值，如果是方法，可以通过加()进行执行
     getattr(d,choice)()
 else:
     setattr(d,choice,bulk)          #设置对象中的choice属性，如可以新增一个变量或方法
     getattr(d,choice)(d)        #func = get(d,choice), func(d)
 d.talk(d)

 delattr(d,choice)               #删除对象中的choice属性，可以是变量，也可以是方法
 d.talk(d)

类的特殊方法：

 # -*- coding:utf-8 -*-
 # LC

 #__doc__ 输出类的描述信息
 class Foo:
     '''
     类的描述信息
     '''
     def func(self):
         pass

 print(Foo.__doc__)

 #__module__ 输出当前操作的对象在那个模块
 #__class__  输出当前操作的对象的类是什么

 from lib.aa import C
 obj = C()
 print(obj.__module__)
 print(obj.__class__)

 #__call__ 对象后加括号，触发执行
 #构造方法的执行是由创建对象触发的，即：对象=类名();而对于__call__方法的执行是由对象加括号触发的，即对象()或类()()
 class Dog(object):
     def __init__(self,name):
         self.name = name

     def __call__(self, *args, **kwargs):
         print("%s running call"%self.name,args,kwargs)

 obj2 = Dog("alex")
 obj2("wawawa",sex="F")

 #__dict__ 查看类或者对象中的成员

 print(Dog.__dict__)
 print(obj2.__dict__)

 #__str__  如果一个类中定义了__str__方法，则在打印对象的时候，默认输出该方法（__str__）的值
 class Cat(object):
     def __str__(self):
         return "str method"

 obj3 = Cat()
 print(obj3)

 #__getitem__,__setitem__,__delitem__  用于索引操作，如字典，分别进行获取，设置，删除数据

 class apple(object):
     def __init__(self):
         self.data = {}
     def __getitem__(self, key):
         print("get apple %s"%key)
         return self.data.get(key)
     def __setitem__(self, key, value):
         print("setting apple,%s,%s"%(key,value))
         self.data[key] = value
     def __delitem__(self, key):
         print("deleting apple %s"%key)
         del self.data[key]

 obj4 = apple()
 obj4["apple1"] = "red"
 obj4["apple2"] = "green"

 res = obj4["apple1"]
 print('---',res)
 print(obj4.data)
 del obj4["apple1"]
 res = obj4["apple2"]        #删除后则没有了。输出为None，具体是否删除，也是由__delitem__方法定义的
 print('---',res)

 #__new__
 class Foo(object):
     def __init__(self,name):
         self.name = name

 f = Foo("Jack")
 print(type(f))
 print(type(Foo))

异常处理

 names = ["Alex","Jack"]
 dict = {}

 try:
     names[3]
 except IndexError as e:         #抓具体的错误类型
     print("ERROR !!!",e)

 try:
     names[3]
 except Exception as e:          #包含所有的错误类型，不建议使用，建议使用在最后抓未知错误
     print("ERROR !!!",e)

 try:
     dict["age"]
 except KeyError as e:         #抓具体的错误类型
     print("ERROR !!!",e)

 try:
     #dict["age"]
     #names[3]
     print(names[3])
 except (IndexError,KeyError) as e:  #抓取两个错误中的任意一个，代码谁先出错则执行谁
     print("ERROR",e)
 else:                           #没有错的时候执行
     print("all is well")

 finally:                        #不管有没有错，都执行
     print("不管有你没有错，都执行")

 class TestException(Exception):     #自定义异常
     def __init__(self,msg):
         self.msg = msg

 try:
     raise TestException('自定义异常')
 except TestException as e:
     print(e)

断言,即是一种简单的判断，如果是True,则通过，如果是Fasle，则报错。

assert type(obj.name) is int