python2
https://www.liaoxuefeng.com/wiki/1016959663602400/1017328655674400
reference：https://www.liaoxuefeng.com/wiki/1016959663602400/1017328655674400
高阶函数
可以吧函数本身赋值给变量
>>> f = abs
>>> f(-10)
10如果把abs指向其它的对象，比如令abs=10，就会发现无法通过abs(-10)调用这个函数了，因为abs这个变量已经不指向求绝对值函数而是指向10这个整数。函数名也可以是变量
传入函数
既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
一个最简单的高阶函数：
def add(x, y, f):
return f(x) + f(y)Python内建的filter()函数用于过滤序列。
Python内置的sorted()函数就可以对list进行排序。
reverse方法可以将列表元素反序
len()方法可以检测数组一个维度的元素个数
map的使用
def mutipl(x):
return x**2
a = input().split()
a = [int(x) for x in a]
print(a)
a = map(mutipl,a)
a = list(a)
print(a) #使用map映射了之后需要重新进行列表化
#我的理解是，相比比简单的列表生成式子，map可以直接调用函数来进行列表的生成，功能可以说更加强大
#sort的简单用法
a = sorted(a)
print(a)
a.sort(reverse=True)
print(a)输入
1 3 5 6
输出
[1, 3, 5, 6]
[1, 9, 25, 36]
[1, 9, 25, 36]
[36, 25, 9, 1]
reduce的用法
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def f(x,y):
return x*10+y
print(reduce(f,[1,3,4,5,6,7]))输出134567
def turn(x):#变成title()类型的单词
return x.title()
s = ['adam', 'LISA', 'barT']
print(list(map(turn,s)))
def muti(x, y):#求积
return x*y
from functools import reduce #载入方法
s = [1,5,3,2,4]
print(reduce(muti,s))
def str2float(s): #将字符串转换成浮点数的函数
point = s.index('.')#index () 方法查找指定值的首次出现
a = s[:point]
b = s[point+1:]
b = reversed(b)
a = reduce(lambda x,y: float(x)*10.+float(y), a) #使用匿名函数
b = reduce(lambda x,y: float(x)*.1+float(y), b)
print(a+b*.1)
r = '113.231'
str2float(r)输出：
['Adam', 'Lisa', 'Bart']
120
113.231
filter的使用：
def not_empty(s):
return s and s.strip()
a = list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
print(a)
#filter练习
def isreverse(x):#检测列表中的回文数
for a in range(len(x)):
if(x[a] != x[-(a+1)]): return False
return True
a = input().split()
a = list(filter(isreverse,a))
print(a)输出1：[‘A’, ‘B’, ‘C’]
输入1：11111 22322 432 123456 34 626 1
输出2：[‘11111’, ‘22322’, ‘626’, ‘1’]
sort的使用:
#sort的使用
a = ['aob','charming','BABABOI','Zip!man']
a = sorted(a,key = str.lower)
print(a)
a.sort(key = str.lower, reverse=True)
print(a)
#降序输出成绩
L = [('Bob',75), ('Adam',92), ('Bart',66), ('Lisa',88)]
L.sort(key = lambda x:x[1],reverse=True)
print(L)输出：
['aob', 'BABABOI', 'charming', 'Zip!man']
['Zip!man', 'charming', 'BABABOI', 'aob']
[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]
返回函数
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
f = lazy_sum(1, 3, 5, 7, 9)
print(f)#函数并没有立即被完全调用
print(f())#返回真正的结果输出
<function lazy_sum.<locals>.sum at 0x0000027D2E82B1C0>
25
在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。
请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False
f1()和f2()的调用结果互不影响。
其它有关闭包的要点见廖雪峰的博客
另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。我们来看一个例子：
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：
>>> f1()
9
>>> f2()
9
>>> f3()
9
全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
类与实例：
class Restaurant:
def __init__(self,name,type):
self.restaurant_name = name
self.cusine_type = type
def Describle_restaurant(self):
print(f"餐厅的名字 = '{self.restaurant_name}\n菜单 = {self.cusine_type}")
def Open_restaurant(self):
print("餐厅正在营业")
restaurant = Restaurant("老八的烧只因店",['新品上市~老八巧克力~❤','chiken招牌⭐香翅捞饭💕','传统美食🥵欧美茗皮'])
print(f"欢迎来到{restaurant.restaurant_name}")
restaurant.Describle_restaurant()
restaurant.Open_restaurant()有关继承与导入类和模块，见蟒蛇书
文件
with open('text') as file_object:
contents = file_object.read()
print(contents)
读写文本
