面向过程与函数式

1. 编程思维/范式

• 编程范式指的就是编程套路，打个比方，如果把编程的过程比喻为联系武功，那编程范式指的就是武林中的各种流派。

2. 面向过程

面向过程的编程想

• 核心：“过程”二字，过程即流程，指的是做事的步骤：先、后、再
• 基于该思想编写程序就好比在设计一条流水线
• 优点：能将复杂的问题程序化，进而简单化
• 缺点：扩展性非常差

面向过程的编程思想应用过程解析：

1. 不是所有的软件都需要频繁的更迭：比如编写脚本

2. 即便是一个软件需要频繁更迭，也并不代表这个软件的所有组成部分都需要一起更迭

3. 函数式

3.1 匿名函数与lambda

# 1.def用于定义有名函数
# func=函数的内存地址
def func(x, y):
    return x + y


print(func)

# 2.lambda用于定义匿名函数
print(lambda x, y: x + y)

# 3.调用匿名函数
# 方式一：
res = (lambda x, y: x + y)(1, 2)
print(res)

# 方式二：
func = lambda x,y:x+y
res = func(1,2)
print(res)

# 4.匿名函数用于临时调用一次的场景：更多的是将匿名函数与其他函数配合使用

3.2 map、reduce、filter（了解）

# map的应用（了解）
l = ['alex', 'lxx', 'wxx', 'egon']
new_l = (name + '_dsb' for name in l)
print(new_l)

res = map(lambda name: name + '_dsb', l)
print(res)  # 生成器

# filter的应用（了解）
l = ['alex_sb', 'lxx_sb', 'wxx_sb', 'egon_sb']
res = (name for name in l if name.endswith('sb'))

res = filter(lambda name: name.endswith('sb'), l)
print(res)

# reduce的应用（了解）
from functools import reduce

# 数字的合并操作
res = reduce(lambda x, y: x + y, [1, 2, 3], 10)
print(res)  # 16

# 字符串的合并操作
res = reduce(lambda x, y: x + y, ['a', 'b', 'c'], 'hello')
print(res)  # helloabc

3.3sorted、max、min

salaries = {
    'siry': 3000,
    'tom': 7000,
    'lili': 10000,
    'jack': 2000
}


# 需求1：找出字典中薪资最高的人=>lili
def func(k):
    return salaries[k]


res = max(salaries, key=func)
print(res)
# max的应用
res = max(salaries, key=lambda k: salaries[k])
print(res)

# 需求2：找出字典中薪资最低的人=>jack
# min的应用
res = min(salaries, key=lambda k: salaries[k])
print(res)

# 需求3：将字典中的人名按照薪资从低到高的顺序进行排列
# sorted的应用
res = sorted(salaries, key=lambda k: salaries[k])
print(res)

3.4 内置函数

# abs() 去绝对值
print(abs(-1))

# all(可迭代对象)，可迭代对象中的元素全为True时all结果才为True
# all(空的可迭代对象)，结果为True
print(all([1, 'aaa', '1']))
print(all([]))

# any(可迭代对象)，可迭代对象中的元素有一个为True时any结果就为True
# any(空的迭代对象)，结果为False
print(any([0, None, 1]))
print(any([]))

# bool() 判断布尔值
print(bool(0))

# callable() # 检查一个对象是否是可调用的

# frozenset({1,2,3}) # 将集合编程不可变集合

# round() # 四舍五入
print(round(1.5))
print(round(1.4))

# pow(10,2,3) =》 10 ** 2 % 3
# s=slice(1,4,2) =》 print(l1[1:4:2]) # l1[s]

# ============  掌握  ============
# zip(可迭代对象1，可迭代对象2) # 类似于衣服拉链，将两个对象中的元素一一对应组成一个个元祖
v1 = 'hello'
v2 = [111, 222, 333, 444, 5555, 6666]
res = zip(v1, v2)
print(list(res))  # [('h', 111), ('e', 222), ('l', 333), ('l', 444), ('o', 5555)]

# divmod() 获取商和余数，可用于分页功能
print(divmod(10000, 33))


# dir(obj) 查看obj下的所有属性
class Foo:
    pass


obj = Foo()
obj.xxx = 111
print(dir(obj))  # obj.哪些属性

# enumerate() 枚举，将可迭代对象依照顺序逐个取出，索引与取出值组成一个个元祖返回
for i, v in enumerate(['a', 'b', 'c']):
    print(i, v)

# eval() 执行字符串中的表达式
res = eval('1+2')
print(res) # 3

# isinstance() 判断段类型是否相同
print(isinstance([],list))
# print(type([]) is list) # 不推荐使用

# __import__将文件中的字符串类型的模块名转换成对应的模块名并返回
# import'time' # 错误
time = __import__('time')
time.sleep(3)