Python学习记录之运算符重载、文件处理、异常处理、元组、集合、字典

探索世界的小白

已于 2022-03-07 16:22:46 修改

阅读量531

点赞数

分类专栏： # Python 学习记录文章标签： python

于 2022-03-07 16:21:15 首次发布

原文链接：https://overiq.com/python-101/operator-overloading-in-python/

版权

Python 学习记录专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、运算符重载

运算符重载允许重新定义对应于类的运算符的含义。
运算符重载是通过在类中定义特殊方法实现的。这些方法以双下划线开头和结尾。用于重载运算符的特殊方法对应关系如下：

算子	特殊方法
+	__ add__(self, object)
_	__ sub__(self, object)
*	__ mul__(self, object)
**	__ pow__(self, object)
/	__ truediv__(self, object)
//	__ floordiv__(self, object)
%	__ mod__(self, object)
==	__ equ__(self, object)
!=	__ ne__(self, object)
>	__ gt__(self, object)
>=	__ ge__(self, object)
<	__ lt__(self, object)
<=	__ le__(self, object)
in	__ contains__(self, value)
[index]	__ getitem____(self, index)
len()	__ len__(self)
str()	__ str__(self)

如何重写？

class A:
    def __add__(self, point_obj):
        return Point(self.__x + point_obj.__x, self.__y +point_obj.__y)

二、文件处理

文件类型：文本文件和二进制文件
可以使用文本编辑器查看其内容的文件称为文本文件。文本文件只是ASCII或Unicode字符的序列。文本文件的一个示例是HTML源代码。

二进制文件存储数据的方式与存储在内存中的方式相同。mp3文件、图像文件、word文档是二进制文件的一些示例。无法用文本编辑器读取二进制文件。

1.打开文件

fileobject = open(filename, mode)
// filename 是文件路径
// mode 是一个字符串，用于指定要对文件执行的操作类型（即读取、写入、追加等）

下面列出可以用的一些mode:

模式	描述
“r”	打开文件进行读取操作。若文件不存在，则会报FileNotFoundError错误
“w”	打开文件行写入。在此模式下，如果指定的文件不存在，则将创建该文件。如果文件存在，其原来的数据会被销毁
“a”	以追加模式打开文件。如果文件不存在，则创建文件。若文件已存在，则会将新数据追加到文件末尾。而不会向“w”一样销毁数据

可以通过附加文本文件和二进制文件来指定要在字符中使用的文件类型（即文本文件“t”或二进制文件"b"），默认是文本文件。

open()成功时，返回一个文件对象，该文件对象在调用时与指定的文件对象相关联。

2.关闭文件

一旦文件使用完毕，或想以其他模式打开文件，需要关闭文件

f.close()

关闭文件会释放宝贵的系统资源。如果网络关文件，Python 将在程序结束或程序中不再引用文件对象时自动关闭文件。但是，如果程序很大，并且正在读取或写入多个文件，则这些文件可能会占用系统上的大量资源。如果不小心打开新文件，可能会耗尽资源。

3.TexIOWrapper类

TextIOWrapper 提供了一些文件读写的方法如下：

方法	描述
read([num])	从文件中读取特定num的字符，并以字符串返回他们。如果没有num，最读取整个文件
readline()	读一行并且以字符串返回
readlines()	一行一行读文件内容，并返回一个字符串列表
write(str)	往文件里写字符串参数，并返回写入文件中的字符数
seek(offset, origin)	把文件指针从origin 移动指定的offset偏离量
tell()	返回当前文件指针的位置
close()	关闭文件

文件指针是一个标记，用于跟踪文件中读取或写入的字节数。此指针在每次读取或写入操作后自动移动。

打开文件时，文件指针指向文件的开头，只要开始读取了，文件指针就在移动。可以用 print 函数往文件里写数据，只需把参数"file=f"（f 文件对象）改成这样即可。

os.isfile(path) 函数可用于检查文件是否存在。
可以以二进制文件的形式读写图像文件。

三、异常处理

异常处理是一种机制，它允许我们在程序运行时正常处理错误，而不是图像结束程序运行。
运行时错误是程序运行时发生的序偶无。运行时错误并不表示程序的结构（或语法）存在问题。发生运行时错误是，python 解释器完全理解程序，但无法执行。是由于程序结构不正确，因此会发生语法错误。

如：1.除以0
2. 整数与字符串相加
3. 访问索引无效的元素
4. 在不存在文件的情况下读取文件

程序运行时发生的错误称为异常。每当发生此类错误是，python 都会创建一个特殊类型的对象。其中包含有关刚刚发生的错误的所有相关信息。

1. try-except 语句处理异常

