函数是组织好的，用来实现某些功能的代码块，它可以重复使用。
函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数，比如print()。但我们也可以自己创建函数，这被叫做用户自定义函数。
定义函数
用户自定义函数的用法如下：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号 : 起始，并且缩进。
- return [表达式] 结束函数，返回一个值给调用方，不带表达式的 return 相当于返回 None。
函数的一般格式如下：
def 函数名(参数列表):
函数体
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
以下是简单的实例：
#不带参数的函数
def hello():
print('hello python')
a=3
b=4
hello()
#带参数的函数
def hello(a,b):
print(a*b)
a=3
b=4
hello(a,b)
#比较两个数的大小
def max(a,b):
if a>b:
return a
else:
return b
print(max(3,4))
函数调用
定义函数时，我们给了函数的名称，指定了函数的参数和代码块结构。那么调用函数时，按照以下格式调用：
函数名(函数实参列表)
上面的max(3,4)就是函数调用，
参数传递
在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的
a=[1,2,3]
print(id(a))
a="Runoob"
print(id(a))执行以上代码，结果如下：
可以看到，a的id改变了，这是因为， a 没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型（[1,2,3]）对象，也可以是指向 String 类型("Runoob")对象。
可更改(mutable)与不可更改(immutable)对象
在 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 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
下面是传不可变对象和可变对象的实例：
#传不可变类型
def change1(a):
print('没改前：',id(a))
a=6
print('改后：',id(a))
return a
a=1
print('没改前：',id(a))
print(change1(a)) #调用change1(a)，并将返回结果打印出来
#传可变类型
def change1(list1):
print('没改前：',id(list2))
list1.append([4,5,6])
print('改后：',id(list2))
return list1
list2=[1,2,3]
print('没改前：',id(list2))
print(change1(list2))
可以看到，如果传的是不可变的数据类型（a），那么重新赋值，会让数据的id改变，说明不是在原有的数据上进行了修改，而是将a重新指向了一个新的对象。
如果传的是可变的数据类型（list2），那么改变它的值后，数据的id并没有改变，说明它是在原有的数据的基础上进行了修改。
参数
python中调用函数时，可使用的正式参数类型如下：
- 必需参数
- 关键字参数
- 默认参数
- 不定长参数
必需参数
必需参数须以正确的顺序传入函数。调用时参数的数量必须和声明时的一样。
例如，执行以下代码，就会报错
def test2(a,b):
print('a*b的值为:',a*b)
a=3
b=2
test2(a)
关键字参数
关键字参数是指在函数调用时，通过指定参数名来传递参数值。关键字参数的主要特点是可以不按照定义顺序传递参数。关键字参数的使用可以增加函数调用的可读性，避免参数顺序混淆的问题。执行下面的代码：
def test3(name,sex):
print('姓名为：',name)
print('性别为：',sex)
test3(sex='男',name='花花')
可以看到，函数调用时，参数没有按照函数声明时的顺序去写，但是不会报错。
默认参数
默认参数是在函数定义时给参数赋予一个默认值，如果在调用函数时没有传递对应的参数，函数将使用默认值。使用默认参数，可以简化函数的调用，尤其是在函数需要被频繁调用的情况下，示例代码如下：
def test4(a,b=4):
print('a+b的值为：',a+b)
a=3
test4(a)
我们没有给出b对应的值，但是b默认为4，计算出来a+b的值是7
要注意的是：我们在定义函数时，参数顺序是：有默认值的参数必须在没有默认值的参数后面，不能默认参数在前。
不定长参数（可变参数）
你可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数。不定长参数在函数定义时不确定参数个数的情况下，可以接收任意数量的参数。Python提供了两种方式来实现不定长参数：使用星号（*）和双星号（**）。
1.使用星号（*）来定义可变参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
下面是一个简单的例子：
def printinfo(arg1, *vartuple):
"打印任何传入的参数"
print("输出: ")
print(arg1)
print(vartuple)
# 调用printinfo 函数
printinfo(70, 60, 50)vartuple就是一个不定长参数，从上面可以看到，它是由60,50组成的一个元组
如果在函数调用时没有指定参数，它就是一个空元组。执行这条语句：printinfo(70)
结果如下：
1.使用两个星号（**）来定义可变参数，参数会以字典的形式导入，以下是一个实例：
def printinfo(arg1, **vardict):
print("输出: ")
print(arg1)
print(vardict)
# 调用printinfo 函数
printinfo(1, a=2, b=3)
强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
#正确用法
f(10, 20, 30, d=40, e=50, f=60)
#错误用法
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式return 语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式或值。
def sum(a,b):
return a+b
a=sum(1,2) #将返回值赋值给a
print(a) #打印a的值
