python day18 异常(高级) 一元运算符重载 、 关系运算符的重载 、

最新推荐文章于 2024-09-05 09:51:29 发布
最新推荐文章于 2024-09-05 09:51:29 发布
阅读量769 收藏
点赞数
分类专栏： python人工智能 Python学习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luohongtuCSDN/article/details/80704803
版权

目录：

异常(高级) 一元运算符重载 、 关系运算符的重载 、

with语句

语法：

with 表达式1 [as 变量名1], 表达式2 [as 变量名2], ...

作用:

用于对资源访问的场合，确保使用过程中不管是否发生异常，都会执行必要有”清理”操作，并释放资源.
如:
文件打开后自动关闭，线程中锁的自动获取和释放(线程后面会讲)

说明:

with语句与try-finally相似，并不会必变异常状态
as 子句用于绑定表达式创建的对象

示例见:

 本示例示意with语句的使用方法

# 打开文件读取文件数据(try-finally来实现关闭文件)
# def read_file():
#     try:
#         f = open("abcd.txt")
#         try:
#             while True:
#                 s = f.readline()
#                 if not s:
#                     break  # return
#                 int(input("请输入任意数字打印下一行:"))
#                 print(s)
#         finally:
#             print("文件已经关闭")
#             f.close()
#     except IOError:
#         print("出现异常已经捕获!")
#     except ValueError:
#         print("程序已转为正常状态")


# 打开文件读取文件数据(with来实现关闭文件)
def read_file():
    try:
        # f = open("abcd.txt")
        with open('abcd.txt') as f:
            while True:
                s = f.readline()
                if not s:
                    break  # return
                int(input("请输入任意数字打印下一行:"))
                print(s)
            print("文件已经关闭")

    except IOError:
        print("出现异常已经捕获!")
    except ValueError:
        print("程序已转为正常状态")


read_file()
print("程序结束")

环境管理器:

  1. 类内有__enter__ 和 __exit__方法的类被称为环境管理器
  2. 能够用with进行管理的对象必须是环境管理器
  3. __enter__ 将在进入with语句时被调用，并返回由as变量管 理的对象
  4. __exit__将在离开with语句时被调用，且可以用参数来判断离开with语句时是否出现异常并做出相应的处理

示例:

# 本程序示意自定义的类作为环境管理器使用
class FileWriter:
    def __init__(self, filename):
        self.filename = filename  # 此属性用于记住文件名

    def writeline(self, s):
        '''此方法用于向文件内写入字符串，同时自动添加换行'''
        self.file.write(s)
        self.file.write('\n')

    def __enter__(self):
        '''此方法用于实现环境管理器'''
        self.file = open(self.filename, 'w')
        print("已进入__enter__方法，文件打开成功")
        return self  # 返回值向用于 with中的as 绑定

    def __exit__(self, exec_type, exec_value, exec_tb):
        '''
        exec_type  为异常类异,没有异常发生时为None
        exec_value 为错误的对象,没有异常时为None
        exec_tb    为错误的traceback对象
        '''
        self.file.close()
        print("文件", self.filename, "已经关闭")
        if exec_type is None:
            print("退出with时没有发生异常")
        else:
            print("退出with时，有异常，类型是", exec_type,
                  "错误是", exec_value)
        print("__exit__法被调用,已离开with语句")


try:
    with FileWriter('log.txt') as fw:
        while True:
            s = input("请输入一行: ")
            if s == 'exit':
                break
            if s == 'error':
                raise ValueError("故意制造的值错误")
            fw.writeline(s)
except:
    print("有错误发生，已转为正常")

print("这是with语句之外，也是程序的最后一条语句")

练习：

实现文件的复制(建议使用二进制方式进行操作)
$ python3 mycp.py
请输入源文件: /etc/passwd
请输入目标文件: ./mypass.txt
提示: ‘文件复制成功’ 或 ‘文件复制失败’
(建议使用with语句打开文件)

运算符重载:
什么是运算符重载
让自定义的类生成的对象（实例）能够使用运算符进行操作
作用：
让实例象数学表达式一样进行运算操作
让程序简洁易读
说明:
运算符重载方法的参数已经有固定的含义，不建议改变原有的含义

各种运算重载

算术运算符:

方法名运算符
add加法 +
sub减法 -
mul乘法 *
truediv除法 /
floordiv地板除 //
mod取模(求余) %
pow幂 **

二元运算符重载方法格式:

def __xxx__(self, other):
....

示例:


# 此程序示意运算符重载
class MyNumber:
    def __init__(self, v):
        self.data = v

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

    def __add__(self, other):
        print("__add__方法被调用")
        obj = MyNumber(self.data + other.data)
        return obj

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


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

练习：

实现两个自定义表的相加

