目录
一、为什么要使用函数？
二、函数的定义与调用
1、函数的定义
2、函数的调用
三、函数的返回值
四、函数的参数
1、实参和形参
2、传递多个参数
3、位置参数
五、总结
一、为什么要使用函数？
1.避免代码重用
2.提高代码的可读性
例1：统计字符串长度
步骤1：
1 li = [1, 2, 3, 43, 'fdsa', 'alex']
2 count = 0
3 for i in li:
4 count += 1
5 print(count)
步骤2：
1 s1 = 'fdsgdfkjlgdfgrewioj'
2
3 count = 0
4 for i in s1:
5 count += 1
6 print(count)
步骤3：
1 s1 = 'fdsgdfkjlgdfgrewioj'
2 def my_len():
3 count = 0
4 for i in s1:
5 count += 1
6 # print(count)
7
8 my_len()
步骤4：
1 def my_len():
2 count = 0
3 for i in s1:
4 count += 1
5 return count
6 print(my_len())
7 print(len(s1))
步骤5：
1 #函数的传参
2 li = [1, 2, 3, 43, 'fdsa', 'alex']
3 s1 = 'fdsgdfkjlgdfgrewioj'
4
5 def my_len(a): # 函数的定义（）放的是形式参数，形参
6 count = 0
7 for i in a:
8 count += 1
9 return count
10 ret = my_len(li) # 函数的执行（） 实际参数，实参
11 print(ret)
12 print(len(s1))
二、函数的定义与调用
1、函数的定义
def 函数名（参数1，参数2）
''' 函数注释'''
print（'函数体'）
return 返回值
定义：def关键字开头，空格之后接函数名和圆括号，最后还要加一个冒号。
def是固定的，不能变。
函数名：函数名是包含字母，数字，下划线的任意组合，但是不能以数字开头。虽然函数名可以随便取名，但是一般尽量定义成可以表示函数功能的。
2、函数的调用
返回值=函数名（参数1，参数2）#记得函数名后面加括号
例2：计算字符串的长度
1 # 1.给定一个字符串，调用函数，当他没有返回值的时候返回Null
2 def length():
3 s='hello world'
4 length=0
5 for i in s:
6 length+=1
7 print(length)
8 print(length())
9
10
11 # 2.return 必须放在函数里，当函数有返回值的时候，必须用变量接收才会有效果
12 def length():
13 s='hello world'
14 length=0
15 for i in s:
16 length+=1
17 return length
18 print(length())
三、函数的返回值
1.return的作用:结束一个函数的执行
2.首先返回值可以是任意的数据类型。
3.函数可以有返回值：如果有返回值，必须要用变量接收才有效果
也可以没有返回值：
没有返回值的时候分三种情况：
1)当不写return的时候，函数的返回值为None
2)当只写一个return的时候，函数的返回值为None
3)return None的时候，函数的返回值为None（几乎不用）
4.return返回一个值（一个变量）
5.return返回多个值（多个变量）：多个值之间用逗号隔开，以元组的形式返回。
接收：可以用一个变量接收，也可以用多个变量接收，返回几个就用几个变量去接收
1 ## 函数有一个或多个返回值
2 def func():
3 a=111
4 b=[1,2,3]
5 c={'a':15,'b':6}
6 #return a#返回一个值
7 #return a,b,c#返回多个值，变量之间按逗号隔开，以元组的形式返回
8 print(func())
9
10 ## 函数没有返回值的函数
11 # 1.不写return时返回None
12 def func():
13 a=111
14 b=[1,2,3]
15
16 ret=func()
17 print(ret)
18
19
20 # 2.只写一个return时返回None
21 def func():
22 a=111
23 b=[1,2,3]
24 return
25 ret=func()
26 print(ret)
27
28 # 3.return None的时候返回None
29 def func():
30 a=111
31 b=[1,2,3]
32 return None
33 ret=func()
34 print(ret)
35
36 ## return的作用
37 def func4():
38 print (1111111)
39 return#结束一个函数的执行
40 print (1242451)
41 func4()
42
43 ## 定义一个列表，返回列表的最后一个值
44 方法一
45 def func():
46 list=['hello','egon',11,22]
47 return list[-1]
48
49 print(func())
50
51 方法二
52 def func():
53 list=['hello','egon',11,22]
54 return list
55
56 m,n,k,g=func()#
57 print(g)
四、函数的参数
1 # 函数定义
2 def fun(s):#参数接受：形式参数，简称形参
3 '''
4 计算字符串长度的函数---------函数的功能
5 参数s：接受要计算的字符串--------参数的信息
6 return：要计算字符串长度 ---------返回值得信息
7 '''
8 length=0
9 for i in s:
10 length+=1
11 return length
12
13 # 函数调用
14 ret=fun('helloword')#参数传入：实际参数，简称实参
15 print(ret)
1、实参和形参
形参：是函数定义时候定义的参数
实参：是函数调用的时候传进来的参数
2、传递多个参数
参数可以传递多个，多个参数之间用逗号分隔。
1 def mymax(x,y):
2 the_max = x if x > y else y
3 return the_max
4
5 ma = mymax(10,20)
6 print(ma)
3、位置参数
### 站在实参角度：
1）按照位置传值，必须一一对应，按顺序
1 # 按照位置传参
2 def mymax(x,y):
3 #此时x=10,y=20
4 the_max = x if x > y else y
5 return the_max
6
7 ma = mymax(10,20)
8 print(ma)
2）按照关键字传值必须一一对应，不分顺序
1 # 按照关键字传参
2 def mymax(x,y):
3 #此时x = 20,y = 10
4 print(x,y)
5 the_max = x if x > y else y
6 return the_max
7
8 ma = mymax(y = 10,x = 20)
9 print(ma)
3）位置、关键字形式混着用，一一对应，且关键字参数必须在位置参数后面
1 # 混合传参
2 def mymax(x,y):
3 #此时x = 10,y = 20
4 print(x,y)
5 the_max = x if x > y else y # 如果x大于y，the_max等于x，否则the_max等于y。
6 return the_max
7
8 ma = mymax(10,y = 20)
9 print(ma)
正确用法：
位置参数必须在关键字参数的前面
对于一个形参只能赋值一次
1 # 传递多个参数，实现比大小的功能
2 def my_max(a,b):#位置参数：按顺序定义参数
3 if a>b:
4 return a
5 else:
6 return b
7 # 站在实参的角度上
8 print(my_max(20,30))
9 print(my_max(10,20))# 1.按照位置传参
10 print(my_max(b=50,a=30))# 2.按照关键字传参
11 print(my_max(10,b=30))#3.位置和关键字传参混搭
### 站在形参角度
1）按照位置传值，必须一一对应，按顺序
1 def func1(x,y):
2 print(x,y)
3 func1(1,2)
2）默认参数，必须在位置参数后面
用法：为什么要用默认参数？将变化比较小的值设置成默认参数（比如一个班的男生多，女生就几个，就可以设置个默认值参数）
定义：默认参数可以不传，不传的时候用的就是默认值，如果传会覆盖默认值。
默认的值是在定义函数的时候就已经确定了的
1 # 默认参数
2 def stu_info(name,sex = "male"):
3 """打印学生信息函数，由于班中大部分学生都是男生，
4 所以设置默认参数sex的默认值为'male'
5 """
6 print(name,sex)
7 stu_info('alex')
8 stu_info('gaodong','female')
1 def register(name,sex='男'):
2 with open('register',encoding='utf-8',mode='a') as f1:
3 f1.write('{} {}
'.format(name,sex))
4
5 while True:
6 username = input('请输入姓名：/q 或者 Q 退出')
7 if username.upper() == 'Q':break
8 if 'a' in username:
9 sex = input('请输入性别：')
10 register(username,sex)
11 else:
12 register(username)
默认参数缺陷：默认参数是一个可变数据类型
1 def default_param(a,l=[]):
2 l.append(a)
3 print(l)
4
5 default_param('alex')
6 default_param('rgon')
7
8 输出：['alex']
9 ['alex', 'egon']
3）动态参数
按位置传值多余的参数都由args统一接收，保存成一个元组的形式
按关键字传值接受多个关键字参数，由kwargs接收，保存成一个字典的形式
1 # 接收所有位置参数，保存成一个元组的形式
2 def fun(a,b,*args):
3 sum=a+b
4 for i in args:
5 sum+=i
6 return sum
7 print(fun(1,5,6,4))#输出1+5+6+4的和
8
9
10 # 接收所有关键字参数，保存成一个字典的形式
11 def fun(a,b,**kwargs):
12 print(a,b,kwargs)
13
14 fun(a = 10,b = 20,cccc= 30,dddd = 50)
15 # 输出：10 20 {'cccc': 30, 'dddd': 50}
16
17
18 # 位置参数, *args, 默认参数, **kwargs
19 def f(a,b,*args,defult=6,**kwargs):
20 #位置参数，*args, 默认参数，**kwargs
21 # print(a,b,args,defult,kwargs)
22 return a,b,args,defult,kwargs
23
24 #传参数的时候：必须先按照位置传参数，再按照关键字传参数
25 print(f(1,2,7,8,ccc=10,der=5))
动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。
1 def func1(*args,**kwargs): # 函数的定义 * 聚合。
2 print(args)
3 print(kwargs)
4 l1 = [1,2,3,4]
5 l11 = (1,2,3,4)
6 l2 = ['alex','wusir',4]
7 func1(*l1,*l2,*l11) # 函数的执行：* 打散功能。
8 # func1(1,2,3,4,'alex','wusir',4,1,2,3,4) # 函数的执行：* 打散功能。
9
10 def func1(*args,**kwargs): # 函数的定义 * 聚合。
11 print(args)
12 print(kwargs)
13 dic1 = {'name1':'alex'}
14 dic2 = {'name2':'laonanhai'}
15 func1(**dic1,**dic2)
五、总结
# 函数
# 定义
# 关键字 def 函数名(形参):
# 参数 ：
# 位置参数
# *args 动态传参 ：接收在调用的时候传过来的多余的所有按位置传的参数
# 关键字参数 默认参数，如果不传会有一个默认的值，如果传了会覆盖默认的值
# **kwargs 动态传参 ：接收在调用的时候传过来的多余的所有按关键字传的参数
# 返回值
# return 停止一个程序的运行，返回参数
# 没有返回值 默认返回None
# 有一个返回值
# 返回多个值
# 调用
# 调用的关键字 函数名(实参)
# 传参数 ：
# 按照位置传
# 按照关键字传
# 接收返回值
# 没有返回值 不接受
# 有一个返回值 用一个变量接收
# 有多个返回值
# 用一个变量接收 所用返回值都会被组织成一个元组
# 用多个变量接收 有多少个返回值 就必须用多少个变量接收
# 函数是第一类对象的概念
# 函数名 --> 函数的内存地址
# 函数名可以作为 容器类型的元素 函数的参数、返回值 还能进行赋值 --> 变量
