python的函数里面定义的变量在函数外面怎么用？

Posted 2023-04-26

def function1():
a=1
return a
def function2():
b=a+1
print(b)
这种情况会显示a是undefined。不考虑变量重名的情况，怎么才能让function2能用上function1里面的那个a？

局部变量是不可以再函数外访问的。
如果坚持访问，有两个办法：
1）把a修改成全局变量；
2）把function2定义在function1的内部。 参考技术A

答:函数一里面返回了变量a，那么你要使用它的话，只需要调用这个函数。 具体使用方法如下。

参考技术B 两种方法，一是把a做为参数传进去，二是在function2中调用function1。
法1：
def function2(a):
...
调用的时候 function2(function1())

法2：
def function2():
a = function1()
b = a + 1
print(b) 参考技术C 用def关键字，括号里是参数列表def add(a, b): return a+b#下面调用print add(1, 2) 参考技术D b=function1()+1

python之函数

什么是函数？它有什么作用？

函数是一个整体，你可以把你经常用的代码定义成一个函数，当你去调用这个函数的时候，就相当于用了整个函数里面的代码，里面的代码就是封装代码。注意，函数是一个整体，所以里面的变量是局部变量，在外面是用不了的，比如说我在函数里面设置a=5，在函数外面我们就用不了这个变量a

定义方法及调用方法如下：

def zhouyu(): #定义一个zhouyu的函数
    print("i am zhouyu") #zhouyu函数内的封装代码
zhouyu() #调用zhouyu这个函数

执行结果

这个是没有参数的函数，一般情况下，函数里面可能有一些数是有变化的，这个数是就是参数，这个数可以由上面代码的结果，或者用户输入的值传到这个函数里面，代替这个参数让函数变得更可用。比如：

def sum_2_nums(a,b):
    sum1 = a + b
    print("%d + %d = %d"%(a,b,sum1))
sum_2_nums(100,200)

从上面的代码可以看出，我们定义了一个函数sum_2_nums，这个函数有两个参数，一个是a，一个是b，（注意：参数一般是写在函数的括号里面的)这两个参数就可以在封闭代码上应该了，如上面代码的第二行就可以知道a,b这两个参数被应用了，下面我们看第四行代码，可以看到这个函数被调用了，与之前调用的不同的是这个函数被调用的时候，还加上了两个数字，一个是100，一个是200，其实可以是这样的，我们调用这个函数的时候，代码就会去找有没有这个函数，如果有，就会执行这个函数，很显然，是有这个函数的，而且这个函数需要我们提供两个参数，一个为a，一个为b，那么我们在调用这个函数的时候，就得提供两个参数，如上代码，我们提供的参数就是100和200函数就会把a=100,b=200放入到这个函数代码中去执行，就会出现以下结果：

像上面的情况来说，a,b就是形参，而100，200就是实参，形参其实就是一个形象的参数，就是虚拟的，而实参就是实实在在的参数，比如100，200就是实际的参数。

如果你把上面代码的100,200换成别的，那a和b的值也会随着变化。

下面说return这个的作用

return就是把一个方法的执行结果返回出来，比如下面我们想获取sum1的结果，可以通过return获取

def sum_function(a,b):
    sum1 = a + b
    return sum1
print(sum_function(100,200))

如果你没有加入return sum1的话，你去执行这个代码，sum_function(100,200)这个方法的结果是空的，也就是None，就什么都没有打印出来，因为这个函数没有返回任何数据。当然，也有另外一种方法，就是把这个sum1定义成一个全局变量，可以通过以下代码：

def new_sum(number):
    global sum2
    sum2 = number + 3
new_sum(50)
print(sum2)

执行结果是

global其实就是声明一个全局变量，这样我们就可以在外面应这个变量啦

有同学可能会说，那我要它的返回值干嘛，请看下面，如果new_sum想要拿到上一个方法的结果来当成我这个方法的变量，怎么办，因为函数里面的变量是局部变量，在外面是获取不到的，所以我们通过返回值来获取我们想要的东西：

def sum_function(a,b):
    sum1 = a + b
    return sum1
def new_sum(number):
    sum2 = number + 3
    print(sum2)
a = sum_function(100,200)
new_sum(a)

当上面的代码执行到第7行代码的时候，就会去调用sum_function这个函数，并传入了两个数值，100和200.这时候就会去执行sum_function这个函数，因为这个函数里面有return，所以就会去return出来的值赋给了a，这样a就有值了，然后再把a的值赋给了new_sum这个函数

注意返回值可以多个，但是return只能有一个，因为方法在执行的时候，看到return它就不执行下面的代码，直接退出方法啦，那如果我们想返回多个值怎么办呢，返回值可以为任何类型，比如元组，字典，列表。这样的话，我们就可以把多个值放在字典或者元组或者列表里面

代码如下：

def sum_function(a,b):
    sum1 = a + b
    d = {a,b,sum1}
    return d
