一、函数式编程---定义：编程的方法论：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 reducemap：处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样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文件 就是一个模块 ######
内置函数
原文地址：https://www.cnblogs.com/newmet/p/10037102.html
时间： 2024-07-30 08:38:23