目录
3.3、lambda函数作为函数参数(列表中字典排序)(扩展)
1、复习
num = 10
def anum():
num = 20
print(num)
print(num) # 10
anum() # 20
---------------------------------------------------------
num = 3.14
print("%.3f" % num) # 3.140 使用此输出方式,控制小数位数
print(f"{num:.3f}") # 3.140 f"{变量:.nf}"
num1 = 1 # 00000001
print('%6d' % num1) # 1
print('%06d' % num1) # 000001
print(f'{num1:06d}') # 000001
2、递归函数[理解]
递归:函数自己嵌套调用自己。
递归函数的形成条件:1.函数自己调用自己;2.函数必须有一个终止条件。
已知:A 比 B 大 2 岁,B比 C 大 2 岁,... , F 年龄为 18 岁,求 A 的年龄。
知道第一个人的年龄是18 岁,后边每个人比前边那个人大2岁,后边一个人的年龄 = 前边那个人的年龄+2。
num = (num -1) + 2
def get_age(num):
"""
求第num个人的年龄,每相邻的两个人的年龄差两岁。已知第一个人的年龄是18岁。
:param num:
:return:
"""
if num == 1:
return 18
# 求第num个人的年龄,只需要num-1,这个人的年龄+2。
age = get_age(num - 1) + 2
return age
print(get_age(4)) # 24
2.1、递归求阶乘
def func1(n):
num = 1
for i in range(1, n + 1): # i:[1,n]
num = num * i
print(num)
def func2(n):
if n == 1:
return 1
# 想要求 n! , 只需要(n-1)! * n
num = func2(n - 1) * n
return num
func1(5) # 120
print(func2(5)) # 120
3、匿名函数
使用
lambda
关键字定义的函数就是匿名函数。lambda 参数列表:表达式
3.1、匿名函数的4种形式
# 1. 无参无返回值
def func1():
print('hello')
(lambda: print('hello lambda'))() # 函数调用:hello lambda
func1() # 函数调用:hello
f1 = lambda: print('hello lambda~~~')
f1() # hello lambda~~~
# 2. 无参有返回值
def func2():
return 1 + 2
f2 = lambda: 1 + 2
print(f2()) # 3
# 3. 有参无返回值
def func3(name):
print(name)
f3 = lambda name: print(name)
f3('hello') # hello
# 4. 有参有返回值
def func4(*args):
return args
f4 = lambda *args: args
print(f4(1, 2, 3, 4, 5)) # (1, 2, 3, 4, 5)
3.1.1、无参数无返回值
def 函数名():
函数代码
lambda:函数代码
3.1.2、无参数有返回值
def 函数名():
return 1 + 2
lambda: 1 + 2
3.1.3、有参数无返回值
def 函数名(a, b):
print(a, b)
lambda a, b: print(a, b)
3.1.4、有参数有返回值
def 函数名(a, b):
return a + b
lambda a, b: a + b
3.2、匿名函数的应用场景--作为函数的参数使用
def my_calc(a, b, func):
"""
进行四则运算
:param a: 第一个数据
:param b: 第二个数据
:param func: 函数,要进行的运算
:return: 运算的结果
"""
print('其他的函数代码...')
num = func(a, b)
print(num)
def add(a, b):
return a + b
# 调用
my_calc(10, 20, add) # 30
my_calc(10, 20, lambda a, b: a + b) # 30
my_calc(10, 20, lambda a, b: a - b) # -10
my_calc(10, 20, lambda a, b: a * b) # 200
my_calc(10, 20, lambda a, b: a / b) # 0.5
my_calc(10, 20, lambda a, b: a + b ** 2) # 10+20^2==410
3.3、lambda函数作为函数参数(列表中字典排序)(扩展)
# 列表排序, 列表中的数据的类型要保持一致。
my_list = [1, 3, 5, 4, 2, 1]
my_list.sort()
print(my_list) # [1, 1, 2, 3, 4, 5]
list1 = [{'name': 'd', 'age': 19}, {'name': 'b', 'age': 16},
{'name': 'a', 'age': 16}, {'name': 'c', 'age': 20}]
# list1.sort() # 程序报错
# 匿名函数的形参是列表中的每一个数据
list1.sort(key=lambda x: x['name']) # 根据name进行排序
print(list1) # [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'c', 'age': 20}, {'name': 'd', 'age': 19}]
list1.sort(key=lambda x: x['age']) # 根据age进行排序
print(list1) # [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'd', 'age': 19}, {'name': 'c', 'age': 20}]
list2 = ['aghdd', 'bc', 'ghlj', 'def', 'ab']
list2.sort()
print(list2) # ['ab', 'aghdd', 'bc', 'def', 'ghlj']
# 需求: 根据列表中字符串的长度,对列表进行排序。
list2.sort(key=len) # 写法1
list2.sort(key=lambda x: len(x)) # 写法2
print(list2) # ['ab', 'bc', 'def', 'ghlj', 'aghdd']
# sort(key=lambda 形参: (排序规则1, 排序规则2, ...))
# 当第一个规则相同,会按照第二个规则排序。
list1.sort(key=lambda x: (x['age'], x['name'])) # 比较元组
print(list1) # [{'name': 'a', 'age': 16}, {'name': 'b', 'age': 16}, {'name': 'd', 'age': 19}, {'name': 'c', 'age': 20}]
list1.sort(key=lambda x: (x['age'], x['name']), reverse=True)
print(list1) # [{'name': 'c', 'age': 20}, {'name': 'd', 'age': 19}, {'name': 'b', 'age': 16}, {'name': 'a', 'age': 16}]
3、列表推导式and字典推导式
# 列表推导式, 为了快速的生成一个列表。
# 1.变量 = [生成数据的规则 for 临时变量 in xxx]
# 每循环一次,就会创建一个数据
my_list = [i for i in range(5)]
print(my_list) # [0, 1, 2, 3, 4]
my_list1 = ['hello' for i in range(5)]
print(my_list1) # ['hello', 'hello', 'hello', 'hello', 'hello']
my_list2 = [f'num:{i}' for i in my_list] # [0, 1, 2, 3, 4]
print(my_list2) # ['num:0', 'num:1', 'num:2', 'num:3', 'num:4']
my_list3 = [i + i for i in range(5)]
print(my_list3) # [0, 2, 4, 6, 8]
# 2.变量 = [生成数据的规则 for 临时变量 in xxx if xxx]
# 每循环一次,并且if条件为True,生成一个数据
my_list = [i for i in range(5) if i % 2 == 0]
print(my_list) # [0, 2, 4]
# 3.变量 = [生成数据的规则 for 临时变量 in xxx for j in xxx]
# 第二个for循环每循环一次,就生成一个数据。循环嵌套
my_list4 = [(i, j) for i in range(3) for j in range(3)]
print(my_list4) # [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# 补充: 字典推导式
# 变量 = {生成字典的规则 for 临时变量 in xx}
# my_dict = {key: value for i in range(3)}
my_dict = {f"name{i}": i for i in range(3)}
print(my_dict) # {'name0': 0, 'name1': 1, 'name2': 2}
my_dict = {f"name{i}": j for i in range(3) for j in range(3)}
print(my_dict) # {'name0': 2, 'name1': 2, 'name2': 2}
my_dict = {f"name{i}{j}": j for i in range(3) for j in range(3)}
print(my_dict) # {'name00': 0, 'name01': 1, 'name02': 2, 'name10': 0, 'name11': 1, 'name12': 2, 'name20': 0, 'name21': 1, 'name22': 2}
4、集合-set
# 集合set,定义使用{},{数据, 数据}
# 1. 集合中的数据必须是不可变类型
my_set = {1, 3.14, False, 'hello', (1, 2)}
print(my_set, type(my_set)) # {False, 1, (1, 2), 3.14, 'hello'} <class 'set'>
# my_set = {[1, 2]} # 代码报错TypeError: unhashable type: 'list'
# 2. 集合是可变类型
my_set.remove(3.14)
print(my_set) # {False, 1, (1, 2), 'hello'}
my_set.pop()
print(my_set) # {1, (1, 2), 'hello'}
print('----')
my_set.add(100)
print(my_set) # {1, (1, 2), 100, 'hello'}
# 修改数据 100 ---> 200
my_set.remove(100)
my_set.add(200)
print(my_set) # {1, (1, 2), 200, 'hello'}
my_set.clear()
print(my_set) # set()
# 3. 集合是无序的,(数据的添加顺序和输出顺序是否一致),不支持下标操作
# 4. 集合中的数据没有重复数据(去重)
my_list = [1, 2, 3, 4, 2, 5, 1, 0]
my_list = list(set(my_list)) # 去重操作:转集合再转列表
print(my_list) # [0, 1, 2, 3, 4, 5]
# 集合,列表,元组 三者之间可以互相转换
5、文件操作
文件的作用:可以永久的保存数据。文件在硬盘中存储的格式是二进制。
文件操作步骤:1.打开文件、2.读写文件、3.关闭文件。
5.1、读文件-r
# 1.打开文件, 是文件从硬盘中存到内存中
'''
open(file, mode='r', encoding)
file:要操作的文件名字, 类型是str
mode:文件打开的方式, r(read)只读打开、w(write)只写打开、a(append)追加打开
encoding:文件的编码格式, 常见的编码格式有两种, 一种是gbk, 一种是utf-8
返回值:文件对象, 后续所有的文件操作, 都需要通过这个文件对象进行。
'''
# 以只读的方式打开当前目录中的1.txt文件, 文件不存在会报错
f = open('0.txt', 'r')
# 2.读文件:文件对象.read()
buf = f.read()
print(buf)
# 3.关闭文件:文件.close(),将内存中三大文件同步到硬盘中
f.close()
5.2、写文件-w
# 1. 打开文件:以w方式打开文件,文件不存在,会创建文件;文件存在,会覆盖清空原文件
f = open('a.txt', 'w', encoding='utf-8') #
# 2. 写文件 文件对象.write(写入文件的内容)
f.write('hello world!\n') # \n表示换行
f.write('hello python!\n')
f.write('你好,中国!')
# 3. 关闭文件
f.close()
5.3、追加文件-a
# a 方式打开文件, 追加内容, 在文件的末尾写入内容。
# 文件不存在,会创建文件。
# 注意点: 不管是a方式打开文件,还是w方式打开文件,写内容都是使用write()函数。
f = open('b.txt', 'a', encoding='utf-8')
f.write('hello world!\n')
f.write('666\n')
f.close()