函数 -- 基本用法

函数定义

def 函数名( 形参表 ):
    函数体
    [ return [ 表达式/函数 ] ] 

• def 是英文 define 的缩写表示定义，注意行尾要加：
• 函数名要符合标识符规则，并能表达函数体的功能
• 形参表中，参数之间使用 , 分隔
• 函数一定要 先定义、后使用

• 无参函数

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

• 带参函数

def area(width, height):
    return width * height

• 空函数

def nop():  # 一个什么事也不做的空函数
    pass

函数调用

函数名 ( 实参表 ) 

• 调用函数时，如果 形参 与 实参 个数不一致，会抛出TypeError
• 函数不调用、不执行

>>> hello()
Hello World!

>>> area(4, 5)
20

参数种类

• 形参：定义函数时小括号中的参数，用来接收数据并在函数内部作为变量使用
• 实参：调用函数时小括号中的参数，用来把数据传递到函数内部

实参的传递

• 不可变类型：数字、字符串、元组作为 实参 时，会将副本传递给 形参 ，因此函数内部的修改不会影响 实参 本身。

def unchgParm( a ):
    a = 10
    print ("函数内取值: ", a)

b = 2
unchgParm(b)  # 传递不可变类型
print ("函数外取值: ", b)    # b不受函数的影响，值仍是2

函数内取值:  10
函数外取值:  2

• 可变类型：列表、字典、集合作为 实参 时，会将 实参 真正的传过去，因此函数内部的修改也会对 实参 产生影响

def chgParm( mylist ):
    mylist.append(40)
    print ("函数内取值: ", mylist)
 
mylist = [10,20,30]
chgParm( mylist )  # 传递可变类型
print ("函数外取值: ", mylist)  # mylist受函数影响，值变成 [10,20,30,40]

函数内取值:  [10, 20, 30, 40]
函数外取值:  [10, 20, 30, 40]

注意： 在同一作用域中函数名不能相同！

形参的种类

• 必选参数（位置参数），要求 实参 必须以正确的顺序和数量传递给 形参 。

def printme( str ):
    print (str)

printme()  # 报错，实参数量不正确

• 关键字参数，将 实参 以赋值语句的形式传递给指定的 形参，允许函数调用时参数的顺序与声明时不一致，由解释器负责匹配

def printinfo( name, age ):
    print ("名字: ", name)
    print ("年龄: ", age)

printinfo( age=50, name="neuedu" )

• 默认参数，为 形参 设置默认值，当没有 实参 时使用该值

def printinfo( name, age = 35 ):  # 形参的默认值为35
    print ("名字: ", name)
    print ("年龄: ", age)
 
printinfo( age=50, name="neuedu" )
print ("------------------------")
printinfo( name="neuedu" )  # 在函数中使用age的默认值


名字:  neuedu
年龄:  50
------------------------
名字:  neuedu
年龄:  35

注意： 默认参数必须指向不变对象！

• 不定长参数，当 实参 数量不定时，可以使用不定长参数。

def printinfo( arg1, *vartuple ):
    print(arg1)
    print(vartuple)

printinfo( 70, 60, 50 )


70
(60, 50)

以 * 开头的形参会以 元组(tuple) 的形式存放多出的 实参。

def printinfo( arg1, *vartuple ):
    print ("输出: ")
    print (arg1)
    for var in vartuple:  # 使用循环避免产生空元组
        print (var)

printinfo( 10 )  # 没有传递可变长实参
printinfo( 70, 60, 50 )


输出:
10
输出:
70
60
50

如果没有传递可变长 实参，会产生一个空元组，可以使用循环来处理

def printinfo( arg1, **vardict ):
    print ("输出: ")
    print (arg1)
    print (vardict)

printinfo(1, a=2,b=3)

输出: 
1
{'a': 2, 'b': 3}

以 ** 开头的形参会以 字典(dictionary) 的形式存放多出的 实参。

• 命名关键字参数，用来限制关键字实参的名字

def person(name, age, **kw):
    if 'city' in kw:
        pass
    if 'job' in kw:
        pass
    print('name:', name, 'age:', age, 'other:', kw)

person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)  # 包含多余的实参

为了限制关键字实参的名字，可以用命名关键字参数，例如，只接收 city 和 job 作为关键字参数

def person(name, age, *, city, job):
    print(name, age, city, job)

person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer   # 正确输出

person('Jack', 24, city='Beijing', job='Engineer', zip=123)  # 含有未指定的实参时报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() got an unexpected keyword argument 'zip'

使用 * 分隔 形参， * 后面的 形参 被定义为命名关键字 形参，只能接收指定名字的 实参

形参的组合

在Python中 形参可以用必选参数、默认参数、可变参数、关键字参数、命名关键字参数。
但定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数。

• 对于任意函数，都可以通过类似 func(*args, **kw) 的形式调用它，无论它的参数是如何定义的
• 虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

函数的返回值

• 在程序开发中，希望函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值是函数完成工作后，给调用者的一个结果
• 在函数中使用 return 关键字来返回结果，调用函数一方，可以使用变量来接收函数的返回结果
• 不带参数值的 return 语句返回 None
• return 表示返回，后续的代码都不会被执行

def sum(num1, num2):
    return num1 + num2

result = sum(10, 20)  # 调用函数，并使用result变量接收计算结果
print("计算结果是 %d" % result)


计算结果是 30

• 返回多个值

def move():
    nx = 100
    ny = 200
    return nx, ny

x, y = move()
print(x, y)


100 200

这其实是一种假象

>>> r = move()
>>> type(r)
<class 'tuple'>

原来返回值是一个 元组(tuple)，在语法上，返回一个 元组(tuple) 可以省略括号，而且多个变量可以同时接收一个元组(tuple)，按位置赋给对应的值。所以，Python的函数返回多值，其实就是返回一个元组(tuple)，但写起来更方便。

函数的文档注释

• 给函数添加注释，应该在函数定义的下方使用一对 ''' 将函数说明括起来
• 在函数调用的位置，可以使用快捷键 CTRL + Q 来查看函数的说明信息
• 如果在函数定义的上方添加注释，应和其他代码之间保留两个空行

在PyCharm中调试函数

• F8 Step Over可以单步执行代码，会把函数调用看作是一行代码直接执行
• F7 Step Into可以单步执行代码，如果是函数，会进入函数内部

- end -