函数的参数

自定义函数的分类

无参函数、有参函数和空函数

无参函数:

在函数定义阶段,括号内没有参数。

def index():    # 定义无参函数,括号内没有参数
    print('今天你吃饭了吗')


index()    # 调用无参函数,括号内也不用写参数

 

有参函数:

在函数定义阶段,括号内有参数,这个参数类似于变量名。

def index(a):    # 定义有参函数,括号内要有参数,类似于变量值
    print('嘿嘿嘿 妹纸有事冲我来', a)


index(123)    # 调用有参函数,括号内也必须要有参数,类似于变量的值

 

空函数:

在函数定义阶段,函数体代码是用pass或者...占位。空函数能让整体的程序框架更加简洁清晰,增强代码的可读性和使用效率。

def index():    # 定义一个空函数
    pass    # 函数体代码用pass语句或者'...'占用替代

函数的返回值return

函数的返回值其实就是在调用的函数执行完毕之后,返回给调用者的结果。

s = 'hello world'
res = len(s)  # 将len函数的返回值赋值给变量res
print(res)

返回值return的用法:

  • 当函数体代码没有return关键字的时候,返回值是None。
# 定义一个函数
def index():
    print('春困秋乏夏打盹儿')    
# 调用这个函数并给变量名赋值
res = index()
print(res)  # None  返回值是以布尔值的方式存在

 

  • 当函数体代码写了return关键字,但是没有跟任何值得时候,返回值也是None。
复制代码
# 定义一个函数
def index():
    print('春困秋乏夏打盹儿')
    return  # 函数的返回值关键字


# 调用这个函数并给变量名赋值
res = index()
print(res)  # None  返回值是以布尔值的方式存在
复制代码

 

  • 当函数体代码写了return关键字,并且跟了数据,那么写什么就返回什么。如果写的是值,那么直接返回值(这个值可以是任意数据类型);如果写的是变量名,那么返回变量名指向的值。
复制代码
# 定义一个函数
def index():
    print('春困秋乏夏打盹儿')
    name = 'jason'    # 变量的赋值
    return name  # 函数的返回值关键字


# 调用这个函数并给变量名赋值
res = index()
print(res)  # jason
复制代码

 

  • return关键字后面还可以跟多个值,值与值之间用逗号隔开,函数调用结束时会自动组织成元组的形式。
复制代码
# 定义一个函数
def index():
    print('春困秋乏夏打盹儿')
    return 111, 'jason', 222  # 函数的返回值是多个,值之间用逗号隔开


# 调用这个函数并给变量名赋值
res = index()
print(res)  # (111,'jason',222) 输出是以元组的形式存在
复制代码

 

  • 当函数体代码遇到return关键字的时候,会立刻结束函数运行。类似于循环语句当中的break关键字。

函数的参数

函数的参数可以分为两大类:分为形式参数和实际参数,简称形参和实参。

形参:

函数在定义阶段括号内写的参数;形参即在定义函数时,括号内声明的参数,形参本质就是一个变量名,用来接收外部传来的值。

实参:

函数在调用阶段括号内写的参数;实参即在调用函数时,括号内传入的值,值可以是常量、变量、表达式或三者的组合。

形参与实参的关系:

形参类似于是变量名、实参类似于是变量的值。

在调用有参函数的时候实参(值)的值会赋给形参(变量名),此时实参会与形参临时绑定;这种关系只在函数调用的时候存在;函数运行结束之后自动解除绑定。

# 定义函数
def index(a, b):  # a和b就是index函数的形参
    print(a, b)


# 调用函数
index(1, 2)  # 1和2就是index函数的实参

note:

实参1会临时绑定给形参a,实参2会临时绑定给形参b,在函数体代码运行期间,可以通过形参直接使用到实参;函数体代码运行完毕之后,解除绑定形参,ab处于没有绑定值得状态,等待下一次函数调用然后再传入实参进行绑定......。

位置参数

位置参数就是指按位置顺序定义的参数,分为位置形参和位置实参两种。

位置形参:

在定义函数时,按照从左到右的顺序依次定义形参,称为位置形参,凡是按照这种形式定义的形参都必须被被传值;即在函数定义阶段括号内从左往右依次填写的变量名。

def index(name,pwd):  # name和pwd就是位置形参
    pass

 

位置实参:

在调用函数时,按照从左到右的顺序依次定义实参,称为位置实参,凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应;即在函数调用阶段括号内从左往右依次传入的真实数据。

index('jason',123)  # jason和123就是位置实参

