函数（一）-CSDN博客

函数

1.什么是函数

在程序中函数就是具备某一功能的代码块，我们可以先把这个功能定义好，遇到需要使用这一功能的应用场景可以直接通过定义好的名字调用这一块代码。

def 函数名():
#     代码块  # 实现某一个具体的功能

2.函数的三种定义方式

1.无参函数：在定义函数阶段括号内没有参数，称为无参函数。需要注意的是：定义时无参，调用时也无需传入参数

def func():
    print('hello nick')
    
func()  # hello nick

2.有参函数：在函数定义阶段括号内有参数，称为有参函数。需要注意的是：定义时有参，意味着调用时也必须传入参数。如果函数体代码逻辑需要依赖外部传入的值，必须得定义成有参函数。

def sum_self(x, y):
    """求和"""
    res = x+y
    print(res)

sum_self(1,2)  # 3

3.空函数：当你知道需要实现某个功能但不知道如何用代码实现时，可以先写个空函数

def func():
    pass

3.返回值

返回值时函数内部经过一系列的逻辑处理获得的结果,如果需要在程序中拿到函数的处理结果做进一步的处理，则函数必须有返回值。函数中用return返回函数处理结果

return是一个函数结束的标志，函数内可以有多个return，只要执行到return，函数就会停止
return的返回值可以返回任意数据类型
return的返回值无个数限制，即可以使用逗号隔开返回多个值
- 0个：返回None
- 1个：返回值是该值本身
- 多个：返回值时元组

def func():
    name = 'nick'
    return name

name = func()
print(name)

# 函数返回多个值
def func():
    name = 'nick'
    age = 19
    hobby_list = ['read', 'run']
    return name, age, hobby_list

name, age, hobby_list = func()
print(name,age,hobby_list)  #('nick', 19, ['read', 'run'])

4.函数的调用

函数名加括号就可以调用函数，执行函数内部代码，直到碰到return或执行完函数体内部的所有代码结束。函数运行完所有的代码，如果函数体没有写return，则返回None

def foo():
    pass

print(foo())        #None

函数调用的三种形式：

def max_self(x,y):
    if x>y:
        return x
    else:
        return y
    
# 1.
max_self(1,2)
# 2.
res = max_self(1,2)*12
# 3.
max_self(max_self(20000,30000),40000)

5.函数参数的应用

形参和实参

1.形参：函数定义的时候括号内的参数称为形式参数，简称形参，本质就是变量名

def func(x, y):
    print(x)
    print(y)

2.实参：函数调用时传入的参数称为实际参数，简称实参，本质就是变量值

func(1,2)

位置参数

1.位置形参：函数定义时依照从左到右的顺序依次定义的形参，称为位置形参，按照位置定义的形参在函数调用时都必须被传值，多一个少一个都不行

def func(x, y):
    print(x)
    print(y)

2.位置实参：在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参，按照位置为对应的形参传值

func(1,2)

关键字参数

在调用时按照key=value的形式为指定的参数传值，称为关键字参数，可以打破位置的限制为对应的形参传值，需要注意的是：

1.位置实参和关键字实参可以混用，但是位置实参必须在关键字参数的左边

2.不能对一个形参重复赋值

def func(x,y)
    return x+y

func(x,y=2)
func(y=2,x) #报错
func(x,x=1) #报错

默认形参

在定义函数是就被赋值的形参称为默认形参，在调用的时候可以不用为其赋值，，如果给默认形参传值的话就会覆盖掉默认形参的值，需要注意的是位置形参必须在默认形参的左边

# 演示形参是可变类型
def register(name, hobby, hobby_list=[]):
    hobby_list.append(hobby)
    print(f"{name} prefer {hobby}'")
    print(f"{name} prefer {hobby_list}")

register('nick', 'read')
register('tank', 'zuipao')
register('jason', 'piao')

nick prefer read'
nick prefer ['read']
tank prefer zuipao'
tank prefer ['read', 'zuipao']
jason prefer piao'
jason prefer ['read', 'zuipao', 'piao']

# 修改形参是可变类型代码
def register(name, hobby, hobby_list=None):
    if hobby_list is None:
        hobby_list = []
    hobby_list.append(hobby)
    print(f"{name} prefer {hobby}'")
    print(f"{name} prefer {hobby_list}")


register('nick', 'read')
register('tank', 'zuipao')
register('jason', 'piao')

nick prefer read'
nick prefer ['read']
tank prefer zuipao'
tank prefer ['zuipao']
jason prefer piao'
jason prefer ['piao']

6.可变长参数

可变长参数是指在调用函数时传入的参数个数可以不固定

1.可变长形参之 *：形参中的星号会将溢出的位置实参全部接收，存储为元组的形式然后把元组赋值给星号后面的参数，星号后面的参数约定俗成为args.

def sum_self(*args):
    res = 0
    for num in args:
        res += num
    return res


res = sum_self(1, 2, 3, 4)
print(res)

2.可变长实参之*

实参中的*号会将星号后的参数循环取出，打散成位置实参，依次传值给对应的形参

def func(x,y,z,*args):
    print(x,y,z,args)
    
func(1,*(1,2),3,4)
#1 1 2 (3,4)

3.可变长形参之**

形参中的**会将溢出的关键字实参全部接收，然后存储成字典的形式，然后把字典赋值给双星号后面的形参，双星号后面的参数约定俗成写成kwargs

def func(**kwargs):
    print(kwarg)
    
func(a=5,b=6)
#{'a':5,'b':6}

4.可变长实参之**

实参中的双星号会将后面参数的值循环取出，打散成关键字实参

def func(x,y,z,**kwargs):
    print(x,y,z,kwargs)
    
fucn(1,2,3,**{'a':1,'b':2})
#1 2 3 {'a':1,'b':2}

5.可变长参数应用

def index(name,age,sex):
    print(f'name:{name},age:{age},sex:{sex}')
    
def wrapper(*args,**kwargs):
    print(args)
    print(kwargs)
    index(*args,**kwargs)
    
wrapper(name='nick',age=19,sex='male')
#()
#{'name':'nick','age':19,'sex':'male'}
#name:nick,age:19,sex:male

转载于:https://www.cnblogs.com/zhaogang0104/p/10960217.html