day10.函数基础及函数参数
一、函数
功能：包裹一部分代码 实现某一个功能 达成某一个目的
特点：
"""
特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
函数基本格式
函数的定义:
def 函数名():
code1
code2 函数的调用:
函数名()
"""
1、函数定义：
# 定义函数
def func():
print("我是一个函数")
2、函数调用
func()
3、函数命名
"""
函数命名
字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦 """
"""
驼峰命名法:
(1) 大驼峰命名法:每个单词的首字符大写 (类:面向对象)
mycar => MyCar mydesk => MyDesk
(2) 小驼峰命名法:除了第一个单词的首字符小写之外,剩下每个单词首字符大写
mycar => myCar mydesk => myDesk
mycar => my_car mydesk => my_desk
symmetric_difference
"""
例：
# 函数的定义处
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()
二、函数的参数
"""
参数:
(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) s_star(5,1,c='',d='',lie=10,,,,b=5)
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="孙敬华")
"""
默认参数和关键字实参 在写法上一模一样
一个是在函数的定义处
一个是在函数的调用处
"""
三、收集参数
"""
收集参数:
(1)普通收集参数: 专门用来收集多余的没人要的普通实参
def func(*args):
code
*args => arguments(参数)
在args这个参数的前面加上一个*表达普通收集参数,形成一个元组
"""
基本使用：
# 基本使用
def func(a,b,c,*args):
print(a,b,c)
print(args) # (1,2,3,4,5,5,6,7,8) func(1,2,3,4,5,5,6,7,8) # 计算任意个数的累加和
def func(*args):
total = 0
for i in args:
total += i print(total) func(1,2,3,4,6,10,11,100)
"""
(2)关键字收集参数 : 专门用来收集多余的没人要的关键字实参
def func(**kwargs):
code1...
**kwargs => keyword arguments
在kwargs参数的前面加上2个**表达关键字收集参数,形成一个字典
"""
基本使用：
# 基本使用
"""
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=15,b=16,c=17)
"""
例：
任意个数字符串的拼接
def func(**kwargs):
print(kwargs)
# 定义一个字典,存放每一位同学的身份
dic = {"monitor":"班长","class_flower":"班花","class_grass":"班草"}
strvar1 = ""
strvar2 = "" # 遍历字典中的键值对
for k,v in kwargs.items():
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="刘聪")
四、命名关键字参数
"""
定义命名关键字参数的两种方式:
(1)def func(a,b,*,c) c是命名关键字
(2)def func(*args,c,**kwargs) c是命名关键字参数
在函数调用时,必须使用命名关键字参数来进行赋值
"""
定义方式一、
# 定义方式一
def func(a,b,*,d,c):
print(a,b)
print(d)
print(c) func(1,2,d = 3,c=10)
定义方式二、
def func(*args,c,**kwargs):
print(args)
print(c)
print(kwargs) func(1,2,3,4,5,6,a=1,b=2,d=6,c=100)
1、关于* 和 ** 的使用方法
关于 *
"""
* 和 ** 在函数的定义处,用来做收集操作,打包
* 和 ** 在函数的调用处,用来做打散操作,解包
""" 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( c=3, d=4 )
组合
# *和**的组合
func(*lst,**dic)
strvar = "abc"
print(*strvar)
2、参数定义顺序
# ### 当所有参数都在一起的时候,按照什么顺序定义呢?
# 参数定义的顺序:普通参数 -> 默认参数 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
# 收集到所有的实参: 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,{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),kw={x:99,y:77} d:67
五、return 返回值
"""
自定义函数的返回值,return 可以把值返回到函数的调用处
(1) return + 六大标准数据类型 , 还有类和对象,函数
如果不定义return , 默认返回的是None (2) 在执行完return之后,立刻终止函数,后面的代码不执行
"""
1、return的返回类型
def func():
# return 1
# return 3.14
# return "abc"
# return []
# return ()
# return {"a":1}
pass
res = func()
# 如果不定义return , 默认返回的是None
print(res) # None
2.在执行完return之后,立刻终止函数,后面的代码不执行
def func():
print(1)
print(2)
return 3
print(4)
print(5) res = func()
print(res) def func():
for i in range(3):
if i == 2:
return 1
print(i)
res = func()
print(res)
3、模拟简单的计算器 + - * /
def func(sign,num1,num2):
if sign == "+":
res = num1 + num2
elif sign =="-":
res = num1 - num2
elif sign == "*":
res = num1 * num2
elif sign == "/":
if num2 == 0:
return "除数不能为0 , 脑弟!"
res = num1 / num2
else:
return "这个本计算器真算不了" return res res = func("+",3,5)
res = func("-",10,20)
res = func("*",10,20)
res = func("/",20,10)
res = func("/",20,0)
res = func("&",20,0)
print(res)
六、练习
'''
1.定义函数:打印用户传入的容器类型数据长度
2.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
3.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
4.定义函数:接收任意个参数,打印其中的最小值
5.定义函数:传入一个参数n，返回n的阶乘(5! = 5*4*3*2*1)
6.写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
将容器中的每个元素依次添加到新的列表中返回
#例:传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
7.写函数，用户传入要修改的文件名，与要修改的内容，执行函数，修改操作
8.写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
9.写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，返回处理后的结果.
#例:参数为:dic = {"k1": "v1v1", "k2": [11,22,33,44]}
10.传入多个一级容器类型数据,计算元素总个数
'''
# 1.定义函数:打印用户传入的容器类型数据长度
def func(container):
len(container) func = lambda contaner : len(contaner)
res = func([1,2,3,45])
print(res)
1
# 2.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
def func(container):
i = 0
while i<len(container):
if i % 2 == 1:
print(container[i])
i+=1
func([1,2,3,43,5,5]) # 方法二
def func(container):
return container[1::2] # 1,3,5,7, ...
res = func([1,2,3,43,5,5])
print(res)
2
# 3.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
def func(container):
return "_".join(container)
func(["","","",""])
print(res) def func(container):
strvar = ""
for i in container:
strvar += str(i) + "_" return strvar.rstrip("_") res = func([1,2,5,7])
print(res)
3
# 4.定义函数:接收任意个参数,打印其中的最小值 # 正常
def func(*args):
# print(args)
lst = list(args)
lst.sort()
return lst[0] res = func(1,5,9,-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,dict,set)):
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)
4
# 5.定义函数:传入一个参数n，返回n的阶乘(5! = 5*4*3*2*1)
def func(n):
total = 1
for i in range(n,0,-1):
total *= i
return total
res = func(6)
print(res)
5
# 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)
return list(args)
func(*[1,2,3],*(22,33))
6
# 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("ceshi.txt","好的","坏的") def func(file,str1,str2):
with open(file,mode="r+",encoding="utf-8") as fp:
strvar = fp.read()
strvar = strvar.replace(str1,str2)
# 把光标移动到开头
fp.seek(0)
# 没有参数等于没有截取,相当于清空
fp.truncate()
fp.write(strvar)
func("ceshi.txt","坏的","好的")
7
# 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 "":
dic["num"] += 1
elif i.lower() in "abcdefghijklmnopqrstuvwxyz":
dic["word"] += 1
elif i == " ":
dic["space"] += 1
else:
dic["other"] += 1 return dic strvar = "234JKJK^&* "
res = func(strvar)
print(res) def func(strvar):
# dic = {"num":0,"word":0,"space":0,"other":0}
dic = {}.fromkeys(["num","word","space","other"] ,0 )
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 = "234JKJK^&* 你好"
res = func(strvar)
print(res)
8
# 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,(str,list,tuple)) 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)
9
day10.函数基础及函数参数的更多相关文章
- 【2017-03-05】函数基础、函数四种结构、ref和out参数、递归
一.函数基础 1.函数/方法:非常抽象独立完成某项功能的一个个体 2.函数的作用: 提高代码的重用性提高功能开发的效率提高程序代码的可维护性 3.分类 固定功能函数高度抽象函数 4.函数四要素:输入, ...
- Python函数基础和函数参数
函数的定义和函数的调用 return的作用 三种参数的定义 常用的内置函数 len() 函数基础 函数的定义 def 函数名(参数): pass return 表达式 pass在这里表示什么都没有,不 ...
- python函数基础以及函数参数简解
python中函数分为函数.内置函数Python所有的内置函数 自定义函数要使用def语句,依次写出函数名.括号.括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回. ...
- 潭州课堂25班：Ph201805201 第八课：函数基础和函数参数 (课堂笔记)
1, 函数定义 def fun(): print('测试函数') fun() #调用函数 return 运行函数返回值 def fun(): name = [1,3,4,5] return name[ ...
- Python 入门基础10 --函数基础3 函数对象、名称空间、装饰器
今日内容 1.函数对象 2.名称空间与作用域 3.函数的嵌套调用与闭包 4.装饰器 一.函数对象 1.1 定义 函数名存放的就是函数地址,所以函数名也就是对象,称之为函数对象 1.2 函数对象的应用 ...
- python函数基础（函数的定义和调用）
函数的定义 python定义函数使用def关键字 return[表达式]语句用于退出函数,选择性的向调用方返回一个表达式,不带参数值的return语句返回none def 函数名(参数列表): 函数体 ...
- python 新手函数基础（函数定义调用值传递等）
1.编程的集中主要方式: 面向过程 >类 >>关键字class 面向函数>函数 >> 关键字def 面向过程> 过程 >> 关键字def 2.py ...
- python基础知识06-函数基础和函数参数
函数基础和函数参数 可迭代对象:序列类型 range . 1.函数的定义 def 函数名(参数): pass return 表达式 ,不能是赋值语句.不写默认返回None.用逗号隔开返回一个元组. 函 ...
- PHP基础入门（三）---PHP函数基础
PHP基础入门(三)---函数 今天来给大家分享一下PHP的函数基础.有了前两章的了解,想必大家对PHP有了一定的基础了解.想回顾前两章的朋友可以点击"PHP基础入门(一)"&qu ...
随机推荐
- 基于图嵌入的高斯混合变分自编码器的深度聚类(Deep Clustering by Gaussian Mixture Variational Autoencoders with Graph Embedding, DGG)
基于图嵌入的高斯混合变分自编码器的深度聚类 Deep Clustering by Gaussian Mixture Variational Autoencoders with Graph Embedd ...
- SQLserver , MySQL的区别和各自的一些简单方法案列
SQL Server数据库和MySQL数据库有什么区别呢?今天我们来分析一下这两种数据库的不同之处以及这两种数据库的一些简单用途:SQL Server数据库和MySQL数据库有什么区别: 对于程序开发 ...
- scrapy 基础组件专题（三）：爬虫中间件
一.爬虫中间件简介 图 1-1 图 1-2 开始这一张之前需要先梳理一下这张图, 需要明白下载器中间件和爬虫中间件所在的位置 下载器中间件是在引擎(ENGINE)将请求推送给下载器(DOWNLOADE ...
- Mysql and ORM
本节内容 数据库介绍 mysql 数据库安装使用 mysql管理 mysql 数据类型 常用mysql命令 创建数据库 外键 增删改查表 权限 事务 索引 python 操作mysql ORM sql ...
- Windows分页文件设置不当导致SQL Server服务被终止
Windows分页文件设置不当导致SQL Server服务被终止 文章说明 在正式开始验证和测试之前,先介绍Windows分页文件和SQL Server的动态内存管理.下面测试将分为两种测试场景:场景 ...
- 用前端姿势玩docker【一】Docker通俗理解常用功能汇总与操作埋坑
前言 首先一句话表达个人对docker的理解:与传统虚拟技术基于硬件及物理资源的虚拟化相比,Docker更加轻量化,docker为基于操作系统或内核级别的虚拟化,并且提供了从各种机制与操作以满足从开发 ...
- 【NET开发】图片处理类-仿照七牛云图片处理功能
介绍 Sop.Common.Img **请看 七牛云的图片处理功能介绍文档了解本项目功能 ** 此项目是有https://github.com/Sopcce/.Net-Common-Utility中的 ...
- @RequestMapping中的produces的作用和使用方式
转发:原博客 1.他的作用是指定返回值类型和返回值编码 2.consumes: 指定处理请求的提交内容类型(Content-Type),例如application/json, text/html; 一 ...
- 题解 SP1812 【LCS2 - Longest Common Substring II 】
对于本题这样的多字符串的子串匹配问题,其实用广义后缀自动机就可以很好的解决,感觉会比普通的后缀自动机做法方便一些. 首先记录出每个节点被多少个字符串更新,也就是记录每个节点有多少个字符串能到达它,可以 ...
- 定长比较环状字符串-------strcat与strncpy的妙用
题目链接:https://vjudge.net/problem/UVA-1584 题解:用strcpy与strcmp定长比较字符串即可,strcat与strcmp对string不适用,所以只能改写为c ...