每天坚持 一天一篇 点个订阅吧  灰常感谢    当个死粉也阔以

　　　　　　　　　　　　　　　　　　　　　　Python人工智能从入门到精通

globals（）/locals（）函数：
　　　　globals（）返回当前全局作用域内变量的字典
　　　　locals（） 返回当前局部作用域内变量的字典
函数变量：
　　函数名是变量，它在def 语句创建时绑定函数
　　fa1 = fa 没有括号 绑定函数 fa1 = fa（） 返回结果
　　　　函数的变量名可以序列交换算法
一个函数可以作为另一个函数的实参传递：
 例如：

def myinput(fn):
    L = [5, 3, 1, 9, 7]
    return fn(L)
    print(myinput(max))
    print(myinput(min))
    print(myinput(sum))
    print(myinput(len))

函数可以作为另一个函数的返回值：
例如：

def get_op():
　　s = input("qing shu ru cao zuo")
　　if s == "zui da":
　　　　return max
　　elif s == "zui xiao":
　　　　return min
　　elif s == "he":
　　　　return sum
L = [2, 3, 4, 6,5, 6, 9, 1]
print(L)
f = get_op()
print(f(L))

函数的嵌套：
　　函数嵌套定义是指一个函数里用def语句来创建其他的函数

示例:

def fn_outter():
　　print("fn_outter被调用")
def fn_inner():
　　print("fn_inner被调用")
　　fn_inner()
　　fn_inner()
　　print("fn_outter调用结束")

fn_outter()

Python的作用域：
　　　　作用域也叫名字空间，是访问变量时查找变量的范围空间
　　python的4个作用域：
　　作用域： 　　　　 　　 　　 　　　　　　 英文解释 　　　　　　 缩写
　　局部作用域（函数内） 　　 　　　　　　 Local（function） 　　     L
　　外部嵌套函数作用域 　　 　　　　　　　 Enclosing functio loc 　　 E
　　函数定义所在模块（文件）作用域　　　　 Global（module）           G
　　python内建模块作用域 　　　　　　　　   Builtin（python） 　　　  B 
包含关系（内建>模块>外部嵌套函数>函数内）
变量名查找规则：
　　　　访问变量时，先查找本地变量，然后是包裹此函数外的函数内部的变量
　　　　，之后是全局变量，最后是内建变量
　　　　　　　　　　L ---> E ---> G ---> B
　　　　在默认情况下，变量名赋值会创建或者改变当前作用域的变量
global语句：
　　告诉解释执行器global语句声明一个或多个变量，
　　这些变量的作用域为模块级别的作用域，也称为全局变量
全局声明（global）
　　将赋值语句操作的变量映射到模块文件内部的作用域
　　语法：
　　　　global 变量1， 变量2， ....
　　说明：
　　　　1. 全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是创建局部变量)
　　　　2. 全局变量在函数内部不经过声明就可以直接访问(变量已经存在并关联一个对象)
　　　　3. 不能先声明局部变量，再用global声明为全局变量，此做法不附合规则
　　　　4. global变量列表里的变量名不能出现在此作用域的形参列表里

nonlocal语句：
　　告诉解释执行器，nonlocal声明变量不是局部变量，也不是全局变量
　　它是外部嵌套函数变量
　　语法：
　　　　nonlocal 变量名1，变量名2，...
　　说明：
　　　　1. nonlocal 语句只能在被嵌套的函数内部进行使用
　　　　2. 访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作
　　　　3. 当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近的一层变量进行操作
　　　　4. nonlocal语句的变量列表里的变量名，不能出现在此函数的参数列表中

lambda表达式（又称匿名函数）（希腊字母：入）
　　作用：
　　　　创建一个匿名函数对象
　　　　同def类似 但是不提供函数名
　　格式：
　　　　lambda[ 参数1， 参数...]： 表达式
　　说明：
　　　　1. lambda 只是一个表达式，它用来创建一个函数对象
　　　　2. 当lambda表达式调用时，先执行冒号(:)后的表达式，并返回表达式的结果的引用关系
　　　　3. lambda 表达式创建的函数只能包含一条表达式
　　　　4. lambda 比函数简单且可以随时创建和销毁，有利于减少程序的偶合度

