开局一张图

　　　　　　　　　　　　　　　　　　　　　　Python人工智能从入门到精通

对象的属性管理函数:
　　getattr(obj, name[,default)
　　　　从对象得到对象的属性，getattr（x， “y”） 等同于x， y 当属性
　　　　不存在时 如果给出default参数则返回default
　　　　如果没有给出default ，则产生一个AttributeError错误

　　hasattr（obj， name）用给定的name返回对象obj是否有此属性
　　　　此种做法可以避免在getattr（obj，name）时引发错误

　　setattr(obj, name, value) 给对象obj的名为name的
　　　　属性设置相应的值value, set(x, ‘y’, v) 等同于 x.y = v

　　delattr(obj, name) 删除对象obj中的name属性
,　　　　 delattr(x, ‘y’) 等同于 del x.y

示例：

class Dog:
    pass


d = Dog()
d.color = "白色"

v = getattr(d, "color")   # 等同于 v = d.color
v = getattr(d, "kinds")  # 出错,没有d.kinds属性
v = getattr(d, "kinds", "没有这个属性")  # v= '没有这个属性'
hasattr(d, 'color')  # True
hasattr(d, 'kinds')  # False
setattr(d, 'kinds', '京巴')  # 等同于d.kinds ='京巴'
hasattr(d, 'kinds')  # True
delattr(d, 'kinds')  # 等同于 del d.kinds
hasattr(d, 'kinds')  # False

异常（高级）：
　　可以用于异常的语句
　　　　try-except # 捕获异常，得到通知
　　　　try-finally # 左任何流程（正常/异常）都必须执行要执行的语句
　　　　raise # 发送异常
　　　　assert # 根据条件发送异常通知
with 语句：
　　语法：
　　　　with 表达式1[as 变量1]， 表达式2[as 变量2]….
　　作用：
　　　　使用与对资源进行访问的场合，确保使用过程中不管
　　　　是否发生异常都会执行必要的“清理操作”，并释放资源
　　　　（如： 文件使用后自动关闭，线程中锁的自动获取和释放等）
　　说明：
　　　　执行表达式，as子句中的变量绑定生成的对象
　　　　with语句并不改变异常的状态
示例：

# with语句打开文件和自动关闭


try:
    with open("a.txt") as f:
        for x in f:
            print(x)
            int("abc")  # 出现异常
except OSError:
    print("文件打开失败")

except ValueError:
    print("文件操作过程中错误")


# try-finally语句打开文件和关闭
try:
    f = open("a.txt")
    for x in f:
        print(x)
except OSError:
    print("打开文件失败")
except ValueError:
    print("文件操作过程中错误")
finally:
    f.close()

    # 修改原来的copy文件功能

src_filename = input("请输入源文件路径名: ")
dst_filename = input('请输入目标文件路径名: ')

try:
    with open(src_filename, 'rb') as src,\
            open(dst_filename, 'wb') as dst:  # 打开源文件用来读数据
                while True:
                    b = src.read(4096)
                    if not b:  # 已经再也读不到数据了
                        break
                    dst.write(b)
                print("复制成功")
except OSError:
    print("复制失败")

环境管理器：
　　类内有__enter__和__exit__实例方法的类被称为环境管理器
　　能够用with进行管理的对象必须是环境管理器
　　说明：
　　　　__enter__将在进入with语句时被调用并返回由as变量绑定的对象
　　　　__exit__将在离开with语句时被调用，且可以用参数来判断在
　　　　离开with语句时是否有异常发生并作出相应的处理

示例：

# 一个自定义的类创建的对象能够使用ｗｉｔｈ语句

class A:
    '''此类的对象可用于ｗｉｔｈ语句进行管理'''
    def __enter__(self):
        print("已经进入ｗｉｔｈ语句中，资源分配成功")
        return self  # <<<-- 此处返回的对象将由as变量绑定

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("离开ｗｉｔｈ语句,资源释放成功")
        if exc_type is None:
            print("当离开ｗｉｔｈ语句时没有异常")
        else:
            print("有异常发生　异常类型：",exc_type , "异常值：",  exc_val)


with A() as a:
    print("这是ｗｉｔｈ语句中的语句")
    raise ValueError("故意制造的异常")

运算符重载：
　　什么是运算符重载
　　　　让自定义的类生成的对象（实例）能够使用运算符进行操作
　　作用：
　　　　1.让自定义的类的实例能够运行运算符操作
　　　　2.让程序简洁易读
　　　　3.对定义对象将运算符赋予新的运算规则
　　说明：
　　　　运算符重载方法的参数已经有固定含义，不建议改变原有的含义
　　　　算数运算符重载：

方法名 　　　　　　 　　　　 运算符和表达式 　　　　　　 说明
__add__(self, rhs) 　　 　　　　  self + rsh 　　　　　　　　 加法
__sub__(self, rhs) 　　　　　　   self – rsh 　　　　　　　　  减法
__mul__(self, rhs) 　　　　　　   self * rsh 　　　　　　　　  乘法
__truediv__(self, rhs) 　　　　     self / rsh 　　　　　　　　   除法
__floordiv__(self, rhs) 　　　　     self // rsh 　　　　　　        地板除
__mod__(self, rhs) 　　　　　　  self % rsh 　　　　　　　    求模
__pow__(self, rhs) 　　　　          self ** rsh 　　　　　　　　  幂

rhs（self hand side） 右手边

示例：

class MyNumber:
    def __init__(self, val):
        self.data = val

    def __repr__(self):
        return "%d" % self.data

    def __add__(self, rsh):
        v = self.data + rsh.data
        return MyNumber(v)

    def __sub__(self, rsh):
        return MyNumber(self.data - rsh.data)


n1 = MyNumber(100)
n2 = MyNumber(200)
n3 = n1 + n2  # 等同于　n3 = n1.__add__(n2)
# n3 = n1.__add__(n2)
print(t(n1, "-", n2, "=", n1 - n2)

反向算术运算符的重载
　　当运算符的左侧为内建类型,右侧为自义类型的对象进行算术运算符运算时,会出现TypeError错误,
　　因无法修改内建类的代码来实现运算符重载,此时需要使用反向算术运算符重载

反向算术运算符重载
方法名 　　　　　　　　　　 运算符和表达式                         说明
__radd__(self, lhs) 　　　　　　 lhs + self 　　　　　　　 　 加法
__rsub__(self, lhs) 　　　　　　 lhs – self 　　　　　　　  　 减法
__rmul__(self, lhs)　　　　　　  lhs * self　　　　　　　   　 乘法
__rtruediv__(self, lhs)　　　　　lhs / self 　　　　　　  　 　 除法
__rfloordiv__(self, lhs)　　　　   lhs // self　　　　　　 　  　 地板除
__rmod__(self, lhs) 　　　　       lhs % self 　　　　　　        取模(求余)
__rpow__(self, lhs)　　　　　    lhs ** self 　　　　　　　  　 幂

lhs(left hand side) 右手边

示例：

# 此示例示意返向算述运算符的重载
class MyList:
    def __init__(self, lst=[]):
        '''在初始化方法内为每个对象都创建一个bata属性
        　　　bata 用来绑定每个对象自己的列表
        '''
        self.beta = [x for x in lst]
        # self.bata = list(lst)

    def __repr__(self):
        return "%s" % self.beta

    def __mul__(self, rhs):

        return MyList(self.beta * rhs)
        print("__mul__　被到调用")

    def __rmul__(self, lhs):
        print("__rmul__　被到调用")
        return MyList(self.beta * lhs)  # 反向传参


L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
L3 = 2 * L1  # L1.__rmul__(2)
print(L3)

L5 = L1 * 2  # L5 = L1.__mul__(2)
print(L5)  # MyList([1, 2, 3, 1, 2, 3])

复合赋值算术运算符的重载
　　以复合赋值算术运算符 x += y 为例,此运算会优先调用x.__iadd__(y) 方法,
　　如果没有__iadd__方法时会将复合赋值运算拆解为 x = x + y,然后调用x = x.__add__(y) 方法
　　如果再不存在 __add__方法则会触发TypeError异常

　　其它复合赋值运算符也具有相同的规则

复合赋值算术运算符重载
　　方法名　　　　　　　　　 运算符和表达式 　　　　　　 说明
__iadd__(self, lhs)　　　　　　 lhs += self 　　　　　　　　 加法
__isub__(self, lhs) 　　　　　　 lhs -= self 　　　　　　　　 减法
__imul__(self, lhs) 　　　　　　 lhs *= self 　　　　　　　　 乘法
__itruediv__(self,lhs) 　　　　　lhs /= self 　　　　　　　　  除法
__ifloordiv__(self, lhs)　　　　   lhs //= self 　　　　　　　　 地板除
__imod__(self, lhs)　　　　　　lhs %= self　　　　　　 　　 取模(求余)
__ipow__(self, lhs) 　　　　　　lhs **= self　　　　　　　　 幂

示例：

class MyList:
    def __init__(self, lst=[]):
        '''在初始化方法内为每个对象都创建一个bata属性
        　　　bata 用来绑定每个对象自己的列表
        '''
        # self.beta = [x for x in lst]
        self.bata = list(lst)

    def __repr__(self):
        return "%s" % self.beta

    def __iadd__(self, rhs):
        self.beta += rhs.beta  # id不变
        return self

    def __add__(self, rhs):
        return MyList(self.beta + rhs.beta)  # id会不变


L = MyList([1, 2, 3])


def f1(lst):
    lst += MyList([4, 5, 6])


f1(L)
print(L)

复合赋值算术运算符重载
　　方法名 　　　　　　　　　　 运算符和表达式 　　　　 　　 说明
__lt__(self, rhs) 　　　　　　　　   self < rhs 　　　　　       　   小于
__le__(self, rhs) 　　　　　　　　  self <= rhs 　　　　　      　  小于等于
__gt__(self, rhs) 　　　　　　　　  self > rhs 　　　　　　　  　 大于
__ge__(self, rhs) 　　　　　　　　 self >= rhs 　　　　　　        大于等于
__eq__(self, rhs) 　　　　　　　　 self == rhs 　　　　　　        等于
__ne__(self, rhs) 　　　　　　　　 self != rhs 　　　　　　         不等于
示例：