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)
- 已经一个列表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)
- 已经列表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
扫一扫
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
