python问题，关于递归的，递归运行函数的话，函数里有return，我_python吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：169,373贴子：
python问题，关于递归的，递归运行函数的话，函数里有return，我收藏
这是一个判断两个字符串有几个字符不同的function：def edit_distance(s1,s2,result=0):
s1=list(s1)
s2=list(s2)
if len(s1)&0:
if s1[0]!=s2[0]:
result=result+1
return edit_distance(s1,s2,result)
return result要是倒数第二步不return会怎么样？还有我递归了这个函数，那每运行一次这个函数就会return一次result，那最后return的到底是什么？
python_总监级名师全程面授,项目实战案例式教学,企业需求无缝对接,助你无忧就业!python,0基础23周快速实现高薪就业,0元试听两周.名额有限,欲报从速.点击抢座
大神快快来！！
倒数第二行去掉return
大神快快来啊，明天考试了！
大神来啊！！！
大神快来啊！！这是以前向吧友求助的一个function，没有return照样运行：def search(L, s):
def flatten_list(X, result = None):
if result == None:
result = []
for i in X:
if isinstance(i,list):
flatten_list(i,result)（无return）
result.append(i)
return result
if s in flatten_list(L):
return True
return False
严格来说，你这个程序只支持字符串长度相等的两个串比较若串长度不同，那么你这个程序就会出错！我用的环境是py2.7我的代码是：执行结果：String1: akslajdfString2: akklcnot same count:5说明：递归函数总要有个结束条件，不然，就会无限执行下去或出错。在这里，最后的return result就好比是这个递归函数的满足结束条件（字符串没有了）时，返回的结果。而第一个return edit_distance(s1, s2, result)则是因为还没有结束，所以需要继续递归。自己百度搜下递归函数的图片，你就会很容易理解这东西了！关于你的第一个问题，要是倒数第二个return不return，那么会发生什么！你当然得不到正确的结果啊！假如第一个字符相同，那么得到的将会是0，要是不同，那么得到的将会是1，因为再次调用递归函数的时候，并没有修改result的值。关于你的第二个问题，最后那个return result只会在满足结束条件的时候，才会return.因为一个函数遇到return后，就不会再执行后面的代码！当然有特例！所以这个return result就是返回你这个两个串中有多少个不同的字符！
def edit_distance(s1, s2, result = 0):
if len(s1) == 1:
if s1[0] != s2[0]:
result += 1
result = edit_distance(s1[1:], s2[1:])
if s1[0] != s2[0]:
result += 1
return result这样的吧。你的步骤多余了，string可以直接用index定位，用slice切割，不需要转list和del
建议看看rmax。注意递归的返回值要在新的运算前。
python零基础授课,紧跟项目实训,远离枯燥理论课程,让学习更有趣只需 90天 圆你月薪过万的梦
return就是函数运算完毕后给出的结果啊。
递归本身就很难读懂了，况且又是在return语句中带有递归？这样使得程序结构不很清晰，不认为这是好的程序风格。关于函数调用的参数，一般情况下，列表和字典等可变数据类型，如果在函数体内整体赋值的话，那么将会与外部变量无关了；如果只是修改内部的数据， 这样的操作实际上等同于外部变量的操作。其他不可变数据类型，形参与实参只是值传递的关系，内部修改返回时一切作废了，不会影响到外部变量。递归调用和一般函数调用一样，不过递归一次调用引起多次的调用，每一次都相当于一般函数调用，都有一个外层和内层作用域的问题，作用域可以认为是环境，外部环境和内部环境，出了作用域范围就是不同的环境了，函数调用都是使用堆栈的进栈和出栈来实现的，进栈是把有用的数据先封存起来，为出栈时再使用；出栈是把原先封存的数据恢复，也就是当前环境了。函数返回值就是把内部处理的结果数据，在返回时带到上一层来，返回值在当前环境中可以作为一个变量使用，同样当前环境中处理的结果数据，又被return语句带到再上一层，以此类推。各种变量名和函数名都是有作用域的。在递归中有些处理的结果数据无法带回到外部去，这时可以考虑在外部中设立一个列表或字典等可变数据类型的变量，作为函数参数或者不作为函数参数，在内层直接使用，注意不能整体被赋值，只能修改其内部数据。在内内层函数处理完数据之后，把结果数据存入可变数据类型的变量中，这样返回时就可以使用内部处理的结果数据了。
把递归中在内层处理的结果数据带到外部去，可以使用列表或字典等可变数据类型的变量，下面是程序代码的示例。代码截图如下：
可变数据类型变量和不可变数据类型变量的区别：在python中，数据类型相当于类，变量相当于对象，对象可以分为不可变对象和可变对象，变量也就分为可变数据类型变量和不可变数据类型变量。整数、字符串和元组都属于不可变数据类型的变量，当指向不可变数据类型的变量的值改变时，系统重新创建一个新的不可变对象赋值给变量。列表、字典和集合都属于可变数据类型的变量，当两个变量指向同一个可变对象时，改变可变对象内部的值，这两个变量同样的进行改变，因为本来就是一个，只是两个变量引用名而已。函数外部定义的可变数据类型的外部变量，在传递给函数形参时，函数形参是变量引用名，和外部可变数据类型变量指向同一个内存区域。函数内部不可变数据类型的局部变量，以及函数参数，在入栈时封存的只是变量引用名，不会再另外开辟内存区域给这些变量；内部定义的可变数据类型的局部变量，在入栈时封存的也是变量引用名，而实际内存区域另外专门的存放，作用域范围也是局部的。
登录百度帐号推荐应用python为什么返回值是None-CSDN论坛_百度知道
python为什么返回值是None-CSDN论坛
我有更好的答案
那么缺省的返回值就是None，也就是除了factorial(1)返回1之外，O(∩_∩)O谢谢 return factorial(n-1) 我是知道的啦，原以为执行else: factorial(n-1) 后便又会调用factorial(n-1）: factorial(n-1) 结果当我 &&& print(factorial(7)) None 之前我还以为返回值应该是1的！很正常呀，你的else分支没有return语句，然后继续递归下去，直到返回值为1停止，可返回值最后竟然是none，我很纳闷啊！; def factorial(n)，谁能解释下原本这是一个递归写得计算阶乘的程序，现在被我改了一下如下 &gt: if n == 1: return 1 &&gt，可没想到竟然是none
采纳率：96%
来自团队：
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。3.关于python函数，以及作用域，递归等知识点
时间： 21:35:39
&&&& 阅读：104
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&一.使用函数编程的好处。大大的提高了代码的重用行，重复的逻辑或者操作，可以定义到一个函数里，多次调用。下面是关于提高代码重用性的例子。现在老板让你写一个监控程序，监控服务器的系统状况，当cpu＼memory＼disk等指标的使用量超过阀值时即发邮件报警，你掏空了所有的知识量，写出了以下代码。& while True：& & & if cpu利用率 & 90%:& & & & & #发送邮件提醒& & & & & 连接邮箱服务器& & & & & 发送邮件& & & & & 关闭连接& & & && & & if 硬盘使用空间 & 90%:& & & & & #发送邮件提醒& & & & &连接邮箱服务器& & & & &发送邮件& & & & &关闭连接& & &&& & &if 内存占用 & 80%:& & & & &#发送邮件提醒& & & & &连接邮箱服务器& & & & &发送邮件& & & & &关闭连接上面这段代码可以看出，每一段代码的重复的地方特别多。如果日后还需要增加群发功能，从上到下，所有的代码都需要去修改。def 发送邮件(内容)& & #发送邮件提醒& & 连接邮箱服务器& & 发送邮件& & 关闭连接& & &while True：& & && & if cpu利用率 & 90%:& & & & 发送邮件(‘CPU报警‘)& & && & if 硬盘使用空间 & 90%:& & & & 发送邮件(‘硬盘报警‘)& & && & if 内存占用 & 80%:& & & & 发送邮件(‘内存报警‘)这段代码就是使用了函数式编程写出的代码，从这段代码中可以有个很明显的特点，把重复的代码单独拿出来，定义了一个函数（也就是放到一个公共的空间，也相当于给这段代码起了个名字），如果以后需要多次使用这个代码，只要调用这个名字就可以了。二.关于python中函数的返回值。当定义了一个函数，如果不使用return给任何返回值，默认就会返回None。下面就是例子。def func01():& & print "this is func"def func02():& & print "this is func"& & return 2test1 = func01()&&&this is functest2 = func02()&&&this is funcprint test1&&&Noneprint test2&&&2在上面定义了两个函数，分别是func01和func02，这两个函数的功能都是打印输出同一句话“this is func”，func01没有定义任何返回值，返回给test1变量的是个空值（None），func02使用return定义了一个返回值，返回的是数字2，返回给test2的就是数字2。那么一个函数，在被调用一次的时候，是否可以同时！注意！是同时！返回多个值呢？（不同if分支判断中的return不能算同时！）我们来试一下。def func01():& & print "this is func"＃定义的第一个函数func01，没有定义任何返回值。def func02():& & print "this is func"& & return 2＃定义的第二个函数func02，定义了一个返回值，返回一个整数2。def func03():& & print "this is func"& & return 1& & return 2＃定义的第三个函数func03，使用两次return，定义了两个返回值，分别是1和2。def func04():& & print "this is func"& & return 1,2,3,4＃第四个函数func4，使用一个return返回四个整数，这四个整数使用逗号隔开。test1 = func01()test2 = func02()test3 = func03()test4 = func04()＃将这四个函数的返回值分别赋给变量，然后看看每个函数的返回值都是什么。print test1&&&None#第一个函数的返回值为空，因为之前说了，函数如果不定义任何返回值，默认就返回None空值。print test2&&&2＃第二个函数，返回了一个整数2，因为使用return指定了返回值，所以就返回了一个整数2，如果返回值是字典，那么return返回的也是个字典。（当返回值只有一个的时候，retrun什么数据类型，就会返回什么数据类型！！这点很重要！）print test3&&&1＃第三个函数，在定义的时候写了两个return，但是只返回了一个值，这个值是整数1。＃明明使用两个return，但是只返回了一个返回值？！～是的，没错，下面要强调一个关于python函数很重要的知识点！＃当python函数在之行的时候，一旦遇到return，函数直接退出！return后面的所有代码都不会被执行！！！！！这点很重要！！！不信我们可以试试～现在我将func03函数做了一下修改。def func03():& & print "this is func"& & return 1& & print "hamasaki ayumi"& & return 2＃我在两个retrun中间插了一行代码，打印字符串“hamasaki ayumi”，这个字符串放到了第一个return后面，看看会不会被执行test3 = func03()print test3&&&1＃见证“奇迹”的时刻到了。＃func03函数依旧只返回了第一个rerun中定义的整数1，第一retrun执行结束后，函数直接退出了，retrun 1后面的所有代码都没有被执行！这也就验证了刚才所说的，当函数执行时，遇到retrun，返回相应的返回值之后，函数直接退出，retrun后面的所有代码都不会被执行。print test4&&&(1, 2, 3, 4)＃第四个函数，也只返回了一个元组，之前定义的返回值，1，2，3，4四个整数，被装进了同一个元组中，这也说明了一个问题，就是，当retrun要返回多个值的时候，会把这些同时返回的多个值，装进同一个元组中。那么可能有人会问，如果同时返回多种数据类型呢？在同一个返回值中，有字典，有列表，有元组会是什么效果？可以肯定的告诉你，返回的这些字典，列表，元组，字符串，统统会被打包进一个元组～做个测试吧。现在将func04函数做了一下修改。修改了一下func04的返回值，现在这个返回值里面充满了各种数据类型，有字典，有数字，有字符串，有元组，有列表，看看最后会返回值是什么。def func04():& & print "this is func"& & return 1,2,3,4,[‘a‘,‘b‘,‘c‘,‘d‘],‘hello‘,{‘k1‘:‘v1‘,‘k2‘:‘v2‘},(9,8,7,6,5)test4 = func04()print test4&&&(1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘, ‘d‘], ‘hello‘, {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}, (9, 8, 7, 6, 5))#可以看到这些不同数据类型的所有对象都被装进了同一个元组～接下来对函数的返回值做个小结：在python中，如果没有给函数定义任何返回值，默认返回值为None。python中的函数不可以同时retrun多次，当函数执行的时候，读到第一个retrun时，函数就会退出执行，retrun后面的代码都将不会被执行。在python的函数中，只return一个对象的话，return的对象是什么类型的数据，返回的就是什么类型的数据。在python函数中，如果要return多个对象，这些对象同时都会被装进一个元组并返回。关于python函数的返回值在这里就说完了，接下来说说函数传参。三.关于函数的参数。说的函数的参数，就要先说说形参和实参的概念了，我理解的型参，就是函数用来接受实际参数的一个“位置”，这个位置只有在函数在调用的时候，才会被分配到内存中去，一旦函数调用结束，型参所在的内存单元会被释放，换句话说，这种形参只能在函数内部使用。def func1(a,b):& & c=a+b&&&&return c＃上面定义了一个函数，函数名为func1，里面的a和b就是型参。下面在说说实参，实参可以是表达式，常量，变量，函数，以及各种对象....总之要有实际的值，因为必须要有确定的值，才可以把它传递给型参。(实参，就是调用函数时，给函数传的值或参数。)print func1(1,2) ＃调用上面定义的func1函数&&&3在调用func1函数时，传给函数内部型参的1，2就是所谓的实参。下面来说说函数的传参方式。按形参的顺序给函数传递参数。def func1(name,city):& & print "name:%s city:%s" %(name,city)＃定义了一个函数，里面定义了两个形参，分别是name和city。func1 ("hamasaki ayumi","Fukuoka")＃刚刚定义的func1函数定义了两个形参，先定义的name，再定义的city，现在按照刚刚定义的顺序给函数传参。&&&name:hamasaki ayumi city:Fukuoka参数被按顺序传递到了函数中。如果传参时不按顺序呢？func1 ("Fukuoka","hamasaki ayumi")&&&name:Fukuoka city:hamasaki ayumi#所传的参数顺序反过来了。& 2.手动指定形参和实参的对应关系，一个函数中定义了很多型参，这些形参的顺序很难记住，如果不想按照型参的顺序去传递参数，在调用函数的时候，可以手动指定哪个形参去接收哪个实参。（这个也叫叫关键字参数！）def func1(name,city):& & print "name:%s city:%s" %(name,city)func1 (city = "Fukuoka",name = "hamasaki ayumi")&&&name:hamasaki ayumi city:Fukuoka从这可以看出，手动指定了形参和实参的对应关系，即使不按照顺序去传参数，参数传递的位置也不会出错。（前提是形参和实参的顺序一定要对应）3.默认参数，默认参数是函数在定义过程中，在形参中指定的，当调用函数的时候，没有给该函数的形参传递指定的实参，那么这个形参直接等于在创建函数时定义的默认参数。（说简单一点，就是在定义函数的时候，给了某个参数一个默认参数，如果没传参数，这个参数直接等于它的默认值）下面是关于默认参数的例子：def func2(name,sex="male"): & ＃创建函数，定义了一个默认值sex默认等于male& & print "name:%s sex:%s" %(name,sex)func2("name ＝ ayumi") &＃在调用函数的时候，只传了一个参数，在调用函数的时候没有给sex传参，sex默认就等于了male。&&&name:ayumi sex:malefunc2(name = "ayumi",sex = "female")再次调用下func2函数，给sex也传一个参数，看看是否可以覆盖默认值。&&&name:ayumi sex:female三.函数参数收集。一次性传递多个参数，将多个参数传递到一个元组中。如果想要让一个形参可以收集多个值，但值这些值会被装进元组，当作一个参数传递给函数，想实现这种效果，只要在定义函数时，给指定的形参前面加一个＊星号就可以做到。def func1(a,*args): ＃定义了两个形参，分别时a和args，其中在args前面加了一个＊，来看看传参的效果是怎么样的。& & print a& & print argsfunc1(1,2,3,4,5,6)&&&1&&&&&&&&(2, 3, 4, 5, 6)参数1给了a，2，3，4，5，6打包成了元组，传给了args。在参数前面加上*就是可变参数。在函数内部，参数args接收得到的是一个tuple元组，调用该函数时，可以传入任意个参数，包括0个参数（如果不给可变的形参传递任何参数，它默认就会等于一个空元组）。我们可以来测试下。def func1(a,*args):& & print a& & print argsfunc1(1)＃调用func1函数的时候，没有给args传递任何实参数，看看会返回什么。&& 1&&&&&&()args返回了一个空的元组。当*args遇到关键字参数的时候会出现什么样的效果呢？func1(1,k1=‘aaa‘)Traceback (most recent call last):& File "/Users/macbook/PycharmProjects/untitled1/2day.py", line 5, in &module&& & func1(1,k1=‘aaa‘)TypeError: func1() got an unexpected keyword argument ‘k1‘＃结果抛出了个异常～如果想传递多个关键字参数给函数，在定义形参的时候，需要在前面加**两个星号，下面就来说说这种可以传递多个关键字参数的写法。&&&&2.一次性传递多组参数，每组参数被传递到一个字典中，作为字典的键值对。让一个形参可以收集多个关键字参数，每个关键字参数都将作为键值对被装进同一个字典，当作一个参数传递给函数，想实现这种效果，只要在定义函数时，给指定的形参前面加两个＊＊星号，就可以实现这种功能。def func1(a,**kwargs):& & print a& & print kwargsfunc1(1,k1=‘aaa‘,k2=‘ccc‘,k3=‘ddd‘)&&&1&&&&{‘k3‘: ‘ddd‘, ‘k2‘: ‘ccc‘, ‘k1‘: ‘aaa‘}func1(1)&&&1&&&&&&&&{}和一个＊星号一样，＊＊星号依旧是可变的形参，两个星号的形参如果不传递任何参数，默认会返回一个空字典。3.当＊单个星号和＊＊两个星号，还有普通的形参放在一起用，会出现什么效果？def test_func(a,b,c,*args,**kwargs):& & print "a = %s" %(a)& & print "b = %s" %(b)& & print "c = %s" %(c)& & print "args= ",args& & print "kwargs =",kwargstest_func(1,2,3,4,5,6,k1="v1",k2="v2")输出结果如下：a = 1b = 2c = 3args= &(4, 5, 6)kwargs = {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}四，分解序列传参。在给python函数传递参数时，如果需要把一个列表，或者元组中的每一个元素拆开，依旧可以适用＊单个星号来实现。不过需要注意的是！！！这次的星号不是放在定义函数的形参前面的！！而是放在实参前面的。举个例子就可以看明白了。def func1(*args): &＃定义了一个函数，给了这个函数一个可变的形参。& & print args接下来调用func1函数，给这个函数的可变的形参传一个列表。func1([1,2,3,4,5,6])&&&([1, 2, 3, 4, 5, 6],)最后，返回了一个元组，整个列表变成了元组中的一个元素。接下来，我们在给函数传参的时候，在序列前面加一个＊星号，看看会出现什么效果。func1(*[1,2,3,4,5,6])&&&(1, 2, 3, 4, 5, 6)&#从显示的结果可以看到，列表中的每一个元素，都单独作为一个元素，放在了元组里面。而不是将一个列表当成一个元素放进元组里。补充！＊星号基本的序列都可以拆开，比如说字符串～func1(*"hello")&&&(‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘)func1("hello")&&&(‘hello‘,)这是加星号和不加星号的对比。字符串中每一个字母都被拆开，放进了元组。五.如何把字典直接传进函数。现在有一个字典类型的值，需要把这个字典完整的传到函数中，该怎么做？首先，我们先来试试，在调用函数的时候，只使用一个＊信号，看看能不能把字典传到列表中。def func1(*args):& & print args首先，试试第一种方法，在函数中定义了一个可变的形参，接受所有参数，将所有接收到的参数，都放到同一个元组中。func1({‘k1‘:‘v1‘,‘k2‘:‘v2‘})&&&({‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘},)在调用func1函数的时候，传参，不做任何分解，直接把字典传给那个可变的形参*args，最后的结果就是，这个字典的确是被传到了函数内部，但是这个字典被放到了一个元组中。然后我们在试试第二个方法。还是上面定义的func1函数，在把字典传进去之前，在前面加个＊号，看看会是什么效果。func1(*{‘k1‘:‘v1‘,‘k2‘:‘v2‘})&&&(‘k2‘, ‘k1‘)只把两个key放到了元组中，没有达到想要的结果。第三种方法，在传参的时候使用两个＊＊星号。def func2(**kwargs):& & print kwargsfunc2(**{‘k3‘: ‘v3‘, ‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘})&&&&{‘k3‘: ‘v3‘, ‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}使用两个**星号，成功的把字典原原本本的传到了函数中。补充！如果只是按照函数赋值的角度来说的话，func2(**{‘k3‘: ‘v3‘, ‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}) 和func2(k1 = ‘v1‘,k2 = ‘v2‘,k3 = ‘v3‘)，效果是一模一样的。五.关于函数与作用域。说到作用域，就要先来说说变量，什么是变量，变量就是一个值的名字，现在定义一个变量为x ＝ 1，也就是将1这个整数赋值给了x，然后通过引用x这个变量名，可以获得这个整数1，这种形式和字典特别像，通过一个key，去取对应的value，这个变量名和变量值的对应所用的是个看不见的字典，如果想看这个‘字典’，可以使用var()函数来进行查看。注意啦！！！与作用域息息相关的三个函数var()函数和locals()函数还有global() 这三个函数会放在面向对象的时候一起做补充～～在这里只是简单说一下，先挖个坑～嘿嘿。这种我们看不到的“字典”就是作用域，除了全局的作用域外，每个函数调用都会创建一个新的作用域。下面，来看一个现象。#!/usr/bin/python2.7# -*- coding:utf-8 -*-def foo(): & &＃首先，定义了一个函数，这个函数里面定义了一个x＝130，然后在函数的外面定义了一个变量，x ＝ 1，执行foo()函数，那么最后x等于多少？& & x = 130x = 1foo()print x&&&1最后，x还是等于1。原本以为执行了foo函数后，会重新定义x变量，但是函数执行结束后，x的值并没有发生改变，这就是因为在调用函数foo的时候，新的命名空间被创建了，x ＝ 130只在这个变量的内部作用域（局部的命名空间）起作用，不会影响到函数外部（全局）作用域中的x变量，因此，函数内部的变量都被称为局部变量。但是如果要在函数的内部访问全局变量该怎么做？如果在函数内部，只是单纯的读取全局变量，是完全没有问题的，只要不重新赋值就没有任何问题。（补充～使用global声明或者全局变量是列表，字典之类的可辨类型除外）不信可以来测试一下。def f1():& & print xx = 1f1()&&& 1从上面的测试可以看出，如果在函数内部只是访问全局变量的话，是没有任何问题的。如果函数中有global关键字，那么被global声明的变量，直接变成全局变量。注意啦！！！！！读取全局变量一般来说，不会出什么问题，但是啊，如果局部变量名或者参数名，和想要访问的全局变量中的变量名有冲突，那么，在这个函数中，就无法直接访问这个全局变量了，局部变量会把全局变量给临时性的“覆盖”。说的通俗点，就是当局部变量和全局变量名相同，在函数内部访问的话，以局部变量为准！！说到了变量和作用域，又不得不提到三个函数，分别是vars(),globals(),locals()，这三个函数在本篇文章中，只做个简单的解释，等博主写到面向对象编程时，会详细说下这三个函数的具体功能。locals() 首先上官方解释：Update and return a dictionary containing the current scope‘s local variables. 博主英语比较渣，查了下不会的单词，大概可以翻译为，更新或者返回一个字典，这个字典中包含了当前范围的本地变量。locals这个函数，根据博主亲测，当放到哪个作用域，就会以字典的形式返回当前作用域中的所有名称空间的所有值（所有的变量名和变量值）。x = 1def f1():& & a = "abc"& & print "locals = ",locals()f1()locals = &{‘a‘: ‘abc‘}print locals(){‘f1‘: &function f1 at 0x102efa668&, ‘__builtins__‘: &module ‘__builtin__‘ (built-in)&, ‘__file__‘: ‘/Users/macbook/PycharmProjects/untitled1/test.py‘, ‘__package__‘: None, ‘x‘: 1, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None}＃分别在全局作用域和f1函数中都调用了一次locals()函数，结果已经很明显了，在f1函数内部调用locals函数后，返回了f1函数作用域中所有的变量名以及对应的变量值，接着，又在函数外，也就是全局作用域调用了一下locals()函数，结果返回了全局作用域中的所有变量名和变量值（名称空间）的使用情况。&&&&2.globals()&Return the dictionary containing the current scope‘s global variables. 返回一个字典，包涵当前范围全局变量。globals函数，用于返回全局变量中所有的变量名以及变量值（ 名称空间）的使用情况。globals函数不管放在任何作用域，显示的都是全局作用域中的变量名和变量值。&&&&3.vars() &这个函数原本想放在面向对象的时候在详细说说的，因为涉及到了“对象”相关的知识点。先来看看官方怎么解释吧。def vars(p_object=None): # re restored from __doc__& & """& & vars([object]) -& dictionary& &&& & Without arguments, equivalent to locals().&&&&＃没有参数时，相当于locals()函数。＃这句话就是说，当vars()函数在没传任何参数之前，和locals()函数是一模一样的。& & With an argument, equivalent to object.__dict__.＃有一个参数传进来的时候,作用就相当于一个对象的__dict__方法。& & """& & return {}官方的意思就是说vars()这个函数如果不加参数，功能和local函数一样，如果加了参数，就可以以字典的方式，返回这个对象内部的变量，在python这门语言中，一切皆对象，变量名，函数名，都是对象，如果想看这些对象内部都包涵什么变量的话，vars（对象名）就可以看到了，给vars函数传一个对象的名称。def f1():& & a = 1 #在这个例子中，我特别在函数中定义了一个变量a ＝ 1，是为了防止f1对象中变量和f1函数的变量混淆& & passvars(f1)&&&{‘x‘: 1}vars(对象名) ＝ 对象.__dict__ 这两个作用是一模一样的。下面补充一个关于globals()函数使用的小技巧！当函数内部变量和全局环境下的变量名一模一样，这时两个一模一样的变量名，就会以函数内部的变量值为准，这样，函数就无法访问这个函数外部同名的全局变量了，如果想访问函数外部的全局变量，就可以借助globals() 函数去拿全局变量。下面是例子：在没有使用globals()函数之前，是无法访问同名全局变量的。name = "suhaozhi"def test1():& & name = "hamasaki"& & print nametest1()&&&hamasaki函数test1想要访问外部的name ＝ “suhaozhi”这个变量，但是只能访问到函数内部的name ＝ “hamasaki”。接下来，我们就使用globals()函数去取全局name变量。name = "suhaozhi"def test1():& & name = "hamasaki"& & print globals()[‘name‘]test1()&&&suhaozhi全局变量中name的值被成功取到了。六.在python中函数不只可以向后引用，也可以向前引用。下面是两个例子：最常见的向后引用。def func1():&&&&print ‘in the func1‘def func2():& & print "in the func2"& & func1()func2()&&& in the func2in the func1&&&&2.向前引用。def func2():& & print "in the func2"& & func1()def func1():& & print ‘in the func1‘func2()&&& in the func2in the func1七.函数嵌套。首先，来看一个函数嵌套的例子，然后分析它的执行过程。name = "suhaozhi"def f1():& & name = "f1"& & def f2():& & & & name = "f2"& & & & print name& & f2()& & print namef1()print name开始执行f1函数。第一步：在f1内部加载局部变量name ＝ “f1”.第二步：加载f2函数。第三步：执行f2函数，并先打印一个字符串“f2”。第四步：f1内部的f2函数执行完毕，退出到f1函数，打印f1中的name变量，打印“f1”字符串。第五步：f1函数执行完毕，退出函数，开始打印全局变量name = "suhaozhi"。八. 函数递归。函数自己调用自己，就是所谓的递归。def func1():& & print "in the func1"& & func1()func1()＃上面这个例子，就是基于函数递归的特性完成的一个“死循环”。func1函数做了两个动作，输出一个"in the func1"然后再次执行func1函数，然后再输出"in the func1"...会一直循环下去。所以说，在做函数递归的时候，必须有个明确的结束条件（使用return去终止）。说简单点，就是在函数中使用if条件判断，然后在指定的条件下return。下面是一个使用函数递归实现的数字递减。def func1(n):& & print n& & if n - 1 == 0:& & & & return n& & return func1(n - 1)func1(10)#调用func1函数,给n传了一个整数10.#现在n = 10 打印一次变量n会显示一次10#开始if判断,10 - 1不等于0,条件不成立,则执行下面的return func1(n - 1),也就是在函数内部继续调用func1函数,并且把n - 1#这时,n = 9 再次进入if判断 9 - 1也不等于0,条件不成立,然后继续调用func1函数 n继续 - 1 ,此时n = 8 .........以此类推.#一直到n == 0 执行retrun n第二点，每次更深入一层递归，问题规模要比上次递归有所减少。关于这个问题，前两天看到了一个很不错的例子。# -*- coding:utf-8 -*-import timeperscon_list = [‘a‘,‘b‘,‘c‘,‘d‘,‘ayumi‘]def find_person(person_list):& & print ‘*‘ * 60& & person = person_list.pop(0)& & if person_list == False:& & & & print "We don‘t even know her~"& & & & return None& & if person == "ayumi":& & & & return "Everyone is a bitch jolin,right？she is a bitch jolin"& & & & #print "%s:Everyone is a bitch jolin,right？she is a bitch join" %(person)& & print "请问%s,你认识bitch jolin吗?" %(person)& & print "i don‘t know her~ But I can help you ask ",person_list& & time.sleep(3)& & re = find_person(person_list)& & print "%s问的结果是,%s" %(person,re)& & return reprint find_person(perscon_list)上面这个例子的输出结果是：************************************************************请问a,你认识bitch jolin吗?i don‘t know her~ But I can help you ask &[‘b‘, ‘c‘, ‘d‘, ‘ayumi‘]************************************************************请问b,你认识bitch jolin吗?i don‘t know her~ But I can help you ask &[‘c‘, ‘d‘, ‘ayumi‘]************************************************************请问c,你认识bitch jolin吗?i don‘t know her~ But I can help you ask &[‘d‘, ‘ayumi‘]************************************************************请问d,你认识bitch jolin吗?i don‘t know her~ But I can help you ask &[‘ayumi‘]************************************************************d问的结果是,Everyone is a bitch jolin,right？she is a bitch jolinc问的结果是,Everyone is a bitch jolin,right？she is a bitch jolinb问的结果是,Everyone is a bitch jolin,right？she is a bitch jolina问的结果是,Everyone is a bitch jolin,right？she is a bitch jolinEveryone is a bitch jolin,right？she is a bitch jolin（第二个例子是真正意义上的递归，实现了返回值回传）递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）堆栈扫盲http://www.cnblogs.com/lln7777/archive//2396164.html&尾递归优化：http://egon09.blog.51cto.com/2475关于函数递归的最后补充：函数自己调用自己，就是所谓的递归，当函数调用自身时，当前函数，和在函数内部调用的“自己”实机上已经是两个不同的函数了，（也就是同一个函数使用了两个不同的命名空间）。本文出自 “” 博客，请务必保留此出处标签：&&&&&&&&&&&&&&&原文：http://suhaozhi.blog.51cto.com/7615
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！}