class Animal(object):
    def __init__(self,name):
        self.name = name
        
    @staticmethod     #静态方法的调用方式
    def eat(self,food):
        print(‘% is eating %s‘ % (self.name,food))
d = Animal(‘zhang‘)
d.eat(‘hanb‘)


#直接按上面写然后执行，会报错：TypeError: eat() missing 1 required positional argument: ‘food‘。说是缺少一个food参数，可是我们不是传了一个food参数hanb嘛，我们稍后再说，看下面代码。


class Animal(object):
    def __init__(self,name):
        self.name = name
        
    @staticmethod
    def eat(food):
        print(‘%s is eating %s‘ % (‘zhangshanci‘,food))
d = Animal(‘zhang‘)
d.eat(‘hanb‘)

#不给eat方法传self了，直接传一个food，代码运行结果：zhangshanci is eating hanb
#这次就没错了，但是类里面的每个方法不是都要传一个self参数嘛，为什么eat不传也不报错呢，接下来看下面的代码，不给eat传任何参数了，


class Animal(object):
    def __init__(self,name):
        self.name = name
        
    @staticmethod
    def eat():
        print(‘%s is eating %s‘ % (‘zhangshanci‘,‘hanb‘))
d = Animal(‘zhang‘)
d.eat()

#运行结果是：zhangshanci is eating hanb，也没有报错。


#通过上面的例子，我们总结出来，静态方法其实跟类没有半毛钱关系，它只是通过类的实例来调用而已，类的self、类的属性、类的任何任何都不会传给静态方法使用，所以上面的eat(self,food)，需要这样用：eat(‘zhangshanci‘,‘chifan‘)，手动传给它两个参数，因为eat里的self参数并不是类的对象，而是一个普普通通需要传入的参数而已。


#那么静态方法如何使用类的属性呢，看如下代码：
class Animal(object):
    def __init__(self,name):
        self.name = name
        
    @staticmethod
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘hanb‘))
d = Animal(‘zhang‘)
d.eat(d)

#把类的对象传入eat方法作为一个参数，然后再调用。这样其实没啥卵用，实际工作中好像也没有用到的地方，不过要知道这个方法，遇到了能看懂。

class Animal(object):
    def __init__(self,name):
        self.name = name
    @classmethod
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘hanb‘))
d = Animal(‘zhang‘)
d.eat()

#上面的代码报错如下：
#print(‘%s is eating %s‘ % (self.name,‘hanb‘))
#AttributeError: type object ‘Animal‘ has no attribute ‘name‘。说是Animal这个类没有name属性，但是构造方法里明明有啊，我们接着看下面的代码。

class Animal(object):
    name = ‘zhangshanci‘     #加了一个类变量
    def __init__(self,name):
        self.name = name
    @classmethod
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘hanb‘))
d = Animal(‘zhang‘)
d.eat()

#结果如下：
#zhangshanci is eating hanb

#由此可见，类方法只能调用类变量。实际工作中也几乎用不到，知道有这个就行了。

#我们还是一点点来，通过用多个例子的结果慢慢引入属性方法的特点、使用

class Animal(object):
    def __init__(self,name):
        self.name = name
    @property     #定义属性方法的装饰器
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘hanb‘))
d = Animal(‘zhang‘)
d.eat()

#上面的代码报错：d.eat()
#TypeError: ‘NoneType‘ object is not callable。说这个eat()方法不能被调用，这是为啥呢，上面的类里都定义了啊，那我们尝试把括号去掉，如下，

class Animal(object):
    def __init__(self,name):
        self.name = name
    @property
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘hanb‘))
d = Animal(‘zhang‘)
d.eat     #调用时去掉了括号

#结果：zhang is eating hanb。可见，属性方法的调用方式是把方法像属性那样调用，属性方法就是把一个方法变成一个属性了，不用加括号直接可调用；
#那能不能给属性方法传参数呢？就上面的代码来看是不可以的，因为嫁入eat(self,food)这样定义，那调用时这样写d.eat(‘chirou‘)和这样写d.eat都会报错缺少一个参数。
#那怎么解决呢?既然属性方法是把方法变成了一个属性，属性可以赋值，所以我们利用给属性赋值的方法来把参数传进去，看下面代码，

