python [函数

函数就是一段实现特定功能的代码，使用函数可以提高代码的重复利用率。Python中有很多内置函数，如常用的 print() 、input() 函数，也可以自定义函数。

---

目录

1.创建函数

自定义函数

匿名函数

2.函数调用

3.参数传递

参数分类

参数传递形式

强制位置参数

4.return 语句

---

1.创建函数

自定义函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

声明函数的语法格式：

def 函数名(参数):
    函数体
    return 返回值

定义无任何功能的空函数：

def 函数名():
    pass

不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明：

def 函数名(*参数名):
    函数体 

示例如下：

def hello() :
    print("Hello World!")

hello()

匿名函数

Python 使用 lambda 来创建匿名函数。所谓匿名，即不使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。

定义匿名函数语法格式：

lambda 参数 : 表达式  

示例如下：

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

## 运行结果：
## 相加后的值为 :  30
## 相加后的值为 :  40

2.函数调用

调用函数即执行函数。调用函数语法格式：

函数名(参数)

示例如下：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

## 运行结果：
## 我要调用用户自定义函数!
## 再次调用同一函数

3.参数传递

参数分类

调用函数时可使用的正式参数类型有4种。

【必需参数】

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()


## 输出结果：
## Traceback (most recent call last):
##   File "test.py", line 10, in <module>
##     printme()
## TypeError: printme() missing 1 required positional argument: 'str'

【关键字参数】

函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="阿发" )

## 输出结果：
## 名字:  阿发
## 年龄:  50

【默认参数】

调用函数时，如果没有传递参数，则会使用默认参数。

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( name="阿发" )

## 输出结果：
## 名字:  阿发
## 年龄:  35

【不定长参数】

和上述 2 种参数不同，声明时不会命名。语法格式1：

def 函数名([形式参数,] *可变参数元组):

    "函数_文档字符串"

    函数主体

    return [表达式]

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

## 输出结果：
## 输出: 
## 70
## (60, 50)

如果在函数调用时没有指定参数，它就是一个空元组：

# 可写函数说明
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

 另一种形式的语法格式2：加了两个星号 ** 的参数会以字典的形式导入。

def 函数名([形式参数,] **可变参数字典):
    "函数_文档字符串"
    函数主体
    return [表达式]

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

## 输出结果：
## 输出: 
## 1
## {'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现：

def f(a,b,*,c):
    return a+b+c

# 如果单独出现星号 *，则星号 * 后的参数必须用关键字传入
f(1,2,c=3)

# 报错：f(1,2,3) 

 

参数传递形式

在 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没有动，只是其内部的一部分值被修改了。

【传不可变对象】

类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

def change(a):
    # 打印变量 a 的内存地址
    print(id(a))   # 指向的是同一个对象
    a = 10
    print(id(a))   # 一个新对象

a = 1
print(id(a))
change(a)

## 输出示例：
## 4379369136
## 4379369136
## 4379369424

【传可变对象】

类似 C++ 的引用传递，如列表、字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。

# 传入函数的和在末尾添加新内容的对象用的是同一个引用
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

## 输出结果：
## 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
## 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

强制位置参数

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 必须使用关键字参数的形式

4.return 语句

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

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

## 运行结果：
## 函数内 :  30
## 函数外 :  30