ParisGabriel
 
 
         每天坚持手写  一天一篇  决定坚持几年 为了梦想为了信仰
 
  开局一张图

                      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语句时是否有异常发生作出相应的处理

示例:

# 一个自定义的类创建的对象能够使用with语句

class A:
'''此类的对象可用于with语句进行管理'''
def __enter__(self):
print("已经进入with语句中,资源分配成功")
return self # <<<-- 此处返回的对象将由as变量绑定 def __exit__(self, exc_type, exc_val, exc_tb):
print("离开with语句,资源释放成功")
if exc_type is None:
print("当离开with语句时没有异常")
else:
print("有异常发生 异常类型:",exc_type , "异常值:", exc_val) with A() as a:
print("这是with语句中的语句")
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                不等于
示例:

# 此示例示意比较运算符的重载
class MyList:
def __init__(self, iterable):
self.data = list(iterable) def __repr__(self):
return 'MyList(%s)' % self.data def __eq__(self, rhs):
return self.data == rhs.data def __gt__(self, rhs):
return self.data > rhs.data L1 = MyList([1, 2, 3])
L2 = MyList([1, 2, 3]) print(L1 == L2) # True
print(L1 > L2) # False
# print(L1 == L2) # 如果没有__eq__ 方法判断两个对象的id
# print(L1 > L2) # 如果没有__gt__ 方法报错

位运算符重载
方法名            运算符和表达式          说明
__invert__(self)               ~ self            取反(一元运算符)
__and__(self, rhs)         self & rhs             位与
__or__(self, rhs)            self | rhs              位或
__xor__(self, rhs)          self ^ rhs             位异或
__lshift__(self, rhs)       self << rhs           左移
__rshift__(self, rhs)       self >> rhs           右移

反向位运算符重载
方法名            运算符和表达式          说明
__rand__(self, lhs)               lhs & self             位与
__ror__(self, lhs)            lhs | self               位或
__rxor__(self, lhs)          lhs ^ self                 位异或
__rlshift__(self, lhs)        lhs << self            左移
__rrshift__(self, lhs)       lhs >> self            右移

复合赋值位运算符重载
方法名            运算符和表达式          说明
__iand__(self, rhs)          self &= rhs            位与
__ior__(self, rhs)            self |= rhs              位或
__ixor__(self, rhs)           self ^= rhs            位异或
__ilshift__(self, rhs)           self <<= rhs          左移
__irshift__(self, rhs)        self >>= rhs          右移

一元运算符重载
方法名          运算符和表达式         说明
__invert__(self)      ~ self             取反(一元运算符)
__pos__(self)        + self              正号
__neg__(self)        - self               负号

