函数是组织好的，用来实现某些功能的代码块，它可以重复使用。

函数能提高应用的模块性，和代码的重复利用率。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的值