python函数全局返回,Python中函数的返回值

python函数的返回值？

题主你好,

在成都网站建设、成都做网站过程中，需要针对客户的行业特点、产品特性、目标受众和市场情况进行定位分析，以确定网站的风格、色彩、版式、交互等方面的设计方向。成都创新互联还需要根据客户的需求进行功能模块的开发和设计，包括内容管理、前台展示、用户权限管理、数据统计和安全保护等功能。

关键点在于函数如果没有明确使用return关键字指定函数的返回值,则默认返回值是none.

-----

所以temp = hello()这句的理解就是: 执行hello()这个函数, 并且把函数的返回值赋给变量temp, 但hello()函数中没有return语句, 所以hello()函数的返回值为默认的none.

-----

题主还可以在hello()函数最后加一个: return 123

然后再行一下看看,就明白了.

=====

希望可以帮到题主, 欢迎追问.

python函数如何同时处理返回值以及返回内容？

python支持返回多个返回值，所以你可以考虑返回两个值来解决。

参考代码和如何调用示例如下：

python 函数返回值返回到哪里

python 函数返回值有两种形式： 1 返回一个值。 2 返回多个值。 现看看返回一个值的吧。

def firstvalue(a,b):

c = a + b

return c

print firstvalue(1,2)结果:3

再看看返回多个值的： 那怎么可以返回多个值呢，其他的语言一般调用函数的话，只能返回一个值，可能我不太熟悉所有的语言，我知道的语言只能返回一个值，而python可以返回多个值，感觉非常方便,发代码看下：

def secondvalue(a,b):

c = a + b

return (a,b,c)

x,y,z = secondvalue(1,2)

print 'x:',x,'y:',y,'z:',z

可能上面的东西写的有点简单，但是有的细节处理也很重要。顺便分享下我如何学习python的经历把，大家没事拍拍砖。

python函数高级

一、函数的定义

函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需要调用函数名即可

特性：

减少重复代码

使程序变得可扩展

使程序变得易维护

二、函数的参数

2.1、形参和实参数

形参，调用时才会存在的值

实惨，实际存在的值

2.2、默认参数

定义：当不输入参数值会有一个默认的值，默认参数要放到最后

2.3、 关键参数

定义： 正常情况下，给函数传参数要安装顺序，不想按顺序可以用关键参数，只需要指定参数名即可，（指定了参数名的就叫关键参数），但是要求是关键参数必须放在位置参数（以位置顺序确定对应的参数）之后

2.4、非固定参数

定义： 如你的函数在传入参数时不确定需要传入多少个参数，就可以使用非固定参数

# 通过元组形式传递

# 通过列表形式传递

# 字典形式（通过k,value的方式传递）

# 通过变量的方式传递

三、函数的返回值

作用：

返回函数执行结果，如果没有设置，默认返回None

终止函数运行，函数遇到return终止函数

四、变量的作用域

全局变量和局部变量

在函数中定义的变量叫局部变量，在程序中一开始定义的变量叫全局变量

全局变量作用域整个程序，局部变量作用域是定义该变量的函数

当全局变量与局部变量同名是，在定义局部变量的函数内，局部变量起作用，其他地方全局变量起作用

同级的局部变量不能互相调用

想要函数里边的变量设置成全局变量，可用global进行设置

五、特殊函数

5.1、嵌套函数

定义： 嵌套函数顾名思义就是在函数里边再嵌套一层函数

提示 在嵌套函数里边调用变量是从里往外依次调用，意思就是如果需要调用的变量在当前层没有就会去外层去调用，依次内推

匿名函数

基于Lambda定义的函数格式为： lambda 参数:函数体

参数，支持任意参数。

匿名函数适用于简单的业务处理，可以快速并简单的创建函数。

# 与三元运算结合

5.3、高阶函数

定义：变量可以指向函数，函数的参数可以接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称之为高阶函数 只需要满足一下任意一个条件，即是高阶函数

接收一个或多个函数作为输入

return返回另一个函数

5.4、递归函数

