模块异常捕获

模块异常捕获

作业补充

# 10.封装一个函数完成斗地主发牌的功能。
def deal_cards():
    # 1)准备一副新的牌
    colors = ['♥', '♠', '♣', '♦']
    nums = [str(x) for x in range(2, 11)] + ['J', 'Q', 'K', 'A']
    pokers = ['joker', 'JOKER']
    for n in nums:
        for c in colors:
            pokers.append(c + n)

    # 2)洗牌
    shuffle(pokers)

    # 3)发牌
    pokers = iter(pokers)
    player1 = []
    player2 = []
    player3 = []
    for _ in range(17):
        player1.append(next(pokers))
        # print(player1)
        player2.append(next(pokers))
        player3.append(next(pokers))
        # print('--------------------------------------------------')
    # 4)理牌
    values = {'J': 11, 'Q': 12, 'K': 13, 'A': 14, '2': 15, 'oker': 16, 'OKER': 17}
    values.update({str(x): x for x in range(3, 11)})

    player1.sort(key=lambda item: values[item[1:]], reverse=True)
    player2.sort(key=lambda item: values[item[1:]], reverse=True)
    player3.sort(key=lambda item: values[item[1:]], reverse=True)
    return player1, player2, player3, list(pokers)

p1, p2, p3, di = deal_cards()
print(p1)
print(p2)
print(p3)
print(di)

一、生成器

1. 什么是生成器

   1)容器(是一种可以创建多个数据的容器)，生成器中保存的是创建数据的方法，而不是数据本身。
   2)特点：
   a.打印生成器无法查看元素；
   b.不能通过len统计元素的个数；
   c.如果需要生成器中的数据，必须将数据取出，而且取一个少一个
   3)生成器获取元素的方法和迭代器一模一样，一个一个取next()

   优点：节省内存

2. 怎么创建生成器 —— 调用带有yield关键字的函数，就可以得到一个生成器。

   def func1():
       print('hello')
       yield
       return 100
   
   result = func1()
   print(f'result:{result}')
   

3. 怎么控制生成器中元素的个数和元素的值

   原理：执行常见生成器的函数的函数体的时候，会遇到几次yield，对应的生成器就可以创建几个数据，每次遇到yield，yield后面的值就是能创建出来的数据

   def func2():
       print('+++++')
       yield 100
       print('------')
       yield 200
       print('=======')
       yield 300
   
   gen2 = func2()
   print(gen2)
   print('next:', next(gen2))
   print('next:', next(gen2))
   print('next:', next(gen2))
   # print('next:', next(gen2))        # 报错！
   
   print(list(gen2))       # []
   
   print('---------------------------------------华丽的分割线------------------------------------')
   
   def func3(n):
       yield 100
       if n % 2 == 0:
           yield 200
       yield 300
   
   gen3 = func3(3)
   print(gen3)
   print(list(gen3))       # [100, 300]
   # print(next(gen3))     # 报错！
   
   num = 1000
   

二、模块

1. 什么是模块

2. 怎么在一个模块中使用另外一个模块中的内容

   1)使用前提：如果想要在一个模块中使用另外一个模块中的内容，被使用的内容所在的模块的模块名必须符合变量名的要求[只能是标识符，不能是关键字]

   2)导入模块
   a.import 模块名 - 作用：导入指定模块，导入后可以通过’模块名.xxx’的方式使用这个模块中所有的内容

   import test
   
   # a.导入方式1
   # import test
   # print(test.a)
   # print(test.name)
   # print(test.f_test1())
   # test.f_test1()
   

   b.from 模块名 import 内容1,内容2,… - 导入指定模块，导入后可以直接使用指定内容

   # b.导入方式2
   # from test import a,f_test1
   # print(a)
   # print(f_test1())
   # print(test.a)
   # print(name)  #会报错，原因是没有导入
   

   c.from 模块名 import * - 导入指定模块，导入后可以直接使用模块中所有内容

   # c.导入方式3
   # from test import *
   # print(a)
   # print(name)
   # print(f_test1())
   

   d.import 模块名 as 新模块名 - 导入指定模块后对模块进行重命名 ：‘新模块名.xxx’

   # d.导入方式4
   # import test as xiaoye
   # test = 1005
   # print(xiaoye.f_test1())
   # print(xiaoye.a)
   # print(xiaoye.name)
   # print(test)
   

   e.from 模块名 import 内容1 as 新内容1 - 对导入的内容重命名

   # e.导入方式5
   from test import name as new_name,a
   name = '小吴'
   print(name) # 小吴
   print(new_name) # 小敏
   print(a)
   

三、包

1. 什么是包 ——包含__init__.py文件的文件夹就是包

2. 怎么使用包或者文件夹中模块的内容

   1)import 包名 - (只适用于包)导入指定的包，导入后可以通过’包名.xxx’去使用包中__init__.py文件中的所有内容
   2)from 包名 import 模块1,模块2,… - 导入指定包中指定的模块，导入后可以通过’模块名.xxx’使用指定模块中的内容
   3)from 包名 import 内容1，内容2，… - （只适用于包）导入指定包中__init__.py文件中的指定内容
   4)import 包名.模块名
   5)from 包名.模块名 import 内容1，内容2，…

# 导入方式1
# import files2
# files2.f_test2()
# print(files2.pi)

# 导入方式2
from files2 import test2,test4,pi,f_test2
print(test2.msg)
print(test4.abc)
print(pi)
print(f_test2())


from files import test1
print(test1.name)

# 导入方式3
import files2.test2
print(files2.test2.msg)

import files2.test2 as t2
print(t2.msg)

# 导入方式4
from files2.test2 import msg
print(msg)

四、异常捕获

1. 异常的定义：程序中错误。[程序出现异常(报错)会直接让程序结束运行(在哪个位置出现异常，程序就会在哪个地方结束)]

print('+++++++++++')
# print('abc'[4]) #会报错  string index out of range
print('------------')
print('============')

2. 异常捕获 - 让程序在出现异常的时候程序不结束，还可以接着往后执行

   1)语法结构1 - 捕获所有异常
   try:
   代码段1（需要捕获异常的代码）
   except:
   代码段2（出现异常后会执行的代码）
   执行过程：先执行代码段1，执行代码段1的时候如果没有出现异常，就不执行代码段2；如果出现异常，程序不报错并且马上执行代码段2
   finally的代码，不论怎样都会执行

   try:
      age = int(input('请输入年龄:'))
      print(age)
   except:
      print('年龄输入有误！')
   

   2)语法结构2(推荐使用) - 捕获指定类型的异常
   try:
   代码段1（需要捕获异常的代码）
   except 异常类型:
   代码段2（出现异常后会执行的代码）
   finally:
   代码段3(最后不论怎样都会执行)

   try:
       print('abc'[4])
   except IndexError:
       print('出错！')
   finally:
       print('不论怎样都会执行')
   

   3)语法结构3 - 同时捕获多种异常
   try:
   代码段1（需要捕获异常的代码）
   except (异常类型1，异常类型2，…):
   代码段2（出现异常后会执行的代码）
   finally:
   代码段3

   4)语法结构3 - 同时捕获多种异常
   try:
   代码段1（需要捕获异常的代码）
   except 异常类型1:
   代码段11（出现异常后会执行的代码）
   except 异常类型2:
   代码段22（出现异常后会执行的代码）
   except (异常类型3,异常类型4):
   代码段33（出现异常后会执行的代码）
   …
   finally:
   代码段99()