还在缓慢的走着，学习也是正在慢慢输入
一、递归函数
递归：函数自己嵌套调用自己
# 递归函数的形成条件
# 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
二、匿名函数
# 使用lambda 关键字定义的函数就是匿名函数
# lambda 参数列表 表达式
# 1.无参无返回值
def func1():
print('hello')
(lambda: print('hello lambda'))()
func1()
f1 = lambda: print('hello lambda')
f1()
# 2.无参有返回值
def func2():
return 1 + 2
f2 = lambda: 1 + 2
print(f2())
# 3.有参数无返回值
def func3(name):
print(name)
f3 = lambda name: print(name)
f3('hello')
# 4.有参数有返回值
def func4(*args):
return args
f4 = lambda *args: args
print(f4(1, 2, 3, 4, 5))
三、匿名函数的应用场景
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)
my_calc(10, 20, lambda a, b: a - b)
my_calc(10, 20, lambda a, b: a * b)
my_calc(10, 20, lambda a, b: a / b)
四、lambda 函数作为函数参数(列表中字典排序)
# 列表排序 ，列表中的数据的类型要保持一致
my_list = [1, 3, 5, 4, 2, 1]
my_list.sort()
print(my_list)
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'])
print(list1)
list1.sort(key=lambda x: x['age'])
print(list1)
list2 = ['aghdd', 'bc', 'ghli', 'def', 'ab']
list2.sort()
# print(list2)
# 需求：根据列表中字符串的长度，列表进行排序
# list2.sort(key=len)
list2.sort(key=lambda x: len(x))
print(list2)
# sort(key= lambda 形参：（排序规制1， 排序规制2，.....）)
# 当第一个规则相同，会按照第二个规制排序
list1.sort(key=lambda x: (x['age'], x['name']))
list1.sort(key=lambda x: (x['age'], x['name']), reverse=True)
print(list1)
五、列表推导式
# 每循环一次，就会创建一个数据
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]
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)
# 补充：字典推导式
# 变量 = { 生成字典的规划 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}
六、集合-set
# 集合 set 定义使用{} ， {数据， 数据}
# 1. 集合中的数据必须是不可变类型
my_set = {1, 3.14, False, 'hello', (1, 2)}
print(my_set, type(my_set))
# 2. 集合是可变类型
my_set.remove(3.14)
print(my_set) # {False, 1, 'hello', (1, 2)}
my_set.pop()
print(my_set) # {1, (1, 2), 'hello'}
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)
my_set.clear()
print(my_set)
# 3. 集合是无序的， （数据的添加顺序给和输出顺序是否一致）， 不支持下标操作
# 4. 集合中的数据没有重复数据（去重）
my_list = [1, 2, 3, 4, 2, 5, 1, 0]
my_list = list(set(my_list))
print(my_list)
七、文件的操作
7.1读文件
# 1.打开文件， 是文件从硬盘存到内存中
# open(file, mode='r', encoding)
# file 要操作的文件名字，类型是str
# mode， 文件打开的方式， r（read） 只读打开， w（write）只写打开 a（appen）追加打开
# encoding 文件的编码格式,常见的编码格式的两种, 一种是gdk, 一种utf- 8
# 返回值, 文件对象, 后续所有的文件操作,都需要通过这个文件对象进行
# 以只读的方式打开当前目录种 1.txt 文件, 文件不存在会报错
f = open('a.txt', 'r')
# 2.读文件 文件对象.read()
buf = f.read()
print(buf)
# 3.关闭文件 文件.close() 将内存三大文件同步到硬盘中
f.close()
7.2 文件的写操作
# 1. 打开文件 w 方式打开文件,文件不存在 ,会创建文件, 文件存在, 会覆盖清空原文件
f = open('a.txt', 'w', encoding='utf-8')
# 2.写文件 文件对象.write (写入文件的内容)
f.write('hello world!\n')
f.write('hello python!\n')
f.write('你好， 中国')
# 3.关闭文件
f.close()
今天就到这里拉，有问题的请多多指教
