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