No.010-Python-学习之路-Day7-面向对象的进阶<类中高级方法|类创建及实例的生成过程|反射>|异常处理|动态的模块导入|断言

类中高级方法

静态方法<装饰器@staticmethod>

• 静态方法仅仅名义上归类管理，但实际上静态方法未利用任何的类中属性；

class Dog(object):
    def __init__(self, name):
        self.name = name
    @staticmethod # 静态方法->实际上跟类没什么关系，仅仅是一个方法，仅仅是需要使用类名来调用
    def eat(food):
        # 因为没有传self进去，则无法使用self.name之类的内容调用
        # 目的就是不在函数内使用
        # 相当于类的工具包
        print("Unknow dog is eating %s" %food)
        
d = Dog("XiLuo")
d.eat("Shit")

类方法<装饰器@classmethod>

• 类方法仅仅可以访问类变量，无法访问实例变量；

class Market(object):
    discount = 10.0
    goods = {"macbook": {"sn": "No.001","price": 9600,"counts": 100},
            "iphone": {"sn": "No.002","price": 5600,"counts": 50}
    }

    def __init__(self, name , owner, address):
        self.name = name
        self.owner = owner
        self.address = address

    @classmethod
    def set_discount(cls, new_discount):
        print("Discount change from %.1f to %.1f" %(cls.discount, new_discount))
        cls.discount = new_discount

    def get_price(self):
        for good in self.goods:
            print("商品名-{} 编号-{} 价格-{}".format(
                good,
                self.goods[good]['sn'],
                self.goods[good]['price'] * self.discount
            ))


mymarket = Market("小苹果百货店", "Amadeus Lee", "尚阳城")

mymarket.get_price() 
mymarket.set_discount(9.0) # 可以更改类变量discount的值
mymarket.get_price() 
Market.set_discount(8.0) # 可以更改类变量discount的值
Market.get_price(mymarket)

属性方法<装饰器@property>

•  @ property 是把一个方法变成一个静态属性

# @ property 是把一个方法变成一个静态属性

# 属性方法如何赋值？
#   使用类似于width.setter的方法来来赋值
# 属性方法如何删除？
#   使用类似于width.deleter的方法来删除
# 把一个方法变成静态属性的作用：
#   1.将直接暴露的属性隐藏，只有通过一定的限定才能够赋值或者取值，而且仍然以属性的方式调用，而非函数
#   2.有些属性是动态的，比如航班的实时状态，如果需要取得这个值，需要执行<联系API->调用函数分析->返回结果>
#     ，这些使用属性方法直接生成，在类外看起来就是一个属性<隐藏实现细节>，而非相对复杂的函数操作；

class Screen(object):
    '''
    显示屏类，定义长和宽
    '''
    def __init__(self):
        self.__width = None
        self.__height = None

    @property # 将width变为属性，目的为了限制width相关的信息，希望其设置的值在范围内
    def width(self):
        return self.__width

    @width.setter # 可以调用方法进行修改
    def width(self, width):
        if isinstance(width, int):
            if 1366 >= width >= 1024:
                self.__width = width
            else:
                raise ValueError("width范围为1024-1366")
        else:
            raise ValueError("width不是int类型")

    @property # 将height变为属性
    def height(self):
        return self.__height

    @height.setter # 可以调用方法进行修改
    def height(self, height):
        if isinstance(height, int):
            if 768 >= height >= 256:
                self.__height = height
            else:
                raise ValueError("height的范围为256-768")
        else:
            raise ValueError("height不是int类型")

    @height.deleter # 当使用del xxx 的时候显示的信息；
    def height(self):
        self.__height = None
        print("已删除height！！！")

    @property # 这个是一个只读属性，没有定义赋值的方法哦；
    def resolution(self):
        if isinstance(self.__width, int) and isinstance(self.__height, int):
            if self.__width * self.__height == 786432:
                return "测试通过"
            else:
                return "测试失败"
        else:
            raise ValueError("width及height必须为int类型")


s = Screen()
s.width = 1024
s.height = 768
print(s.width, s.height, s.resolution)

类中的特殊方法

