函数的定义与调用

    
  定义函数的格式:

    def 函数名（参数）：
      代码

  Python 使用def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的具体功能实现代码
  定义一个打印函数
  def printinfo():
    print('''
    春游去动物园
    ''')

  调用函数
  定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
  调用函数很简单的，通过 函数名() 即可完成调用
  
  printinfo()  # 春游去动物园

  '''
  注意：
  每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
  当然了如果函数中执行到了return也会结束函数
  '''

  # 定义一个函数
  def test(a,b):
      #2个数求和
      print("%d" % (a + b))
  test(11,12) # 23

函数的分类

  目前学到的有两种函数第一个是从入门就开始使用的print这类的python内置函数，然后还有就是需要我们自己写的自定义函数。
  
  1.内置函数
    Python内置函数随着python解释器的运行而创建。在Python的程序中，你可以随时调用这些函数，不需要定义。
    我们可以使用ctrl+鼠标的左键来查看这些内置函数的内部源码。
    一下就是目前python中的所有内置函数：

  2.自定义函数
    自定义函数可以理解为我们自己编写的一些具有有一定功能的代码。自定义函数还可以分成三类，无参函数，有参函数和空函数。
    
    无参函数：
      调用函数时不用给函数传入参数的函数，或者在定义函数时括号内没有参数。
            
      def printinfo():
          print('这是一个无参函数')

      printinfo()  # 这是一个无参函数
      调用时不需要给函数传入参数，可以直接调用。
    
    有参函数：
      调用函数时需要给函数传入参数的函数，或者是在定义函数时括号内有参数。
    
      def printinfo(info):
          print(info)

      printinfo('这是一个有参函数')  # 这是一个有参函数
      在调用函数时我们需要给函数传入参数，如果未传参，运行时会报错。

    空函数：
      没有任何功能的代码，甚至连函数代码体都没有。
      前期能够通过空函数快速的罗列出程序中大致的功能
      让程序整体框架清晰  空函数大量的使用在项目前期的功能框架搭建
      def printinfo():
          ...

      def printinfo():
          pass

函数的返回值

  返回值：运行函数时有时会得到一个结果，这个结果就是返回值
  
  获取函数的返回值：
    变量名 = 函数调用

  操作返回值：
    1.没有return关键词时 返回值是None
      def test():
          print('春游去动物园')

      a = test()
      print(a)  # None
    
    2.有return关键词，没返回值
      def test():
          print('春游去动物园')
          return

      a = test()
      print(a)  # None

    3.有return关键词，且有返回值
      def test():
          print('春游去动物园')
          a = '春游去动物园'
          return a

      a = test()
      print(a)  # 春游去动物园

    4.return后面还可以跟多个值 逗号隔开  会自动组织成元组返回出去后
      def test():
          print('春游去动物园')
          return '春游去动物园', '秋游去动物园', '11111'

      a = test()
      print(a)  # ('春游去动物园', '秋游去动物园', '11111')
  
    5.函数体代码遇到return会立刻结束函数运行
      函数体代码里面写return相当于循环体代码里面写break
      遇到了就立刻结束函数和循环的执行

函数的参数（非常重要）

    定义时小括号中的参数，用来接收参数用的，称为 “形参”
    调用时小括号中的参数，用来传递给函数用的，称为 “实参”
    
    形参：定义函数的时候的变量 叫形参(名字任意)
	def welcome(a):
	    print('welcome',a) # 这个a就是形参
    实参：真实的数据信息,调用函数的时候 传递 叫实参
	welcome('tom')
	welcome('lily') # tom和lily是实参


  此处引用别人的例子:
  def add2num(a, b):
    c = a+b
    print c

  add2num(110, 22) # 调用带有参数的函数时，需要在小括号中，传递数据

  形参与实参的关系
    形参类似于是变量名、实参类似于是变量的值
		在调用函数的时候传入实参 会与形参临时绑定
		函数运行结束之后自动解除绑定

