一、面向过程编程

面向过程是一门编程思想

面向 | 过程 | 编程：

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

优点
- 将复杂的问题流程化，进而简单化
缺点
- 可扩展性差（牵一发而动全身，若修改当前程序设计的某一部分，会导致其他部分同时需要修改，扩展性差）

def get_user_pwd(): # 获取用户注册的用户名和密码
    while True:
        username = input('请输入注册的用户名：').strip()
        if username.isalpha():
            break
        else:
            print('您输入的用户名不合法，请重新输入')
    while True:
        password = input('请输入注册的密码：').strip()
        re_password = input('请确认密码：').strip()
        if password == re_password:
            break
        else:
            print('您输入的两次密码不一致')
    return username, password


def cut_user_pwd(user, pwd):    # 用户名密码拼接字符串
    user_pwd_str = f'{user}:{pwd}
'
    return user_pwd_str


def save_data(user_pwd_str):
    with open('user_name.txt', 'a', encoding='utf-8') as f:
        f.write(user_pwd_str)


def register(): # 注册
    # 先让用户输入用户名和密码，效验合法性
    user, pwd = get_user_pwd()
    # 设计字符串的拼接，得到拼接好的字符串
    user_pwd_str = cut_user_pwd(user, pwd)
    # 写入文件
    save_data(user_pwd_str)


register()

二、匿名函数

匿名函数：无名字的函数

对比使用def关键字创建的是有名字的函数，使用lambda关键字创建则是没有名字的函数，即匿名函数，语法如下

lambda 参数1，参数2...：expression

举例：

lamdba x,y,z:x+y+z
    
#等同于
def func(x,y,z)
		return x+y+z

匿名函数需要一次使用，单独使用毫无意义，它必须配合“内置函数”一起使用

函数中的关键字 def 和 return已经自动添加了，所以只需 lamdba 参数即可

三、内置函数

Python内部提供的内置方法，如

print()
range()
len()

max 求最大值
min 求最小值

获取字典（字典中，value最大的key的名字）

max(dict1,key=lambda x:dict1[x])

例如：

dict1 = {
     'tank': 1000,
     'egon': 500,
     'sean': 200,
     'jason': 500
 }

print(max(dict1,key = lambda x:dict1[x]))
print(min(dict1,key = lambda x:dict1[x]))
tank
sean

sorted:默认升序（从小到大） reverse：反转 reverse默认是False

例如：

list1 = [3, 5, 4, 8, 9, 7, 6, 1, 2]
print(sorted(list1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
# 反转 
print(sorted(list1, reverse= True))
[9, 8, 7, 6, 5, 4, 3, 2, 1]

map：映射
- map(函数地址，可迭代对象)——> map对象

map会将可迭代对象中的每一个值进行修改，然后映射到一个map对象中

可以再将map对象转换成列表/元组。 注意：只能转一次

定义一个可迭代对象

array = [1, 2, 3, 4, 5])

对每个元素做平方处理

res1 = map(lambda x : x **2, array)
print(res1)		#直接打印是一个内存地址
print(list(res1))	# 所以转换成list后打印

<map object at 0x0000021E34B376D8>	
[1, 4, 9, 16, 25]

reduce：合并
- reduce(函数地址，可迭代对象，初始值默认为0)

每次从可迭代对象中获取两个值并合并

初始值：执行reduce函数时，都是从初始值开始合并

reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值

求上面array的和

from functools import reduce
res2 = reduce(lambda x, y: x + y, array)
print(res2)
15

默认第三个参数初始值为0 ，但也可以自己指定

from functools import reduce
res2 = reduce(lambda x, y: x + y, array, 100)
print(res2)
115

filter：过滤
- filter(函数地址可迭代对象)

例如将array中大于3的元素过滤出来

res3 = filter(lambda x : x > 3, array)
print(res3)	# 得到的结果仍然是迭代器
print(list(res3))

<filter object at 0x000002350F8E76D8>
[4, 5]