目录
1、函数定义
2、函数调用
3、函数参数
基本功能
小总结
扩展功能
缺省参数
不定长参数
引用传参
4、函数返回值
单个返回值
多个返回值
5、函数嵌套
1、函数定义
定义函数的格式如下：
def 函数名():
代码demo:
# 定义一个函数，能够完成打印信息的功能
def printInfo():
"这是一个例子"###这里可以添加函数文档说明
print '------------------------------------'
print ' 人生苦短，我用Python'
print '------------------------------------'
help(printInfo)###可以查看函数文档说明2、函数调用
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用
demo:
# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()3、函数参数
基本功能
demo:
#定义了一个带有参数的函数
def sum_2_nums(a, b):
#a = 10
#b = 20
result = a+b
print("%d+%d=%d"%(a,b,result))
num1 = int(input("请输入第1个数字:"))
num2 = int(input("请输入第2个数字:"))
#调用带有参数的函数
sum_2_nums(num1, num2)小总结
- 定义时小括号中的参数，用来接收参数用的，称为 “形参”。
- 调用时小括号中的参数，用来传递给函数用的，称为 “实参”。
扩展功能
缺省参数
demo:
def test(a,d,b=22,c=33):
print(a)
print(b)
print(c)
print(d)In [4]: test(10,20)
10
22
33
20In [6]: test(a=10,d=22,c=44)
10
22
44
22注意：
1、带有默认值的参数一定要位于参数列表的最后面。
2、实参向特定变量传参时，可以指定变量的值，但是实参中的变量名必须与形参对应的变量名保持一致，这个叫命明函数。
不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
基本语法如下：
def functionname([formal_args,] *args, **kwargs):
"函数_文档字符串"
function_suite
return [expression]加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。args和kwargs名称为约定俗成，可以是其他名字，但是*不能缺少。
>>> def fun(a, b, *args, **kwargs):
... """可变参数演示示例"""
... print "a =", a
... print "b =", b
... print "args =", args
... print "kwargs: "
... for key, value in kwargs.items():
... print key, "=", value
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
>>>fun(1, 2, 3)
a = 1
b = 2
args = (3,)#元组只有一个元素时必须末尾加逗号，如（20,）,否则不能被认定为元组
kwargs:
>>>
>>>拆包元组字典
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d) # 注意元组与字典的传参方式
a = 1
b = 2
args = (3, 4, 5)
kwargs:
p = 8
m = 6
n = 7
#函数实参中*和**表示拆包
#*是把元组的数字拆开放进*args里面
#**是把字典里面的key,vlue拆开放进**kwargs里面
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args = ((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>引用传参
- 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
- Python有没有类似C语言中的指针传参呢？
>>> def selfAdd(a):
... """自增"""
... a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。
想一想为什么
>>> def selfAdd(a):
... """自增"""
... a = a + a # 我们更改了函数体的这句话
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2] # 想一想为什么没有变呢？可看出执行结果一样，但是一个修改了a,一个没有修改
a=a+a 执行过程是 先计算=右边的值,赋予给a,相当于a重新指向新的引用。
4、函数返回值
所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果
想要在函数中把结果返回给调用者，需要在函数中使用return
单个返回值
demo:
def num(a, b):
c = a+b
return c
或者
def add2num(a, b):
return a+b保存函数的返回值
#定义函数
def num(a, b):
return a+b
#调用函数，顺便保存函数的返回值
result = num(10,28)
#因为result已经保存了num的返回值，所以接下来就可以使用了
print result多个返回值
def test(a,b):
he=a+b
ji=a*b
return he,ji
n1,n2=test(5,6)
print("和是%d"%n1)
print("积是%d"%n2返回多个值时用逗号隔开，多个值默认组成元祖进行返回，return [x,y]这种写法表示返回列表
5、函数嵌套
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
demo:
def test1():
pass
def test2():
print("我是第二个函数")
print("#"*2)
test3()
def test3():
print("我是第三个函数")
print("#"*2)
test2()结果：
我是第二个函数
##
我是第三个函数
##- 如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
