​

 目录

🎇前言：大纲思维导图

🎇一、初识函数

🎆函数的作用

🎇二、函数的定义与调用

🎆定义一个函数简单的规则

🌠函数的定义

🌠函数的注释

🌠函数的调用

🎆函数的返回值

🎇三、函数的参数

🌠1.形参

🌠2.实参

🎆1、位置参数

🌠站在实参角度

✨1、按照位置传值（涉及if的三元表达式）

✨2、按照关键字传值

✨3、位置、关键字形式混着用

🌠站在形参角度

✨1、位置参数必须传值

🎆2、默认参数

🌠1、默认参数的概念

🌠2、默认参数陷阱问题（超重点）

🎆3、动态参数

🌠动态参数的概念

🌠*args求和函数应用

🌠**kwargs应用

🎇前言：大纲思维导图

🎇一、初识函数

• 🎆函数的作用

• 1.使程序变得更简短而清晰
• 2.有利于程序维护
• 3.可以提高程序开发的效率
• 4.提高了代码的重用性(复用性)

🎇二、函数的定义与调用

• 🎆定义一个函数简单的规则

🌠函数的定义🌠

• def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。

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

def func():
    print('hello world')
    

🌠函数的注释🌠

• 注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。

>>>def func():
>>>    '''
>>>    这是一个输出hello world的函数
>>>    :return: 
>>>    '''
>>>    print('hello world')

🌠函数的调用🌠

• 使用函数名加小括号就可以调用了 写法:函数名() ，这个时候函数的函数体会被执行

  只有解释器读到函数名() 时，才会执行此函数，如果没有这条指令，函数里面即使有10万行代码也是不执行的。而且是这个指令你写几次，函数里面的代码就运行几次

>>>def func():
>>>   print('hello world')
>>>func()
>>>func()
hello world
hello world

• 🎆函数的返回值

返回值的三种情况：

🌠没有返回值🌠

一、没有返回值----返回None（不报错）
1、不写return

​
#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值，此时的str_len为None
print('str_len : %s'%str_len)

输出结果：
11
str_len : None

​

2、只写return：结束整个函数

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

输出结果：
111
None

3、return None ---- 不常用

def ret_demo():
    print(111)
    return None
    print(222)

ret = ret_demo()
print(ret)

输出结果：
111

🌠二、返回一个值🌠
1、return和返回值之间要有空格且可以返回任何数据类型

def f():
    return {'k':'v'}
print(f())

输出结果：
{'k':'v'}

2、只要返回就可以接收到
3、如果在一个程序中有多个return，那么值执行第一个：因为函数只要遇到return就会终止

🌠三、返回多个值：🌠

可以用多个变量接收多个返回值（return 1,2)但如果只用一个变量接收多个返回值的话那么得到的就是一个元祖 

def f2():
    return 1,2,3
print(f2())

输出结果：
(1,2,3)

原因：为什么返回的是(1,2,3)、而不是返回1,2,3或其他？

>>> 1,2  #python中把用逗号分割的多个值就认为是一个元组。
(1, 2)
>>> 1,2,3,4
(1, 2, 3, 4)
>>> (1,2,3,4)
(1, 2, 3, 4)

🌠序列解压扩展🌠

#序列解压一
>>> a,b,c,d = (1,2,3,4)
>>> a
1
>>> b
2
>>> c
3
>>> d
4
#序列解压二
>>> a,_,_,d=(1,2,3,4)
>>> a
1
>>> d
4
>>> a,*_=(1,2,3,4)
>>> *_,d=(1,2,3,4)
>>> a
1
>>> d
4
#也适用于字符串、列表、字典、集合
>>> a,b = {'name':'eva','age':18} 
>>> a
'name'
>>> b
'age'

🎇三、函数的参数

• 🌠1.形参🌠

　　　　写在函数声明的位置的变量叫形参,形式上的一个完整.表示这个函数需要xxx

• 🌠2.实参🌠

　　　　在函数调用的时候给函数传递的值.加实参,实际执行的时候给函数传递的信息.表示给函数xxx

