【千锋Python2205班10.11笔记-day14-模块和异常（一阶段）】

01-review

1. 匿名函数

lambda 形参列表: 返回值

2. 实参高阶函数

1) max、min、sorted(sort)

函数的要求：

​ a.有且只有一个参数(代表序列中的元素)
​ b.返回值是比较对象
​

2）map

map(函数, 序列1, 序列2, …)
函数的要求:

​ a.参数的个数和后面序列的个数保持一致
​ b.返回值就是新序列中的元素
​

3)reduce

reduce(函数, 序列, 初始值)
函数的要求:

​ a. 有两个参数
​ b.返回值是合并规则
​

4)filter - 筛选出符合函数制定要求的元素

filter(函数, 序列)
函数的要求:

​ a.有一个参数（元素）
​ b.返回值写留下来的条件

from functools import reduce

nums = [19, 56, 78, 99, 34]
result = filter(lambda item: item % 2 == 0, nums)
print(list(result))

3. 迭代器(iter)

1）创建迭代器

i1 = iter('abcd')

2）获取元素

print(next(i1))
for x in i1:
    print(x)

4.生成器 - 生产多个数据

def func1():
    data = 0
    while True:
        yield data
        data += 1


g1 = func1()

print(next(g1))
print(next(g1))

for _ in range(10):
    print(next(g1))

02-homework

from functools import reduce

1.写一个匿名函数，判断指定的年是否是闰年

is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
print(is_leap_year(2000))

2.写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

def reverse_list(list1: list):
    return list1[::-1]


nums = [12, 4, 90, 67]
result = reverse_list(nums)
print(result)


def reverse_list2(list1: list):
    count = len(list1)
    for n in range(count//2):
        m = count - 1 - n
        list1[n], list1[m] = list1[m], list1[n]


nums = [12, 4, 90, 67]
reverse_list2(nums)
print(nums)

# [12, 4, 90, 67,  90, 89, 23]

"""
4:  0 -> 3;  1->2                   n:  0 ~ 个数//2-1    m: 个数-1-n
6:  0 -> 5;  1->4; 2->3 
5:  0 -> 4;  1->3                   
7:  0 -> 6;  1 -> 5; 2->4
"""
nums = [12, 4, 90, 67]
result = map(lambda item: nums[len(nums)-1-item], range(len(nums)))
print(list(result))

3.编写一个函数，计算一个整数的各位数的平方和

nums = 123

# 0 + 1**2 + 2**2 + 3**2

result = reduce(lambda i, item: i + int(item)**2, str(nums), 0)
print(result)

4.求列表 nums 中绝对值最小的元素

nums = [-23, 100, 89, -56, -234, 123]
result = min(nums, key=lambda x: x**2)

# result = min(nums, key=abs)

print(result)

5.已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
result = dict(map(lambda a, b: (a, b), A, B))
print(result)

6.已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
result = dict(map(lambda i1, i2, i3: (i1, i3+i2), names, nums, subjects))
print(result)

7. 已经一个列表message, 使用reduce计算列表中所有数字的和

message = ['你好', 20, '30', 5, 6.89, 'hello']
result = reduce(lambda i, item: i + item, [x for x in message if type(x) in (int, float)], 0)
print(result)

# 0 + 0 + 20 + 0 + 5 + 6.89 + 0

result = reduce(lambda i, item: i+item if type(item) in (int, float) else i + 0, message, 0)
print(result)

8. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）

points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

1）获取列表中y坐标最大的点

print(max(points, key=lambda item: item[-1]))

2）获取列表中x坐标最小的点

print(min(points, key=lambda item: item[0]))

3）获取列表中距离原点最远的点

print(max(points, key=lambda item: item[0]**2 + item[1]**2))

4）将点按照点到x轴的距离大小从大到小排序

print(sorted(points, key=lambda item: item[-1]**2))

9.封装一个函数完成斗地主发牌的功能。

from random import shuffle, choice


def deal_cards():

    # 1）准备一副牌

​    colors = ['♥', '♠', '♣', '♦']
​    nums = [str(x) for x in range(2, 11)] + ['J', 'Q', 'K', 'A']
​    pokers = []
​    for n in nums:
​        for c in colors:
​            pokers.append(c+n)
​    pokers.extend(('JOKER', 'joker'))

    # print(pokers)

    # 2）洗牌

​    landlord = choice(pokers)
​    pokers.remove(landlord)
​    landlord = '地' + landlord
​    pokers.append(landlord)

​    shuffle(pokers)

    # print(pokers)

    # 3）发牌

​    player1 = []
​    player2 = []
​    player3 = []
​    d_pokers = iter(pokers)
​    for _ in range(17):
​        player1.append(next(d_pokers))
​        player2.append(next(d_pokers))
​        player3.append(next(d_pokers))

    # 4）理牌

​    table = {str(x): x for x in range(3, 11)}
​    table.update({'J': 11, 'Q': 12, 'K': 13, 'A': 14, '2': 15, 'oker': 16, 'OKER': 17})
​    player1.sort(key=lambda item: table[item[2:]] if item.startswith('地') else table[item[1:]], reverse=True)
​    player2.sort(key=lambda item: table[item[2:]] if item.startswith('地') else table[item[1:]], reverse=True)
​    player3.sort(key=lambda item: table[item[2:]] if item.startswith('地') else table[item[1:]], reverse=True)

​    return player1, player2, player3, list(d_pokers)

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

03-模块

1. 什么是模块

python中一个py文件就是一个模块。

2.如何在一个模块中去使用另外一个模块中的内容

使用前提：1)需要被别的模块使用的模块的模块名必须符合变量名的要求
2)导入模块 - 模块里面的内容必须要先导入再使用

