函数
1. 如何使用函数
作用: 包裹一部分代码,实现某一个功能,达成某一个目的
特点: 可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
函数的基本格式
函数的定义:
def 函数名():
code1
code2
函数的调用:
函数名()
1. 定义函数
def func():
print("我是一个函数")
2. 调用函数
func()
3. 定义一个函数并且调用
# 函数的定义处
def func():
print("我是一个函数")
# 函数的调用处
func()
# 函数的定义处
def cfb_99():
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d " % (i,j,i*j),end="")
print()
# 函数的调用处
for i in range(10):
cfb_99()
4. 函数命名
字母数字下划线,开头不能是数字
严格区分大小写,不能使用关键字
函数命名有意义,不能使用中文名
5. 驼峰命名法
-
大驼峰命名法 : 每个单词的首字符大写 (类 : 面向对象)
mycar => MyCar mydesk => MyDesk
- 小驼峰命名法 : 除了第一个单词的首字符小写之外,剩下的每个单词首字符都大写
ycar => myCar mydesk => myDesk
- 其他方式
ycar => my_car mydesk => my_desk symmetric_difference
2. 函数的参数
参数:
1. 形参: 形式参数,在函数的定义处
2. 实参: 实际参数,在函数的调用处
形参: 普通形参(位置) , 默认形参 , 普通收集形参 , 命名关键字形参 , 关键字收集形参
实参: 普通实参 , 关键字实参
遵循原则:
形参和实参要一一对应
1. 普通形参
# 函数的定义处
"""hang , lie 是函数的普通形参"""
def s_star(hang,lie):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
"""10 , 10 是函数的实际参数"""
s_star(10,10)
s_star(3,8)
2. 默认形参
# 函数的定义处
"""hang , lie 身上有默认值,是默认形参"""
def s_star(hang=10,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
"""
在函数调用时:
如果给予实参,那么直接使用实际参数
如果没有给予实参,那么使用参数默认自带的值
"""
s_star()
s_star(3,8)
s_star(4)
3. 普通形参 + 默认形参
# 函数的定义处
"""默认形参必须跟在普通形参的身后,顺序是一定的"""
def s_star(hang,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
s_star(3,3)
s_star(3)
# s_star() error
4.关键字实参
"""关键字实参是对具体的某个参数赋值,具体的顺序可以打乱"""
# 函数的定义处
def s_star(hang,a,b,c,d,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
s_star(hang=4,a=1,b=2,c=3,d=4,lie=5)
s_star(c=3,d=4,lie=5,hang=4,a=1,b=2)
5. 普通实参 + 关键字实参
# 函数的定义处
def s_star(hang,a,b,c,d,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
# 函数的调用处
"""关键字实参必须跟在普通实参的身后,顺序是一定的"""
s_star(5,6,99,c=7,d=8,lie=9)
# s_star(c=7,d=8,lie=9,5,6,99) error
s_star(5,1,c=2,d=3,lie=10,b=5) # ok
# s_star(5,1,c=2,d=3,lie=10,a=5) error
# s_star(5,1,c=2,d=3,lie=10,,,,b=5) error
# s_star(5,1,c='',d='',lie=10,,,,b=5) error
6. 区分 默认形参 和 关键字实参
默认形参和关键字实参: 在写法上一模一样
一个是在函数的定义处
一个是在函数的调用处
# 函数的定义处
def lol31_gameteam(top="王盼盼",middle="吴洪昌",bottom="孙敬华",jungle="孙致和",support="周鹏飞"):
print("上单选手{}".format(top))
print("中单选手{}".format(middle))
print("下单选手{}".format(bottom))
print("打野选手{}".format(jungle))
print("辅助选手{}".format(support))
# 函数的调用处
lol31_gameteam()
lol31_gameteam(top="牧树人",middle="李亚",bottom="周鹏飞",jungle="温子越",support="孙敬华")
7. 收集参数
-
普通收集参数:
作用: 专门用来收集多余的没人要的普通实参
def func(*args):
code
*args => arguments(参数)
在args这个参数的前面加上一个*表达普通收集参数,形成一个元组
(1). 基本使用
def func(a,b,c,*args): print(a,b,c) print(args) # (4,5,5,6,7,8) func(1,2,3,4,5,5,6,7,8)(2). 计算任意个数的累加和
def func(*args): total = 0 for i in args: total += i print(total) func(1,2,3,4,6,10,11,100) -
关键字收集参数:
作用: 专门用来收集多余的没人要的关键字实参
def func(**kwargs):
code1…
**kwargs => keyword arguments
在kwargs参数的前面加上2个**表达关键字收集参数,形成一个字典
(1). 基本使用
def func(a=1,b=2,c=3,**kwargs): print(a,b,c) print(kwargs) # {'f': 1, 'g': 2, 'j': 3} func(f=1,g=2,j=3,a=10,b=20,c=30)(2). 任意个数字符串的拼接
""" 班长:宋云杰 班花:刘彩霞 班草:刘子涛 吃瓜群众:牧树人,晏国彰,刘聪 """ def func(**kwargs): print(kwargs) # 定义一个字典,存放每一位同学的身份 dic = {"monitor":"班长","class_flower":"班花","class_grass":"班草"} strvar1 = "" strvar2 = "" # 遍历字典中的键值对 for k,v in kwargs.item(): print(k,v) # monitor 宋云杰 class_flower 刘彩霞 class_grass 刘子涛 # 判断键是否在字典当中,如果在,获取对应的身份,拼装成字符串 if k in dic: strvar1 += dic[k] + ":" + v + "\n" # 班长 + ":" + 宋云杰 + "\n" else: strvar2 += v + "," # 去掉右边多余的 "\n" 和 "," , 形成最后的效果 print(strvar1.strip()) print("吃瓜群众:" + strvar2.rstrip(",")) func(monitor="宋云杰",class_flower="刘彩霞",class_grass="刘子涛",eatgua1="牧树人",eatgua2="晏国彰",eatgua3="刘聪")
8. 命名关键字参数
-
定义命名关键字参数的两种方式:
-
def func(a,b,*,c) c是命名关键字
-
def func(*args,c,**kwargs) c是命名关键字参数
在函数调用时,必须使用命名关键字参数来进行赋值
# 定义方式一 def func(a,b,*,c,d): print(a,b) print(c,d) func(1,2,c=3,d=4) # 定义方式二 def func(*args,c,**kwargs): print(args) print(c) print(kwargs) func(1,2,3,4,5,6,a=7,b=8,d=9,c=10)
-
-
关于 * 和 ** 的使用方法
* 和 ** 在函数的定义处,用来做收集操作,打包
* 和 ** 在函数的调用处,用来做打散操作,解包
def func(a,b,*,c,d): print(a,b) print(c,d) lst = [1,2] # * 把列表里面的所有元素拿出来,当成参数一个一个赋值给func进行调用 func(*lst,c=3,d=4) def func(a,b,*,c,d): print(a,b) print(c,d) dic = {"c":3,"d":4} # ** 把字典里面所有的元素拿出来,拼装成 键=值 的参数形式,赋值给func进行调用 func(1,2,**dic) # func( a=1 , b=2 , c=3 , d=4 ) # * 和 ** 的组合 func(*lst,**dic) strvar = "abcd" print(*strvar) -
参数定义的顺序:
普通参数 -> 默认参数 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
-
收集到所有实参的方法:
def func(*args,**kwargs)
-
总结练习
def f1(a, b, c=0, *args, **kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) def f2(a, b, c=0, *, d, **kw): print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw) """ 以上两个函数 打印结果 """ f1(1,2) # a=1,b=2,c=0,args=(),kw={} f1(1,2,c=3) # a=1,b=2,c=3,args=(),kw={} f1(1, 2, 3, 'a', 'b') # a=1,b=2,c=3,args=('a','b'),kw={} f1(1, 2, 3, 'a', 'b', x=99) # a=1,b=2,c=3,args=('a','b'),kw={"x":99} f2(1, 2, d=99, ext=None) # a=1,b=2,c=0,d=99,kw={"ext":None} args = (1, 2, 3, 4) kw = {'d': 99, 'x': '#'} f1(*args,**kw) # a=1,b=2,c=3,args=(4,),kw={"d":99,"x":"#"} """f1(1,2,3,4,d=99,x='#')""" myargs = (1,2,3) mykw = {'d': 88, 'x': '#'} f2(*myargs,**mykw) # a=1,b=2,c=3,d=88,kw={'x':'#'} """f2(1,2,3,d=88,x='#')""" def f1(a, b, c=0, *args,d,**kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) print(d) f1(1,2,3, 'a', 'b', d=67,x=99,y=77) # a=1,b=2,c=3,args=('a','b'),d=67,kw={'x':99,'y':77}
练习
练习1
定义函数:打印用户传入的容器类型数据长度
# 方法一
def func(container):
print(len(container))
func([1,2,3,4,5,6])
# 方法二
func = lambda contaner : len(contaner)
res = func([1,2,3,4,5,6])
print(res)
练习2
定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
# 方法一
def func(container):
i = 0
while i < len(container):
if i % 2 == 1:
print(container[i])
i+=1
func([1,2,3,4,5,6])
# 方法二
def func(container):
return container[1::2] # 1,3,5,7, ...
res = func([1,2,3,4,5,6])
print(res)
练习3
定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
def func(container):
return "_".join(container)
res = func(["a","b","c","d"])
print(res)
练习4
定义函数:接收任意个参数,打印其中的最小值
# 正常
def func(*args):
print(args)
lst = list(args)
lst.sort()
return lst[0]
res = func(1,-5,-3,99,-100)
print(res)
# 升级
def func(*args):
lst_new = []
print(args)
for i in args:
if isinstance(i,(int,float)):
lst_new.append(i)
elif isinstance(i,(list,tuple,set,dict)):
if isinstance(i,dict):
i = i.values()
# print(i.values())
for j in i:
if isinstance(j,(int,float)):
lst_new.append(j)
lst_new.sort()
return lst_new[0]
res = func(1,5,9.1,"你好",[1,19,100],(99,-7),{"a":1000,"b":3,"c":"abc"},{98,-10})
print(res)
练习5
定义函数:传入一个参数n，返回n的阶乘(5! = 54321)
def func(n):
total = 1
for i in range(n,0,-1):
total *= i
return total
res = func(6)
print(res)
练习6
写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
将容器中的每个元素依次添加到新的列表中返回
#例:传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
# 方法一
def func(*args):
lst = []
print(args)
for i in args:
for j in i:
lst.append(j)
return lst
res = func([1,2,3],(22,33))
print(res)
# 方法二
def func(*args):
print(args)
func(*[1,2,3],*(22,33))
# 将元组转成列表
def func(*args):
print(args)
return list(args)
res = func(*[1,2,3],*(22,33))
print(res)
练习7
写函数，用户传入要修改的文件名，与要修改的内容，执行函数，修改操作
# 方法一
def func(file,str1,str2):
# 打开文件读取所有内容
with open(file,mode="r+",encoding="utf-8") as fp:
strvar = fp.read()
print(strvar)
# 替换字符串
strvar = strvar.replace(str1,str2)
# 重新写入
with open(file,mode="w+",encoding="utf-8") as fp:
fp.write(strvar)
func("ceshi1","好的","坏的")
# 方法二
def func(file,str1,str2):
# 打开文件读取所有内容
with open(file,mode="r+",encoding="utf-8") as fp:
strvar = fp.read()
print(strvar)
# 替换字符串
strvar = strvar.replace(str1,str2)
# 把光标移动到开头
fp.seek(0)
# 没有参数等于没有截取,相当于清空
fp.truncate()
fp.write(strvar)
func("ceshi1","好的","坏的")
练习8
写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
# 方法一
def func(strvar):
# dic = {"num":0,"word":0,"space":0,"other":0}
dic = {}.fromkeys(["num","word","space","other"],0)
print(dic)
for i in strvar:
if i in "0123456789":
dic["num"] += 1
elif i in "abcdefghijklmnopqrstuvwxyz":
dic["word"] += 1
elif i == " ":
dic["space"] += 1
else:
dic["other"] += 1
return dic
strvar = "12345abcd$%^& 你好"
res = func(strvar)
print(res)
# 方法二
def func(strvar):
# dic = {"num":0,"word":0,"space":0,"other":0}
dic = {}.fromkeys(["num","word","space","other"],0)
print(dic)
for i in strvar:
if i.isdecimal():
dic["num"] += 1
# elif i.isalpha(): isalpha 可以在字节流模式下,分辨出中文(False)和英文(True)
elif i.encode().isalpha():
dic["word"] += 1
elif i.isspace():
dic["space"] += 1
else:
dic["other"] += 1
return dic
strvar = "12345abcd$%^& 你好"
res = func(strvar)
print(res)
练习9
写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，返回处理后的结果.
例:参数为:dic = {“k1”: “v1v1”, “k2”: [11,22,33,44]}
def func(dic):
for k,v in dic.items():
print(k,v)
if isinstance(v,(list,tuple,str)) and len(v) > 2:
dic[k] = v[:2]
return dic
dic = {"k1": "v1v1","k2": [11,22,33,44],"k3":123}
res = func(dic)
print(res)
练习10
传入多个一级容器类型数据,计算元素总个数
def func(*args):
total = 0
for i in args:
total += len(i)
return total
res = func([1,2,3],(3,4),{6,7,8},{"a":1,"b":2})
print(res)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
