一.函数：
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。
但你也可以自己创建函数，这被叫做用户自定义函数。
定义函数规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
函数定义示例：
1 def 函数名(参数1,参数2):
2 '''
3 这是一个解决什么问题的函数
4 :param 参数1: 参数1代表输入什么
5 :param 参数2: 参数2代表输入什么
6 :return: 返回什么东西
7 '''
8 函数体
9 返回值
10 return 返回值
例如定义计算字符串长度的函数：
1 def my_len(my_str): #定义函数
2 '''
3 用于计算可变类型长度的函数
4 :param my_str: 用户输入的参数内容
5 :return:返回参数的长度
6 '''
7 count = 0
8 for val in my_str:
9 count += 1
10 return count
11 a = my_len("hightgood")
12 print(a) #输出值9
定义一个函数后，尽量不要用print,尽量return结果
自己是可以知道函数代码内部打印的是啥，自己可以随时修改，但是别人不知道
函数中的return：
1.返回None
有三种情况：
（1）无return的情况
（2）本来就return None
（3）return #return空白
#无return
def my_print(parameter):
print("Welcome",parameter)
#return None
def my_print(parameter):
return None
#return
def my_print(parameter):
return #一般用于结束函数体
2.返回一个值
1 def my_len(my_str): #定义函数
2 #计算可变类型值的长度
3 my_str = "goodnight"
4 count = 0
5 for val in my_str:
6 count += 1
7 return count #count就是那个返回值
3.返回多个值
1 def my_print():
2 return 11,22,33,[1,2,3]
3 a = my_print()
4 print(a)
5 #打印结果：(11, 22, 33, [1, 2, 3])
return后面的值用逗号隔开，然后以元组的形式返回
4.结束函数代码
1 def my_print():
2 print('one')
3 return #遇到return不继续函数下面的代码
4 print('two')
5 my_print() #结果：one
5.补充：接收多个值
1 def my_print():
2 return 1,2,3
3 a,b,c=my_print()
4 print(a,b,c) #相当于用a接收1，b接收2，c接收3
5 def my_print():
6 return [4,5,6]
7 a,b,c=my_print()
8 print(a,b,c) #一个列表里有三个值，分别用abc去接收，相当于解包
函数的参数：
1 def my_len(my_str): #这里的my_str就是形参，形式参数，输入对象不确定，形参可以有多个，用逗号隔开
2 my_str = "goodnight"
3 count = 0
4 for val in my_str:
5 count += 1
6 return count
7 a = my_len("hightgood") #这里的hightgood就是实参，实际参数，输入对象确定
8 print(a)
函数参数详解：
1.位置参数：
1 def demo_1(a,b): #位置参数 用户必须传入的参数，不传会报错
2 print(a,b)
3 demo_1(1,2) #输出结果：1 2 按照位置传参
4 demo_1(b=1,a=2) #输出结果：2 1 按照关键字传参
5 demo_1(1,b=2) #输出结果：1 2 混用，但必须注意先按照位置传参，再按照关键字传参，不然会报错
2.默认参数：
1 def welcome(name,sex='man'): #sex为默认参数
2 print('welcome %s,sex %s'%(name,sex))
3 welcome('zrh') #输出结果：welcome zrh,sex man
4 welcome('lml','women') #输出结果：welcome lml,sex women
5 #默认参数如果不传参数，就用默认值，如果默认参数传入参数，就用传入值
默认参数的陷阱：
（1）
1 a = 18
2 def age(a1,a2=a):
3 print(a1,a2)
4 a = 20
5 age(10) #输出结果：10 18
内部原理：
（2）
专门针对可变数据类型
1 def demo(a = []):
2 a.append(1)
3 print(a)
4 demo() #输出结果：[1]
5 demo() #输出结果：[1] [1]
6 demo() #输出结果：[1] [1] [1]
7 def demo_1(a = []):
8 a.append(1)
9 print(a)
10 demo_1([]) #输出结果：[1]
11 demo_1([]) #输出结果：[1]
12 demo_1([]) #输出结果：[1]
因为可变类型改变不是在内存中开辟一个新空间，而是在原来的基础上做修改，而10--12行是开辟了三块新内存
3.动态参数：
定义动态参数
1 def demo(*agrs): #按位置输入的动态参数，组成一个元组
2 pass
3 def demo_1(**kwargs): #按关键字传入的参数，组成一个字典
4 pass
站在函数定义的角度：*做聚合作用，将一个一个的参数组合成一个元组（**则是字典）
站在函数调用的角度：*做打散用，将一个列表或元组打散成多个参数（**则是关键字形式）
1 #函数定义角度：
2 def demo(*agrs): #按位置输入的动态参数
3 print(agrs)
4 demo(1,2,3,4,5) #输出结果(1, 2, 3, 4, 5)
5 def demo_1(**kwargs): #按关键字传入的参数，组成一个字典
6 print(kwargs)
7 demo_1(a=1,b=2,c=3) #输出结果{'a': 1, 'b': 2, 'c': 3}
8 #函数调用角度：
9 val = [1,2,3,4]
10 val2 = {'a':1,'b':2}
11 demo(*val) #将val打散成 1 2 3 4，然后传入函数
12 demo_1(**val2) #将val2打散成 a=1 b=2，然后传入函数
解释一下为什么在混用的传参中有必须先按位置传参，再按关键数传参：
1 def demo(*agrs,**kwargs): #*agrs和**kwargs的位置是python固定死的
2 #所以必须先是按照位置传参的*agrs，再是按照关键字传参的**keagrs
3 print(agrs)
4 print(kwargs)
5 demo(1,2,3,4,a = 1,b = 2)
6 # 输出结果：
7 # (1, 2, 3, 4)
8 # {'a': 1, 'b': 2}
第3行对应第7行的输出结果
第4行对应第8行的输出结果
定义多个不同类型参数时的顺序：
1 def demo(位置参数1,位置参数2,*args,默认参数=x,**kwargs):
2 pass
3 #以后职业生涯用到多种参数时必须这么写
格式及原理：
情况总结：
1 def demo(*args,**kwargs): #接收参数个数不确定的时候用动态传参，用到的时候再用
2 pass
3 def demo_1(a,b,c): #位置参数，几个参数必须都要传入几个值，最常用
4 pass
5 def demo_2(a,b=10): #默认参数，当参数信息大量形同时用到
6 pass
函数的嵌套：
1 #函数的嵌套调用
2 def demo_1():
3 print(123)
4 def demo_2():
5 demo_1()
6 print(456)
7 demo_2()
8 # 输出结果：
9 # 123
10 # 456
11
12 #函数嵌套定义
13 def demo_1():
14 print(123)
15 def demo_2():
16 print(456)
17 demo_2()
18 demo_1()
19 # 输出结果：
20 # 123
21 # 456
注意：内存读函数的时候先读定义函数名（不能里面的函数体），后面遇到调用此函数的时候，再返回读函数的函数体。
在函数外调整内部嵌套函数内容的方法：
1 def case(x,y,z):
2 def new_case(a,b,c):
3 print('content',a,b,c)
4 new_case(x,y,z)
5 case(1,2,3)
6 #输出结果 content 1 2 3
进阶：
①到⑦表示代码运行顺序
*args 和 **kwargs 只是函数定义参数的方式，和混合传参不是一回事哦