语法:
def __xxx__(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 __neg__(self):
return MyList((-x for x in self.beta)) def __pos__(self):
return MyList((abs(x) for x in self.beta))
# L = []
# for x in self.beta:
# if x > 0:
# L.append(x)
# else:
# L.append(-x)
# return MyList(L) L1 = MyList([1, -2, 3, -4, 5])
L2 = -L1
print(L2) # MyList([-1, 2, -3, 4, -5]) # 实现用正号运算符返回全部元素为正数的自定义列表
L3 = + L1
print(L3) # MyList([1, 2, 3, 4, 5])

in / not in 运算符重载
重载方法:
def __contains__(self, e):
....
示例:

# in  not in 重载

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 __contains__(self, e):
return e in self.beta L1 = MyList([1, 2, -3, 4, -5]) print(2 in L1)
print(3 in L1)
print(4 in L1)
print(5 in L1)

索引和切片运算符的重载
方法名 运算符和表达式 说明
__getitem__(self, i) x = self[i] 索引/切片取值
__setitem__(self, i, val) self[i] = val 索引/切片赋值
__delitem__(self, i) del self[i] 删除索引/切片

作用:
让自定义的类对象能够支持索引和切片操作
示例:

# 此示例示意 索引/切片 运算符的重载
class MyList:
def __init__(self, iterable):
self.data = list(iterable) def __repr__(self):
return 'MyList(%s)' % self.data def __getitem__(self, i):
print("索引i的值是:", i)
return self.data[i] def __setitem__(self, i, v):
print("__setitem__被调用, i=", i, 'v=', v)
self.data[i] = v def __delitem__(self, i):
del self.data[i] L1 = MyList([1, -2, 3, -4, 5])
v = L1[2] # v = 3
print(v) #
L1[1] = 2
print(L1) # MyList([1, 2, 3, -4, 5])
del L1[3]
print(L1) # MyList([1, 2, 3, 5])

slice 函数:
作用:
用于创建一个slice切片对象,此对象存储切片的信息
格式:
slice(start=None, stop=None, step=None)
slice对象的属性
s.start 切片的起始值, 默认为None
s.stop 切片的终止值, 默认为None
s.step 切片的步长, 默认为None
示例:

# 此示例示意 索引/切片 运算符的重载
class MyList:
def __init__(self, iterable):
self.data = list(iterable) def __repr__(self):
return 'MyList(%s)' % self.data def __getitem__(self, i):
print("索引i的值是:", i)
if type(i) is int:
print("正在进行索引操作")
elif type(i) is slice:
print("正在进行切片操作")
print("起始值是:", i.start)
print("终止值是:", i.stop)
print("步长值是:", i.step)
return self.data[i] def __setitem__(self, i, v):
print("__setitem__被调用, i=", i, 'v=', v)
self.data[i] = v def __delitem__(self, i):
del self.data[i] L1 = MyList([1, -2, 3, -4, 5])
L2 = L1[::2]
print(L2)

特性属性 @property
实现其它语言所拥有的 getter 和 setter 的功能

作用:
用来模拟一个属性
通过@property 装饰器可以对模拟属性的取值和赋值加以控制
示例见:
示例:

class Student:
def __init__(self, s):
self.__score = s # 私有属性,不让其它人任意修改成绩 @property
def score(self):
'''伪装模拟私有一个成绩属性 并返回成绩'''
return self.__score @score.setter
def score(self, v):
'''实现设置者setter , 对用户的复制加以限制'''
assert 0 <= v <= 100, "成绩不合法"
self.__score = v s = Student(59)
print(s.score) # 希望有一个属性能得到成绩  虚拟属性不能复制
s.score = 80 # 通过s.score 来修改成绩
print(s.score) # 修改成功 s.score看似属性 是模拟属性 实际内部已经被替换

问题:
L = [1, 2, 3]
def f1(lst):
lst += [4, 5, 6]

f1(L)
print(L) # [1, 2, 3, 4, 5, 6] 为什么

L = (1, 2, 3)
def f1(lst):
lst += (4, 5, 6) # lst = lst + (4, 5, 6)
f1(L)
print(L) # (1, 2, 3) 为什么

练习:
1. 实现两个自定义的列表相加
class MyList:
.... 此处自己实现
L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
L3 = L1 + L2
print(L3) # MyList([1, 2, 3, 4, 5, 6])
L4 = L2 + L1
print(L4) # MyList([4, 5, 6, 1, 2, 3])
L5 = L1 * 2
print(L5) # MyList([1, 2, 3, 1, 2, 3])

练习:
实现有序集合类 OrderSet() 能实现两个集合的交集 &,全集 |,
补集 - 对称补集 ^, ==/!= , in/ not in 等操作
要求集合内部用 list 存储
class OrderSet:
...
s1 = OrderSet([1, 2, 3, 4])
s2 = OrderSet([3, 4, 5])
print(s1 & s2) # OrderSet([3, 4])
print(s1 | s2) # OrderSet([1, 2, 3, 4, 5])
print(s1 ^ s2) # OrderSet([1, 2, 5])
if OrderSet([1, 2, 3]) != OrderSet([3, 4, 5]):
print("不相等")
if s2 == OrderSet(3, 4, 5):
print('s2 == OrderSet(3, 4, 5) is True')
if 2 in s1:
print("2在 s1中")

Python全栈工程师(异常(高级)、运算符重载)的更多相关文章

  1. Python全栈工程师(装饰器、模块)

    ParisGabriel                每天坚持手写  一天一篇  决定坚持几年 全栈工程师     Python人工智能从入门到精通 装饰器 decorators(专业提高篇) 装饰 ...

  2. Python全栈工程师(递归函数、闭包)

    ParisGabriel            每天坚持手写  一天一篇  决定坚持几年 全栈工程师     Python人工智能从入门到精通 函数式编程: 是指用一系列函数解决问题 每一个函数完成细 ...

  3. Python全栈工程师(Python3 所有基础内容 0-0)

    ParisGabriel              每天坚持手写  一天一篇  决定坚持几年 为了梦想为了信仰    开局一张图     Python一个月的基础语法 基本就到这咯    接下来是数据 ...

  4. Python全栈工程师(Python3 所有基础内容 0-0)

    转发:https://www.cnblogs.com/ParisGabriel/p/9388030.html statements  语句print   输出quit()  退出exit() 退出ct ...

  5. 【目录】python全栈工程师

    第一阶段:Python 语言核心编程1. Python核心   -- 2048 游戏核心算法2. 面向对象   -- 天龙八部游戏技能系统3. Python高级   -- 集成操作框架项目:2048游 ...

  6. Python全栈工程师之从网页搭建入门到Flask全栈项目实战(1) - ES6标准入门和Flex布局

    1.简述 1.什么是ES6?ES6, 全称 ECMAScript 6.0,是 JavaScript 的下一个版本标准,2015年6月份发版.ES6的主要目的是为了解决 ES5 的先天不足. 2.了解E ...

  7. Python全栈工程师(异常(基础))

    ParisGabriel                每天坚持手写  一天一篇  决定坚持几年 为了梦想为了信仰     Python人工智能从入门到精通 补充:包的相对导入 只对后两种导入方式有用 ...

  8. Python全栈工程师(运算符、if)

    ParisGabriel       Python 入门基础   比较运算符:< 小于<= 小于等于> 大于>= 大于等于== 等于!= 不等于 语法: 表达式1>表达式 ...

  9. Python全栈工程师(数值类型、运算符)

    ParisGabriel       Python 入门基础     python的应用领域: 1.系统运维 2.网络编程(如:网络爬虫,搜索引擎,服务器编程) 3.科学计算 4.航空领域(如:卫星, ...

随机推荐

  1. 缓存验证Last-Modifie和Etag的使用

    看这张图,是浏览器发出请求到请求缓存到过程,这么一个原理 那么http里面如何进行验证呢?主要有两个验证到http头 Last-Modified(上次修改时间) 主要配合If-Modified-Sin ...

  2. window/win7/wamp下安装Xdebug

    1.写一个php文件,输出phpinfo(); 然后把该页面Ctrl+A全选,然后贴到http://xdebug.org/wizard.php这个地址的文本框里,他会自动检查你的配置,然后告诉你用哪个 ...

  3. halcon保存带有region的图片算子

    显示带区域的图片除了可以用dev_display挨个显示外再截图,还可以通过一个算子来实现这一功能 这个算子是:dump_window_image.(其实就是截图) 这个算子的意思是把WindowHa ...

  4. 如何在linux服务器部署Rstudio server,配置ODBC远程访问win 服务器上的SQL server

    如何在linux服务器部署Rstudio server,配置ODBC后通过RODBC包远程访问SQL server 背景介绍:之前写过一篇文章,提到近期要部署Rstudio server(搭建数据分析 ...

  5. textkit

    更详细的内容可以参考官方文档 <Text Programming Guide for iOS>. “Text Kit指的是UIKit框架中用于提供高质量排版服务的一些类和协议,它让程序能够 ...

  6. mysql存储问题

    为什么标题要起这个名字呢?commen sence指的是那些大家都应该知道的事情,但往往大家又会会略这些东西,或者对这些东西一知半解,今天我总结下自己在mysql中遇到的一些commen sense类 ...

  7. SVN中trunk,branches,tags用法详解(转载)

    转载出处:http://www.cnblogs.com/dafozhang/archive/2012/06/28/2567769.html Subversion是一个自由开源的版本控制系统.在Subv ...

  8. Git学习第一天--安装Git和创建版本库

    Windows上安装Git msysgit是Windows版的Git,从https://git-for-windows.github.io下载(备份:百度网盘),然后按默认选项安装即可. 安装完成后, ...

  9. Golang反射机制

    Go反射机制:在编译不知道类型的情况下,可更新变量.在运行时查看值.调用方法以及直接对它们的布局进行操作. 为什么使用反射 有时需要封装统一接口对不同类型数据做处理,而这些类型可能无法共享同一个接口, ...

  10. tcl之array操作