函数编程

globals() 和 locals()函数
globals()
返回当前全局作用域内的函数变量字典
locals()
返回当前局部作用域内的变量的字典
eval函数
作用：
把一个字符串当成一个表达式来执行，返回表达式执行的结果
格式：
eval(source, globals=None，locals=None）
x = 100
y = 200
s = "x + y"
eval(s)
300
把字符串翻译成一个表达式然后解释执行
exec函数
作用：
把一个字符串当成程序来执行
格式：
esec(source, globals=None，locals=None）
lambda表达式
（又称匿名函数）
作用：
创建一个匿名函数对象
同def类似，但不提供函数名
语法：
lambda [形参名1，形参民2，...]: 表达式
注：[ ]内的内容可省略
lambda语法说明：
1.lambda只是一个表达式，它用来创建一个函数对象
2.当lambda表达式执行时，返回的是冒号后（：），表达式的值
3.lambda表达式创建的九只能包含一条语句
4.lambda比函数简单且可以随时创建和销毁，有利于减少程序的偶合度

函数式编程：
是指用一系列函数解决问题
python语言 函数是一等公民
函数本身可以赋值给面量，赋值后变量绑定函数
允许将函数本身作为参数传入另一个函数
允许函数返回一个函数

好处：
每一个函数完成细小的功能，一系列函数的任意组合可以解决大问题函数仅接收输入并且产生输出，不包含任何可以影响输出的内部状态
要求：
def 创建的函数最好不要访问局部作用域以为的变量，这样可以保证返回结果的唯一性（函数的可重入性）
可重入性

可重入性：
输入一定，结果必然一定的函数
*例：
def myadd (x, y): #这是可重入函数
return x + y
s = 0
def myadd2(x, y):
"""这是不可重入函数，因为它会改变局部以外的变量"""
global s
s += x + y
return s

高阶函数high order function
什么是高阶函数：
满足下面两个条件之一的就为高阶函数
1.函数接受一个或多个作为参数传入
2.函数返回一个函数

Python内置（builtins）的高阶函数：
map   filter    sorted

map函数
map(func，interables)用函数对可迭代对象中每一个元素作为参数计算出新的可迭代对象，当最短的一个迭代器完成迭代后此迭代器生成结束
(func，interables)
func-是个函数
*interables- 是个可迭代对象

def power2(x):
return   x ** 2
mit  = map (power2,  range(1, 10))
[ x for  x in mit ]

*map生成一个可迭代对象，此可迭代对象可以生成：

1**4   2**3  3**2  4**1   这样的数
pow  (x,  y,  z = None)

[  x for  x   in   map  (pow, range(1, 5)  range(4,  0, -1)

3.    [x  for x in map  (pow, range(1, 5),
[4, 3, 2, 1],  range(5, 10))]

练习：
1.求12 + 22 + 32 + ...... 92的和

for  x in range(1，10）
s   +=  x  **  2
print(s)
二：
def     p2(x):
return  x ** 2
print(sum(map(p2, range(1, 10))))

三：print(sum(lambda x: x ** 2, range(1, 10)))

*2.求12 + 22 + 32 + ...... 99的和

print(sum(map(lambda x, y: x**y, range(1, 10), range(9, 0, -1)))

方法二：
print(sum(lambda x: x ** x, range(1, 10)))

3.求12 + 22 + 32 + ...... 91的和（11377）

filter函数
格式：
filter (function, iterable)
作用：
筛选可迭代对象iterable中的数据，返回一个可迭代对象，此可迭代对象将对iterable生成的数据进行筛选
函数function将对iterable中的每一个元素进行求值，返回False则将此数据丢弃，返回True,则保留此数据

#示例

def isodd（X）：
return x % 2 == 1````
odd [ x for x in filter(isodd, range(10))]
even = [x for x in filter (lambda x : x % 2 == 0, range(100))]

sorted函数：

可迭代对象
key
reverse

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

格式：
iterable 可迭代对象

key 函数是提供一个值，此值作为排序的依据
reverse标志是设置是否降序排序
示例：

L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L)
L2 = sorted(L, reverse=True)
L2 = sorted(L, key=abs) #[1, -2, 3, -4, 5]
依据是按照这些数的绝对值来排序

len函数：

以字符串的长度进行排序
name = ['Tom', 'Tyke', 'Jerry', 'Spike']
L = sorted(names, key=len)

递归函数（recursion）：

函数直接或间接的调用自身
def f()
f() 调用自身
f()
print('f()调用已返回!')
可代替循环，也可直接循环

示例：
可直接或间接的调用自身
def fa():
fb()

def   fb():
fa()
fa()
print("递归完成是不可能的，此句不会被打印")

递归说明：
递归一定要控制递归层数，当符合某一条件是要终止递归调用
几乎所有的递归都能用while循环来代替

>>示例：
>打印1 2 3 4 5
def fn(n):
if n == 5:
return
fn(n + 1) #递归调用至下一层

>>>此示例，递归函数的调用过程：

def f(n)
print("调用f（%d）开始" % n)
if   n   ==   3:
return
f(n  + 1)
print("调用f(%d)结束“ % n)

fn(1)
print("程序结束"!)
见：图片

示例2：
def factorial(n):
if n == 1:#1的阶乘是1
return 1
return n * factorial(n-1)
print(factorial(5))

递归的优点/缺点：
优点：
递归可以把问题简单化，让思路更为清晰，代码更简洁
缺点：
递归因系统环境影响大，当递归深度太大时，可能得到不可预知的结果……

>>
练习：
1.
编写程序：使用递归算5！阶乘
2.
算1-20的阶乘的和
1！+2！+3！..... +19！+20！
3.
学生信息管理项目：

>1.写一个函数input_student()返回用户输入的学生信息列表
def input_student():
name = input("请输入学生姓名:")
...
return L # L为列表
返回的列表的格式如下：
[{'name': 'tarena', 'age' : 20, 'socre‘：100}]
{'name': 'tarena', 'age' : 20, 'socre‘：100}

{'name': 'tarena', 'age' : 20, 'socre‘：100}

列表内用字典来保存每个学生的信息
学生信息有：
姓名：name
年龄：age
成绩：socre

2.写一个以表格方式打印的学生信息的函数output_stdent(lst)
def output_stdent(lst)
打印格式如下：
+---------+---------+-----------+
| name | age | score |
+---------+---------+-----------+
| tarena | 20 | 100 |
| aaaaaa | 21 | 98 |
| ................................... |
+-------------------------------+
(3) 主程序如下:
docs = input_student() # 得到学生信息
output_student(docs) # 打印学生信息