位置参数的特点:

  1. 位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定。
  2. 位置形参与位置实参的个数要一致,多一个不行,少一个也不行。
复制代码
def index(a, b):    # 定义一个有参函数
    print(a, b)  # 外界传入什么实参这里就打印什么


index(1, 2)    # 调用有参函数,实参1和2
index('jason', 123)    # 调用有参函数,实参'jason'和123
# NOTE:
index()  # 调用的时候不传实参不可以
index(111)  # 传少了也不行
index(111, 222, 333)  # 传多了也不行
复制代码

关键字参数

在调用函数时,实参可以是key=value的形式,称为关键字参数,凡是按照这种形式定义的实参,可以完全不按照从左到右的顺序定义,但仍能为指定的形参赋值。关键字参数只能出现在实参当中。

def index(a, b):    # 定义一个有参函数
    print(a, b)

# 调用这个有参函数
index(b=111, a=222)  # 指名道姓的说形参a接收数据222 b接收数据111

NOTE:

需要注意在调用函数时,实参也可以是按位置或按关键字的混合使用,但必须保证关键字参数在位置参数后面,且不可以对一个形参重复赋值!!!

def index(a, b):
    print(a, b)


# NOTE:
index(b=333, 222)  # 报错 关键字参数必须放在位置参数的后面
index(222, a=111)  # 报错 形参只能指向一个实参
index(222, b=111)  # 可以 相当于位置参数

 

默认参数

在定义函数时,就已经为形参赋值,这类形参称之为默认参数。当函数有多个参数时,需要将值经常改变的参数定义成位置参数,而将值改变较少的参数定义成默认参数。

NOTE:

默认参数的出现也打破了形参与实参之间个数一致的情况。

1、默认参数必须定义在位置参数的后面。

2、默认参数的值仅仅能在函数定义的阶段被赋值一次。

例如编写一个注册学生信息的函数,如果大多数学生的性别都为男,那完全可以将形参sex定义成默认参数。

复制代码
def register(name, age, gender=''):
    print("""
    学员姓名:%s
    学员年龄:%s
    学员性别:%s
    """ % (name, age, gender))


register('jason', 18)    # 不传就使用默认的  男
register('kevin', 28)    # 不传就使用默认的  男
register('jerry', 22, '美女')  # 传了就使用自己的
复制代码

可变长参数

参数的长度可变指的是在调用函数时,实参的个数可以不固定,而在调用函数时,实参的定义无非是按位置或者按关键字两种形式,这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数。

  • 可变长度的位置参数

*号在形参中,可以接收多余的位置参数,并组织成元组的形式赋值给*号后面的变量名,即,溢出的位置实参,都会被接收,以元组的形式保存下来赋值给该形参。

def func(*a):    # 多变量形参
    print(a)


func()  # ()
func(1, 2)  # (1, 2)
func(1, 2, 3, 4, 5, 6)  # (1, 2, 3, 4, 5, 6)
def index(a, b, *ag):
    print(a, b, ag)


index(999)  # 会报错  因为形参a,b的存在,意味着index函数最少要给两个参数
index(1, 2)  # 1 2 ()
index(1, 2, 3, 4, 5, 6, 7)  # 1 2 (3, 4, 5, 6, 7)
index(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  # 1 2 (3, 4, 5, 6, 7, 8, 9, 10)

 

  • 可变长度的关键字参数

**在形参中,用于接收多余的关键字参数,在调用函数时,溢出的关键字参数,都会被接收,以字典的形式保存下来赋值给该形参。

def index(a, b, **k):    # **k关键字形参,可以接受多个关键字参数
    print(a, b, k)


index(a=1, b=2)  # 1 2 {}
index(a=1, b=2, c=3, name='jason')  # 1 2 {'c': 3, 'name': 'jason'}
index(1, 2, name='jason', age=18, pwd=123)  # 1 2 {'name': 'jason', 'age': 18, 'pwd': 123}
def func(**k):
    print(k)


func()  # {}
func(a=1, b=2)  # {'a': 1, 'b': 2}
func(a=1, b=2, c=3, d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

 

定义函数的时候,如果不确定这个函数将来需要多个实参,那么可以采用*a和**k组合的方法。

def func(*a, **k):
    print(a, k)


func()  # () {}
func(1, 2, 3, 4, name='jason', age=18)  # (1, 2, 3, 4) {'name': 'jason', 'age': 18}

NOTE:

*和**在形参中的使用,后面的变量名并不是关键,但是针对这两个特殊符号后面的变量名,有推荐的写法:

def index(*args, **kwargs):
    pass

 

posted @   *sunflower*  阅读(188)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示