函数是一组有组织的、可重用的代码，用于执行单个相关操作。函数为应用程序提供更好的模块化和高度的代码重用。Python 提供了许多内置函数，如 print() 等。也可以创建自己的函数。这些函数称为用户定义函数。

定义函数

可以定义函数以提供所需的功能。以下是在 Python 中定义函数的简单规则。

• 函数块以关键字def开头，后跟函数名称和圆括号 ( ( ) )。
• 任何输入参数或自变量都应放在这些括号内。您还可以在这些括号内定义参数。
• 函数的第一条语句可以是可选语句——函数的文档字符串或文档字符串。
• 每个函数中的代码块都以冒号 (:) 开头并缩进。
• 语句 return [expression] 退出函数，可选择将表达式返回给调用者。没有参数的 return 语句与 return None 相同。

语法

def functionname( parameters ):   #函数名和参数
   ...   #具体代码
   return [expression]   #函数返回值

例如，定义一个打印函数，将输入的内容打印在显示器上。没有返回值。

def printer( str ):
   print (str)
   return

调用函数

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。例如，调用上面定义的函数printer()。

def printer( str ):
   print (str)
   return

printer("打印一行内容！")   # 调用函数printer()
#运行结果
打印一行内容！

参数传递

在 python 中，类型属于对象，变量是没有类型的。

可更改(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 add(x,y):
    x = x + 1
    y = y * 2
    print("x:", x, '    ','y:',y)
    return x + y

a = 3
b = 5
c = add(a,b)
print('c:',c)
print("a:", a, '    ','b:',b)

运行结果

x: 4      y: 10
c: 14
a: 3      b: 5
#说明是互不影响的

传递可变对象时，函数内外参数是相互影响的。

def updatelist(list):
   list[1] = 5 
   print ("inside the function: ", list)
   return

#调用函数
list = [10,20,30]
updatelist( list )
print ("outside the function: ", list)

运行结果

inside the function:  [10, 5, 30]
outside the function:  [10, 5, 30]
#内外部结果同时发生变化。

参数

以下是调用函数时可使用的参数类型：

• 必备参数
• 关键字参数
• 默认参数
• 不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。例如调用上面定义的add()函数，必须传入两个参数，不然会出现语法错误：

c = add(a)
print('c:',c)
#运行结果
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [68], line 1
----> 1 c = add(a)
      2 print('c:',c)

TypeError: add() missing 1 required positional argument: 'y'

关键字参数

关键字参数与函数调用有关。在函数调用中使用关键字参数时，调用者通过参数名称识别参数。这允许跳过参数或乱序放置它们，因为 Python 解释器能够使用提供的关键字将值与参数匹配。例如：

def add(x,y):
    x = x + 1
    y = y * 2
    return x + y

a = 3
b = 5
c = add(y=b, x=a)
print('c:',c)
#运行结果
14

默认参数

默认参数是在函数调用中未为该参数提供值时采用默认值的参数。例如：

def add(x, y = 3):
    x = x + 1
    y = y * 2
    return x + y

c = add(5,5)
d = add(x=5)
print('c:',c)
print('d:',d)
#运行结果
c: 16
d: 12

不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   ...
   return [expression]

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

输出:
10
输出:
70
60
50

return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

def add(x, y):
    return x + y

c = add(5,5)
print('c:',c)

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 5 # 这是一个全局变量
def add( x, y ):
   total = x + y # total在这里是局部变量.
   print("局部变量 total: ", total )
   return total
 
#调用函数
add( 10, 10 )
print("全局变量 total: ", total )
#运行结果
局部变量 total:  20
全局变量 total:  5