#20200927 函数
# 函数的概念：将一段程序封装起来，当需要使用时进行调用
#def 函数名(形参)： 注意：1、参数个数随意，2、后面跟冒号1
# def sumdata(a,b): #这是形式参数，简称形参
# print(a+b) #函数内部语句，必须缩进
#sumdata(6,6) #这是实际参数，简称实参
#这个函数是最基础的，因为没有返回值
#print(sumdata(6,5)) #这里打印函数的返回值，返回的是none，表示没有返回值。怎样才能有返回值呢？
# def sumdata(a,b):
# print(a+b) #因为这个print语句在函数里面，所以执行函数的时候会把它打印出来，但是这个不是返回值
# return a+b #这个才是返回值。函数的返回值用return表示。一个函数如果没有返回值，或者return后面没有数据，函数的返回值就是None
# print(sumdata(6,6)) #这里有返回值了 ，返回的12
#思考图：函数中可以有多个return吗？
#可以！！！分支语句！！！eg:写一个函数可以返回某数的绝对值
# def jueduizhi(number):
# if number>=0:
# return number
# else:
# return -number
# print(jueduizhi(-5)) #有了返回值得打印出来才能看到
#在同一个分支里可以有多个return吗？ 可以！！！elif!!! 但是只有第一个语句可以执行，后面的叫不可达语句
# def sumdate(a,b):
# return a+b
# return a*b #可以有多个return，但是不会被执行
# print('lalal') #不只是return不会被执行，所有语句都不会被执行
# print(sumdate(1,2))
#思考：return可以有多个值吗？？可以的！多个值会已元组房形式出现
# def sumdate(a,b):
# return a+b,a*b,a**6
#这里如果是return [a+b,a*b,a**6] ,返回的就是一个列表，为什么？因为这个对于return来说就只是一个值，一个列表也只是一个值
#这里如果是return (a+b,a*b,a**6),可以理解为也是一个值，这个值是元组，有多个元素的元组
# q=sumdate(2,3) #可以给函数自定义命名
# print(q) #打印的时候打印名字就行了
# print(sumdate(2,3)) #查看类型可以用type()函数print(type(sumdate(2,3)))
#参数的默认值/缺省值
# def sumdate(a=6,b=9):
# return a+b
# print(sumdate()) #这里因为在定义函数的时候就设置了缺省值，所以打印的时候没有传实参，也可以有结果15，
# print(sumdate(2,6)) #也可以直接传参，这样就用的是当前传的参数
# print(sumdate(a=2,b=6))
# print(sumdate(2,b=6))
#print(sumdate(a=2,6)) #以上写法都者却，只有前全后不全写会报错
#对于普通的参数而言（当没有缺省值时），形参和实参的数量得一致，不能多也不能少。当有缺省值时，可以少传，但是不能多传
#可变长度参数*args
# def fu(a,*args): #定义一个函数，两个参数，第二个参数是可变长度参数
# #return a,args #这样子会多一层元组
# return a,*args #这样子不会多一层元组，都是平级的
# #print(fu(12)) #当只传一个值时，打印结果是：(12, ())，后面多了一个元组
# print(fu(12,11,10)) #当传值大于等于2个时，会把第一个之后的只都放到元组里面去
#按住Ctrl键点击函数名可以查看内置函数缺省值，比如：def print(self, *args, sep=' ', end='
', file=None):
# print(10,20,30,sep='a') #sep缺省值是空格，传参a,结果是10a20a30
# print(10,20,30,end='eee') #10 20 30eee5 6 7
# print(5,6,7)
#关键字参数 **kwargs
# def fun2(a,*args,**kwargs): #书写顺序，必须是普通参数>可变长度参数>关键字参数
# return a,kwargs
# print(fun2(100,aa=99123456.
# ,bb=98,cc=97))
# --心田老师录播课笔记：函数：
# 本节课大纲:
'''
# 1--函数的定义与调用 ---基本操作
# 2--函数的参数与返回值
# 3--内置函数
规则:函数一定要先定义后调用,否则会报错
'''
# 变量:给一个对象取一个名字,方便后续的调用与维护
# 需求:在实际工作中,一些步骤重复使用,就可以做一个函数来替代这些步骤,提高工作效率,从而引入函数的概念, 函数概念:
#1-函数的定义与调用-定义:定义函数不会执行函数里面的代码
# def test():#最简单的定义函数,test函数名课自己定义
# # 多行代码往后缩进怎么破?TAB键,往前缩进,用shift+tab
# print('书山')
# # print('书山有路勤为径') #只打印了书山有路勤为径,函数里的书山未打印出来,说明定义函数不会执行函数里面的代码
#2-函数调用--要调用才会执行函数里面的代码
# test() #现在才执行了代码,打印得:书山
#3-函数的参数:
'''
1- 形参--一般是函数定义时候的参数 比如a,b
1- 必填形参,就是一个变量名函数调用的时候一定得传递,个数一致
2- 缺省参数,可传可不传,传的话就用实际传的值,不传就用缺省值,这个参数是在定义函数的时候加的,如:def first(a=3,b=3),后续调用的时候如果有重新给ab复制就用最新定义的,没有复制就用缺省值
用途:考虑到用户使用习惯,减少参数的输入
3- 可变数量参数,叫不定长参数 test(a,*a)
4- 关键字参数,也是可变数量参数,在定义函数的时候,是两个*键,,写作: **变量名 # 会把**变量名封装成一个字典;调用该函数的时候,一定是变量=值
2- 实参
'''
# def test():
# print(3+1)
# return test #注释掉下面哪行,打印返回值,没有返回值,这个函数是低级函数
# test() #打印得4,但是这种函数很不好,不能自己决定参数改变值,只能有一个结果,换个说法,没有返回值
# 1- 必填参数
# def test(a,b):
# print (a+b)
# return test
# # test() #调用的时候没有传参数,报错了TypeError: test() missing 2 required positional arguments: 'a' and 'b',这是必填形参
# test(3,3) #顺序传递 #调用的时候直接在函数空号内定义实参,可直接得到函数的返回值
# test(a=9,b=2) #指定参数传递
# test(10,b=20) #指定
##错误示范:test(a=10,20) 如果函数调用的时候出现了变量=值的写法,后续的变量也必须是变量=值的写法.保持队形
# def test(a,b,c):
# print (a+b-c)
# return test
# test(a=10,b=20,c=5) #参数增多,没有保持队形,也会报错:SyntaxError: positional argument follows keyword argument
# 2- 缺省参数
# def first(a=3,b=3):
# print(a+b)
# return
# first() #不传值就用缺省值:打印得6
# first(6,6) #传值就用实际传的值:打印得12
# 3- 可变数量参数
# * 自己封装成元组
# def test(a,*args): #a是必填参数,后面的args是可变数量参数,可写可不写
# print (a,args)
# test(1) #打印得:1 () ,
# test(1,2,3,'是') #打印得:1 (2, 3, '是') ,后面的参数都装在元组里面的,长度没有限制
# test(1,[10,20,30]) #打印得:1 ([10, 20, 30],),如果传的是列表,也是只有两个元素,列表和其他一起装在元组里面
# test(1,*[10,20,30])#打印得:1 (10, 20, 30),,拆包,把列表拆掉
# test(1,(10,20,30)) #打印得:1 ((10, 20, 30),)试试元组能不能被拆掉
# test(1,*(10,20,30)) #打印得:1 (10, 20, 30),,,元组也能被拆掉
# 4- 关键字参数
# 在定义函数的时候,是两个*键,,写作: **变量名 # 会把**变量名封装成一个字典,同理.**也可以拆字典
# 在调用该函数的时候,一定是变量=值
# def test(a,**kwargs):
# print(a,kwargs)
# test(1,name="Tom",age=23) #打印得:1 {'name': 'Tom'} 因为调用的时候必须是:变量=值,所以调用的时候写name变量="Tom"这个值,才会封装成字典的形式
# **如何用**拆字典?
# test1={"name":"Tom","age":"23"}
# print(test1)
# test(**testq)这串代码有问题,一哈哈再找原因
# 找到原因的,需要字典1(**字典2),会把字典2拆包成字典一的内容,类型是<class 'NoneType'>
# def test1(**kea): #kea系统自动装包成字典
# print(kea)
# #调用
# test1() #打印得:{},是一个空字典
# test1(a=1,b=2,c=3) #使用关键字的key来进行赋值,打印得:{'a': 1, 'b': 2, 'c': 3}
# test1(a=1) #打印得:{'a': 1}
# test2={'age':23,'name':'tom'} #再定义一个字典,然后用字典{**{字典}}就可以吧里面那个字典进行拆包了
# print(type(test2)) #类型是:<class 'dict'>
# test1(**test2) #打印得:{'age': 23, 'name': 'tom'}将字典拆包成关键字形式
# print(type(test1(**test2))) #类型是:<class 'N
# 5- 返回值:函数执行完成后返回一个值,就叫返回值
'''
情形1:
a同事:编写一个求和函数
b同事:需要调用a同事的函数的求和结果,再加上5
知识点:
1- 函数的return是一个函数的结束,
2- 如果return后面跟一个值,接受到的值就是该类型
3- 如果return后面跟多个值,接受到的值一定是元组
4- 如果一个函数的返回值是None,说明该函数没有返回值
'''
# a同事:编写一个求和函数
# def get_sum(a,b):
# # print(a+b) #这一行要注释掉,因为不想这个值传到控制台
# return (a+b) #用return把这个值返回来,返给谁,看谁要接这个值
# # b同事:需要调用a同事的函数做二次计算
# get_sum(1,2) #如果没有return,,打印得3,这个3在控制台,无法取出来做计算.但是b同事不想要它打印出来,b同事只想拿到这个值号做运算,所以需要把这个值return出来
#上面的函数调用需要注意一点,注释掉print(),只有return的时候这样调用函数没有值的,因为值已经被返回出去了
# res=get_sum(1,2)
# print(res+5) #res打印得3,再+5打印得8
# 知识点举例:
# def get_sum(a,b):
# return(a+b)
# print(type(get_sum(1,2))) #如果return后面跟一个值,接受到的值就是该类型,得3,<class 'int'>
# def get_sum(a,b):
# return(a+b),10,'lalala'
# print(get_sum(1,2)) #如果return后面跟多个值,接受到的值一定是元组,打印得:(3, 10, 'lalala'),<class 'tuple'>
# def get_sum(a,b):
# pass
# print(get_sum(1,3)) #如果一个函数的返回值是None,说明该函数没有返回值
# def get_sum(a,b): #函数比较复杂的时候,在该函数下换行,打出三引号'''''',然后再中间敲回车就可以查看反函数的注释了,实例:
# '''
#
# :param a:
# :param b:
# :return:
# '''
#查看函数的说明.print(函数名._doc_),示例:
# def get_sum(a,b):
# return (a+b)
# print(get_sum(1,2))
# print(get_sum.) #这里不对,
# 什么叫内置函数
# Python中有很多内置函数,不需要调用直接可以用,如:print,len,max
# 类型相关的函数:str,int,list,tuple 这些是强制转换的时候需要用到