day10回顾:

函数变量

函数可以嵌套:

def 语句

创建一个函数对象

def xxx():

def yyy():

def zzz():

pass

全局变量，局部变量

全局变量的生命周期,通常以模块的生命周期为准(del语句除外)

局部变量的生命周期,是在函数调用过程中存在，调用结束则销毁

python 的作用域:

L Local 局部

E Enclosing 外部嵌套函数作用域

G Global 全局

B builtin 内建（内置)模块作用域

global 语句

nonlocal 语句

lambda表达式

globals()

locals()

day11笔记:

闭包 closure

将组成函数的语句和这些语句的执行环境打包在一起，得到的对象称为闭包closure

闭包说明:

如果一个内嵌函数访问的外部嵌套函数作用域的变量，则这个函数就是闭包

闭包必须有三个条件:

1. 必须有一个内嵌函数

2. 内嵌函数必须引用外部嵌套函数中的变量

3. 外部函数返回值必须是内嵌函数

示例见:closure.py

函数是一等公民:

1. 函数本身可以赋值给变量,赋值后变量的绑定函数

2. 允许将函数本身作为参数传入另一个函数

3. 允许函数返回一个函数

函数的可重入性:

对于一个函数，如果参数一定，返回结果必然一定，则这样的函数为可重入函数.

说明：

可重入函数通常不会引用外部作用域的变量

# 不可重入函数的例子：

y = 200:

def myadd1(x):

return x + y

print(myadd1(10)) # 210

y = 300

print(myadd1(10)) # 310

# 可重入函数，传参一定，结果必须一定:

def myadd2(x, y):

return x + y

函数式编程：

是指用一系列函数解决问题

好处:

每一个函数完成细小功能，一系列函数的任意组合可以完成大问题

函数仅接受输入并产生输出，不包含任何能影响输入的内部状态

高阶函数:

什么是高阶函数:

满足下列条件中的一个的函数即为高阶函数：

- 函数接收一个或多个参数作为参数传入

- 函数返回一个函数

python3 内置的(builtin)的高阶函数:

map

filter

sorted

map函数:

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

示例见: mymap.py

课堂练习：

1. 求1**2 + 2**2 + 3**2 + .... + 9**2的和

要求用函数式编程

2. 求1**3 + 2**3 + 3**3 + .... + 9**3的和

3. 求:1**9 + 2**8 + 3**7 + ... + 9**1的和(11377)

s = sum(map( (lambda x, y: x + y), [1,3,5,7,9], [2,4,6]))

filter函数:

filter(function or None, iterable) 筛选可迭代对象iterable 中的数据，返回一个可迭代对象，此可迭代对象将对iterable生成的数据进行筛选

function 函数将对iterable中每个元素进行求值，返回Flase则将此数据丢充，返回True则保留此数据

示例：

# 写一个函数判断是奇数还是偶数：

def isodd(x):

return x % 2 == 1

# odd = [x for x in range(10) if isodd(x)]

odd = [x for x in filter(isodd, range(10))]

练习：

1. 将1~20的偶数用filter函数和range函数生成,将这些数存入列表中

2. 用filter函数将1~100 所有素数求和后打印出来

sorted 函数:

作用：

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

格式：

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

说明：

iterable 可迭代对象

key 函数是用来提供一个值，这个值将作为排序的依据

reverse 标志是用来设置是否降序排序

示例：

L = [5, -2, -4, 0, 3, 1]

L2 = sorted(L) # L2 = [-4, -2, 0, 1, 3, 5]

L3 = sorted(L, reverse=True) # L3 = [5, 3, 1, 0, -2, -4]

# 思考，不能按绝对值排序？

L4 = sorted(L, key=abs)#L4 = [0, 1, -2, 3, -4, 5]

names = ['Tom', 'Jerry', 'Spike', 'Tyke']

L5 = sorted(names)

练习：

names = ['Tom', 'Jerry', 'Spike', 'Tyke']

用上述列表生成一个排序的列表，

排序依据为字符串的反序:

如:Tom 排序依据为 'moT'

结果为: ['Spike', 'Tyke', 'Tom', 'Jerry']

eval()函数 和exec()函数

eval()

作用：

把一个字符串当成一个表达式来执行，返回表达式执行的结果

格式:

eval(source, globals=None, local=None)

示例：

x = 100

y = 200

s = "x + y"

a = eval(s) # 300

print(a)

ls = {"x": 1, "y": 2}

a = eval(s, None, ls) # 3

print(a)

gs = {'x': 10, 'y': 20}

a = eval("x+y", gs, None)

exec()函数:

作用：

把一个字符串当成程序来执行

格式:

exec(source, globals=None, local=None)

示例：

x = 100

y = 200

s = "print('hello:', x, y)"

exec(s)

gd = {'x': 10, 'y':20}

ld = {'x': 1, 'y':2}

exec("z = x + y", gd, ld)

# exec函数可以改变locals 字典和globals字典的内容

print(ld)

递归 函数 recursion

递归调用是指函数直接或间接的调用自身

示例:

def f():

f() # 调用自己

f()

print("递归调用完成")

# 见recursion.py

递归说明：

1. 递归函数一定要控制递归的层数（也叫深度）当符合一定条件时要终止递归调用

2. 几乎所有的递归都能用while 循环来代替

递归函数的实现方法：

先假设此函数已经实现

示例：

见print_number.py

# 写一个递归函数打印1 2 3 ~ 10 的数

def fn(n):

print(n)

思考：如何用递归(不用while,for和sum)来实现1+2+3+...+100的和

示例见 : mysum.py

递归的优缺点:

优点：

递归可以把问题简单化，让思路更为清晰,代码更简洁

缺点：

递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

CPython 默认递归深度是 1000 层

思考：

能否看懂这个函数在做什么：

def mysum2(n):

if n == 1:

return 1

return n + mysum2(n-1)

print(mysum(100)) # 5050

答案是: 递归求1~100的和

练习：

1. 编写函数fac(n) 优先使用递归返回n的阶乘

print(fac(5)) # 120

n! = n * (n-1)*(n-2)* ... * 4*3*2*1

2. 写程序算出1~20的阶乘的和

1! + 2! + 3! + .... 20!

3. 改写之前的学生信息的程序

输入5个学生的成绩，要求写4个函数来实现如下功能：

1) 按成绩从高至低打印学生信息

2) 按年龄从高至低打印学生信息

3) 按年龄从低至高打印学生信息

4) 按原来输入的顺序打印学信息

4. 思考题:

已知有五位朋友在一起

第五位朋友比第四个人大2岁

第四位朋友比第三个人大2岁

第三位朋友比第二个人大2岁

第二位朋友比第一个人大2岁

第一个人说他10岁

编写程序求出第五个人几岁?