a = sum_function(100,200)
print(a)
print(type(a))

这样我们返回的就是一个set的数据类型

如果你想返回一个列表，可以用以下方法代码如下：

def sum_function(a,b):
    sum1 = a + b
    return {a,b,sum1}
a = sum_function(100,200)
print(a)
print(type(a))

字典也是同理

如果你默认返回多个值的话，方法会把它封装成一个元组如下代码：

def sum_function(a,b):
    sum1 = a + b
    return a,b,sum1
print(sum_function(100,200))

下面说一下函数的嵌套

下面代码是把把print_line函数嵌套在print_5_line函数上

def print_line():
    print("-"*50)
def print_5_line():
    i = 1
    while i <= 5:
        print_line()
        i = i + 1
print_5_line()

上面的执行结果就可以说明函数是可以嵌套的。

下面说一下缺省参数，缺省参数就是参数有默认的值，如果你没有给这个参数值，这个参数就用它默认的值。如下代码中，zhouyu函数有两个形参a和b，也就是说我们去调用它的时候要传入两个参数，那为什么代码去调用zhouyu的时候只传入一个参数却没有报错呢，因为b=12是缺省参数，也就是说，如果只传入一个参数，那么b就会使用默认值也就是12，所以执行结果是sum = 13。

def zhouyu(a,b=12):
    sum1 = a + b
    print("sum = %d" %sum1)
zhouyu(1)

如果你调用zhouyu的时候传入两个参数，那b=12就不生效啦，如下：

def zhouyu(a,b=12):
    sum1 = a + b
    print("sum = %d" %sum1)
zhouyu(1,22)

执行结果是sum = 23

这里要注意一下，缺省参数只能放在最后，不能放在中间或者前面，如下面代码，一定会报错的：

def zhouyu(a=12,b):
    sum1 = a + b
    print("sum = %d" %sum1)
zhouyu(1,22)

如果你有三个参数呢最后两个是缺省参数，然后你只想让第三个参数不要用默认值，用你传入的值，怎么办呢，可以看看下面代码：

def zhouyu(a,b=12,c=22):
    sum1 = a + b + c
    print("sum = %d" %sum1)
zhouyu(1,c=33)

从上面代码可以看出b的默认值是12，c的默认值是22，那如果你想改变c的值而不改变b的值的话，你可以在传入参数的时候写上c=33，这样c就不会应用默认值22，而用33，像这种我们就称c=33是命名参数

这里我们是明确知道我们想要传入几个参数，那么，如果我们不知道自己想传入几个参数怎么办呢

def long_argue(a,b,*argue):
    print(a)
    print(b)
    print(argue)
long_argue(1,2,3,4)

上面代码中，*argue是用来接收多余的参数的，我们可以看看执行结果

上面的代码中，把多余的3,4传入到argue这个参数里面，变成了一个元组，那么它有什么用呢，比如说，我们想让很多个值相加，可是不知道大概有多少个值，就可以通过这个来实现。如下代码：

def long_argue(a,b,*argue):
    for i in argue:
        sum1 = sum1 + i
    sum1 = sum1 + a + b
long_argue(1,2,3,4)

由上面的代码就可以知道，把多余的3,4传入给了argue，这样argue就是一个元组啦，如果要让他们想加的话，就得把元组里面的值一个一个的取出来，并让它们相加，然后再让结果去加上a,b这样就可以实现多个值相加啦。

下面还有一种，就是在*argue后面加上**kwargue这个参数，那么它又是什么意思呢，可以看看下面代码的解释：

def long_argue(a,b,*argue,**kwargue):
    print(a)
    print(b)
    print(argue)
    print(kwargue)
long_argue(1,2,3,4)

执行结果如下:

上面可以知道，其实我们的*argue是用来接收一些数值或字符串的，并把这些数据变成元组，而**argue是用来接收命名参数（什么是命名参数可以看看上面红色字体部分，有相关的解释），并把这些命名参数变成字典。

如果我们有一个元组和一个字典，现在想把元组和字典都传递到函数中，应该怎么做呢，可以看看以下代码：

def long_argue(a,b,*argue,**kwargue):
    print(a)
    print(b)
    print(argue)
    print(kwargue)
A = (44,55,66)
B = {‘name‘:‘zhouyu‘,‘age‘:22}
long_argue(11,22,*A,**B)

如果你不在第8行代码中，A和B前面加上*号的话，传入参数的时候就会默认把A和B看成一个整体，也就是字符串，然后把这两个字符串都传入到*argue这个参数里面去，就变成了元组的值。而上面代码就是把*A拆成一个个数字，也就是44,55,66的数值，然后传递给*argue，把B拆成"name"="zhouyu"，"age"=22，然后传入了B，像这种过程，我们称这为拆包

本文出自 “爱周瑜” 博客，请务必保留此出处http://izhouyu.blog.51cto.com/10318932/1966099