函数的传参就是函数将实际参数交给形式参数的过程.

def my_sum(a):              #a为形式参数
    print(a)
res = my_sum('hello')       #此时的'hello'为实际参数
print(res)

输出结果：
hello
None

🎆1、位置参数

• 🌠站在实参角度🌠

✨1、按照位置传值（涉及if的三元表达式）

def mymax(x,y):
    #此时x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

输出结果：
20

✨2、按照关键字传值

def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

输出结果：
20

✨3、位置、关键字形式混着用

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)
print(ma)

注意：

1、位置参数必须在关键字参数的前

2、对于一个形参只能赋值一次

• 🌠站在形参角度🌠

✨1、位置参数必须传值

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

#调用mymax不传递参数
ma = mymax()
print(ma)

输出结果：
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'

🎆2、默认参数

• 🌠1、默认参数的概念🌠

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：(一般将变换不大的值设为默认参数)

#可写函数说明
def func( name, age = 18 ):
   "打印任何传入的字符串"
   print ("名字: ", name，"年龄: ", age)
 
#调用printinfo函数
func( age=100, name="zhou" )
func( name="zhou" )

输出结果：
名字:  zhou 年龄:  100
名字:  zhou 年龄:  18

• 🌠2、默认参数的陷阱问题（超重点）🌠

        默认参数中超级重要的知识点：默认参数的陷阱问题（当默认参数是一个可变的数据类型时如列表，字典等）

        如果默认参数的值是一个可变数据类型，那么每一次调用函数时如果不传值就公用这个数据类型的资源

'''
    如果默认参数的值是一个可变数据类型
    那么每一次调用函数时如果不传值就公用这个数据类型的资源
'''
#==========当默认参数是一个列表时====================
def f(l = []):
    l.append(1)
    print(l)
f()
f()
f([])
f()
f()

#==========当默认参数是一个字典时====================
def f2(l = {}):
    l['k'] = 'a'
    print(l)
f2()    #覆盖
f2()
def f3(k,l = {}):
    l[k] = 'a'
    print(l)
f3(1)
f3(2)
f3(3)

输出结果：
[1]
[1, 1]
[1]
[1, 1, 1]
[1, 1, 1, 1]
{'k': 'a'}
{'k': 'a'}
{1: 'a'}
{1: 'a', 2: 'a'}
{1: 'a', 2: 'a', 3: 'a'}

🎆3、动态参数

🌠动态参数的概念🌠

动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就⽤*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

*args   ： 接收的是按照位置传参的值，组织成一个元组
**kwargs： 接受的是按照关键字传参的值，组织成一个字典
args必须在kwargs之前

• 🌠*args求和函数应用🌠

def mysum(*args):
    the_sum = 0
    for i in args:
        the_sum+=i
    return the_sum

the_sum = mysum(1,2,3,4)
print(the_sum)

输出结果：
10

• 🌠**kwargs应用🌠

def stu_info(**kwargs):
    print(kwargs)
    print(kwargs['name'],kwargs['sex'])

stu_info(name = 'lisa',sex = 'male')

dir = {'a':97,'b':98}
print(*dir)

输出结果：
{'name': 'lisa', 'sex': 'male'}
lisa male
a b

🎇小结

站在实参的角度：
        按照位置传参
        按照关键字传参
注意：两个混着用可以但是必须先按照位置传参，再按照关键字传参， 因为不能给同一个变量传多个值

        
站在形参的角度上：
       位置参数：必须传，且有几个参数就传几个值
       默认参数：可以不传，如果不传就是用默认的参数，如果传了就用传的

只有调用函数的时候
      按照位置传：  直接写参数的值
      按关键字传：  关键字 = 值
    
定义函数的时候：
     位置参数：直接定义函数
     默认参数（关键字参数）：参数名 = ‘默认的值’
     动态参数：可以接受任意多个参数
                参数名之前加*， 习惯参数名args;
                参数名之前加**， 习惯参数名kwargs;
参数的顺序（必须死记）：位置参数 > *args > 默认参数 > **kwargs