一.函数: 功能(包裹一部分代码 实现某一个功能 达成某一个目的)
(1)特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
函数基本格式
函数的定义:
def 函数名():
code1
code2
函数的调用:
函数名()
(2) 定义函数
1 def func():
2 print("我是一个函数")
(3)调用函数
1 func()
(4)函数命名
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦
(5)驼峰命名法:
(1) 大驼峰命名法:每个单词的首字符大写 (类:面向对象)
mycar => MyCar mydesk => MyDesk
(2) 小驼峰命名法:除了第一个单词的首字符小写之外,剩下每个单词首字符大写
mycar => myCar mydesk => myDesk
二.函数的参数 (参数:配合函数运算的值)
参数:(1)形参:形式参数,在函数的定义处
(2)实参:实际参数,在函数的调用处
形参:普通形参(位置) , 默认形参 , 普通收集形参 , 命名关键字形参 , 关键字收集形参
实参:普通实参,关键字实参
遵循原则:
形参和实参要一一对应
(1)普通形参
函数的定义处
&hang,lie是函数的普通形参
1 def s_star(hang,lie):
2 i = 0
3 while i < hang:
4 j = 0
5 while j < lie:
6 print("*",end="")
7 j+=1
8 print()
9 i+=1
函数的调用处
10,10 是函数的实际参数
1 s_star(10,10)
(2)默认形参
函数的定义处
&hang,lie身上有默认值,是默认形参
1 def s_star(hang=10,lie=10): 2 i = 0 3 while i < hang: 4 j = 0 5 while j < lie: 6 print("*",end="") 7 j+=1 8 print() 9 i+=1
函数的调用处
在函数调用时:
如果给予实参,那么直接使用实际参数
如果没有给予实参,那么使用参数默认自带的值
1 s_star()
2 s_star(3,8)
3 s_star(4)
(3)普通形参 + 默认形参
函数的定义处
默认形参必须跟在普通形参的身后,顺序是一定的
1 def s_star(hang,lie=10):
2 i = 0
3 while i < hang:
4 j = 0
5 while j < lie:
6 print("*",end="")
7 j+=1
8 print()
9 i+=1
函数的调用处
1 s_star(3,3)
2 s_star(3)
(4)关键字实参
关键字实参是对具体的某个参数赋值,具体的顺序可以打乱
函数的定义处
1 def s_star(hang,a,b,c,d,lie=10): 2 i = 0 3 while i < hang: 4 j = 0 5 while j < lie: 6 print("*",end="") 7 j+=1 8 print() 9 i+=1
函数的调用处
1 s_star(hang=4,a=1,b=2,c=3,d=4,lie=5)
2 s_star(c=3,d=4,lie=5,hang=4,a=1,b=2)
(5)普通实参 + 关键字实参
1 def s_star(hang,a,b,c,d,lie=10):
2 i = 0
3 while i < hang:
4 j = 0
5 while j < lie:
6 print("*",end="")
7 j+=1
8 print()
9 i+=1
函数的调用处
关键字实参必须跟在普通实参的身后,顺序是一定的
1 s_star(5,6,99,c=7,d=8,lie=9)
2 s_star(5,1,c=2,d=3,lie=10,b=5)
3 s_star(c=7,d=8,lie=9,5,6,99) error
4 s_star(5,1,c=2,d=3,lie=10,a=5) error
区分 默认形参 和 关键字实参
默认参数和关键字实参 在写法上一模一样
一个是在函数的定义处
一个是在函数的调用处
三.收集参数
收集参数:
(1)普通收集参数: 专门用来收集多余的没人要的普通实参
def func(*args):
code
*args => arguments(参数)
在args这个参数的前面加上一个*表达普通收集参数,形成一个元组
<1>基本使用
1 def func(a,b,c,*args):
2 print(a,b,c)
3 print(args) # (4,5,5,6,7,8)
4 func(1,2,3,4,5,5,6,7,8)
<2>计算任意个数的累加和
1 def func(*args):
2 total = 0
3 for i in args:
4 total += i
5 print(total)
6 func(1,2,3,4,6,10,11,100)
(2)关键字收集参数 : 专门用来收集多余的没人要的关键字实参
def func(**kwargs):
code1...
**kwargs => keyword arguments
在kwargs参数的前面加上2个**表达关键字收集参数,形成一个字典
<1>基本使用
1 def func(a=1,b=2,c=3,**kwargs):
2 print(a,b,c)
3 print(kwargs) # {'f': 1, 'g': 2, 'j': 3}
4
5 func(f=1,g=2,j=3,a=15,b=16,c=17)
<2>任意个数字符串的拼接
1 def func(**kwargs):
2 print(kwargs)
3 # 定义一个字典,存放每一位同学的身份
4 dic = {"monitor":"班长","class_flower":"班花","class_grass":"班草"}
5 strvar1 = ""
6 strvar2 = ""
7 # 遍历字典中的键值对
8 for k,v in kwargs.items():
9 print(k,v) # monitor a class_flower b class_grass c ....
10 # 判断键是否在字典当中,如果在,获取对应的身份,拼装成字符串
11 if k in dic:
12 strvar1 += dic[k] + ":" + v + "\n" # 班长 + ":" + a + '\n'
13 else:
14 strvar2 += v + ","
15 # 去掉右边多余的\n和,形成最后的效果
16 print(strvar1.strip())
17 print("吃瓜群众:"+ strvar2.rstrip(","))
18 func(monitor="a",class_flower="b",class_grass="c",eatgua1="e",eatgua2="f,eatgua3="h)
(3)命名关键字参数
定义命名关键字参数的两种方式:
(1)def func(a,b,*,c) c是命名关键字
(2)def func(*args,c,**kwargs) c是命名关键字参数
在函数调用时,必须使用命名关键字参数来进行赋值
<1>定义方式一
1 def func(a,b,*,d,c):
2 print(a,b)
3 print(d)
4 print(c)
5 func(1,2,d = 3,c=10)
<2>定义方式二
1 def func(*args,c,**kwargs):
2 print(args)
3 print(c)
4 print(kwargs)
5
6 func(1,2,3,4,5,6,a=1,b=2,d=6,c=100)
(4)关于* 和 ** 的使用方法
* 和 ** 在函数的定义处,用来做收集操作,打包
* 和 ** 在函数的调用处,用来做打散操作,解包
1 def func(a,b,*,c,d):
2 print(a,b)
3 print(c,d)
4 lst = [1,2]
5 # *把列表里面的所有元素拿出来,当成参数一个一个赋值给func进行调用
6 func(*lst,c=3,d=4)
7
8 def func(a,b,*,c,d):
9 print(a,b)
10 print(c,d)
11 dic = {"c":3,"d":4}
12 # **把字典里面的所有元素拿出来,拼装成键=值的参数形式,赋值给func进行调用
13 func(1,2,**dic,) # func( c=3, d=4 )
当所有参数都在一起的时候,按照以下顺序定义
参数定义的顺序:普通参数 -> 默认参数 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
收集到所有的实参: def func(*args,**kwargs)