class Animal(object):
    def __init__(self,name):
        self.name = name
    @property
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘baozi‘))
d = Animal(‘zhang‘)
d.eat
d.eat = ‘junzi‘

#直接给属性方法赋值是会报错的：    d.eat = ‘junzi‘
#AttributeError: can‘t set attribute，提示不能设置这个属性，需要特殊处理才能赋值，接着往下看，


class Animal(object):
    def __init__(self,name):
        self.name = name
    @property    #定义属性方法
    def eat(self):
        print(‘%s is eating %s‘ % (self.name,‘baozi‘))
    @eat.setter    #给属性方法赋值
    def eat(self,food):
        print(‘eat set food:‘,food)
d = Animal(‘zhang‘)
d.eat
d.eat = ‘junzi‘

#结果：
#zhang is eating baozi
#eat set food: junzi
#可见，直接调用属性方法，它会执行@property下面的方法；给属性方法赋值，会执行@eat.setter下面的方法；他俩的方法名必须是一样的，这样就起到了给属性方法传参数的效果。（d.eat = ‘juanzi‘ 就好像是 d.eat(‘jaunzi‘)）

下面的代码依然是给属性方法传参，更接近实际使用，如下，
class Animal(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):
        self.__food = food
d = Animal(‘zhang‘)
d.eat = ‘junzi‘     #先给属性赋值（也就是变相的传参）
d.eat    #再调用属性

#结果：
#zhang is eating junzi  #本来self.__food是None，经过d.eat=‘juanzi‘后，d.eat再执行时self.__food就变成了juanzi。



接下来的问题是，既然属性方法是一个属性，那怎么删除呢？我们还是直接删除看看，
class Animal(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):
        self.__food = food
d = Animal(‘zhang‘)
d.eat
d.eat = ‘junzi‘
d.eat
del d.eat    #尝试删除这个属性
#结果报错：del d.eat
#AttributeError: can‘t delete attribute，提示不能删除这个属性，跟设置属性值一样，我们需要稍微处理一下，代码如下，

class Animal(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):
        self.__food = food
    @eat.deleter   #删除属性方法的装饰器
    def eat(self):
        del self.__food
        print(‘delete self.__food‘)
d = Animal(‘zhang‘)
d.eat
d.eat = ‘junzi‘
d.eat
del d.eat     #删除属性d.eat
d.eat

#结果：
#zhang is eating None
#zhang is eating junzi
#delete self.__food
#   print(‘%s is eating %s‘ % (self.name,self.__food))
#AttributeError: ‘Animal‘ object has no attribute ‘_Animal__food‘，提示Animal这个类对象没有__food变量，这是因为执行del d.eat时调用了eat@deleter下面的方法，方法里有个del self.__food，既然删了自然就找不到了。

#总结：直接调用属性方法，会调用@property下面的方法；给属性方法赋值，会调用@func_name.setter下面的方法；删除属性方法，会调用@func.deleter下面的方法；至于各个方法里写什么就比较灵活了，写什么执行什么。

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


    def checking_status(self):
        print("checking flight %s status " % self.flight_name)
        return  1


    @property
    def flight_status(self):
        status = self.checking_status()
        if status == 0 :
            print("flight got canceled...")
        elif status == 1 :
            print("flight is arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")
   
    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
            0 : "canceled",
            1 :"arrived",
            2 : "departured"
        }
        print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) )

    @flight_status.deleter  #删除
    def flight_status(self):
        print("status got removed...")

f = Flight("CA980")
f.flight_status
f.flight_status =  2 #触发@flight_status.setter 
del f.flight_status #触发@flight_status.deleter 

class Foo:
    """ 描述类信息，这是用于看片的神奇 """
 
    def func(self):
        pass
 
print Foo.__doc__
#输出：类的描述信息

#注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的

class Dog(object):
    def __init__(self):
        self.name = ‘zsc‘
        
d = Dog()
d()
直接在对象后面加括号调用，会报错：d()
#TypeError: ‘Dog‘ object is not callable

class Dog(object):
    def __init__(self):
        self.name = ‘zsc‘
    def __call__(self,*args,**kwargs):
        print(‘this is call,‘,args,kwargs)   
d = Dog()
d(1,2,3,name=‘zsc‘)