class MyList:
      def __init__(self, iterable):
          self.data = [x for x in iterable]
      ...  # 类内以下的部分自己实现

  L1 = MyList([1,2,3])
  L2 = MyList(range(4, 7))
  L3 = L1 + L2
  print("L3 =", L3)  # MyList([1,2,3,4,5,6])
  L4 = L1 * 2  # 实现乘法运算
  print('L4 =', L4)  # MyList([1,2,3,1,2,3])

反向算术运算符:

方法名运算符
radd加法 +
rsub减法 -
rmul乘法 *
rtruediv除法 /
rfloordiv地板除 //
rmod取模(求余) %
rpow幂 **

示例见:

# 此示例示意返向算术运算符的重载
class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    # def __add__(self, rhs):
    #     return MyList(self.data + rhs.data)

    def __mul__(self, rhs):
        return MyList(self.data * rhs)

    def __rmul__(self, lhs):
        print("__rmul__被调用, lhs=", lhs)
        return MyList(self.data * lhs)  # lhs (left hand side)


L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
L4 = L1 * 2  # 实现乘法运算
print('L4 =', L4)  # MyList([1,2,3,1,2,3])
L5 = 2 * L1  # 可以吗？
print(L5)

复合赋值运算符重载:

方法名运算符
iadd加法 +=
isub减法 -=
imul乘法 *=
itruediv除法 /=
ifloordiv地板除 //=
imod取模(求余) %=
ipow幂 **=

示例见:

# 此示例示意复合赋值算术运算符的重载
class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    def __add__(self, rhs):
        print("__add__方法被调用")
        return MyList(self.data + rhs.data)

    def __iadd__(self, rhs):
        print("__iadd__方法被调用")
        self.data.extend(rhs.data)
        return self

L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
print("id(L1) =", id(L1))
L1 += L2  # 相当于 L1 = L1 + L2
print('L1 =', L1)
print("id(L1) =", id(L1))

问题:
# 算法1
a = [100]
def test(x):
x = x + x
print(x)
test(a)
print(a)

# 解法2
a = [100]
def test(x):
x += x # 此处与上题不同。结果也会不同
print(x)
test(a)
print(a)

比较的运算符的重载

方法名运算符
lt< 小于
le<= 小于等于
gt> 大于
ge>= 大于等于
eq== 等于
ne!= 不等于

注:
比较运算符通常返回True或False

位运算符重载

方法名运算符
inert~ 取反(一元运算符)
and& 位与(交集)
or| 位或(并集)
xor^ 位异或(对称补集)
lshift<< 左移
rshift>> 右移

反向位运算符重载:

方法名运算符
rand& 位与(交集)
ror| 位或(并集)
rxor^ 位异或(对称补集)
rlshift<< 左移
rrshift>> 右移

复合赋值运算符重载:

方法名运算符
iand&= 位与(交集)
ior|= 位或(并集)
ixor^= 位异或(对称补集)
ilshift<<= 左移
irshift`>>= 右移

一元运算符的重载:

方法名运算符
neg
  • 负号
pos
  • 正号
invert~ 按位取反

格式:

def __xxx__(self):
....

示例见:

# 此示例示意一元运算符的重载
class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    def __neg__(self):
        print("__neg__方法被调用!")
        L = (-x for x in self.data)
        return MyList(L)


L1 = MyList([1, -2, 3, -4, 5])
print("L1 =", L1)
L2 = -L1
print("L2 =", L2)

in / not in运算符的重载

格式:

def __contains__(self, e): # e代表元素
...

说明:

not in 相当于 in取反，所有只需要重载in 即可

示例见:

# 此示例示意in / not in 运算符的重载
class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    def __contains__(self, e):  # e 代表测试元素
        print("__contains__被调用")
        for x in self.data:
            if e == x:  # 如果相同，则说明e在列表中
                return True
        return False


L1 = MyList([1, -2, 3, -4, 5])
if 2 in L1:  # 需要重载 __contains__方法
    print("2在L1中")
else:
    print("2 不在L1中")

索引和切片运算符的重载:

重载方法:

  1. 方法

    方法名作用
    getitem(self, i)用于索引/切片取值
    setitem(self, i)用于索引/切片赋值
    delitem(self, i)用于del语句删除索引操作
  2. 作用：
    让自定义的类型的对象能够支持索引和切片操作

  3. 示例见:

    

# 此示例示意索引 index 和切片 slice 运算符的重载

class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    def __getitem__(self, i):
        print("__getitem__被调用", i)
        return self.data[i]

    def __setitem__(self, i, v):
        self.data[i] = v

L1 = MyList([1, -2, 3, -4, 5])
print(L1[2])  # 3?
L1[1] = 2
print(L1)

  4. 练习：
    实现有序集合类 OrderSet(), 能实现两个集合的交集 &, 并集 |
    补集 -, 对称补集 ^, ==, != 等操作(写集合相同)
    要求:
    集合内部用list存储
    class OrderSet:
    def init(self, iterable):
    self.data = [x for x in iterable]
    …
    测试用例:
    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([1,2,3,4]):
    print(“不相同”)
    其它自己测试….

Python---运算符重载
无痕有静
03-23 445
什么是运算符重载： 让自定义的类生成的对象(实例)能够使用运算符进行操作. 算数运算符重载： 方法名 运算符和表达式 说明 __add__(self,other) self + other 加法 __sub__(sel...
Python运算符重载
Phoenix_FuliMa
07-17 2710
在Python语言中提供了类似于C++的运算符重在功能： 一下为Python运算符重在调用的方法如下： Method         Overloads         Call for __init__        构造函数         X=Class() __del__         析构函数        对象销毁 __add__         +
12 Python面向对象编程：运算符重载
最新发布
避免专业名词，喜欢讲人话。
09-05 654
知道了什么是重载，也知道了什么是运算符（加减乘除等），那么运算符重载也很好理解了，其实就是在类里面也定义一些特殊方法，使得调用这些方法能实现类对象的加减乘除。方法不是典型的运算符重载方法，但它确实是一种特殊的方法，用于定义对象的“官方”字符串表示形式。不是用来重载算术或比较运算符的，但它可以被认为是一种形式的“方法重载”，因为它允许你自定义对象如何被转换成字符串形式。在理解运算符重载之前我们已经知道了什么是方法重载，方法重载就是子类继承父类并且定义了一个和父类一样的方法。在这个例子中，我们定义了一个。
python 重载一元运算符
MZP_man的博客
08-24 626
本文讲述python如何实现重载运算符的，
python中的运算符重载
Leo_cumt的博客
10-26 745
python中的运算符重载其实我一直不明白为什么有人一定要用python一个脚本语言去实现c++或是java的功能…… 不过既然人家有这样的用法，那就写写吧。举个栗子： 实现加法的重载。class Fruit: def __init__(self,price=0): self.price=price def __add__(self,other):
日期类重载运算符的运算符重载优先级
# 1. 简介 ## 1.1 日期类的定义与常见运算符 在编程中，日期类通常用于处理日期时间相关的操作，包括日期的加减、比较等。常见的日期类运算符包括加法运算符(+), 减法运算符(-...了解和掌握运算符重载优先级，可以避免
理解日期类中重载运算符的重载规则
日期类中的运算符重载简述 在编程中，日期类通常需要进行加法、减法等运算操作。为了方便对日期类对象进行运算，可以通过重载运算符来实现对日期类的加法和减法操作。接下来，我们将详细介绍日期类中运算符重载的...
日期类中常用运算符的重载示例
本章将介绍什么是运算符重载、为什么需要在日期类中重载运算符以及运算符重载的基本原则。让我们深入了解这些内容。 # 2. 日期类的设计 在实现日期类的过程中，我们需要考虑如何定义日期类的结构、构造函数、成员...
日期类中重载运算符与异常处理的结合实践
## 1.2 引入重载运算符和异常处理在日期类中的应用 为了提高日期类的灵活性和易用性，我们可以利用重载运算符来扩展日期类的功能，使其支持更多的操作方式，例如日期的加减运算、比较操作等。同时，异常处理在日期...
Python 运算符重载
qiqiaiairen的博客
11-07 838
类和模块的第三个主要差别：运算符重载。简而言之，运算符重载就是让用类写成的对象，可截获并响应用在内置类型上的运算：加法、切片、打印和点号运算等。这只是自动分发机制：表达式和其他内置运算流程要经过类的实现来控制。这里也和模块没有什么相似之处：模块可以实现函数调用，而不是表达式的行为。 重载运算符主要概念的概要 以双下划线命名的方法（__X__）是特殊钩子。Python运算符重载的实现是提供特殊命
2020-12-07
weixin_45224503的博客
12-07 208
class MyClass: #自定义一个类 def init(self, name , age): #定义该类的初始化函数 self.name = name #将传入的参数值赋值给成员交量 self.age = age def str(self): #用于将值转化为字符串形式，等同于 str(obj) return “name:”+self.name+";age:"+str(self.age) repr = str #转化为供解释器读取的形式 def lt(self,
一元运算符重载
diaohong5075的博客
08-08 142
一元运算符只对一个操作数进行操作，下面是一元运算符实例： 递增运算符（++） 和递减运算符（--） 一元减运算符，即符号（-） 逻辑非运算符（!） /*** overone.cpp ***/ #include<iostream> using namespace std; class Distance { private: ...
Python运算符重载详解及示例
一元运算符重载： 1. `-` (`__neg__`)：这是用于计算一个数的相反数的运算符。实现时，方法只有一个参数`self`，返回一个新的对象，其值为当前对象的相反数。例如，如果你有一个Vector类，`-vector`应该创建一个与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值