今日内容概要

• 函数的本质

• 函数的语法结构

• 函数的分类

• 函数的返回值

• 函数的参数

  今日内容详细

  函数的本质

  """
  函数可以看成是工具
  	提前定义好，随用随拿，比较方便，可以反复使用
  	举例说明代码中有函和没有函数的区别
  	没有函数（就是没有工具）
  		每次需要用的时候需要现场去制作 浪费时间和消耗能量
  	有函数（有工具）
  		每次需要用到的时候  把工具拿出来就可以使用了  非常的方便
  	注意：函数必须要先定义  之后才可以被使用
  """
  # 函数的定义（就是前期做工具的过程）
  dey my_func():
      pass
  # 函数的使用（选择工具并且使用）
  my_funt()  #使用函数 习惯性称呼：调用函数 函数调用
  

  函数的语法结构

  def 函数名（参数）：
  	'''函数注释'''
      函数体代码
      return 返回值
  """
  1.def
  	用来定义函数的关键字 固定的格式 例如 if... while...  for...  等
  2.函数名
  	在函数关键字 def 后面   与变量名命名的含义一致  尽量做到见名之意
  3.括号
  	在定义函数名后面必须跟括号  固定格式
  4.参数
  	定义函数括号里填写的数值叫参数 可以是一个 也可以是多个 用 ，号隔开  也可以什么都不写 都可以 参数不固定  用于接收外界传递给函数代码体内部的数据  参数的写入和你之后调用函数关联
  5.函数注释
  	说明一下这个函数代码执行的意义 能达到怎样的作用和功能 怎么用的 相当于说明书的效果一样
  6.函数代码体
  	整个函数最核心的位置（逻辑代码） 整个函数的功能和作用 由它控制
  7.return
  	控制函数的返回值 可以是准确的数据值 也可以是变量 但是要找到变量对应的值 
  	
  """
  

  函数的定义与调用

  1.函数必须先定义后使用
  	只有先把函数的代码定义好 后面才可以随时调出来使用 定义运行之后 才可以使用函数名随时调用
  2.定义函数的关键字是 def 调用函数  则使用函数名加括号（可能括号需要填写参数  具体看定义时 函数名 括号里填写情况）
  3.函数在定义阶段只检测函数体代码的语法 不执行函数代码体 例如
  def func ():
      jdajdkajdlkasd
      dajkdadakd
      dandadad
      上面写入的代码体就是一串无意义的字节 无任何的语法  但是python不会报错 因为此阶段 只是去检测你的代码体中是否存在语法的错误 如果检测不到语法错误 就不会报错
      def func ():
          for dhaj
          dasdad
  	此类情况就会报错 因为检测到有语法的错误 所有会报错提醒
  4.函数名到底是什么东西
  	函数名绑定的是一块内存地址 里面存放了函数体代码
      想要运行该代码 就需要调用函数   函数名加括号
      def func():
          pass
      调用函数：func()  # 这样就可以把函数调用出来
      """
      在函数代码中 函数名加（）执行优先级最高 就是最先执行（定义阶段除外）
      """
  

  函数的分类

  1.内置函数
  	pycharm解释器会提前定义好的 用户可以直接调用
      len()
      str.strip
      """
      内置函数可以直接调用
      但是数据类型的内置方法（函数）必须使用数据的类型点的方式才可以调出
      """
  2.自定义函数
  	1.空函数
      	就是在书写函数代码体先用pass顶替 暂时的使用 没有任何的功能 顶替作用 想到合适的代码 可以直接删除填写 提示的作用
          def func（）：
          	pass
       2.无参函数
      	函数定义阶段函数名后面的括号内没有填写参数
  # def home():
  #     print('from anhui')
  # func()  # from anhui
  * 无参函数直接函数名加括号就可以调用
  3.有参函数
  	函数定义阶段括号内填写的有参数（参数不固定）
  
  # def func(a, b):
  #     print('from func')
  # 
  # func(1,1)
  ps：有参函数调用需要函数名加括号并且给到参数数据值 可以是任何类型  但是要对应定义参数时的参数数量
  调用时也要给到相同的参数数量
  

  函数的返回值

  """
  返回值就是调用函数之后产生的结果 
  获取函数返回值的方式是固定格式
  	变量名 = 函数（）
  # def home():
  #     print('from func')
  # a = home()  # 变量名 = 函数（）
  # print(a)  # None
  上述方式有则获取 没有则默认接收None
  """
  1.函数体代码没有return关键字 默认返回None
  # def home():
  #     print('from func')
  # a = home()  # 变量名 = 函数（）
  # print(a)  # None
  2.函数体代码有return关键字：关键字后面不写值 也是默认返回 None
  # def home():
  #     print('from func')
  #     return  # 后面没有跟值
  # a = home()
  # print(a)  # None
  3.函数体代码里有return关键字：则返回关键字 后面的值（return 后面写什么返回值就是什么 如果是变量名则返回变量名对应的那个数据值返回）
  情况一：
  # def home():
  #     print('from func')
  #     return 222
  # a = home()
  # print(a)  # 222
  情况二：
  # def home():
  #     print('from func')
  #     age = 18
  #     return age
  # a = home()
  # print(a)  # 18
  4.函数体代码有return关键字并且后面写了多个数据值 只要用逗号隔开 默认情况下自动返回成元组
  情况一： 整型数据值
  # def func():
  #     return 1, 2, 3, 4, 5, 4, 2, 1
  # a = func()
  # print(a)  # （1, 2, 3, 4, 5, 4, 2, 1）
  情况二： 列表 字典 整型
  # def func():
  #     return[1, 2, 3, 4],{'name':'jason'},123
  # a = func()
  # print(a)  # ([1, 2, 3, 4], {'name': 'jason'}, 123)
  5.函数体代码遇到return关键字 会立刻停止函数体代码的运行
  # def func():
  #     print(1, 2, 3, 4)
  #     return 123
  #     print(2, 23, 4, 4)
  # func()  # 1 2 3 4
  	只运行关键字return上面的函数体代码 下面的不运行 和 break 作用相似
  
  

  函数的参数

  """
  参数有两大类
  	1.形式参数
  		函数在定义阶段括号内填写的参数 简称为'形参'（随便定义一个参数 x 没有直接价值）
  		def func（x）
  	2.实际参数
          函数在调用阶段括号内填写的参数 简称为'实参'（有实际价值 会决定着调用函数的数据值 下面的例子就能看出来）
  # def func(x):
  #     print(x)
  # func(213)
          
  形参与实参关系	
  	行参相当于是变量名
  	实参相当于是数据值
  	在函数调用阶段形参会临时于实参进行绑定  等调用结束后 立刻解除 因为下次调用的时候 形参又会和下一个实参进行临时的绑定
  	称为：动态绑定 动态解绑
  	"""
  

  位置参数

  1.位置形参
  	在函数定义阶段括号内从左到右依次填写的变量名称为位置形参（就是括号内参数 不在是一个 而是多个）
   2.位置实参
  	在函数调用阶段括号内 从左到右依次填写的数据值称为位置实参（调用函数时 括号了的参数对应形参的数量要一致 位置是从左到右）
     """
     1.实参可以是数据值也可以是绑定了数据值的变量名
  # def func(a, b, c):
  #     print(a, b, c)
  # age = 99
  # func(age, 2, 3)
  '下面的变量 age 对应的就是数据值 18 '
     2.位置实参 给 位置形参传值的时候 对应的参数数量要一致 不能少或多 不匹配就会直接报错
  例如：下面的 实参 对应 形参 的数量不匹配 直接报错
  # def func(a, b, c):
  #     print(a, b, c)
  # func(1, 2,)  # 应该三个参数
  这样才对：
  # def func(a, b, c):
  #     print(a, b, c)
  # func(1, 2, 3)
  
     """
  

  关键字参数

  1.关键字实参
  	在函数调用的阶段括号内已明确的去将形参等于具体的数据值的形式称为关键字实参
  """
   1.1 直接给形参传值（不按照之前对应位置去传值）
   1.2 位置实参必须在关键字实参的前面
   	记住：无论是形参还是实参都遵循短（简单）的在前 长（复杂）的在后的原则
   1.3 同一个形参在调用阶段只能传值一次
   查看实例：
  # def func(a, b, c):
  #     print(a, b, c)
  # func(1 ,2 , 3)  # 1 2 3  
  # func(a=1, c=2, b=3)  # 1 3 2 --可以直接给形参传值
  # func(b=1 ，2， 3)  # 报错  --违背了短的在前 长的在后 
  # func(3,b=1, c=2)  # 3 1 2
  # func(3,a=3, c=2)  # 报错  --违背了同一个形参在一次调用中只能传一次值
   """
  

  默认值参数

  默认值形参
  	在函数定义阶段括号内已明确的去将输出的实参等于具体的数据值的形式称为默认值参数
  # def func(a, b, c='make'):
  #     print(a, b, c)
  # func(1, 2)  # 1 2 make --在函数定义阶段就给形参绑定值 后续调用阶段就可以不传 调用出绑定值
  # func(1, 2, 'jason')  # 1 2 jason  --调用阶段不传值就使用定义阶段默认的值 传了就用传了的值
  
  注意：：还是需要遵循之前的总结 无论是形参还是实参都遵循短（简单）的在前 长（复杂）的在后的原则
      
  

  可变长的参数

  可变长形参
  	可以打破之前说的形参与对应的实参 数量要一致的限制 随意的去传值
      def func（*x）
      	print（x）
  """
  	* 这个*号在形参中的作用是接收调用时多余的位置参数 并且用元组的形式 展示出来
  """
  知识点演练：
  # def func(*x):
  #     print(x)
  # func()  # （）---这个空的括号 就是原本调用出的结果 形参中没有任何的变量
  # func(1,2,3,4)  # (1, 2, 3, 4) ---多余的全部用元组的形式赋值给*号后面的变量名 也就是赋值给x
  
  def func(**y):
      print(y)
  知识点演练：
  # def func(**y):
  #     print(y)
  # func()  # {} ---这个空的花括号 就是原本调用出的结果 形参中没有任何的关键字参数
  # func(age=18)  # {'age': 18} 多余的全部以字典的形式赋值给了**后面的变量 y 
  # func(age=18, name='make')  # {'age': 18, 'name': 'make'}
  """ 
  **在形参中的作用
  	接收多余的关键字参数并组织成字典的形式赋值给**后面的变量名
  """
  习题：
  # def func(*x,**y):
  #     print(x)
  #     print(y)
  # func()  #() {}
  # func(1)  # (1,) {}
  # func(1,2)  # (1, 2) {}
  # func(a=1)  # () {'a': 1}
  # func(a=1,b=2,c='make')  # () {'a': 1,'b': 2, 'c': 'make'}
  # func(1,2,3,4,a=1,b=2,c='make')  # (1,2,3,4) {'a': 1,'b': 2,'c'= 'make'}