try:
    # 在这里写可能会发生异常的语句
except ExceptionType:
    # 这里写用于处理异常的代码

当 try 发生异常时，将跳过try 中其余语句的执行。如果引发的异常与 except 子句中的异常类型匹配，则执行相应的处理程序。如果异常类型不匹配，则程序将停止并回溯。如果 try 中未发生异常，则跳过 except 部分。

i. 处理多个异常

可以根据需要添加任意数量的字句来处理不同类型的异常。一般格式如下：

try:
    # 在这里写可能会发生异常的语句
except <ExceptionType1>:
    # 这里写用于处理异常的代码
except <ExceptionType2>:
    # 这里写用于处理异常的代码
    ...
except:
    #任意类型的处理语句

程序运行时，如果遇到异常，会按顺序匹配异常类型。一旦匹配到，剩下的 except 语句就都不执行了。

ii. else 和 finally 条款

try-except 语句还可以具有可选字句 else，该字句仅在try-except 未发生异常时执行。

try:
    # 在这里写可能会发生异常的语句
except <ExceptionType1>:
    # 这里写用于处理异常的代码
except <ExceptionType2>:
    # 这里写用于处理异常的代码
    ...
except:
    #任意类型的处理语句
else:
    <statements>

同样，可以在所有字句后都有一个 finally 语句。无论是否发生异常， finally 语句下的字句都会执行。

try:
    # 在这里写可能会发生异常的语句
except <ExceptionType1>:
    # 这里写用于处理异常的代码
except <ExceptionType2>:
    # 这里写用于处理异常的代码
    ...
except:
    #任意类型的处理语句
finally:
    <statements>
    # 这部分语句通常用于定义在任意环堵中都必须执行的清理操作。

如果 else statements 有一个 finally clause, 这个 clause 一定出现在它之后。

2.异常传播和引发异常

异常是由函数引发的对象，该对象表示发生了意外事件。而函数本身无法处理，函数通过从适当的类创建异常对象来引发异常，然后使用关键字 raise 将异常抛出调用代码。

当异常在函数内部引发且未被捕获时，它会自动传播到调用函数（以及堆栈中任何函数），直到它被某个调用函数中的语句捕获。如果异常到达主模块仍未处理，则程序将终止并显示错误。

通常，被调用的函数会向调用方引发异常，并且调用代码的职责是处理异常。这种方法允许我们以不同的方式处理异常。如果我们在被调用的函数中处理异常。那么每次需要新行为时，我们都必须更新函数。除此之外，python 标准库中所有函数都符合次行为。库函数仅检测问题并引发异常。客户端需要决定执行那些操作来处理这些错误。

3.访问异常对象

使用 except 子句访问异常对象

except ExceptionType as e:

每当子句 except 捕获异常 ExceptionType 时，就会将异常分配给变量 e.

创建自己的except

python 中异常类层次结构（都在build-in 类中）：
这些异常都属于build-in 类中
可以从build-in 类中创建自己的exception类。下面给出例子如何创建：

## class_name.py
class Error_name(Exception):
    def __init__(self, message):
        supper().__init__()
        self.message = message
    def __str__(self):
        return self.message

## 调用文件
from class_name import *
def factorial(n):
    if not isinstance(n, int):
        raise class_name("Argument must be int")
    if n < 0:
        raise class_name("Argument must be >= 0")
    f = 1
    for i in range(n):
        f *= n
        n -= 1
    return f
try:
    print("Factorial of 12 is:", factorial("12"))
except class_name as e:
    print("Error:", e)

下面是输出：

Error: Argument must be int

四、元组

元组一旦创建就不能添加、删除、或修改元素。元组用于存储不可更改的项目列表。

1.创建元组

元组可以通过列出一对括号内用都好分割的元素来表示，括号也可以省略掉。
可以使用构造函数 tuple() ，该函数接受任何类型的序列或可迭代对象。
下面是创建示例：

>>> t = ("apple", "peach", "pear")
# 也可以创建空元组
>>> t = ()
# 使用构造函数 tuple()
>>> t1 = tuple("abcd")
>>> t1
('a', 'b', 'c', 'd')
>>> t2 = tuple(range(1,5))
>>> t2
(1, 2, 3, 4)
>>> t3 = tuple([1, 3, 5, 7])
>>> t3
(1, 3, 5, 7)
## 也可以用列表推导创建
>>> t4 = tuple([x*2 for x in range(1,5)])
>>> t4
(2, 4, 6, 8)
# 若要创建仅包含一个元素的元组，必须在值后面加上逗号。否则就不是元组
>>> t5 = (4,)

2.元组解压缩

元组允许一次将值分配给多个变量

