python函数返回引用 python中返回函数

Python中 自己定义的函数内生成的列表 怎么在外部中引用？

下面的例子演示了用3种方法来在外部引用函数内部定义的列表：

成都创新互联公司是一家集网站建设,高陵企业网站建设,高陵品牌网站建设,网站定制,高陵网站建设报价,网络营销,网络优化,高陵网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

#返回函数内部定义的列表

def int_list1():

l=[1,2]

return l

#将函数内部列表定义成全局的

def int_list2():

global l

l=[3,4]

#将函数内部列表定义成函数的一个属性

def int_list3():

l=[5,6]

int_list3.l=l

print(int_list1())

int_list2()

print(l)

int_list3()

print(int_list3.l)

这是截图：

求帮助，Python闭包和返回函数问题

（1）unpack tuple和list, 可以让函数返回多个值

def count():

return (1, 2, 3) # 或者 return [1, 2, 3]

# 把列表解包，把1 2 3 分别赋值给 a b c

a, b, c = count()

print a, b, c

# 输出 1, 2, 3

（2）假设你知道Python的dict类型。Python中，在函数中定义一个变量的时候，会在一个隐藏的叫locals的dict里面插入key-value，其中key是变量名，value是变量值。而引用一个变量的时候，则首先会在这个叫locals的dict里面，根据变量名作为key，去查对应的值。

var = 1 # 你可以认为这里进行了 locals['var'] = 1 的操作

print var # 在对var变量进行求值的时候，就在locals['var']里面找var变量对应的值

（3）for循环中，每次循环只是给 `i` 重新绑定值

for i in (1, 2, 3):

print i

print i

# 一次输入 1 2 3 3

每次`for i in (1, 2, 3)`相当于在`print i`之前，进行了

`locals['i'] = 1`

`locals['i'] = 2`

`locals['i'] = 3`

的操作

所以最后的`print i`再去locals字典里面找`i`的时候，就变成 3 了。

（4）闭包是 一个函数加上这个函数引用的外部变量

var = 1

def f():

print var

# 这里的闭包是函数 f 和 f 引用的外部变量 var

def count():

var2 = 2

def f():

print var2

# 这里的闭包是函数 f 和 f 引用的外部变量 var2

return f

拿第一个函数 f 来说。在 f 运行的时候，解释器拿着'var'这个字符串去locals字典里面找，发现找不到，于是在closure字典里面找，最后closure字典里面找，你可以认为就是找closure['var']，然后发现找到对应的值。count里面的 f 函数同理。

（为了容易理解，我这里说谎了。实际上 f 压根没有closure，count里面的 f 才有。其实closure压根不是像locals那样的字典）

（5）函数定义时，函数只是记录变量的名字。

要区分什么是名字，什么是值。

`i = 1`这里 i 只是名字，只是一个字符串 'i' 。这句话运行完，locals['i'] = 1，就说 i 对应的值是1

def count():

fs = []

for i in range(1, 4):

# 定义一个函数，等价于运行了 locals['f'] = 真正生成的函数

# 每次循环，这里都会重新生成一个函数，然后把重新生成的函数赋值给 locals['f']

def f():

return i * i # 引用了'i'这个名字，但并不是引用了'i'对应的值

# 等价于 locals['fs'].append(locals['f'])

# f 不是函数，它只是一个名字'f'。f 引用的东西，也就是locals['f']才是真正的函数

fs.append(f)

# 于是这个for循环生成了三个函数，这三个函数是没有名字的，这个函数运行完后，它们跟'f'这个名字就毛关系都没有了(是的我说慌了，但可以先不管)

# 把整个列表返回，这个列表包含了三个函数

return fs

# count()返回三个函数的列表，unpack 列表的语法把列表中的三个函数抽出来，重新给他们命名为 f1, f2, f3

# 也就是说，

# locals['f1'] = 列表中的第1个函数

# locals['f2'] = 列表中的第2个函数

# locals['f3'] = 列表中的第3个函数

# 这三个函数跟'f'这个名字现在毛关系都没有。（其实是有的，但为了说明需要简化，现在你可以完全不管括号里面说的话）

f1, f2, f3 = count()

print f1(), f2(), f3()

# 好了我们运行它们，输入都是 9

# def f():

# return i * i

这是因为 f1 现在对应的函数，里面引用了 'i' 这个字符串，我们根据 'i '这个字符串去找它对应的值，先找到 f 当前的locals字典，发现没有，因为函数定义的时候没有定义 i 变量。然后再去closure['i']里面找，因为Python是通过closure字典实现闭包的（就当它是对的好不好），所以我们可以在closure['i']找到值，这个值就是我们上一次运行的时候count函数里面残留的locals['i']，而由于for循环三遍之后，locals['i'] == 3，所以找到 i 的值就是3。所以最后输出都是9

python中变量的引用、可变和不可变类型、局部变量和全局变量

变量的引用

变量和数据都是保存在内存中的

变量和数据是分开存储的

数据保存在内存中某个位置，通过地址来标记

变量保存的是数据的地址，通过地址可以找到数据在内存空间的位置

把变量保存数据地址的过程称为引用

变量的重新赋值修改的是变量中引用数据的内存地址

变量之间的赋值实际是引用的传递

函数参数的传递，本质也是引用的传递

函数的返回值本身也是引用的传递

可变和不可变类型

不可变类型，内存中的数据不允许被修改：数字类型（int,bool,float,complex,long(2,x)、字符串、元组（tuple）

可变类型，内存中的数据可以被修改：列表list、字典dict

无论是可变还是不可变数据类型，通过赋值语句，都会改变变量的引用

Hash函数只能接收不可变数据类型，字典的键也只能是不可变数据类型，字典的value值可以是任意数据类型

局部变量

1.在函数内部定义的变量就是局部变量（作用范围只能是当前函数内部）

2.在函数外部无法直接访问局部变量

3.不同的函数中可以定义同名的局部变量

4.局部变量的生命周期：从定义变量时开始，到函数运行结束

全局变量

1.在所有函数外边定义的变量就是全局变量

2.让所有函数都能访问到，可以作为函数通信的桥梁

3.一般情况下，为了和普通变量的区别，需要加上g_或gl_前缀

4.全局变量一般放在所有函数的最上面

5.在函数内部修改全局变量，必须要加上global关键字，如果不加global只是定义了一个同名的局部变量

函数的多个返回值

Python 里为什么函数可以返回一个函数内部定义的函数

没有复制，函数也是个对象，基本就和你 return 一个 list 一个 dict 没什么两样。

试试看在 Python REPL 中创建一个 function:

def foobar(): print("你好")

foobar

func_list = [foobar, foobar, foobar]

func_list[0]()

后者是一个闭包 ( closure )，简单来说就是函数对象中包装了函数中引用的外部变量，可以想象成这个函数被动态创建的时候，引用的外部变量冻结在函数里面了。

你新补充的我没怎么看懂，*args 的作用吗？*args 在形参上的作用类似捕获给函数的实参放在一个 args 的表中作为形参，如果作为实参传入的话，就是将 args 这个表解开作为分别的形参输入。