Python-17-函数_06_函数式编程

Posted 2021-01-23 newmet

一、函数式编程---定义：
编程的方法论：
1、函数式
2、面向过程
3、面向对象
    函数式编程：函数式=编程语言定义的函数+数学意义的函数
    简单说：函数式就是用编程语言去实现数学函数
    函数式编程，主要在Hsahell、clean、erlang等这几门语言中利用。

def cal(x):
    return 2 * x + 1  # 函数式

a、不可变，不用变量保存状态，不修改变量

def cal(x):  # 非函数式
    res = 2 * x
    res += 1
    return res  # 面向过程

b、第一类对象：函数即"变量“
      函数名可以当做参数传递
      返回值可以是函数名

c、高阶函数：
      函数接收的参数是一个函数 or 返回值中包含函数

d、map filter reduce
map：处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样
filter：遍历序列中的每个元素，判断每个元素，得到布尔值，如果是True则留下来
reduce：处理一个序列，根据逻辑，然后把序列进行合并操作

# 找到age小于等于20的元素
people = [{"name": "name1", "age": 18}, {"name": "name2", "age": 50}, {"name": "name1", "age": 100}]
print(list(filter(lambda x: x["age"] <= 20, people)))

二、函数式编程---方法：
1、----------------  map  ---------------------

# 一、通常版
num1 = [1,2,3,4,5,6]
def add_one(x):                     # 1、利用函数，定义一系列需求
    return x+1
def minus_one(x):
    return x-1
def square_one(x):
    return x**2

def map_test(func,array):           # 2、定义一个通用函数格式
    res = []
    for i in array:
        ress = func(i)
        res.append(ress)
    return res

print(map_test(add_one,num1))        # 3、调用函数
print(map_test(square_one,num1))

# 求某列表元素，+1、-1、平方
############  最终版  ############
def map_test(func,array):
    res = []
    for i in array:
        ress = func(i)
        res.append(ress)
    return res
map_test(lambda x:x+1,num1)
############  最终版  ############

###########  map方法  ###########
# dissect 1
print(map(lambda x:x+1,num1))       # 结果：<map object at 0x0000000002863748> 内存地址

# dissect 2
res = map(lambda x:x+1,num1)
# for i in res:
#     print(i)
print(list(res))

# result
# 1、如果需求的逻辑精简，可以直接用lambda；
# 2、如果需求的逻辑比较复杂，可以调用自定义函数。
# 3、map第二个位置（num1） 只要是可迭代对象，就可以。
print("map函数利用：",list(map(lambda x:x**2,num1)))         # 一行、省去上面【最终版】代码过程
print("map函数利用：",list(map(add_one,num1)))
str1 = "newmet.top"
print(list(map(lambda x:x.upper(),str1)))

###########  map方法  ###########

map

2、---------------  filter  -------------------

# 去除某列表中，以 ss 结尾的元素，即：保留除ss结尾以外的元素。
num1 = ["new_ss","met_ss","newmet"]

def add_one(x):
    return not x.endswith("ss")

############  最终版  ############
def filter_test(func,array):                # array - 可迭代对象，交给 func ，如果func == True，当前array元素保留下来
    res = []
    for i in array:
        if not func:
            res.append(i)
    return res
filter_test(lambda x:not x.endswith("ss"),num1)          # lambda x:not x.endswith("ss")是True，留下
############  最终版  ############

###########  filter方法  ###########
# dissect 1
print(filter(lambda x:not x.endswith("ss"),num1))       # 结果：<filter object at 0x0000000002866C88> 内存地址

# dissect 2
res = filter(lambda x:not x.endswith("ss"),num1)
# for i in res:
#     print(i)
print(list(res))

# result
# 1、如果需求的逻辑精简，可以直接用lambda；
# 2、如果需求的逻辑比较复杂，可以调用自定义函数。
# 3、filter第二个位置（num1） 只要是可迭代对象，就可以。
print("filter函数利用：",list(filter(lambda x:not x.endswith("ss"),num1)))         # 一行、省去上面【最终版】代码过程
print("filter函数利用：",list(filter(add_one,num1)))


###########  filter方法  ###########

filter

3、---------------  reduce  -------------------

# from functools import reduce        # 从functools模块中导入reduce模块

# 1、求列表元素的和
num1 = [1,2,3,4,5,6]
res = 0
for i in num1:
    res += i
print(res)

# 2、求列表元素的积
def multi(x,y):
    return x*y
# lambda x,y:x*y

############  最终版  ############
def reduce_test(func,array,init=None):          # init=None 用户定义一个初始值，可以写、可不写
    if init is None:
        res = array.pop(0)
    else:
        res = init
    for i in array:
        res = func(res,i)
    return res
print(reduce_test(lambda x,y:x*y,num1,10))
############  最终版  ############

###########  reduce方法  ###########

from functools import reduce                # 从functools模块中导入reduce模块
num2 = [1,2,3,4,5,6]
print(reduce(lambda x,y:x*y,num2,10))

###########  reduce方法  ###########

reduce

三、函数式编程---内置函数：

