01-homework
1.编写一个函数,交换指定字典的key和value。
def exchange_key_value(d: dict):
for key in d:
value = d.pop(key)
d[value] = key
dict1 = {'a': 1, 'b': 2, 'c':3}
exchange_key_value(dict1)
print(dict1)
def exchange_key_value2(d: dict):
new_dict = {d[key]: key for key in d}
return new_dict
dict1 = {'a': 1, 'b': 2, 'c': 3}
result = exchange_key_value2(dict1)
print(result)
2.编写一个函数,提取指定字符串中所有的字母,然后拼接在一起产生一个新的字符串
def get_letter(str1: str):
new_str = ''
for x in str1:
if x.islower() or x.isupper():
new_str += x
return new_str
print(get_letter('安徽三建h22buKJ2jks0'))
3.写一个自己的capitalize函数,能够将指定字符串的首字母变成大写字母
def capitalize(str1: str):
first_char = str1[0]
if 'a' <= first_char <= 'z':
return chr(ord(first_char) - 32) + str1[1:]
return str1
print(capitalize('mskHs'))
4.写一个自己的endswith函数,判断一个字符串是否已指定的字符串结束
def endswith(str1: str, end: str):
return str1[-len(end):] == end
print(endswith('abcms', 'ma'))
5.写一个自己的isdigit函数,判断一个字符串是否是纯数字字符串
def isdigit(str1: str):
for x in str1:
if not '0' <= x <= '9':
return False
return True
6.写一个自己的upper函数,将一个字符串中所有的小写字母变成大写字母
def upper(str1: str):
new_str1 = ''
for x in str1:
if 'a' <= x <= 'z':
new_str1 += chr(ord(x)-32)
else:
new_str1 += x
return new_str1
7.写一个自己的rjust函数,创建一个字符串的长度是指定长度,原字符串在新字符串中右对齐,剩下的部分用指定的字符填充
def rjust(str1: str, length: int, char: str):
if length >= len(str1):
return char * (length - len(str1)) + str1
return str1
8.写一个自己的index函数,统计指定列表中指定元素的所有下标,如果列表中没有指定元素返回-1
def index(list1, item):
result = []
for x, y in enumerate(list1):
if y == item:
result.append(x)
if result:
return result
return -1
11.写一个函数实现自己in操作,判断指定序列中,指定的元素是否存在
def list_in(list1, item):
index = 0
while True:
if list1[index] == item:
return True
index += 1
if index >= len(list1):
return False
02- review
1.函数的参数
1)位置参数和关键字参数
2)参数默认值
3)参数类型说明
4)不定长参数(了解)
def func1(x: str, a=1, b=2) -> int:
pass
def func2(a, *, c):
pass
def func3(*args, **kwargs):
pass
2.返回值 - 从函数内部传递到函数外部的数据
1)怎么确定函数返回值 - return
2)怎么在函数外部去获取和使用函数返回值
3.变量作用域
1)全局变量
2)局部变量
3)global
03-匿名函数
1. 匿名函数 - 本质还是函数(除了定义函数的语法以外的函数相关内容都适用于匿名函数)
语法:
函数名 = lambda 形参列表: 返回值
相当于:
def 函数名(形参列表):
return 返回值
案例:写一个匿名函数求任意两个数的和
sum2 = lambda num1, num2=10: num1 + num2
print(sum2(10, 20))
print(sum2(100, 200))
print(sum2(num2=4, num1=5))
print(sum2(200))
案例:写一个匿名函数求任意三个整数的个位数的和
sum3 = lambda num1, num2, num3: num1 % 10 + num2 % 10 + num3 % 10
04-高阶函数(了解)
1. 高阶函数 - 实参高阶和返回值高阶函数
实参高阶: 参数是函数的函数
返回值高阶函数:返回值是函数的函数
2.函数的参数的确定方式
x可以任何数据
def func1(x):
print(x)
x可以传整数、浮点数、布尔、列表、字符串、元组
def func2(x):
print(x * 2)
x可以传列表、字符串、元组、字典
def func3(x):
print(x[1])
x只能传列表
def func4(x):
print(x.append(100))
1)func5和func6是实参高阶函数
x必须是不需要传参就可以调用的函数
def func5(x):
# x = t1
print(x()) # print(t1())
def t1():
print('abc')
func5(t1)
x必须是一个可以接收两个实参的函数,并且函数的返回值是数字
def func6(x):
print(x(10, 20) + 30)
2)func7是一个返回值高阶函数
def func7():
def func8():
print('abc')
return func8
05-常见的实参高阶函数
注意:函数的参数如果是函数,提供实参方式有两种:1.直接使用匿名函数 2.使用普通函数的函数名
1.max、min、sorted(sort)
1)max(序列) - 直接比较序列中元素的大小求最大值
2)max(序列, key=函数) - 根据函数指定的比较规则比较序列中元素的大小获取最大值
函数要求:a.有且只有一个参数(代表序列中的每个元素)
b.需要一个返回值(返回值代表比较对象 - 将参数看成序列中的元素,返回值对应的位置描述清楚比较对象和元素之间的关系)
1)求nums中值最大的元素
nums = [19, 23, 90, 34, 56, 78]
print(max(nums))
print(max(nums, key=lambda item: item))
2)求nums中个位数最大的元素
nums = [19, 23, 90, 34, 56, 78]
print(max(nums, key=lambda item: item % 10))
3)求nums中绝对值最大的元素
补充:abs(数据) - 返回数据的绝对值
nums = [19, 23, -90, 34, -56, 78]
print(max(nums, key=lambda item: item**2))
4)求students中分数最高的学生
students = [
{'name': '小明', 'age': 19, 'score': 73},
{'name': '小红', 'age': 22, 'score': 99},
{'name': '小花', 'age': 32, 'score': 80},
{'name': '张三', 'age': 20, 'score': 77}
]
print(max(students, key=lambda item: item['score']))
5)按照年龄的大小对students中元素从小到大排序
print(sorted(students, key=lambda item: item['age']))
6)将names中所有的元素按照每个名字的长度从大到小排序
names = ['路飞', '乌索布', '索罗', '鲁班7号', '烬']
names.sort(key=lambda item: -len(item))
print(names)
7)求nums中各个位数之和最大的元素
nums = [123, 98, 562, 90, 990, 1000]
方法1:
print(max(nums, key=lambda item: sum(int(x) for x in str(item))))
方法2:
def temp(item):
s = 0
for x in str(item):
s += int(x)
return s
print(max(nums, key=temp))
2. map - 基于原序列中的元素通过指定的规则创建一个新的序列
1)map(函数, 序列)
函数的要求:a.有且只有一个参数(代表序列中的每个元素)
b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)
map(函数, 序列1, 序列2)
函数的要求:a.有且只有2个参数(分别代表后面两个序列中的每个元素)
b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)
map(函数, 序列1, 序列2, 序列3)
函数的要求:a.有且只有3个参数(分别代表后面3个序列中的每个元素)
b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)
map(函数, 序列1, 序列2, 序列3, …)
案例:将nums中所有的元素乘以2
nums = [2, 11, 33, 40, 9]
[4, 22, 66, 80, 18]
result = map(lambda item: item*2, nums)
print(list(result)) # [4, 22, 66, 80, 18]
案例:计算三个学生的总分
score1 = [98, 78, 80]
score2 = [99, 90, 60]
[197, 168, 140]
result = map(lambda item1, item2: item1+item2, score1, score2)
print(list(result))
练习1:使用map函数提取nums中所有元素的十位数
nums = [68, 1023, 23.34, 145.89, 192]
result = map(lambda item: int(item) // 10 % 10, nums)
print(list(result))
练习2:将学科和班号合并成班级名称
subjects = ['Python', 'java', 'h5']
nums = [2206, 2214, 2219]
['python2206', 'java2214', 'h52219]
result = map(lambda item1, item2: item1 + str(item2), subjects, nums)
print(list(result))
练习3:根据提供的学生信息,创建学生字典
names = ['张三', '李四', '王五', '小明']
genders = ['男', '女', '男', '男']
tels = ['1110', '12091', '27181', '18231']
[{'name': '张三', 'gender':'男', 'tel': '1110'}, ....]
result = map(lambda i1, i2, i3: {'name': i1, 'gender': i2, 'tel': i3}, names, genders, tels)
print(list(result))
练习4:使用map函数来创建字典
keys = ['name', 'age', 'gender', 'tel']
values = ['小明', 18, '男', '110']
{'name': '小明', 'age': 18, ...}
[('name', '小明'), ('age', 18),...]
result = map(lambda i1, i2: (i1, i2), keys, values)
print(dict(result))
练习5:使用map函数将nums中所有的偶数除以2,所有的奇数乘以2
nums = [1, 4, 5, 7, 8]
[2, 2, 10, 14, 4]
result = map(lambda item: item//2 if item % 2 == 0 else item * 2, nums)
print(list(result))
3. reduce - 将序列中所有的元素合并成一个数据
reduce(函数, 序列, 初始值) - 将序列中的元素按照函数制定的规则合并成一个数据
函数的要求:a.有且只有两个参数(第一个参数指向初始值, 第二个参数代表序列中的每个元素)
b.有一个返回值(用来描述合并规则)
from functools import reduce
案例:求nums中所有元素的和
nums = [12, 30, 89, 76, 55]
# 0 + 12 + 30 + 89 + 76 + 55
result = reduce(lambda i, item: i+item, nums, 0)
print(result)
案例:求nums中所有元素的乘积
nums = [12, 30, 89, 76, 55]
# 1 * 12 * 30 * 89 * 76 * 55
result = reduce(lambda i, item: i * item, nums, 1)
print(result)
案例:求nums中所有元素的个位数和
nums = [12, 30, 89, 76, 55]
# 2+0+9+6+5
# 0 + 12%10 + 30 % 10 + 89 % 10 + 76 % 10 + 55 %10
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)
案例:将nums中所有元素合并成一个数字
nums = [12, 30, 89, 76, 55]
# 1230897655
# '' + '12' + '30' + ... '55'
# '' + str(12) + str(30) + ... + str(55)
result = reduce(lambda i, item: i + str(item), nums, '')
print(int(result))
案例:将list1中所有字符串的最后一个字符合并成一个新中字符串
list1 = ['anm', 'abc', 'hello', 'world']
# 'mcod'
result = reduce(lambda i, item: i + item[-1], list1, '')
print(result)
4.filter(自学)
06-迭代器
1. 什么是迭代器(iter)
容器型数据类型;
迭代器起器作为容器打印的时候无法显示元素;无法通过len获取迭代器中元素的个数;
如果要使用迭代器中元素必须将元素从迭代器中取出来,而且一旦取出就无法再放回去。
2. 怎么创建迭代器
1)将其他序列转换成迭代器
2)创建生成器
i1 = iter('abc')
i2 = iter([10, 20, 30, 40])
print(i1)
print(i2)
# print(len(i1)) # 报错!
3.怎么获取迭代器中元素
注意:不管以什么样的方式获取到了迭代器中的元素,对应的元素一定会从迭代器中消失
1)查单个: next(迭代器)
print(next(i1)) # a
print(next(i1)) # b
print(next(i1)) # c
# print(next(i1)) # 报错! StopIteration
2)遍历
print('------------------------------------------华丽的分割线------------------------------------------------')
next(i2)
for x in i2:
print(f'x:{x}')
i3 = iter('hello')
print(i3)
print(list(i3))
# print(next(i3)) # StopIteration
07-生成器
1.什么是生成器
容器型数据类型(生成器作为容器不具备同时保存多个数据的能力,具备的是创建多个数据的能力)
打印生成器也无法查看生成器中的元素;生成器无法统计个数;
获取生成器中的元素,也是取一个就少一个。(生成器获取元素的方式和迭代器一样)
2. 怎么创建生成器
调用带有yield关键字的函数就可以得到一个生成器
def func1():
print('abc')
yield
return 100
result = func1()
print(f'result:{result}')
print('------------------------------------------华丽的分割线------------------------------------------------')
3. 生成器的元素 - 控制生成器产生数据的个数和产生的值
执行创建生成器的函数的函数体会遇到几次yield,对应的生成器就可以创建多少个数据;
每次遇到yield的时候,yield后面的数据就是这个生成器能够创建的值。
def func2():
for x in range(5):
yield x*2
g2 = func2()
print(next(g2))
for x in g2:
print('====', x)
def func3():
print('========1===========')
yield 100
print('========2===========')
yield 200
print('========3===========')
yield 300
g3 = func3()
print(next(g3))
print('------------------------------------------华丽的分割线------------------------------------------------')
s = 0
for x in range(100):
s += x
print(s)
print(next(g3))