first, second, third = ("apple", "peach", "pear")

这称为元组解压缩。变量数（左侧）与元组中的元素数（右侧）***必须***匹配，否则会报错。

3.元组上的操作

元组本质上是一个不可变的列表。因此可以再列表上执行的大多数操作也对元组有效。如：
1. [ ] 访问单个元素或元组切片
2. max(), min(), sum() 对元组也是有效的
3. in, ont in
4. 比较两个元组
5. + 和 * 运算
6. for 循环访问元组等
但修改列表本身的操作无法用于元组。

五、集合

集合是另一种可变序列类型，用于存储唯一项的集合，可以将集合视为列表，但他们在以下方面有所不同：
1. 集合中的每个元素必须是唯一的
2. 集合中的元素不按特定顺序存储

1.创建集合

a_set = {item1, item2, ..., itemN}

也可以用构造函数 set() 创建。其参数可以是元组、列表、字符串集合等。可以用函数 len() 获取集合中元素数量。

max(), min(), sum() 也可以用于集合。

集合是可变对象，可以在集合中添加和删除元素，无需在此过程中创建其他集合对象。使用 add() 和 remove() 方法分别执行添加和删除操作。

如果删除一个不存在的元素，则会报KeyError 错误。可以使用 discard() 方法。该方法也会从集合中删除元素，但如果找不到元素，它将以静默方式忽略该错误。

可以使用 update() 方法一次向集合中添加多个元素。 update() 接受可迭代类型对象，如元组、列表、字符串等。注意对象的各个元素会成为集合中的元素，而非对象本身。

要从集合中清楚所有元素，使用 clean() 方法，集合.clear()

可以使用 for 循环查看访问集合中元素。

2.子集和超集

如果 A 中所有元素也是集合 B 中元素，则 A 是 B 的子集，也可以说 B 是 A 的超集。可以使用 issubset() 和 issuperset() 测试一个集合是另一个集合的子集还是超集。也可以使用关系运算符测试一个集合是另一个集合的子集还是超集。

“==” 和 “！=” 用于测试两个集合是否相同（即是否具有相同的元素）

3.并集和交集

集合1.union(集合2) = 集合1 并 集合2
集合1.intersection(集合2) = 集合1 交 集合2

4.集合的差

A-B = 表示A 中有但 B 中没有的元素。python 中用“-”号或 difference() 方法来执行差的操作。

5.集合的对称差

两个集合的***对称差*** 由在一个集合中而不在两个集合中的元素组成的集合。“△” 符号表示对称差。如

s1 = {20, 30, 40}
s2 = {30, 40, 200, 300}
s1 △ s2 = {20, 200, 300}

python 中用 symmetric_difference() 或 ∧ 运算执行对称差。

六、字典

字典是另一种内置类型，用于存储键值对的集合。

字典中每个元素都有两部分：键和值。存储在字典中的元素没有特定的存储顺序，使用键访问特定的值。大多数时候，键是一个字符串，但它可以使任何不可变的类型，如 int, float, 元组，字符串等。每个键都映射一个值，因此不能有重复的键。字典是可变对象。

1.创建字典

# 用以下语法创建字典
variable_name = {
    'key1': 'value1',
    'key2': 'value2',
    ...
    'keyN': 'valueN'
    }

# 也可以用构造函数 dict 创建字典。语法如下：
dict_contacts = dict(item1='value1', item2='value2', ..., itemN='valueN')

2.访问字典的值

从字典访问值

dict_name[key]
# 如果指定的 key 不存在，则引发异常 KeyError

添加和修改

dict_name[key] = value
# 如果这个 key 在 dict_name 中已存在，则更新 key 对应的值。

删除元素

del dict_name[key]
# 如果 key 这一项 dict_name 中不存在，则引发异常 KeyError

len() 可以返回字典中元素的数量
可以用 for 循环访问字典中的所有键
可以用 in 和 not in 判断字典中是否存在 key
可以用 == 和 != 比较两个字典是否包含相同元素，其他比较运算符不能用于字典

3.字典中的常用方法

方法	功能
keys()	返回字典中键的序列
values()	返回字典中值的序列
items()	返回一个元组序列，其中每个元组都包含有一个元素的键和值
get(key, [default])	返回与key相关联的值。如果未找到key，则返回None。也可以提供可选的default作为第二个参数。在这种情况下，如果未找到key，则将返回 default 而不是 None。
pop(key)	返回与 key 关联的值，然后从字典中删除指定的键及对应的值。如果 key 不存在，则会引发异常 KeyError。
popitem()	从字典中删除随机元素并将其作为元组返回
copy()	创建字典的新副本
clear()	删除字典中所有元素