python 函数，,预习：　　1函数的返

python 函数，,预习：　　1函数的返

预习：

　　1函数的返回值可以以元组的形式返回多个。

　　补充一个小知识：　

　　判断是否为元组的核心是逗号，即便是没有（）包裹起来，它也是元组。明白这一点，就会有恍然大悟的感觉。

　　例如：　

a=1,2print(a,type(a))

　　输出：

(1, 2) <class ‘tuple‘>

　　所以，下面就比较容易理解了：

def plus(x,y):    return x,x+y                 #看起来是两个返回值，本质上是一个元组，因为有个逗号，所有python会认为x，x+y 就是元组（x，x+y）。下面的结果就是理所当然print(plus(1,2))

　　等价于：

def plus(x,y):    a=x,x+y                      #在这里，a就是一个元组。    return aprint(plus(1,2))

　　输出：

(1, 3)

　　2 函数传参的时候注意可变类型与不可变类型。

　　传参的时候，一定要区分可变类型与不可变类型。两者会有本质的区别。　　

　　传的参数是不可变类型时：

name=‘hello‘def func(x):    return x.replace(‘l‘,‘g‘)
result=func(name)print(result)print(name)

　　输出：

heggohello

　　会发现，传入的变量本身并没有变化。

　　传的参数是可变类型时：

l=[1,2,3,4]def func(x):    x.append(5)    return x

result=func(l)print(result)

print(l)

　　输出：

[1, 2, 3, 4, 5][1, 2, 3, 4, 5]

　　去上面不可变类型不同的是，可变类型作为参数传入的时候，会被函数所影响，会发生变化。

　　原因就在于，传参实际上是有这样一个过程。参数传进来的时候，会有一个赋值的过程。

name=‘hello‘def func(x):    return x.replace(‘l‘,‘g‘)result=func(name)# name=‘hello‘# x=name# x=‘hello‘              #x，name在这个时候尽管都等于‘hello’，指向‘hello’在内存中的同一个地址。但是因为是不可变类型，所哟x.repalce()之后，x就会指向一个新的内存地址，表现出来x发生了变化。而name本身没有变化print(result)print(name)

l=[1,2,3,4]def func(x):    x.append(5)    return xresult=func(l)    # l=[1,2,3,4]      #x=l，实际上变量名x，变量名l，指向内存中同一个空间。列表是可变类型，对其的方法都会使其本身发生变化。    # x=l    # x=[1,2,3,4]print(result)print(l)

python 函数