• __init__(self) : obj init method；
• __call__(self, *args, **kwargs) :Called when the instance is “called” as a function; if this method is defined, x(arg1, arg2, ...) is a shorthand for x.__call__(arg1, arg2, ...).
• __str__(self）：compute the “informal” or nicely printable string representation of an object. The return value must be a string object.When a object is Called by str(object) and the built-in functions format() and print();
• obj/class.__doc__: return the description of the class or class of the obj;
• obj/class.__module__: the class of obj is import from which module , return the module's name;
• obj.__class__: return the class of the obj;
• obj/class.__dict__ : return all attribute of a class or a obj , class only include class attrubute, not include instance attribute;obj have them all;

class Dog(object):
    '''
        这个类是描述狗这个对象的
    '''
    type = "dog"
    def __init__(self):
        self.name = "Baby"

    def get_name(self):
        print("come from get_name fun", self.name)

    
    def __call__(self, *args, **kwargs):
        self.name = args[0]
        self.type = args[1]

    def __str__(self):
        return "<obj>:%s" % self.name # 可以使用打印的时候看到比如下面的print(d) # 在jango中使用较多

d = Dog()

d("Bruce", "Mydog") # call方法的调用1 # 如果涉及类变量不会更改,只会覆盖
print("obj.__call__", d.name, d.type)
Dog()("Amadeus", "yourdog") #call方法的调用2 # 如果涉及实例及类变量不会更改不会覆盖
print("class.__call__", Dog.name, Dog.type)

print(d) # 显示显示信息-->调用的是__str__(self)方法

print(Dog.__doc__) # 打印这个类的描述信息
print(d.__doc__) # 打印这个类的描述信息

print("__module__",Dog.__module__, d.__module__) # 表示当前操作的对象的模块，即是从哪个模块导入的
print("__module__",d.__class__) # 表示当前的对象属于什么类


print(Dog.__dict__) #类调用打印类里的所有属性，不包括实例属性
print(d.__dict__) # 实例调用，打印实例中的属性
d.age = 2
print(d.__dict__) # 实例调用，打印实例中的属性

• __getitem__(self, key): # 在使用obj[xxx]取值时即调用这个方法
• __setitem__(self, key, value): # 在使用obj[key] = value赋值使，使用这个方法
• __delitem__(self, key): # 在使用del obj[key] 时调用这个函数，具体操作自定义

class Foo(object):  # 自封装字典 # 2.7里面可以变成列表，3.0里面没有

    def __init__(self):
        self.dic = {}

    def __getitem__(self, key): # 在使用obj[xxx]取值时即调用这个方法
        print('__getitem__', key)
        return self.dic[key]

    def __setitem__(self, key, value): # 在使用obj[key] = value赋值使，使用这个方法
        print('__setitem__', key, value)
        self.dic[key] = value

    def __delitem__(self, key): # 在使用del obj[key] 时调用这个函数，具体操作自定义
        print('__delitem__', key)
        self.dic.pop(key)

obj = Foo()
obj['name'] = "Bruce"
obj['age'] = 19
del obj['name']
print(obj)
try:
    print(obj['name'])
except KeyError as KeyNotFound:
    print("key-name已经被删除！")
print(obj['age'])

 类的创建及实例的生成

class Foo(object):  # 定义一个类
    def __init__(self, name):
        self.name = name
f = Foo("Bruce") # 实例化这个类

以上代码中，f是对象， Foo是类；在python中一切皆对象，那么Foo这个类本身也是一个对象，是对象就有相应的类，那么它的类是什么呢？

>>> type(f)
<class '__main__.Foo'>  # 可以看到对象f的class是 Foo
>>> type(Foo)    
<class 'type'> # 可以看到对象Foo的class是type

以上代码中，类Foo身为对象时的类是type；也就是说我们可以直接通过实例化一个type类来创建Foo，如下：

# 定义一个单独的函数
def func(self):
    print('hello Bruce!!')
# 定义一个单独的函数
def init(self, name, age):
    self.name = name
    self.age = age

# 使用以上参数生成一个type类的对象Foo
Foo = type('Fooo', (object,), {'talk':func, '__init__':init}) 
# 可以看到如正常的Foo类一样
print(type(Foo))
f = Foo('Bruce', 12)
print(f.age)

 So...从上面所有的来看，obj<f>的class是Foo类，Foo类的类是type.......type呢则是python解释器自己来创建的；

事实上这也是我们在使用class关键字的时候Python所做的事情。Python通过使用metaclass-<这里是metaclass = type>来实现这一过程。

一个类的创建过程详解

__metaclass__ ：

• 源类，指定源类的参数，是用来生成类的类，比如type即是源类；
•  影响class初始化过程、修改class的内容，返回修改过的class
• 一般用来做一些逻辑比较复杂的操作，比如自省，修改继承，以及改变类的默认attribute比如__dict__等；

__new__(cls, *args, **kwargs)：

• 用来创建一个类的实例的，起创建一个类实例的作用构造器（constructor）；
• new第一个参数为cls，因为new工作时self并不存在，所以要传入一个类<cls>用于创建对象<self>;

__init__(self, *args, **kwargs)：

• 用来初始化一个实例的,起初始化一个已被创建的实例的作用, 初始化（initializer）；

class Mytype(type):

    def __init__(self, what, bases=None, dict=None):
        super(Mytype, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        print('--Mytype call--')
        obj = self.__new__(self, *args, **kwargs)
        self.__init__(obj, *args, **kwargs)
　　　　　return obj

class Foo(object, metaclass=Mytype):  # 源类，即类的类，可以重写, 在python3中需要写在class内部

    __metaclass__ = Mytype

    def __new__(cls, *args, **kwargs):
        print("Foo __new__")
        self = object.__new__(cls)  # 建立对象，返回对象的内存地址# 继承父类的__new__()方法，不继承无法实例化
        print(self)
        return self

    def __init__(self):
        self.name = "Bruce"


f = Foo() 
# Foo()中的“()”是Foo作为实例call其类<源类>的__call_方法，即本质是呼叫源类 Mytype中的__call__方法；
# 而在__call__方法中，传入了Mytype的对象即<self = Foo>，并以此调用Foo.__new__及Foo.__init__方法来创建Foo类的对象；
# __new__方法通过使用父类中的__new__方法成功建立了一个对象<开辟了内存空间>并将其返回, 则 obj = __new__.return即新生成的对象<空内存区域>；
# 随后调用__init__方法，传入obj<__new__生成的对象的指针>及相关变量值，完成类实例的初始化,并将obj返回，则f = obj，完成整个Foo的实例的创建；
# 详解在这里面
'''https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python'''

 再具体点如下：

class MyType(type):
    def __init__(self,*args,**kwargs):

        print("Mytype __init__",*args,**kwargs)
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        print("Mytype __call__", *args, **kwargs)
        obj = self.__new__(self)
        print("obj ",obj,*args, **kwargs)
        print(self)
        self.__init__(obj,*args, **kwargs)
        return obj

    def __new__(cls, *args, **kwargs):
        print("Mytype __new__",*args,**kwargs)
        return type.__new__(cls, *args, **kwargs)


def __new__(cls, *args, **kwargs):
    print("Foo __new__",cls, *args, **kwargs)
    return object.__new__(cls)
def __init__(self,name):
    self.name = name

# 生成MyType的实例Foo,则会先调用MyType类的__new__,然后再调用__init__完成Foo的创建
Foo = MyType('Foo', (object, ), {"__new__": __new__, "__init__": __init__})
# 生成Foo的实例f,过程如上
f = Foo("Bruce")
print("f",f)
print("fname",f.name)

Metaclass可以不是一个类，也可以是一个函数，如下：

def myMeta(class_name , bases, class_attributes):
    print("class_name-{}
bases-{}
class_attributes-{}".format(
        class_name, bases, class_attributes
    ))
    return type(class_name, bases, class_attributes)
# 从这里可以看出定义类的关键字class，其真实操作即：
# Foo = metaclass(class_name="Foo", bases=(object,), class_attributes={})
class Foo(object, metaclass=myMeta):

    def __init__(self, name):
        self.name = name

    def get_name(self):
        print(self.name)
f = Foo("Bruce")
f.get_name()

metaclass的一个应用，我希望所有自定义类的属性名字都是大写，可以使用metaclass来实现：

class MyMeta(type):

    def __new__(cls, class_name, base, attributes):
        upper_attributes = {}

        for key , var in attributes.items():
            if key.startswith("__"):
                upper_attributes[key] = var
            else:
                upper_attributes[key.upper()] = var
        print(upper_attributes)
        return super(MyMeta, cls).__new__(cls, class_name, base, upper_attributes)

class Foo(object, metaclass=MyMeta):
    def __init__(self):
        self.name = "Bruce"
    def get_name(self):
        print(self.name)
f = Foo()
print(hasattr(f, "GET_NAME"))
print(hasattr(f, "get_name"))

反射

反射->通过字符串映射或修改程序运行时的状态、属性、方法，有以下4个方法：

hasattr(object, name)：

• 判断object对象中是否存在name属性
• getattr(object, name[, default])：
• 获取object对象的属性的值，如果存在则返回属性值，如果不存在分为两种情况，一种是没有default参数时，会直接报错；
• 给定了default参数，若对象本身没有name属性，则会返回给定的default值；

getattr(object, name[, default])

• 返回object的名字为str{name}的attribute方法；
• 如果没有这个属性，返回default的值<如果设置>，否则报错；

setattr(object, name, value)

• 给object对象的name属性赋值value，如果对象原本存在给定的属性name，则setattr会更改属性的值为给定的value；
• 如果对象原本不存在属性name，setattr会在对象中创建属性，并赋值为给定的value；

delattr(object, name)

• 用来删除指定对象的指定名称的属性，和setattr函数作用相反;

callable(object)

• 函数用于检查一个对象是否是可调用的;
• 返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功;
• 对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True;

def bulk(self):
    print("%s is yelling..." )
class Dog(object):
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("%s is eating ..." % self.name)
d = Dog("Vick")
choice = input(">>:").strip() # 用户通过输入调用instance的方法；
if hasattr(d, choice): # 判断在某个instance中是否有这个字符串对应的方法 # 如果是属性呢，属性无法执行，如何而从新赋值呢？setattr
    print(getattr(d, choice)) # 映射出了eat函数对的内存对象地址
    getattr(d,choice)() # 然后执行
else:
    setattr(d, choice, bulk) # 动态装入一个方法，也可以动态装入一个属性
    getattr(d, choice)(d) # 因为没在类中 self没有自动传入
delattr(d, "eat") # 相当于 del d.eat 删除object中的某一属性

 异常处理

常用的异常之类，后期补充

• AttributeError 试图访问一个对象没有的树形，比如foo.x 但是foo没有x
• IoError 输入/输出一场，基本上是无法打开文件
• ImportError 无法引入模块或包；基本上是路径问题或名称错误
• IndentationError 语法错误（的子类）；代码缩进有问题
• IndexError index超出界限
• KeyError 试图访问字典里不存在的键
• KeyboardInterrupt Ctrl+C 被按下
• NameError 使用一个还未被赋予对象的变量
• SyntaxError 代码不能编译，一般是语法错误
• TypeError 传入对象类型与要求的不符合
• UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于令有一个同名的全局变量，导致你以为正在访问它
• ValueError 传入一个调用者不期望的值，即使值的类型是正确的

 异常抓取具体语法：

try:
    #data['name']
    #name[3]
    open('test.txt')
    a = 1
    print(a)
except (KeyError, IndexError) as ke: # 一次判断多个错误，但是不知道是哪个代码出错了，一般不这么写
    print("Index或者key不存在", ke)          # 可以用在不管出来什么错误，处理方法都是相同的
except Exception as e:  # 可以抓住所有错误，都可以抓住 # 前面写明细，后面抓所有，防止出现前面未抓到的某些错误
                        # 注意IndentationError SyntaxError 这种是无法抓的，因为根本编译不了
    print("出错了", e)
else: # 没有出现错误的时候执行这个
    print("一切正常")
finally: # 不管有没有错误都会执行
    print("不管有没有错误，都执行")

自定义异常并触发

class BruceException(Exception):
    def __init__(self, msg):
        self.message = msg
    def __str__(self): # 父类中存在这个方法，即return self.message
         return super(BruceException, self).__str__()
try:
    raise BruceException('数据库连不上') # 使用raise直接触发自己写的异常
except BruceException as e:
    print(e)
    
# 题外话#####__str__的作用，即在str(obj)的时候生效###
fault = BruceException("My fault!!") # 实例化
print(str(fault))  # 调用obj的__str__方法  ##，当然不止str()可以触发，只要将obj-->str即会触发；

 动态的模块导入

正常导入操作如下：

import lib.aa 

如果我有以下的需求如何实现呢？

# 已知
modname = "aa"
# 需要导入lib.aa，尝试：
from lib import modname #这样是无效的 类似于from lib import "aa"

以上需求有两种方式，第一种方式为python解释内部机制使用，如下：

modname = "lib.aa"
lib = __import__(modname) # 只导入lib的级别
print(lib)
lib.aa.myfun()

另外一种为正常代码编写过程中使用，如下：

import importlib
modname = "lib.aa"
mod = importlib.import_module(modname) # 写到哪层就是哪层
print(mod)
mod.myfun()

 断言

name = "Bruce"
assert type(name) is str # 断言正确接着执行
print("aaa")
assert type(name) is int # 断言错误报错
print("bbb")
# 断言的作用在于，之后的程序依赖于前面的断言通过，而程序相对重要，不能出错；

’

end