一、 1.什么是函数？ 函数就是盛放代码的容器，把实现某一功能的一组代码丢到一个函数中就做成了一个小工具 2.为什么要用函数？ 没有用函数之前面临的问题 1，代码冗余，程序组织结构不清晰，可读性差 2，扩展性差 有了函数解决了类似的问题 3.如何用函数： 先定义，后调用 3.1如何定义函数？ 定义函数的语法： def+函数名（参数1，参数2，参数3，.......） """ 文档注释 建议写，解释说明 """ 代码1 代码2 代码3 return 返回值 如何调用函数： 函数名(1,2,3) #一 先定义、后调用 #def func(): #print("start...") #print("xxx") #print("stop...")

				#func()
				#func()
				#func()
				#二：函数在定义阶段发生的什么事情
				#定义函数不执行函数体代码，但是会检测函数体语法：语法错误会报错，定义的时候逻辑错误不会报
				#x = 100
				#print(x)
				#def func():  # func=函数的内存地址；定义函数名通常用动词
				#print("start...")
				#x
				#if True
				#print('ok')
				#print("xxx")
				#print("stop...")
				#print(func)
				#func()
				四 练习：
				#案例1
				#def foo():
				#print('from foo')
				#bar()                    #属于逻辑错误，不报错
				#foo()

				#案例2
				#def bar():            #定义后不报错了
				#print('from bar')
				#def foo():
				#print('from foo')
				#bar()
				#foo()

				#案例3
				#def foo():
				#print('from foo')
				#bar()                  #定义阶段只检测语法
				#def bar():
				#print('from bar')
				#foo()                  #调的时候已经定义完了




				函数的返回值
				#res = input('username>>: ')  # res = "egon"
				#print(res)

				#res = print("hello")
				#print(res)                                #print无返回值

				#l = [11,22,33]
				#res = l.pop()                           #pop取走有返回值
				#res = l.remove(11)                  #remove删掉没有返回值
				#print(res)

二、 1.如何控制自定义函数的返回值 ？ 用return控制函数的返回值 函数内可以有多个return，但只要执行一次，整个函数就立即结束，并且将return后的值分三类： 1、return 值：返回的就是该值本身 2、return 值1,值2,值3：返回的是一个元组 3、函数内可以没有return，或就一个return后没有值返回的是None

例子： #def max2(x,y): # #x = 3.3 #y = 5.5 #if x > y: #return x #else: #return y #print(res * 12) #函数调用者需要对结果做进一步后续处理需要有返回值 登陆认证功能 不需要返回值 该做的都做了

2.定义与调用函数的三种格式 2.1定义函数： 1.无参 #定义和调用都不用参数 #def func(): #print('=====') #print('hello') #print('=====') #func() 2.有参 #有无参数跟着需求走 #def max2(x,y): #if x > y: #print(x) #else: #print(y) #max2(10,11)

	#def login(user,pwd):       函数传的
	#def login():
	#user = input("u>>>: ")    用户传的
	#pwd = input("p>>>: ")
	#if user == 'egon' and pwd == '123':
	#print('ok')
	#else:
	#print('error')
	#login('egon','123')

	  3.空函数
	#def func():    #站位，统筹规划编程任务
	#pass
			# ...
2.2调用函数：
		# 2.1 语句形式
		    input(">>:")     #就是函数名+（）
				
#def login():
#user = input("u>>>: ")
#pwd = input("p>>>: ")
#if user == 'egon' and pwd == '123':
#print('ok')
#else:
#print('error')
#login()

#2.2 表达式形式
#res = input(">>: ")      #参与了赋值运算

#def max2(x,y):
#if x > y:
#return x
#else:
#return y
#sal = max2(30,40) * 12

#2.3 可以把函数调用当做参数传给另外一个函数
#def max2(x,y):
#if x > y:
#return x
#else:
#return y
#res = max2(max2(10,20),30)
#print(res)

三、 函数参数分为两大类：

#1、形参：在函数定义阶段括号内定义的变量名，称之为形式参数，简称形参 #2、实参：在函数调用阶段括号内传入的值，称之为实际参数，简称实参 定义阶段参数形参，调用阶段参数实参 #形参与实参的关系是： #在调用函数时，实参的值会绑定给形参名，然后可以在函数内使用，函数调用完毕后，解除绑定 #def func(x,y): #x=1 #y=2 #print(x+y) #m = 1 #n = 2 #func(m,n)

