419笔记，今天学了递归递推，lambda匿名函数

'''
面向过程  ==》函数

函数作用 ：模块化编程，代码重用
'''



def yanzhengma(num):
    import random
    '''
    功能：生成一个指定长度随机验证码
    :return:验证码
    '''
    list = ''
    str1 = "123456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
    for i in range(num):
        index = random.randint(0,len(str1)-1)
        list +=str1[index]

    return list

# print(yanzhengma(4))


# 定义一个全局变量:不仅可以在全局中访问到，也可以在局部访问，作用范围广泛
num =10
def func():
    # 局部变量 ：只能在局部使用，函数外不可以单独使用
    num = 100
    return num


# global num  声明变量 使用全局变量

'''
global应用场景 

'''
student =  []
def funcA():
    global student
    #向全局变量中增加数据
    student.append(1)
    student.append(2)
    student.append(3)

def funcB():
    for i in student:
        print(i)


def funcC():
    return funcB()

# funcA()
# funcC()
'''
函数参数类型：位置参数，关键词参数（Python特有）
位置参数：注意事项：位置参数强调的是参数传递的位置必须一一对应，不能颠倒
关键词参数：函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
'''


def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')


# 调用函数
user_info('Tom', 23, '美国纽约')

def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')

# 调用函数（使用关键词参数）
user_info(name='Tom', age=23, address='美国纽约')


'''
函数定义时缺省参数（参数默认值）
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。
谨记：我们在定义缺省参数时，一定要把其写在参数列表的最后侧
'''
# def user_info(name, age, gender='男'):
#     print(f'我的名字{name}，今年{age}岁了，我的性别为{gender}')
#
#
# user_info('李林', 25)
# user_info('振华', 28)
# user_info('婉儿', 18, '女')
# 不定长参数
### ☆ 不定长元组（位置）参数

#
# def user_info(*args):
#     # print(args)  # 元组类型数据，对传递参数有顺序要求
#     print(f'我的名字{args[0]}，今年{args[1]}岁了，住在{args[2]}')
#
# # 调用函数，传递参数
# user_info('Tom', 23, '美国纽约')
#
#
# ### ☆ 不定长字典（关键字）参数
#
#
# def user_info(**kwargs):
#     # print(kwargs)  # 字典类型数据，对传递参数没有顺序要求，格式要求key = value值
#     print(f'我的名字{kwargs["name"]}，今年{kwargs["age"]}岁了，住在{kwargs["address"]}')
#
# # 调用函数，传递参数
# user_info(name='Tom', address='美国纽约', age=23)

'''
学生管理系统



'''

students = []
def menu():
    print('-'*40)
    print('1、添加学员信息')
    print('2、删除学员信息')
    print('3、修改学员信息')
    print('4、查询学员信息')
    print('5、遍历所有学员信息')
    print('6、退出系统')
    print('-' * 40)

def add_student():
    '''

    :return:
    '''
    name = input('请输入学员的姓名：')
    age = int(input('请输入学员的年龄：'))
    mobile = input('请输入学员的电话：')

    global students

    student = {}

    student['name']=name
    student['age'] = age
    student['mobile'] = mobile

    students.append(student)

    print('信息已添加成功')

def del_student():
    name = input('请输入删除学员的姓名：')
    # 声明全局变量
    global students

    for student in students:
        if student['name'] == name:
            students.remove(student)

            print('删除成功')
            break
        else:
            print('找不到该学生信息')



# 8、edit_student()函数，修改学员信息
def edit_student():
    name = input('请输入修改学员的姓名：')
    # 声明全局变量
    global students
    for student in students:
        if student['name'] == name:
            student['age'] = int(input('请输入要修改学员的年龄：'))
            student['mobile'] = input('请输入要修改学员的电话：')
            print('信息已更新成功！')
            break
        else:
            print('暂未查询到任何相关信息...')


# 封装一个show_students()函数，遍历所有学员信息
def show_students():
    # 声明全局变量
    global students
    for student in students:
        print(student)


def find_student():
    name = input('请输入查询学员的姓名：')
    # 声明全局变量
    global students
    for student in students:
        if student['name'] == name:

            print(student)
            break
        else:
            print('暂未查询到任何相关信息...')


