Python函数的定义与其他语言都有不同。
定义函数的时候要遵循以下简单的规则：
1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4. 函数内容以冒号起始，并且缩进。
5. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
一：语法
def 函数名（参数列表）:
函数体
二：函数实例及调用
def first():
print("我的第一个函数")
调用：
first()
三：函数参数
1：传递参数
# 函数参数
def sumToNumber(a,b):
sum = a + b
print("%d + %d = %d" % (a,b,sum))
sumToNumber(10,20)
2：传递可变对象及不可变对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型： 变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
可变类型： 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型： 类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。
可变类型： 类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
（1）：传递可变对象
# 定义一个列表
lists = ["one","two","three"]
# 定义一个函数传递可变参数
def changeable(param):
param[1] = "twotwo"
print(lists)
changeable(lists)
print(lists)
输出：
['one', 'two', 'three']
['one', 'twotwo', 'three']
（2）：传递不可变对象
# 传递不可变参数
abc = 123456
# id函数输出变量在内存中的地址
def noChangeAble(param):
# 此时变量的地址还跟之前的相同
print(id(param))
param = 654321
# 这是一个新的地址
print(id(param))
print(id(abc))
noChangeAble(abc)
输出：
1532489914768
1532489914768
1532489915376
3 ：默认参数
我们可以给函数的参数付默认值，这里要注意，当多个参数的时候，有默认值的参数要放在最后，否则会报错，这个好像其他语言也是一样的。
# 默认值参数函数
def sumToNumberMo(a,b = 10):
sum = 2 * a + 2 * b
print("2 * %d + 2 * %d = %d" % (a,b,sum))
sumToNumberMo(10)
输出：
2 * 10 + 2 * 10 = 40
4 ：不定长参数
（1）：以元组的形式存储未命名的参数（字数可变的位置参数）
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
注意，元组只能存放未命名的参数。
# 以元组形式传递不定长参数
def nolongtuple(param,*tuples):
print(param)
print(tuples)
nolongtuple(10,20,30,40)
# 这样写会报错
# nolongtuple(10,a=20,b=30,c=40)
输出：
10
(20, 30, 40)
（2）：以字典的形式存储已命名的参数（字数可变的关键参数）
加了两个星号 ** 的参数会以字典的形式导入。存放已命名的变量参数。
# 以字典的形式存储
def nolongdict(param,**dict):
print(param)
print(dict)
nolongdict(10,a=20,b=30,c=40)
# 这样写会报错
# nolongdict(10,20,30,40)
输出：
10
{'a': 20, 'b': 30, 'c': 40}
5 ：以关键字形式传入
单独一个 * 放在参数中，那么从这个 * 之后，则必须使用关键字传入。
def fun(a,b,*,c,d):
print(a)
print(b)
print(c)
print(d)
# c,d必须用 关键字参数传入，否则报错
# fun(1,2,3,4)
fun(1,2,c=3,d=4)
fun(a=1,b=2,c=3,d=4)
6：总结：函数传参的七种方式
# 第一种传参方法
def fun1(a,b=10):
print(a)
print(b)
fun1(10)
# 第二种传参方法 个数可变的位置形参 以元组的形式传递
def fun2(*param):
print(param)
fun2(10,20,30,40)
# 第三种传参方法 个数可变的关键形参 以字典形式传递
def fun3(**param):
print(param)
fun3(a=1,b=2,c=3)
# 第四种传参方法 关键字形参
def fun4(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
fun4(1,2,3,4)
# 第五种
def fun5(a,*,b,c):
print(a)
print(b)
print(c)
fun5(1,b=2,c=3)
# 第六种
def fun6(a,*,b,c):
print(a)
print(b)
print(c)
fun6(1,b=2,c=3)
# 第七种 ,关键字传参
def fun7(a,*,b,c,**param):
print(a)
print(b)
print(c)
print(param)
fun7(1,b=2,c=3,d=1,e=2,f=3)
# 第八种
def fun8(a,b=10,*param):
print(a)
print(b)
print(param)
fun8(1,2,3,4,5)
# 第九种
def fun9(a,b,c,*param):
print(a)
print(b)
print(c)
print(param)
fun9(1,2,3,4,5)
# 第十种
def fun10(a,b=10,*param,**params):
print(a)
print(b)
print(param)
print(params)
fun10(1,2,3,4,5,c=11,d=22)
四：函数返回值
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，
def sumToNumberReturn(a,b = 10):
sum = 2 * a + 2 * b
return sum
a = 10
b = 20
# 将返回值 赋值给sum
sum = sumToNumberReturn(a,b)
print("2 * %d + 2 * %d = %d" % (a,b,sum))
输出：
2 * 10 + 2 * 20 = 60
五：函数嵌套
1：正常使用
# 函数嵌套函数
def one(name):
def one_in_one(name):
strs = "我是外层函数传递的参数:"+name
return strs
return one_in_one(name)
# 调用函数
res = one('python');
print(res)
输出：
我是外层函数传递的参数:python
2：return返回内层嵌套函数不加括号时，输出，内层嵌套函数的内存地址
# 函数嵌套函数
def one(name):
def one_in_one():
strs = "我是外层函数传递的参数:"+name
return strs
return one_in_one
# 调用函数
res = one('python');
print(res)
输出：
<function one..one_in_one at 0x000001263ECEE310>
3：一般写法
上边只是讲解函数嵌套的原理，但是一般都不会这么写。一般都是下边这样写的。
# 上边只是讲解函数嵌套的原理，但是一般都不会这么写。
def one(name):
# 在函数体中调用其他函数
return one_in_one(name)
def one_in_one(name):
strs = "我是外层函数传递的参数:"+name
return strs
# 调用函数
res = one('python');
print(res)
六：匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
1. lambda 只是一个表达式，函数体比 def 简单很多。
2. lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
3. lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
4. 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
1：语法
lambda [arg1 [,arg2,.....argn]]:expression
2：示例
# 匿名函数实例
aa = 10
bb = 20
sum = lambda aa , bb : aa * bb
result = sum(10,20)
print("%d * %d = %d" % (aa,bb,result))
输出：
10 * 20 = 200
七：函数的注释
Python的函数注释和其他语言的不同。
他的注释是写在函数体里边的。
def sumToNumberReturn(a,b = 10):
"""
计算两个数的平方和
:param a:第一个数 int
:param b:第二个数 int
:return:返回和 int
"""
sum = a * a + b * b
return sum
a = 10
b = 20
# 将返回值 赋值给sum
sum = sumToNumberReturn(a,b)
print("%d * %d + %d * %d = %d" % (a,a,b,b,sum))
我们在调用的时候查看注释其实也还挺方便的，光标放在调用的函数上，按下CTRL + Q
即可出现该函数的注释：
函数的内容稍稍有点多。
有好的建议，请在下方输入你的评论。