#结果：
#this is call, (1, 2, 3) {‘name‘: ‘zsc‘}
#可见，当在对象后面加括号时会调用这个对象的类的__call__方法。

class Dog(object):
    def __init__(self):
        self.name = ‘zsc‘
d = Dog()
print(d)
#结果：<__main__.Dog object at 0x0000026023C5C4A8>


class Dog(object):
    def __init__(self):
        self.name = ‘zsc‘
    def __str__(self, *args, **kwargs):  #加了个__str__方法。
        return "<obj:%s>" % self.name
d = Dog()
print(d)
#结果：<obj:zsc>    
#可见__str__方法可以控制打印对象时的返回值。

class Dog(object):
    def __init__(self):
        self.data = {}
    def __getitem__(self,key):       
        print(‘get‘)
        return self.data.get(key)
    def __setitem__(self,key,value):
        self.data[key] = value
        print(‘set‘)
    def __delitem__(self,key):
        del self.data[key]
        print(‘del‘)
d = Dog()
print(d[‘name‘])
print(‘----------------------‘)
d[‘name‘] = ‘zsc‘
print(d[‘name‘])
print(‘----------------------‘)
del d[‘name‘]
print(d[‘name‘])

#结果：
#get
None
----------------------
set
get
zsc
----------------------
del
get
None

class Foo(object): 
    def __init__(self,name):
        self.name = name
obj = Foo("alex")

print type(obj) # 输出：<class ‘__main__.Foo‘>     表示，obj 对象由Foo类创建
print type(Foo) # 输出：<type ‘type‘>              表示，Foo类对象由 type 类创建

class Foo(object):  
    def func(self):
        print ‘hello zsc‘

def func(self):
    print ‘hello zsc‘
  
Foo = type(‘Foo‘,(object,), {‘talk‘: func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员

def func(self):
    print("hello %s"%self.name)

def __init__(self,name,age):
    self.name = name
    self.age = age
Foo = type(‘Foo‘,(object,),{‘func‘:func,‘__init__‘:__init__})

f = Foo("jack",22)
f.func()

#加上构造方法

class Foo(object):
    def __init__(self):
        print(‘__init‘)
    def __new__(cls, *args, **kwargs):
        print(‘__new‘)
        return object.__new__(cls, *args, **kwargs)

obj = Foo()

#结果：
__new
__init
#可见实例化Foo对象后，会调用__init__和__new__方法，而且__new__方法在__init__之前被调用。

下面我们注释了__new__里的return，
class Foo(object):
    def __init__(self):
        print(‘__init‘)
    def __new__(cls, *args, **kwargs):
        print(‘__new‘)
#         return object.__new__(cls, *args, **kwargs)

obj = Foo()

#结果：__new。发现没有调用__init__方法，不是说所有类实例化时都会执行__init__方法吗？原因是，所有类的基类object里有一个__new__方法，这个方法会去调用类里的__init__方法，假如子类重写了__new__方法同时又不调用object.__new__方法的话，就会出现上面的情况；在obj = Foo()等于没有实例化对象。

#注：__new__里的cls参数实际是Foo这个类，把这个类传给了__new__方法。

#作用：假如有一些方法是需要在构造方法之前执行的，就可以重写__new__方法。

def talk(name):
    print(‘this is talk %s‘ % name)

class Foo(object):
    def __init__(self):
        self.name = ‘zsc‘       
    def eat(self):
        print(‘%s is eating.‘ % self.name)

obj = Foo()
choice = input(‘>>‘)
if hasattr(obj, choice):     #判断是否有用户输入的方法
    getattr(obj, choice)()   #如果有，就调用这个方法；如果choice是个属性，就去掉后面的括号。
else:
    setattr(obj, choice, talk)   #如果没有就设置这个方法，设置为已有的talk方法
    getattr(obj, choice)(‘zhangshanci‘)
delattr(obj, choice)     #删除这个方法
getattr(obj, choice)()   #删除后，再用getattr就会报错：没有对应方法。

try:
    code
except error as e:    #捕捉一个异常
    print(e)
except (error1,error2) as e:    #捕捉多个异常
    print(e)
except Exception as e:    #捕捉所有异常，建议放在最后，因为它的范围太大，不好定位异常。
    print(e)