定义:一个函数可以调用其他函数，如果一个函数调用自己本身，这个函数就称为递归函数

在默认情况下Python最多能递归1000次，（这样设计师是为了防止被内存被撑死）可以通过sys.setrecursionlimit(1500)进行修改

递归实现过程是先一层一层的进，然后在一层一层的出来

必须有一个明确的条件结束，要不然就是一个死循环了

每次进入更深层次，问题规模都应该有所减少

递归执行效率不高，递归层次过多会导致站溢出

# 计算4的阶乘 4x3x2x1

# 打印数字从1-100

5.5、闭包现象

定义:内层函数调用外层函数的变量，并且内存函数被返回到外边去了

闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

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

“在Python中，函数本身也是对象”

这一本质。那不妨慢慢来，从最基本的概念开始，讨论一下这个问题：

1. Python中一切皆对象

这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：

alist = [1, 2, 3]

时，你就创建了一个列表对象，并且用alist这个变量引用它：

当然你也可以自己定义一个类:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后创建一个类的对象：

house = House(200, 'Shanghai')

OK，你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：

2. 函数是第一类对象

和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：

def func(a, b):

return a+b

在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值。

所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当作数据处理，例如赋值、作为参数传递给函数，或者作为返回值return 等

因此，你完全可以用其他变量名引用这个函数对象：

add = func

这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者将函数对象作为参数，传递给另一个函数：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函数对象func作为参数传递给caller_func函数，传参过程类似于一个赋值操作f=func；

于是func函数对象，被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc

当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；

因此输出结果为3。

3. 函数对象 vs 函数调用

无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用。

用一个更加简单，但从外观上看，更容易产生混淆的例子来说明这个问题。例如定义了下面这个函数：

def func():

return "hello,world"

然后分别执行两次赋值：

ref1 = func #将函数对象赋值给ref1

ref2 = func() #调用函数，将函数的返回值("hello,world"字符串)赋值给ref2

很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值。通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

传参的效果与之类似。

4. 闭包LEGB法则

所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象

听上去的确有些复杂，还是用一个栗子来帮助理解一下。假设我们在foo.py模块中做了如下定义：

#foo.py

filename = "foo.py"

def call_func(f):

return f() #如前面介绍的，f引用一个函数对象，然后调用它

在另一个func.py模块中，写下了这样的代码：

#func.py

import foo #导入foo.py

filename = "func.py"

def show_filename():

return "filename: %s" % filename

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：实际发生调用的位置，是在foo.call_func函数中

当我们用python func.py命令执行func.py时输出结果为：

chiyu@chiyu-PC:~$ python func.py

filename:func.py

很显然show_filename()函数使用的filename变量的值，是在与它相同环境(func.py模块)中定义的那个。尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部。

而对于嵌套函数，这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：

#enclosed.py

import foo

def wrapper():

filename = "enclosed.py"

def show_filename():

return "filename: %s" % filename

print foo.call_func(show_filename) #输出：filename: enclosed.py

实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__globals__属性：

#show_filename inside wrapper

#show_filename.__globals__

{

'__builtins__': module '__builtin__' (built-in), #内建作用域环境

'__file__': 'enclosed.py',

'wrapper': function wrapper at 0x7f84768b6578, #直接外围环境

'__package__': None,

'__name__': '__main__',

'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局环境

'__doc__': None

}

当代码执行到show_filename中的return "filename: %s" % filename语句时，解析器按照下面的顺序查找filename变量：

Local - 本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量；

Enclosing - 直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)；

Global - 全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；

Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；

在任何一层先找到了符合要求的filename变量，则不再向更外层查找。如果直到Builtin层仍然没有找到符合要求的变量，则抛出NameError异常。这就是变量名解析的：LEGB法则。

总结：

闭包最重要的使用价值在于：封存函数执行的上下文环境；

闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常。

5. 装饰器语法糖(syntax sugar)

那么闭包和装饰器又有什么关系呢？

上文提到闭包的重要特性：封存上下文，这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能。而这就是装饰器。

