0基础,跟我一起学python--基础篇(2)


哈喽！大家好，我是「奇点」，江湖人称 singularity。刚工作几年，想和大家一同进步欄欄
一位上进心十足的【Java ToB端大厂领域博主】！
喜欢java和python，平时比较懒，能用程序解决的坚决不手动解决

✨ 如果有对【java】感兴趣的【小可爱】，欢迎关注我

❤️❤️❤️感谢各位大可爱小可爱！❤️❤️❤️
————————————————

如果觉得本文对你有帮助，欢迎点赞，欢迎关注我，如果有补充欢迎评论交流，我将努力创作更多更好的文章。
————————————————
 

 今天继续给大家分享python的学习笔记，之前吧python的基础知识，譬如特点、发展史、基本数据类型，逻辑语句和循环语句和集合等基础知识，有了这些入门知识，我们就能写一下简单的逻辑代码了。今天我们继续深入学习python到基础知识。

对python 0基础的同学可以看一下我的上篇文章，再来学习这篇文章，大佬可以直接跳过。

0基础跟我学python系列

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。python中内置了很多方法供我们使用。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

同其他编程语言一样，每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式，当然python中还有很多时间模块供我们选择，使用datetime模块、pytz模块和dateutil模块。我们今天主要讲的是time模块如函数time.time()用于获取当前时间戳, 如下实例:

import time  # 引入time模块

ticks = time.time()
print("当前时间戳为:", ticks)

结果如下 

当前时间戳为: 1658989655.302531

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。 

很多Python函数用一个元组装起来的9组数字处理时间:

上述也就是struct_time元组。这种结构具有如下属性

从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

localtime = time.localtime(time.time())
print("本地时间为 :", localtime)

返回的结果如下： 

本地时间为 : time.struct_time(tm_year=2022, tm_mon=7, tm_mday=28, tm_hour=15, tm_min=46, tm_sec=4, tm_wday=3, tm_yday=209, tm_isdst=0)

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)

本地时间为 : Thu Jul 28 17:11:02 2022

我们可以使用 time 模块的 strftime 方法来格式化日期，：

time.strftime(format[, t])

import time

# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
 
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))

2022-07-28 17:15:42
Thu Jul 28 17:15:42 2022
1459175064.0 

python中时间日期格式化符号：

• %y 两位数的年份表示（00-99）
• %Y 四位数的年份表示（000-9999）
• %m 月份（01-12）
• %d 月内中的一天（0-31）
• %H 24小时制小时数（0-23）
• %I 12小时制小时数（01-12）
• %M 分钟数（00=59）
• %S 秒（00-59）
• %a 本地简化星期名称
• %A 本地完整星期名称
• %b 本地简化的月份名称
• %B 本地完整的月份名称
• %c 本地相应的日期表示和时间表示
• %j 年内的一天（001-366）
• %p 本地A.M.或P.M.的等价符
• %U 一年中的星期数（00-53）星期天为星期的开始
• %w 星期（0-6），星期天为星期的开始
• %W 一年中的星期数（00-53）星期一为星期的开始
• %x 本地相应的日期表示
• %X 本地相应的时间表示
• %Z 当前时区的名称
• %% %号本身

Calendar 模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：

import calendar

cal = calendar.month(2022, 1)
print("以下输出2022年1月份的日历:")
print(cal)

以下输出2022年1月份的日历:
    January 2022
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31

此模块的函数都是日历相关的，例如打印某月的字符月历。星期一是默认的每周第一天，星期天是默认的最后一天。

更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：

>>> import calendar
>>> print(calendar.isleap(2000))
True
>>> print(calendar.isleap(1900))
False

>>> import calendar
>>> calendar.monthrange(2014, 11)
(5, 30)

和其他语言一样python中的函数也是为了实现某一功能的代码段，用来实现单一功能，能够重复使用。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

例如比较两个数，并返回较大的数:

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

如下实例调用了 printme() 函数：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的：

a=[1,2,3]

a="Runoob"

 以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

• 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

通过 id() 函数来查看内存地址变化：

