python 高階函式、柯里化
這裡是一段防爬蟲文字，請讀者忽略。
本文原創首發於csdn，作者idys
部落格首頁：
高階函式
def
couter
(base)
:def
inc(step=1)
:nonlocal base
base += step
return base
return inc
if __name__ ==
"__main__"
: foo = couter(10)
foo1 = couter(10)
print
("foo1 is foo:"
, foo1 is foo)
print
("foo1(1):"
, foo1(1)
)print
("foo1(1):"
, foo1(1)
)print
("foo(1):"
, foo(1)
)print
("fo0(1):"
, foo(1)
)
上面的foo1和foo，每次往其中加入乙個引數，那麼就自動的加上這個引數。foo和foo1不相等。因為它們引用的是不同函式裡面的counter函式
思路
新建乙個列表，遍歷原列表，和新列表的值依次比較決定如何插入到新列表中
def
my_sort
(iterable, key=
lambda a,b:afalse):
ret =
for i in iterable:
for j, k in
enumerate
(ret)
: flag = key(k, i)
if reverse else key(i, k)
if flag:
ret.insert(j, i)
break
else
:return ret
if __name__ ==
"__main__"
: list1 =[1
,4,6
,7,8
,9] tuple1 =(3
,5,6
,7,8
,9)print
(tuple
(list1)
)print
(list
(tuple1)
)print
(my_sort(list1)
)print
(my_sort(list1, reverse=
true
))
(1,
4,6,
7,8,
9)[3
,5,6
,7,8
,9][
1,4,
6,7,
8,9]
[9,8
,7,6
,4,1
]
自定義乙個函式，函式引數能夠接收可迭代元素、和reverse值的設定，同時可迭代元素是什麼型別，便返回什麼型別。
函式內部自己氣泡排序，然後根據reverse的值，自己決定氣泡排序的比較方式
返回乙個新的可迭代元素，對原來的可迭代元素不做修改
import copy
defmy_sorted
(iterable_arg, reverse=
false):
iterable = copy.deepcopy(iterable_arg)
is_tuple =
false
iftype
(iterable)
istuple
: iterable =
list
(iterable)
is_tuple =
true
for i in
range
(len
(iterable)):
for j in
range(1
,len
(iterable)
- i):if
not reverse:
if iterable[j-1]
> iterable[j]
: iterable[j]
, iterable[j -1]
= iterable[j -1]
, iterable[j]
else
:if iterable[j -1]
< iterable[j]
: iterable[j]
, iterable[j -1]
= iterable[j -1]
, iterable[j]
if is_tuple:
return
tuple
(iterable)
else
:return iterable
if __name__ ==
"__main__"
:print
(my_sorted([12
,56,78
,89,34
,1,88
,23,4
]))print
(my_sorted((1
,0,3
,-1,
90,23,
89,10)
))print
(my_sorted((1
,0,3
,-1,
90,23,
89,10)
, reverse=
true
))
[1,
4,12,
23,34,
56,78,
88,89]
(-1,
0,1,
3,10,
23,89,
90)(90
,89,23
,10,3
,1,0
,-1)
filter(function, iterable) --> filter object
map(func, *iterables) --> map object
例如，過濾出數列中能被3整除的數字
list(filter(lambda x: x%3==0, [1,9,55,150,-3,78,28,123]))
list(map(lambda x:2*x+1, range(5)))
print
(list
(filter
(lambda x: x %3==
0,[23
,12,56
,12,90
,3,2
,5,8
])))
print
(list
(map
(lambda x:
4*x+1,
range(10
))))
print
(dict
(map
(lambda x:
("x"
+str
(x),
2*x+1)
,range(10
))))
[12,
12,90,
3][1
,5,9
,13,17
,21,25
,29,33
,37]
z = f(x, y)轉換成z = f(x)(y)的形式
def
add(x, y)
:return x + y
def
add(x, y)
:return x + y
def
add(x)
:def
_add
(y):
return x+y
return _add
add(5)
(6)
def
num_add
(x=0
, y=
0, z=0)
:return x+y+z
def
add(x)
:def
_add
(y):
def_add1
(z):
return x+y+z
return _add1
return _add
Python高階1 高階函式 柯里化
高階函式 不相等自定義sort函式 內建函式 高階函式 sort函式 def sort2 lst,key none,reverse false res if key is none key lambda x,y x ifreverse key lambda x,y x y for x in lst ...
高階函式 函式柯里化與反柯里化
一 函式柯里化 currying 是把接受多個引數的函式變換成接受乙個單一引數 最初函式的第乙個引數 的函式，並且返回接受餘下的引數而且返回結果的新函式的技術。例 記錄程式設計師乙個月的加班總時間，那麼好，我們首先要做的是記錄程式設計師每天加班的時間，然後把乙個月中每天的加班的時間相加，就得到了乙個...
高階JS 函式柯里化
什麼是函式柯里化？在電腦科學中，柯里化 currying 是把接受多個引數的函式變換成接受乙個單一引數 最初函式的第乙個引數 的函式，並且返回接受餘下的引數且返回結果的新函式的技術。通俗點說就是將乙個函式拆分成多個函式，是固定部分引數，返回乙個接受剩餘引數的函式，也稱為部分計算函式，目的是為了縮小適...