还是举个例子，代码如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回。alist假设为1到100的整数列表：

alist = range(1, 101)

但是出于某种原因，我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果。于是我用一个wrapper函数对其进行包装：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函数对象

if __name__ == "__main__":

lazy_sum() #5050

这是一个典型的Lazy Evaluation的例子。我们知道，一般情况下，局部变量在函数返回时，就会被垃圾回收器回收，而不能再被使用。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中，通过__globals__)，从而延长了生命周期。

当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050。

当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：

def add(a, b):

return a+b

这是很简单的一个函数：计算a+b的和返回，但我们知道Python是 动态类型+强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器无情的抛出了一个TypeError异常。

动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；

强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算)；

因此，为了更加优雅的使用add函数，我们需要在执行+运算前，对a和b进行参数检查。这时候装饰器就显得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

return a + b

def checkParams(fn):

def wrapper(a, b):

if isinstance(a, (int, float)) and isinstance(b, (int, float)): #检查参数a和b是否都为整型或浮点型

return fn(a, b) #是则调用fn(a, b)返回计算结果

#否则通过logging记录错误信息，并友好退出

logging.warning("variable 'a' and 'b' cannot be added")

return

return wrapper #fn引用add，被封存在闭包的执行环境中返回

if __name__ == "__main__":

#将add函数对象传入，fn指向add

#等号左侧的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #经过类型检查，不会计算结果，而是记录日志并退出

注意checkParams函数：

首先看参数fn，当我们调用checkParams(add)的时候，它将成为函数对象add的一个本地(Local)引用；

在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用了fn(a, b)，根据LEGB法则，解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；

注意最后的return wrapper，这将创建一个闭包，fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收；

当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn，继续调用原始的add进行+运算。

因此调用add(3, 'hello')将不会返回计算结果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人觉得add = checkParams(add)这样的写法未免太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：

@checkParams

def add(a, b):

return a + b

这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行。

6. 回归问题

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代码：

@addspam装饰器，相当于执行了useful = addspam(useful)。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；

再回到addspam函数体：

return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；

而fn此时是useful的一个引用，当执行return fn(*args)时，实际相当于执行了return useful(*args)；

最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：

Python 函数 - 返回生成器

如果函数要返回一系列结果，我们常见的方法就是将结果放到一份列表中，然后返回给调用者。比如下面的函数，返回字符串中每个单词的首字母在真个字符串中的索引：

运行结果：

上述的结果完全符合我们的预期，但 get_word_index 函数不够简洁。下面我们尝试使用生成器来实现：

运行结果：

改写之后，不仅运行结果符合要求，由于不需要和 result 列表交互，函数也变得非常简洁。下面我们就来详细学习下生成器吧~

生成器是指使用 yield 表达式的函数，调用生成器函数时，它并不会真的运行，而是会返回迭代器。每次在这个迭代器上面调用内置的 next 函数时，迭代器就会把生成器推进到下一个 yield 表达式那里。生成器传给 yield 的值均会由迭代器返回给调用者。

此外，如果输入量非常大，使用列表作为返回值，那么程序就有可能耗尽内存并崩溃。相反，使用生成器之后，则可以应对任意长度的输入数据。

例如，下面这个生成器函数可以获取文件中单词的索引，而不管文件内容多大，该函数执行时消耗的内存，只由单行的文本长度决定：

其中 test_generator.txt 中的内容如下：

运行结果：

下面这句话特别重要： 生成器函数返回的迭代器，是由状态的，及调用者不应该反复使用它 。我们那 word_index_iter 来说明：

如果想重复调用，请将其封装成容器：

运行结果：

关于上述自定义容器的实现原理，我的另外一篇文章做了详细介绍，链接奉上：

网页名称：python函数全局返回,Python中函数的返回值
网站URL：https://www.cdcxhl.com/article44/hogohe.html

成都网站建设公司_创新互联，为您提供定制网站、网站策划、做网站、品牌网站设计、品牌网站制作、网页设计公司

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联