# 1、编写一个while死循环
while True:
    menu()

    # 3、提示用户输入要操作的功能编号
    num = int(input('请输入要操作的功能编号：'))
    if num == 1:
        add_student()
    elif num == 2:
        del_student()

    elif num == 3:
        edit_student()
    elif num == 4:
        find_student()
    elif num == 5:
        show_students()
    elif num == 6:
        # 5、退出系统
        print('感谢您使用传智教育通讯录V1.0系统，欢迎下次继续使用！')
        break

    else:
        print('您输入的信息有误，请重新输入')

lambda

递归递推

'''
在Python中，我们可以把7种数据类型分为两大类：可变类型 + 非可变类型
① 非可变类型
数值（int整型、float浮点类型）
bool类型（True和False）
字符串类型（str）
元组（tuple 1,2,3）
② 可变类型
列表（list [1, 2, 3]）
字典（dict {key:value})
集合（set {1, 2})

综上所述：不可变类型在函数中，局部或全局的改变对外部和内部都没有任何影响。
'''


# 定义一个函数
def func(names):
    names.append('赵六')


# 定义一个全局变量
names = ['张三', '李四', '王五']
# 调用函数
func(names)

# print(names)  # ???['张三', '李四', '王五', '赵六']

# 斐波那契数列
dict1 = {}


def func(n):
    if n == 1 or n == 2:
        return 1
    dict1 = {1: 1, 2: 1}
    for i in range(3, n + 1):
        dict1[i] = dict1[i - 1] + dict1[i - 2]
    return dict1


# print(func(15))

# 推进算法 求斐波那契数列

def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n - 1) + f(n - 2)


print(f(15))

'''
递归三步走:
① 函数想要什么
②找出递归结束条件
③找到函数的等价关系式
递归实现斐波那契数列
f(n)=f(n-1)+f(n-2)
'''


def func1(n):
    # 如果n=1 或者n=2时会自动终止
    if n == 1 or n == 2:
        return 1
    # 寻找数学模型

    return func1(n - 1) + func1(n - 2)


# 调用func1函数
# print(func1(15))

'''
递归算法求阶乘
n!=1*2*...*n
'''


def func2(n):
    if n <= 2:
        return n
    # 寻找数学公式
    return func2(n - 1) * n


# 调用func2求10阶乘
print(func2(10))


'''
# 猴子吃桃问题
最后一天1个桃子
前一天 （1+1）*2  = f(2)
到数第二天f(3)=(f(2)+1)*2
。。。
最后一天 f(n)=(f(n-1)+1)*2
'''
def func3(n):
    if n==10:
        return 1
    return (func3(n+1)+1)*2


print(func3(1))


'''
lambda 表达式
带有默认参数的lambda表达式
'''
# 求两个数的和
fn2 = lambda a,b : a+b
print(fn2(1, 2))

fn1 = lambda a,b,c=100:a+b+c

print(fn1(1, 2,4))
# 元组
fn3=lambda *args:args
#字典
fn4=lambda **kwargs:kwargs
print(fn3(1, 2, 3))
print(fn4(name='ailin', age=16))
#带三目运算符的lambda表达式

fn5 = lambda a,b:a if a>b else b
print(fn5(3, 8))

#列表数据+字典数据排序 列表.sort(key=排序的key索引, reverse=True)
students = [
    {'name': 'Tom', 'age': 20},
    {'name': 'Rose', 'age': 19},
    {'name': 'Jack', 'age': 22}
]
# 按name值降序排列
students.sort(key=lambda x:x['name'],reverse=True)
'''
执行流程：students是一个列表，内部由字典组成
students.sort（）系统首先将列表中的三个字典元素通过遍历的方式取出
当第一次循环时，系统将第一个字典取出放入变量x中，经过lambda表达式，返回结果x['name']=Tom
当第二次循环时，系统将第二个字典取出放入变量x中，经过lambda表达式，返回结果x['name']=Rose
...
数据全部取出，系统对三个值排序，排序后相应字典也会自动排序
'''
print(students)

fn = lambda *args: (sum(args),sum(args)/len(args))
print(fn(1,2,3,4,5))
print('-------------------------------------------')
fn = lambda string: lambda msg: f'{string}: {msg}!'

fnh = fn("hello")
print(fnh)
print(fnh("MrSun"))

fnw = fn("welcome to")
print(fnw("China"))

F = lambda **kwargs: 1
print(F(1))