la = [1, 2, 3]
print("...")
print("la的地址" + str(id(la)))
la[2] = 5
print('la的地址' + str(id(la)))


def change(a):
    print(id(a))  # 4363387120  还是原来的对象，形式参数和实参是一个对象
    a = 10
    print(id(a))  # 4363387408  修改了对象之后，不再是原来的对象，新生成了一个对象


a = 1
print(id(a))  # 4363387120
change(a)
print(a)  # 1 还是源对象，方法中的是局部变量
print(id(a))  # 4363387120

la的地址4366217024
la的地址4366217024

4363387120
4363387120
4363387408
1
4363387120

可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

def changeme(mylist):
    "修改传入的列表"
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    print("mylist地址2" + str(id(mylist)))
    return


# 调用changeme函数
mylist = [10, 20, 30]
print("mylist地址1" + str(id(mylist)))
changeme(mylist)
print("mylist地址3" + str(id(mylist)))
print("函数外取值: ", mylist)

mylist地址24366783488
mylist地址34366783488

以下是调用函数时可使用的正式参数类型：

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

Traceback (most recent call last):
  File "test.py", line 10, in 
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "我是菜鸟一枚")

结果：

我是菜鸟一枚 

以下实例中演示了函数参数的使用不需要使用指定顺序：

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

结果：

名字:  runoob
年龄:  50

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

 结果：

名字:  runoob
年龄:  50
------------------------
名字:  runoob
年龄:  35

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

结果

输出: 
70
(60, 50)

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

结果：

输出:
10
输出:
70
60
50

还有一种就是参数带两个星号 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

以上实例输出结果：

输出: 
1
{'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现，例如:
 

def f(a,b,*,c):
    return a+b+c

如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "", line 1, in 
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

设置参数 a 加上 10:

x = lambda a : a + 10
print(x(5))

以下实例匿名函数设置两个参数：

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

结果：

相加后的值为 :  30
相加后的值为 :  40

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

结果

22

33

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

结果：

函数内 :  30
函数外 :  30

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

好嘞，学到这里，我们把函数就学习完了，哈哈哈给自己点一个赞吧，休息一下马上回来。

Python open() 方法用于打开一个文件，并返回文件对象。

在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数有：

默认为文本模式，如果要以二进制模式打开，加上 b 。

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

例如下面的例子

当然可以根据自己的需求，在上面的mode参数中根据自己的需求选择不同的模式

"""
文件写操作
"""
try:
    file_path = "abc.txt"
    # file_path = "/Users/ligang/Desktop/abc.txt"
    file = open(file_path, 'a', encoding='utf-8')
    file.write("写文件你好啊")
finally:
    file.close()

"""
之前的东西没有了     w-会把文件的指针放到开头
                  a-追加
"""

这时由于之前没有这个文件，创建了一个新的文件

f = open('abc.txt', 'r', encoding='utf-8')
print(f.read())
f.close()

这是运行3遍程序之后的abc.txt文件内容

这里说一下read()和readlines()、readline()三者各自的作用：
（1）read() ——不管文件内容的多少一次性全部读出

（2）readlines()——按照行的方式把整个文件中的内容进行一次性的读取，并且返回的是一个列表，其中每一行的数据为一个元素

（3）readline()—— 一次读取一行

try:
    f = open('abc.txt', 'r', encoding='utf-8')
    # print('read方法' + f.read())
    # list = f.readline()
    # for x in list:
    # print(f.readline())
    # print('readline方法' + str(x))
    list = f.readlines()
    print(list)
    for x in list:
        print('readlines方法' + x)
finally:
    f.close()

结果

 readline方法

try:
    f = open('abc.txt', 'r', encoding='utf-8')

    print(f.readline())

finally:
    f.close()

结果

写文件你好啊1 

再加一个readline方法

try:
    f = open('abc.txt', 'r', encoding='utf-8')

    print(f.readline())
    print(f.readline())

finally:
    f.close()

这时的输出就是下面的样子，多读取了一行

写文件你好啊1

写文件你好啊2

当访问模式中有b时，代表以二进制格式处理。

try:
    f = open('python.png', 'rb')
    print(f.read())
finally:
    f.close()

结果： 

在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

>>> str(1/7)
'0.14285714285714285'

>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"

这里有两种方式输出一个平方与立方的表:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

意：在第一个例子中, 每列间的空格由 print() 添加。

str.format() 的基本使用如下:

print('{}网址： "{}!"'.format('hello', 'www.hello.com'))

 hello网址： "www.hello.com!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

print('{0} 和 {1}'.format('Google', 'hello'))

Google 和 hello

print('{1} 和 {0}'.format('Google', 'hello'))

hello 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

 print('{name}网址： {site}'.format(name='hello', site='www.hello.com'))

hello网址： www.hello.com

位置及关键字参数可以任意的结合:

print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'hello', other='Taobao'))

