python全局变量、回调函数

1、python全局变量相关概念及使用

来自菜鸟教程上的例子： http://www.runoob.com/python3/python3-function.html

一、python入参需要注意地方

a=1
def speak(a=None):
    if a is None:
        print('None')
    else:
        print(a)
speak()
None
speak(a=a)
1

class A():
    def talk(self,filename=''):
        if filename=='':
            filename='filename'
        print('take:',filename)
        return filename

    def see(self,filename=None):
        if filename is not None:
            a='a'
            print(a)
        elif filename is None:
            a='elif'
            print('a:',a)
            print('filename:',filename)

    def speak(self):
        a=self.talk();print('a:',a)
        print('-------------')
        self.see()
        print('-------------')
        print('a:',a)
aa=A()
aa.speak()

take: filename
a: filename
-------------
a: elif
filename: None
-------------
a: filename

class A():
    def talk(self,filename=''):
        if filename=='':
            filename='filename'
        print('take:',filename)
        return filename
    def see(self,filename=None):
        if filename is not None:
            a='a'
            print('a:',a)
        elif filename is None:
            a='elif'
            print('a:',a)
            print('filename:',filename)
    def speak(self):
        a=self.talk();print('a:',a)
        print('-------------')
        self.see(filename=a)
        print('-------------')
        print('a:',a)
aa=A()
aa.speak()

take: filename
a: filename
-------------
a: a
-------------
a: filename

二、python中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量在哪里赋值的。

变量的作用域决定了哪一部分程序可以访问哪个特定的变量名称。python的作用域一共有4中。分别是：

L(local)局部作用域；E(Enclosing)闭包函数外的函数中；G(Global)全局作用域；B(Built-in)内建作用域

# Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，
# 其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，
# 也就是说这这些语句内定义的变量，外部也可以访问，
if True:
    msg='msg'
print(msg)
msg
#如果将 msg_new 定义在函数中，则它就是局部变量，外部不能访问：
def test():
    msg_new='msg_new'
print(msg_new)
Traceback (most recent call last):
  File "D:\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 2862, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-3-ac28ad2bc0fc>", line 4, in <module>
    print(msg_new)
NameError: name 'msg_new' is not defined

二、全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，访问结束后销毁，而全局变量可以在整个程序范围内访问。

total=0
def sum(arg1,arg2):
    total=arg1+arg2
    print(total)
    return total
sum(10,10)
print(total)
20
0  #函数sum内total=20变量销毁掉，打印最初赋值全局变量，total=0，如果没有total=0，则报错
total=0
def sum(arg1,arg2):
    global total
    total=arg1+arg2
    print(total)
    return total
sum(10,10)
print(total)
20
20

三、如果要修改嵌套作用域(enclosing 作用域，外层非全局作用域)中的变量，则需要nonlocal关键字，代码如下，比较两者区别。

def outer():
    num=10
    def inner():
        num=100
        print(num)
    inner()
    print(num)
outer()
100
10

def outer():
    num=10
    def inner():
        nonlocal num  #nonlocal关键字声明
        num=100
        print(num)
    inner()
    print(num)
outer()
100
100  #从上面代码10 变为100

2、什么是回调函数，感觉好复杂？？存在的意义是什么？

1、知乎上的回答：https://www.zhihu.com/question/19801131

你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。回答完毕。

2、什么是回调：http://www.jb51.net/article/68797.htm

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。

同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；

回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；

异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方(即调用客户方的接口)。

回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。

同步调用时三者中最简单的，而回调又常常是异步调用的基础。

回调函数：通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。如下面的例子1：来源  https://www.cnblogs.com/hainan-zhang/p/6222552.html

下面例子：我猜测函数指针应该为function_name

def clean1(times):
    """
    就假装扫地
    param times :次数
    return None
    """
    print('已完成扫地次数：',times)
def clean2(times):
    """
    假装洗抽油烟机
    param times:次数
    return: None
    """
    print('已洗抽油烟机次数：',times)
def call_clean(times,function_name):
    """
    这个很重要，就是家政公司的业务系统，要啥业务都得在这说
    这个是实现回调函数的核心
    param times:次数
    param function_name:回调函数名
    return：调用的函数结果
    """
    return function_name(times)
call_clean(10,clean2)   #call_clean(10,clean2)

这个例子介绍回调函数的使用，没有说明回调函数存在的意义？这样写还不如直接调用clean2函数10次。

下面在网上找的另外一个，例子2：http://blog.csdn.net/ma52103231/article/details/61432120

看着有点懵，难度大，换一个

class Callback:
    def __init__(self,instance,function_name):
        self.instance=instance
        self.function_name=function_name
    def action(self,params):
        self.instance.__getattribute__(self.function_name)(params)
class Test:
    def __init__(self):
        self.clb=None
    def register(self,clb):
        self.clb=clb
    def do_test(self):
        params=[]
        self.clb.action(params)
class Api:
    def __init__(self,test_instance):
        test_instance.register(Callback(self,self.function.__name__))
    def function(self,params):
        print('function')
t=Test()
a=Api(t)
t.do_test()
#function

例子3：http://blog.csdn.net/ma52103231/article/details/61432120

#called.py文件，为回调函数
def test_call(p_call):
    print('in called.py test_call()')
    b=p_call()
    return b

###call.py文件，主程序
import called
def callback():
    a=1
    b=a+1
    print('in callback')
    return b
def main():
    global x
    #called.test()
    x=called.test_call(callback)
    print('in call.py')
main()
print(x)

运行主程序结果：
in called.py test_call()
in callback
in call.py
2

3、一个主程序脚本文件，main.py，一个回调函数脚本文件，pyCallBack.py，main.py调用pyCallBack.py，在回调函数中生成数据，现在想把数据传到主程序上来，该如何写？

解答：可以用return直接返回即可。如上面例子3