20200206
##命名空间（namespace）
指的是变量存储的位置，每一个变量都需要存储到指定的命名空间中
每一个作用域都会有一个它对应的命名空间
全局命名空间，用来保存全局变量，函数命名空间用来保存函数中的变量
命名空间实际上就是一个字典，是一个专门用来存储变量的字典。
locals（）用于获取当前作用域的命名空间
r如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()
返回一个字典
示例代码：
scope=locals()
print(scope)
print(scope['a'])
在函数内部locals()会获取函数的命名空间，使用globals()获取全局命名空间。
可以使用locals()可以来操控函数的命名空间，但是不建议这么操作。
##递归
1.基线条件（问题可以被分解为的最小问题，当满足基线条件时，递归就不再执行了）
2.递归条件（将问题继续分解的条件）
递归编写起来容易，不容易阅读。
循环编写起来难，容易阅读。
问题：求解10的阶乘
示例代码：
def factorial1(n):
'''
求解任意数的阶乘
参数：
n要求阶乘的数字
'''
result=n
for i in range(1,n):
result*=i
return result
def factorial2(n):
'''
求解任意数的阶乘
参数：
n要求阶乘的数字
'''
#基线条件，判断n是否为1，若为1，不再继续。
if n==1:
return 1
return n*factorical2(n-1)
函数power为任意数字做幂运算
def power(n,i):
if i==1:
return n
ruturn n*power(n,i-1)
判断回文字符串,是的话返回ture，反之flase
def huiwen(str):
if len(s)<2:
return ture
elif s[0]!=s[-1]:
return false
return huiwen(s[1:-1])
##高阶函数
在python中，函数是一等对象
一等对象一般都会具有如下特点：
对象在运行时创建
能赋值给变量或作为数据结构中的元素
能作为参数传递
能作为返回值返回
高阶函数至少要符合以下两个条件：
接收函数作为参数或者函数作为返回值的函数
实际上是将函数中保存的代码传输至函数中
应用场景：
定义函数，可以将指定列表中的所有的偶数，保存到一个新的列表中进行返回
def fn(lst):
#创建新列表
new_list=[]
#对列表进行筛选
for n in lst:
if n%2==0:
new_list.append(n)
return new_list
#定义一个函数，用来检查一个任意的数字是否为偶数
def fn2(i):
if i%2==0:
return True
return False
#定义一个函数，用来检查一个任意的数字是否大于5
def fn3(i):
if i>5:
return True
return False
def fn(func,lst):
# 创建新列表
new_list = []
# 对列表进行筛选
for n in lst:
if func(n):
new_list.append(n)
return new_list
#filter（）可以从序列这种过滤出符合条件的元素，保存到一个新的序列中
参数：
1.函数，根据该函数来过滤序列（可迭代的结构）
2.需要过滤的序列（可迭代的结构）
返回值：
过滤后的新序列（可迭代的结构）
print(list(filter(fn,l)))
##匿名函数lamba
lambda函数表达式专门来创建一些简单的函数，是创建函数的又一种方式.
语法：lambda 参数列表：返回值
匿名函数一般都是作为参数使用，在其他地方一般不会使用
def fn5(a,b):
return a+b
#也可以将匿名函数赋值给一个变量，一般不会这么做
lambda a,b:a+b
filter(fn5,l)
filter(lambda a,b:a+b,l)
map()函数可以对对象中所有元素做指定的操作，然后添加到一个新的对象中进行返回。
map(lambda i:i+1,l)
#定义一个函数，用来检查一个任意的数字是否为偶数
def fn2(i):
if i%2==0:
return True
return False
#定义一个函数，用来检查一个任意的数字是否大于5
def fn3(i):
if i>5:
return True
return False
def fn(func,lst):
# 创建新列表
new_list = []
# 对列表进行筛选
for nin lst:
if func(n):
new_list.append(n)
return new_list
##匿名函数lamba
lambda函数表达式专门来创建一些简单的函数，是创建函数的又一种方式：
def fn5(a,b):
return a+b
#也可以将匿名函数赋值给一个变量，一般不会这么做
lambda a,b:a+b
filter(fn5,l)
filter(lambda a,b:a+b,l)
map()函数可以对对象中所有元素做指定的操作，然后添加到一个新的对象中进行返回。
##sort
该方法用来对列表中的元素进行排序
sort()默认是直接比较列表中元素的大小
sort()可以接收一个关键字参数，key
key作为函数的一个参数，当设置了函数作为参数
每次都会一列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小
l=['a','vv','cccc','dddddd']
l.sort(key=len)
print(l)
l.sort()
print(l)
sorted()
这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
sorted排序不会影响原来的序列，而是返回一个新的序列
print(sorted(l,key=len))
##闭包
函数作为返回值返回
通过闭包可以创建一些只有当前函数能访问的变量
形成闭包的条件
1.函数的嵌套
2.将函数作为返回值进行返回
3.内部函数必须使用外部函数的变量
使用闭包主要是想隐藏不想让他人看到的数据
def fn():
#函数内部定义一个函数
def inner():
print('wo')
return inner
#r是一个函数，是调用fn()后的返回的函数
#这个函数是在fn()内部定义的，并不是全局函数
#所以这个函数总是能访问到fn()函数内的变量
r=fn()
print(r)
#求多个数的平局值
nums=[11,2,34,33]
print(sum(nums)/len(nums))
def make_average()
nums=[]
def average(n):
nums.append(n)
return sum(nums)/len(nums)
return average
##装饰器
创建几个函数
def add(a,b):
r=a+b
return r
def mul(a,b):
r=a*b
return r
r=add(1122,22)
print(r)
#我们不希望在不修改原函数的情况下，对函数进行扩展
def fn():
print('我是fn函数')
def fn2():
print('程序开始执行')
fn()
print('程序执行结束')
def new_add(a,b):
print('程序开始执行')
r=add(a,b)
print('程序执行结束')
return r
r=new_add(11,22)
print(r)
#上边的方式在不修改源码的情况下，对函数进行扩展，但是每扩展一个函数需要手动创建一个函数
#为了解决这个问题，我们创建一个函数，让这个函数自动帮助我们创建生产函数
def begin_end(old):
'''
用于对其他函数进行扩展，是其他函数在执行前打印开始执行，执行后打印执行结束
参数：old要扩展的函数'''
def new_function(*args,**kwargs):
print('程序开始执行')
r = old(*args,**kwargs)
print('程序执行结束')
return r
#返回新函数
return new_function
#像begin_end（）这种函数，我们成为装饰器，通过装饰器，可以在不修改原函数的情况下对函数进行修改
#在定义函数时，可以通过@装饰器，来使用指定的装饰器，同时可以为多个函数指定多个装饰器
#多个装饰器的时候，从内往外进行装饰。
#典型用法：
@begin_end
def say_hello():
print('大家好')
#希望函数可以在计算前，打印开始计算值，计算结束后打印计算完毕
#我们可以直接修改函数中的代码完成需求，但是会产生以下一些问题：
#1.函数多，修改会方便
#2.后期不方便维护
#3.违反开闭原则（OCP） 程序的设计，要求开发对程序的扩展，要关闭对程序的修改