3.怎么导入模块

1)import 模块名 -

​ 导入指定模块，导入后可以通过’模块名.xxx’的方式使用这个模块中的全局变量

2)from 模块名 import 变量1,变量2,变量3,… -

​ 导入指定模块，导入后可以直接使用指定的变量

3) from 模块名 import * -

​ 导入指定模块，导入后可以直接使用模块中所有的全局变量

4)import 模块名 as 新模块名 -

​ 对模块重命名

5)from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2, … -

对变量重命名

# =============导入方式1============

# import test1

#

# print(test1.a)

# print(test1.name)

# test1.func1()

# =============导入方式2============

# from test1 import a, func1

# print(a)

# func1()

# # print(name)     # 报错

# =============导入方式3============

# from test1 import *

# print(a)

# print(name)

# func1()

# =============导入方式4============

# import test1 as t1

# print(t1.name)

# print(t1.a)

# t1.func1()

# =============导入方式5============

# from test1 import name as n, a, func1

# print(n)

04-导入模块的原理

1. 导入原理

不管是import还是from-import导入模块的时候，系统都会自动进入指定的模块，将模块中的代码全部执行一遍。

2. 阻止导入

导入模块的时候，不让模块中的所有代码都执行，只执行需要执行的部分。

阻止的方法：在被导入的模块中添加main对应的if语句，把不希望被别的模块执行的代码放到if语句里面

# from test1 import a

# from test2 import download

#

# download('肖生克的救赎')


# 注意：同一个模块如果导入多次，模块中的代码只会执行一次（自动查重）

import test1
import test1

import test2

if __name__ == '__main__':
    pass

05-包

1.什么是包

python中将包好了__init__.py文件的文件夹叫做包，它是专门用来管理模块的。

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

1)import 包名 -

直接导入包，导入后可以用’包名.xxx’去使用包中__init__.py文件中的所有的全局变量

2)import 包名.模块名 -

导入包中指定的模块，导入后可以用’包名.模块名.xxx’去使用指定模块中的所有的全局变量

3)from 包名 import 模块名1,模块名2,…

4)from 包名.模块名 import 变量1, 变量2, …

# =================导入方式1==============

# import files2

# print(files2.x)

# =================导入方式2==============

# import files2.test3

# print(files2.test3.b)

# print(files2.test3.age)

# files2.test3.func2()

# import files2.test3 as test3

# print(test3.b)

# print(test3.age)

# test3.func2()

# =================导入方式3==============

# from files2 import test3

# print(test3.b)

# print(test3.age)

# test3.func2()

# =================导入方式4==============

# from files2.test3 import b, func2

# print(b)

# func2()

from files2.test.test4 import message
print(message)

06-异常捕获

1. 异常 -

程序执行过程中报的错就是异常

# 如果程序执行过程中出现了异常，程序会崩溃，不会再执行后面的代码

print('====')
print('++++')

# print('abc'[5])

print('------')

2. 异常捕获 -

让程序在出现异常的时候不崩溃，还能接着往后执行

1）异常捕获的场景：

程序员知道某个位置可能会出现异常(出现异常的原因不是代码本身的问题，而是使用者操作不当等原因)，但是又希望在出现异常的时候程序不崩溃还可以接着往后执行，这个时候才需要进行异常捕获。

2）捕获异常的语法结构：

a. 捕获任何类型的异常
try:
代码段1(需要捕获异常的代码)
except:
代码段2(捕获到异常以后会执行的代码)

执行过程：先执行代码段1，如果代码段1出现异常不会报错，而是马上执行代码段2；如果代码段1没有出现异常，代码段2不执行。

b.捕获特定类型的异常
try:
代码段1(需要捕获异常的代码)
except 异常类型:
代码段2(捕获到异常以后会执行的代码)

c.可以同时捕获多种异常，针对不同的异常做相同的处理
try:
代码段1(需要捕获异常的代码)
except (异常类型1, 异常类型2,…):
代码段2(捕获到异常以后会执行的代码)

d.可以同时捕获多种异常，针对不同的异常做不同的处理
try:
代码段1
except 异常类型1:
代码段11
except 异常类型2:
代码段22
except 异常类型3:
代码段33
…

# try:

#     age = int(input('请输入年龄:'))

#     if age >= 18:

#         print('成年')

#     else:

#         print('未成年')

#     print(age + '岁')

# except ValueError:

#     print('年龄输入有误！')


print('===========')

# print('abc'[4])

# print(3 + 'abc')

# print({'a': 10}['b'])

# print(int('abc'))

3.异常捕获完整结构

try:
代码段1（需要捕获异常的代码）
except:
代码段2（捕获到异常后会执行的代码）
else:
代码段3（没有出现异常会执行的代码）
finally:
代码段4（无论有没有出现异常也不管异常有没有捕获到，都会执行的代码 - 无论什么情况都会执行）

try:
    print('abc'[4])
except KeyError:
    print('出现异常')
else:
    print('没有出现异常')
finally:
    print('都会执行')

07-抛出异常

1. 抛出异常 -

主动让程序报错、崩溃

语法：raise 异常类型

# 自定义异常类型：

class AgeError(Exception):
    def __str__(self):
        return '年龄值有误，正确的年龄范围是0岁到150岁!'

age = int(input('请输入正确的年龄(0~150):'))
if age < 0 or age > 150:
    raise AgeError