print(abs(-1))                    # abs 绝对值
print(all([1,2,"1"]))            # all 列表中所以元素都为True，输出True，否则False  属于False( 空,0,None,(),[],{} )
print(any(["",0]))               # any 有一个是True，就是True
print(bin(3))                    # bin 10进制-转换成-2进制
print(hex(3))                    # hex 10进制-转换成-16六进制
print(oct(3))                    # oct 10进制-转换成-8进制
print(bool(2))                   # bool 判断是否为True or False
print(bytes("哈喽",encoding="utf-8"))                         # bytes 编码 转换成二进制（python默认用utf-8编码）
print(bytes("哈喽",encoding="utf-8").decode("utf-8"))        # bytes 解码 （用什么编码，就用什么解码，ascii不能编码中文）
print(chr(97))                  # chr ASCII码 数字对应得字符
print(ord("a"))                 # ord ASCII码 字符对应得数字
print(dir(all))                 # dir 打印某一个对象下都有哪些方法
print(divmod(10,3))             # divmod 结果：(3, 1)   （商，余） 可以用来分页：分成4页
print(divmod(10,2))             # divmod 结果：(5, 0)   （商，余） 可以用来分页：分成5页

dic = {"name":"newmet"}
v = str(dic)
print(eval(v))                  # eval 把字符串中的数据结构提取出来
express = "1+2*3-(4/2-1)*2"
print(eval(express))            # eval 把字符串中的表达式运算

# 可hash的数据类型，是不可变数据类型；不可hash的数据类型，是可变数据类型；
# 用处：网上下载一个软件，该软件对应一个hash值，下载后，又获取一个值，如果2个值相同，证明该软件没有被更改（中毒），安全
print(hash("sdfsf"))

print(help(all))                # help 获取某一个方法具体的使用方法。

print(isinstance(2,int))              # isinstance  判断2 是否是int类型
print(isinstance("sfds",str))        # isinstance  判断"sfds" 是否是str类型

v = "newmet.top111"
print(globals())                # globals 打印全局变量
print(locals())                 # globals 打印局部变量


print(list(zip((‘a‘,‘b‘,‘c‘),(1,2,3))))             # 结果：[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]
print(list(zip((‘a‘,‘b‘,‘c‘),(1,2,3,4))))           # 结果：[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]
print(list(zip((‘a‘,‘b‘,‘c‘,‘d‘),(1,2,3))))        # 结果：[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]

dic = {"name":"newmet","age":18,"gender":"sss"}
print(list(zip(dic.keys(),dic.values())))               # 拉链，一一对应，两个序列多出来的元素，不考虑。


# 最大值 - max、最小值 - min
# 一、max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能比较；
# 二、每个元素间进行比较，是从每个元素的第一个位置依次比较，如果这一个位置分出大小，后面的都不需要
#     比较了，直接得出这两个元素的大小。

# 1、最简单
l = [1,2,4,7,9,3]
print(max(l))
print(min(l))

# 2、字典，比较keys 或者 values
d = {"age1":15,"age2":18,"age3":88,"age4":50}
print(max(d.values()))  # 比较字典中的values值，但是不知道是与哪个keys对应
print(max(d))           # 默认比较字典中的keys值 但是不知道是与哪个values对应

# 3、结合zip使用
for i in zip(d.values(),d.keys()):
    print(i)

print(max(zip(d.values(),d.keys())))      # 取得当前字典中，数值最大的元素，并输出起keys、values值

# 4、【终极】--利用max 里的key
# def max(*args, key=None):
age = [{"name":"new1","age":15,},{"name":"new2","age":18,},{"name":"new3","age":88,},{"name":"new4","age":50}]
print(max(age,key=lambda age:age["age"]))

print(pow(2,3))                 # pow 相等于：2**3   几次方
print(pow(2,3,3))                 # pow 相等于：2**3%2  几次方，求余

# 序列--反转 -- reversed
l1 = [1,2,4,7,9,3]
print(list(reversed(l1)))

# 四舍五入 -- round
print(round(3.5))

# 切片 -- slice
l = "hello"
# print(l[3,5])
s1 = slice(3,5)
s2 = slice(1,4,2)
print(l[s1])
print(l[s2])
print(s2.start)         # 结果：1
print(s2.stop)          # 结果：4
print(s2.step)          # 结果：2

# 按年纪排序 -- sorted
age = [{"name":"new1","age":15,},{"name":"new2","age":18,},{"name":"new3","age":88,},{"name":"new4","age":50}]
print(sorted(age,key=lambda dic:dic["age"]))

# 求和 -- sum
l = [1,2,3,4]
print(sum(l))
print(sum(range(101)))

# 判断数据类型 -- type
msg = "232"
if type(msg) is str:
    msg = int(msg)
    res = msg + 1
    print(res)

# 将对象以字典的形式输出 -- vars
def test():
    msg = "sffewfefwefw"
    print(locals())             # 结果：{‘msg‘: ‘sffewfefwefw‘}
    print(vars())               # 结果：{‘msg‘: ‘sffewfefwefw‘}
test()
print(vars(int))            # 以字典的形式，输出int对象下的所有方法

######  一个py文件 就是一个模块  ######

import test                  # 不能导入字符串类型
# import ‘test‘              # 报错
m = __import__(‘test‘)      # 能导入字符串类型

######  一个py文件 就是一个模块  ######

内置函数