站点列表 Google, hello, 和 Taobao。 

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

str = input("请输入：");
print ("你输入的内容是: ", str)

这会产生如下的对应着输入的结果：

请输入: hello world
你输入的内容是:  hello world

作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这里我们来学习

Python 有两种错误很容易辨认：语法错误和异常。

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

在异常处理方面python的处理方式和java很相似，我们能够通过类比的方式学习python的异常处理机制。

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

while True print('Hello world')

  File "", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

对异常的处理有两种方式，这个也是和java中的处理方法一样，是不是学起来就简单了呢。

即使语句或表达式使用了正确的语法，执行时仍可能触发错误。执行时检测到的错误称为 异常，异常不一定导致严重的后果：很快我们就能学会如何处理 Python 的异常。大多数异常不会被程序处理，而是显示下列错误信息：

>>> 10 * (1/0)
Traceback (most recent call last):
  File "", line 1, in 
ZeroDivisionError: division by zero



>>> 4 + spam*3
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'spam' is not defined



>>> '2' + 2
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str

错误信息的最后一行说明程序遇到了什么类型的错误。异常有不同的类型，而类型名称会作为错误信息的一部分中打印出来：上述示例中的异常类型依次是：ZeroDivisionError， NameError 和 TypeError。作为异常类型打印的字符串是发生的内置异常的名称。对于所有内置异常都是如此，但对于用户定义的异常则不一定如此（虽然这种规范很有用）。标准的异常类型是内置的标识符（不是保留关键字）。

此行其余部分根据异常类型，结合出错原因，说明错误细节。

错误信息开头用堆栈回溯形式展示发生异常的语境。一般会列出源代码行的堆栈回溯；但不会显示从标准输入读取的行。

可以编写程序处理选定的异常。下例会要求用户一直输入内容，直到输入有效的整数，但允许用户中断程序（使用 Control-C 或操作系统支持的其他操作）；注意，用户中断程序会触发 KeyboardInterrupt 异常。

while True:
    try:
        x = int(input("Please enter a number: "))
        break
    except ValueError:
        print("Oops!  That was no valid number.  Try again...")

try 语句的工作原理如下：

• 首先，执行 try 子句 （try 和 except 关键字之间的（多行）语句）。

• 如果没有触发异常，则跳过 except 子句，try 语句执行完毕。

• 如果在执行 try 子句时发生了异常，则跳过该子句中剩下的部分。 如果异常的类型与except 关键字后指定的异常相匹配，则会执行 except 子句，然后跳到 try/except 代码块之后继续执行。

• 如果发生的异常与 except 子句 中指定的异常不匹配，则它会被传递到外部的 try 语句中；如果没有找到处理程序，则它是一个 未处理异常 且执行将终止并输出如上所示的消息。

try 语句可以有多个 except 子句 来为不同的异常指定处理程序。 但最多只有一个处理程序会被执行。 处理程序只处理对应的 try 子句 中发生的异常，而不处理同一 try 语句内其他处理程序中的异常。 except 子句 可以用带圆括号的元组来指定多个异常，例如:

except (RuntimeError, TypeError, NameError):
    pass

⛳️ 

⛳️