　　函数：
　　　　eval （） / exec（） 函数
　　　　eval(source, globals=None, local=None) 把一个字符串 srouce 当成一个表达式来执行，返回表达式执行的结果
　　　　exec(source, globals=None, locals=None) 把一个字符串source 当成程序来执行

练习:
写一个函数叫hello(name),部分代码如下:
count = 0
def hello(name):
print('你好', name)
... 此处代码省略,需要同学们自己填写
... 此处代码需要改变全局变量来记录此函数曾经被调用过多少次.

hello('小张')
hello('小李')
print('hello 函数被调用', count, '次') # 2次

count = 0
def hello(name):
    global count
    count += 1
    print("hello", name)
hello("name")
hello("xiaoli")
hello("xiaoliu")
hello("xiaowei")
hello("xiaozhang")

1. 写一个lambda 表达式，判断这个数的2次方+1是否能被5整除，如果能被整除返回True, 否则返回False
例:
fa = lambda x: .....
print(fa(2)) # True
print(fa(4)) # False

fa = lambda x: (x ** 2 + 1) % 5 == 0
print(fa(2)) # True
print(fa(4)) # False

2. 写一个lambda表达式，求两个变量的最大值
例如:
def mymax(x, y):
...
mymax = lambda ...
print(mymax(100, 200)) # 200

def mymax(x, y):
    if x > y:
        return x
    else:
        return y
print(mymax(100, 200)) # 200

mymax = lambda x, y: x if x > y else y 
print(mymax(100, 200)) # 200

1. 给出一个整数n,写一个函数myfac来计算n!(n的阶乘)
n! = 1 * 2 * 3 * 4 * ..... * n
如:
print(myfac(5)) # 120

def myfac(n):
    x = 1
    for i in range(1, n + 1):
        x = x * i
    return x
print(myfac(5))

2. 给出一个整数n,写一个函数计算myfn(n):
1 + 2**2 + 3**3 + .... + n**n的和
如:
print(myfn(10)) # ???

def myfu(n):
    s = 0
    for x in range(2, n + 1):
        s += x ** x
    return s
print(myfu(10))

3. 完全数:
1 + 2 + 3 = 6 (6为完全数)
1,2,3都为6的因数(因数是能被一个数x整除的整数为y,则y为x的因数)
1 x 6 = 6
2 x 3 = 6
完全数是指除自身以外的所有因数相加之和等于自身的数
求 4~5个完全数并打印出来
答案:
6
28
496
......

def mywqs(x):
    s = 0
    L = []
    for i in range(1, x):
        if x % i == 0:
            L.append(i)
    for i in L:
        s += i
    if s == x:
        return True
    else:
        return False
i = 0
wqs = 0
while wqs < 5:
    i += 1
    if mywqs(i) == True:
        print(i)
        wqs += 1

    咳咳 又到了吹NB环节
locals（）、globals（）
　　　　就是一个查询函数 以字典形式返回信息而已
函数变量？
　　　　你就就把它看做一个全局变量 变量绑定数据 而它绑定语句块 就这么简单
什么是作用域？
　　　　作用域就是变量的所属范围 超过范围就失效
　　　　在别的地方一般是3个作用域 而python有4个
　　　　内建变量 局部变量 模块全局变量
　　　　特殊那个就是两个函数嵌套之间的范围（外部嵌套）
　　　　分别都是包含关系（内建>模块>外部嵌套函数>函数内）
　　　　内建函数 不可删除或修改 其他作用域 不能与内建函数重名
　　　　否则内建函数失效 只作用于当前空间自定义函数
　　　　各作用域各不相干 同空间不可重名
global 　　 不管在任何空间使用global都直接声明全局变量
nonlocal 　 只能在被嵌套函数内部使用 多层嵌套 只会跳一层
lambda 　  用表达式创建一个函数 和if一样