参数详解 #2.1 位置形参：：在函数定义阶段按照从左到右的顺序依次定义的形参，称之为位置形参 #特点：必须被传值，多一个不行少一个也不行 #def func(x,y): #print(x+y)

#func(1,2) #func(1,2,3) 多一个不行 #func(1,) 少一个也不行

#2.2 默认形参：在函数定义阶段就已经为某个形参赋值了，称之为默认形参 #特点：在函数定义阶段就已经赋值了，意味着在调用阶段可以不用为其赋值 （性别男多女少）

#ps: 可以混用位置形参与默认形参，但是位置形参必须在前 #def func(x,y=2): #print(x) #print(y)

#func(1,3) #func(1)

#def register(name,age,gender="male"): #print(name,age,gender) #register("李铁蛋",38) #register("王全蛋",19) #register("赵银蛋",28) #register("lili",18,"female") #各例单独传一下即可

#默认形参需要注意的问题是: #1、默认形参的值只在函数定义阶段被赋值一次 #2、默认形参的值通常应该是不可变类型 #案例1 #m = 100 #def func(x,y=m): # y -> 100的内存地址 #print(x,y) #m = 200 #func(1)

#案例2 #m = [11,22,] #def func(x,y=m): # y -> [11,22,]的内存地址 #print(x,y) #m = 200 #m.append(33) #func(1)

#def register(name,x,hobbies=None): # hobbies = []内地址 #if hobbies is None: #hobbies = [] #hobbies.append(x) #print("%s 的爱好是 %s" %(name,hobbies)) #register("egon",'read') #register("liu",'chou') #register("hxx",'tang')

#2.3 位置实参：在函数调用阶段按照从左到右的顺序依次传入的值，称之为位置实参 #特点：按照顺序与形参一一对应 #def func(x,y): #print(x) #print(y) #func(1,2) #func(2,1)

#2.4 关键字实参：在函数调用阶段按照key=value的格式传入的值，称之为关键字实参 #特点：可以打乱顺序，但是仍然能够为指定的形参赋值

#ps：可以混用位置实参与关键字实参，但是 #1、位置实参必须在关键字实参前 #2、不能为同一个形参重复赋值 #def func(x,y): #print(x) #print(y)

#func(y=2,x=1) #func(1,y=2) #func(y=2,1) #func(1,2,y=3)

2.5 *与**在形参与实参中的应用

可变长的参数：可变长指的是在函数调用阶段，实参的个数不固定,而实参是为形参赋值的，所以对应着必须要有一种特殊格式的形参能用来接收溢出的实参

  1. #形参中带*，*会接收溢出的位置实参，然后将其存成元组，然后赋值给紧跟其后的变量名 #def func(x,*args): # y=(2, 3, 4, 5, 6) #print(x) #print(args) #func(1,2,3,4,5,6)

#def my_sum(*args): #res = 0 #for num in args: #res += num #print(res)

#my_sum(1,2,3,4,5) #my_sum(1,2)

2.形参中带**：**会接收溢出的关键字实参，然后将其存成字典，然后赋值给紧跟其后的变量名

#def func(x,**kwargs): #y = {'a':1,'b':2,'c':3} #print(x) #print(kwargs)

#func(1,a=1,b=2,c=3) #func(1,2,3,a=1,b=2,c=3) # 报错

在形参中中带和**是一种汇总行为 在实参中带和**是一种打散行为

#实参中带*：*后跟的必须是一个可以被for循环遍历的类型，*会将实参打散成位置实参 #def func(x,y,z): #print(x) #print(y) #print(z)

#func([11,22,33]) # func(11,22,33) #func("hello") # func("h","e","l","l","o")

#实参中带**：**后跟的必须是一个字典，**会将实参打散成关键字实参 #def func(x,y,z): #print(x) #print(y) #print(z)

#func(**{"x":1,"y":2,"z":3}) # func(z=3,x=1,y=2)

def index(x,y,z): print(x,y,z)

def wrapper(*args,kwargs): # args = (1,2,3,4,5,6,7) kwargs={"a":1,"b":2,"c":3} # print(args) #print(kwargs) index(args,**kwargs) # index((1,2,3,4,5,6,7),{"a":1,"b":2,"c":3}) # index(1,2,3,4,5,6,7,a=1,b=2,c=3)

#wrapper(1,2,3,4,5,6,7,a=1,b=2,c=3) #wrapper(1,2,3) wrapper(1,z=3,y=2)