面向过程与函数式

面向过程是一门编程思想

面向过程编程：

核心是 '过程' 二字，过程指的是一种解决问题的步骤，即先干什么再干什么基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。

详细的讲，就是程序一开始要解决一个大的问题，按照过程式的思路就是把这个大的问题分解成很多个小问题或子过程去实现，然后依次调用即可

# 1.先让用户输入用户名和密码、用户角色，校验合法性
def get_user_pwd():
    while True:
        # 让用户输入用户名与密码
        username = input('请输入用户名:').strip()
        # 校验用户名是否为 英文字母  str.isalpha 校验英文字母、中文
        if username.isalpha():
            break
        else:
            print('用户名不合法')

    while True:
        password = input('请输入密码:').strip()
        re_password = input('请确认密码:').strip()
        # 校验两次密码是否一致
        if password == re_password:
            break
        else:
            print('两次密码不一致。')

    # 作业: 保证用户输入的角色范围 [普通用户、管理员用户、超级用户]
    user_role = input('请输入用户角色:').strip()

    return username, password, user_role

# 2.拼接用户字符串
def cut_user_pwd(user, pwd, user_role):
    user_pwd_str = f'{user}:{pwd}:{user_role}
'
    return user_pwd_str, user

# user = 'tank'
# user_name = user

# 3.保存用户数据，写入文件中
# 每一个用户保存一个文件,以用户的名字当做文件名
def save_data(user_pwd_str, user_name):
    with open(f'{user_name}.txt', 'w', encoding='utf-8') as f:
        f.write(user_pwd_str)

# 注册功能Demo
def register():
    # 1.设计先让用户输入用户名和密码，校验合法性，得到合法的用户名与密码
    user, pwd, user_role = get_user_pwd()

    # 2.设计字符串的拼接, 得到拼接好的字符串
    user_pwd_str, user_name = cut_user_pwd(user, pwd, user_role)

    # 3.开始写入文件
    save_data(user_pwd_str, user_name)


register()

匿名函数

无名字的函数

#语法：lambda 参数1，参数2，...: experssion


#:左边是参数，:右边是返回值lambda 
#PS：定义即调用，因为函数的调用是通过函数名 + ()，而匿名函数没有名字
#匿名函数需要一次性使用
#注意: 匿名函数单独使用毫无意义，它必须配合 “内置函数” 一起使用的才有意义。

举例

#1.定义
lambda x,y,z:x + y + z
#等同于
def func(x, y, z)
	return x + y + z
#调用方式
#方式一：
res = (lambda x, y, z:x + y + z)(1, 2 ,3)
print(res)
#方式二：
func=lambda x,y,z:x+y+z # “匿名”的本质就是要没有名字，所以此处为匿名函数指定名字是没有意义的
res=func(1,2,3)

匿名函数与有名函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，所以匿名函数用于临时使用一次的场景，匿名函数通常与其他函数配合使用

内置函数

python内部提供的内置方法

max min(取最大值最小值)

#比较工资的最大值 最小值
salaries = {
    'egon': 20000,
    'sean': 7000,
    'tank': 5000,
    'jack': 3000
}
print(max(salaries))
#结果为
tank
#内置max和min都支持迭代器协议，工作原理都是迭代字典，取得是字典的键，因而比较的是键的最大和最小值，但是取出的键值为字符串，字符串的比较是按照ASCII码，而我们想要的是比较值的最大值与最小值，所以
print(max(salaries, key=lambda k: salaries[k]))
print(min(salaries, key=lambda k: salaries[k]))
#结果为
egon
jack

#sorted(排序，默认从低到高)
sorted:默认升序(从小到大) reverse:反转 reverse默认是False
print(sorted(salaries, key=lambda k: salaries[k]))
print(sorted(salaries, key=lambda k: salaries[k], reverse=True))
#结果为
['jack', 'tank', 'sean', 'egon']
['egon', 'sean', 'tank', 'jack']

map(映射)

#语法：
#map(函数地址, 可迭代对象) ---> map对象
#map会将可迭代对象中的每一个值进行修改，然后映射一个map对象中，
#可以再将map对象转换成列表/元组。
#注意: 映射对象只能转一次

#例
name_list = ['egon', 'json', 'sean', 'tank']
map_obj = map(lambda name: name +'喜欢吃生蚝' if name == 'tank' else name +'DBJ',name_list)
print(map_obj)
print(list(map_obj))
#结果为
<map object at 0x0000028CD4FC9908>
['egonDBJ', 'jsonDBJ', 'seanDBJ', 'tank喜欢吃生蚝']

#例
list1 = [1, 2, 3, 4]
res = map(lambda x: x*x, list1)
print(res)
print(tuple(res))
print(list(res))
#结果为
<map object at 0x000001851194C588>
(1, 4, 9, 16)
[]   #注意这里因为res为一个迭代器对象只能迭代一次

reduce(合并)

#比如求和运算，这就用到了reduce函数
#reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值
#语法：
reduce(函数地址, 可迭代对象, 初始值)
#例
from functools import reduce
res = reduce(lambda x, y:x+y,range(1, 101), 0)
print(res)
#结果为
5050
#解析：
1 没有初始值，reduce函数会先迭代一次range(1,101)将得到的值作为初始值，作为第一个值数传给x，然后继续迭代一次range(1,101)得到的值作为第二个值传给y，运算的结果为3

2 将上一次reduce运算的结果作为第一个值传给x，然后迭代一次range(1,101)得到的结果作为第二个值传给y，依次类推，知道迭代完range(1,101)中的所有元素，得到最终的结果5050

filter(过滤)

#语法
filter(函数地址, 可迭代对象) --> filter 对象

l1 = [1, 2, 3, 4, 5]
res = filter(lambda x: x > 2, l1)
print(list(res))
#结果为
[3, 4, 5]