位置参数

  位置参数:形参和实参必须保持一致，最好按位置传参，如果位置不对应就指定说明
    位置形参
	在函数定义阶段括号内从左往右依次填写的变量名
  	def index(name,pwd):  # name和pwd就是位置形参
          pass
    位置实参
	在函数调用阶段括号内从左往右依次传入的真实数据
  	index('春游去动物园',123)  # 春游去动物园和123就是位置实参

    
位置参数的特征
    1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
    2.位置形参与位置实参的个数要一致 多一个不行少一个也不行

默认参数

  形参和实参可以不一致，如果不想使用默认的参数，在调用函数的时候可以指定(调用函数时，默认参数的值如果没有传入，则被认为是默认值)
  
'''
  注意： 默认参数必须定义在位置参数的后面
'''
  
  def add(a, b, c=100):
    d = a + b + c
    print(d)

  add(100, 100)  # 不给c传值，c使用默认值  300
  add(100, 100, 200)  # 给c传入值，c就会使用传入的值  400

关键字参数

  关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

  说得简单的就是指名道姓的给形参传值 不需要遵循位置
  
  def add(a, b):
    print(a, b)

  add(a=1, b=2)  # 1 2
  add(b=1, a=2)  # 2 1
  add(1, b=2)  # 1 2

'''
  注意：关键字参数必须放在位置参数的后面，不然会报错。
'''

可变长参数（重要）

  在函数的参数中带有一个“*”，或者两个“*”的称之为可变参数
  比如func(*args, **kwargs)
  变量名可以随意，但是强烈建议使用*args, **kwargs，因为这是普遍使用的，别人看你代码时，一眼就能看懂。

"""
*号在形参中
    可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
"""
  def fun(a, b, *args):
    print(a, b, args)
  
  fun(1,2) # 1 2 ()
  fun(1) # 会报错  前面有位置参数时，至少要先满足位置参数每个都有值传入
  fun(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)  # 1 2 (3, 4, 5, 6, 7, 8, 9, 0)

"""
**在形参中
    用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
"""
  def fun(a, b, **kwargs):
    print(a, b, kwargs)

  fun(1,2) # 1 2 {}
  fun(a = 1, b = 2, c = 3, d = 4) # 1 2 {'c': 3, 'd': 4}

  def fun(**kwargs):
    print(kwargs)

  fun(a=1, b=2, c=3, d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

'''
同时接收任意类型的参数:
  def fun(*args, **kwargs):
    print(args, kwargs)

  fun(1, 2, 3, 4, a=1, b=2)  # (1, 2, 3, 4) {'a': 1, 'b': 2}
'''
  

*实参和**实参（重要）

  *和**不单单可以在形参中使用 还可以在实参中使用

  *实参
'''
实参中的*后面跟的是可迭代对象，此时形参为位置参数或可变参数都可以
  def test(a, b, c, d):
    print(a, b, c, d)
 
  test(*[1, 2, 3, 4])    # 1 2 3 4
      
  def test(*args):
      print(args, type(args))
   
  test(*[1, 2, 3, 4])     # (1, 2, 3, 4) 

除了list, str, tuple等，还可以用dict作为实参，获取的是dict中的key值：
  def test(a, b, c, d):
    print(a, b, c, d)
 
  test(*{'a': 1, 'b': 2, 'c': 3, 'd': 4})    # a b c d
   
  def test(*args):
      print(args, type(args))
   
  test(*{'a': 1, 'b': 2, 'c': 3, 'd': 4})     # ('a', 'b', 'c', 'd') 
'''

  **实参
'''
实参中的**后面跟的是可迭代映射,获取的是可迭代映射的 value。
此时，当形参为位置参数时，获取的是可迭代映射的value，当形参为关键字参数时，获取的是dict。
  def test(a, b, c, d):
    print(a, b, c, d)
 
  test(**{'a': 1, 'b': 2, 'c': 3, 'd': 4})    # 1 2 3 4
     
  def test(**args):
      print(args, type(args))
      
  test(**{'a': 1, 'b': 2, 'c': 3, 'd': 4})     # {'a': 1, 'b': 2, 'c': 3, 'd': 4} 
'''