python实现函数ifodd_python 高阶函数-CSDN博客

函数式编程

用一系列函数解决问题

传入参数一定，结果必一定(只有一个输入一个输出)

def myadd(x, y):#不可重入函数:

return x +y

y= 200

def myadd2(x):#可重入函数

return x +yprint(myadd2(10)) #210

y = 300

print(myadd2(10)) #310

函数式编程的要求：

创建函数最好不要访问局部作用域以外的变量，这样可以保证返回结果的唯一性(可重入性)

高阶函数

满足下面条件之一的为高阶函数：

1、函数接受一个或者多个函数作为参数传入

2、函数返回一个函数

python内建的高阶函数：

map、filter、sorted

map函数

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

格式：

map(func,iterables1,,iterables2,.........)

参数：

function -- 函数，有一个或两个参数

iterable -- 一个或多个序列

返回值

Python 2.x 返回列表。

Python 3.x 返回迭代器

defpower(x):return x**2

#for x in map(power,range(1,10)):#print(x)#for x in map(lambda x :x**2,range(1,10)):#print(x)

print(list(map(power,range(1,10))))#[1, 4, 9, 16, 25, 36, 49, 64, 81]

#提供了两个列表，对相同位置的列表数据进行相加

print(list(map(lambda x,y:x+y,[1,2,3,4],[4,3,2,1])))#[5, 5, 5, 5]#必须要加list，不加list返回的是内存地址#

#求：1 ** 9 + 2 ** 8 + 3 ** 7 + ......9 ** 1

s =0for x in map(pow, range(1, 10), range(9, 0, -1)):

s+=xprint(s)

map(function,iterable...)

filter函数

函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回　True 或 False，最后将返回 True 的元素放到新列表中。

语法：

filter(function,iterable)

参数：

function——判断函数

iterable——可迭代函数

#def is_odd2(n):#if n%2 ==1:#return True#return False

defis_odd(n):return n%2 == 1

#过滤出列表中的所有奇数

list1 = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])print(list1)#[] python3返回的是一个filter类，相当于迭代器

list2 = list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10]))print(list2)

L= [x for x in filter(is_odd,range(1,10))]print(L)#[1, 3, 5, 7, 9]

filter(function)

defis_prime(x):if x <2:returnFalsefor y in range(2,x):#当循环里面所有的值都不能整除x的时候，则返回True

#if x==y:

#continue

if x%y==0:returnFalsereturnTrue

L2= [x for x in filter(is_prime,range(20,30))]print(L2)

fliter(function,iterable)

sorted函数

将原可迭代对象的数据进行排序，生成排序后的列表

sort与sorted区别：

sort是应用在列表list上的方法，sorted可以对可迭代的对象进行排序操作，list 的 sort 方法返回的是对已经存在的列表进行操作,永久性的修改原始的list,，而内建函数 sorted 方法返回的是一个新的 list，原来的list顺序不变，而不是在原来的基础上进行的操作。

参数：

sorted(iterable,key=None,reverse=False)

iterable:可迭代对象

key:主要用来进行元素比较，指定可迭代对象中的一个元素来进行排序

reverse:排序规则，reverse = True 降序， reverse = False 升序(默认)

返回值：

返回重新排序的列表

利用key进行倒序排序

ex_list = [5,4,7,1,9,3,5,7,0]

re_list= sorted(ex_list,key = lambda x : x*-1,reverse =False)print(re_list)#[9, 7, 7, 5, 5, 4, 3, 1, 0]

利用reverse来对可迭代对象进行倒序排序

re_list = sorted(ex_list,reverse =True)print(re_list)#[9, 7, 7, 5, 5, 4, 3, 1, 0]

按字典的 key值对字典排序

d = {"lilee":25, "wangyan":21, "liqun":32, "lidaming":19}print(sorted(d.keys()))#['lidaming', 'lilee', 'liqun', 'wangyan']

按字典的 value值对字典排序

d = {"lilee":25, "wangyan":21, "liqun":32, "lidaming":19}print(sorted(d.items(), key=lambda item:item[1]))#[('lidaming', 19), ('wangyan', 21), ('lilee', 25), ('liqun', 32)]

练习key排序

同时可以利用key的值来进行数组\字典的排序

arry = [{"age":20,"name":"a","score":78},

{"age":18,"name":"b","score":60},

{"age":23,"name":"c","score":99}]

array= sorted(arry,key = lambda x :x["age"])print(array)#[{'age': 18, 'name': 'b', 'score': 60},#{'age': 20, 'name': 'a', 'score': 78},#{'age': 23, 'name': 'c', 'score': 99}]

再次练习用key来对可迭代对象来排序

names = ["Tom","Jerry","Spike","Tyke"]def fun(x): #x为可迭代对象中的值，传入了函数

print("k()传入:",x, "返回去的",x[::-1])return x[::-1] #逆序

name = sorted(names,key =fun)#k()传入: Tom 返回去的 moT#k()传入: Jerry 返回去的 yrreJ#k()传入: Spike 返回去的 ekipS#k()传入: Tyke 返回去的 ekyT

print(name)#['Spike', 'Tyke', 'Tom', 'Jerry']

递归函数

函数直接或者间接的调用自身

说明：

递归一定要控制递归层数，当符合一定条件时要终止递归

无return的函数递归，可理解为函数嵌套

无return递归

#函数嵌套无return