函数(一)

函数的定义与调用

——------------------------------------------------------------------------

1.  函数一定要遵循先定义后调用的原则
2. 函数在定义阶段只检测语法不执行代码
3. 函数体代码只有在调用函数的时候才会执行
4. 函数名其实相当于是变量名指向的是内存中函数体代码所在的位

    

    '''不遵循先定义后调用原则'''
    func()  # 报错  name 'func' is not defined
    # 定义函数
    def func():
        print('hello world')

    '''遵循先定义后调用原则'''
    # 定义函数
    def func():
        print('hello world')
    # 调用函数
    func()  # 正常 就是去内存中找到函数体代码并执行

 

函数的分类

——------------------------------------------------------------------------

内置函数

    内置函数
        它的底层使用c++来写的
	python解释器提前定义好可以直接调用的函数
  	eg:len、cunt、open...  # 如何查看代码的内部源码ctrl+鼠标左键

自定义函数

    自定义函数
	再使用到某些功能内置函数无法实现时，自己编写的函数
  	1.无参函数
        2.有参函数
        3.空函数

    '''无参函数'''
    # 无参函数:在定义函数的时候括号内没有参数
    def index():
        print('玩个勾吧游戏！')
    # 调用无参函数:在调用的时候括号内也不需要参数
    index()

    '''有参函数'''
    # 有参函数:在函数定义阶段括号内有参数>>>:类似于变量名
    def index(a):
        print('玩个勾吧游戏！',a)
    # 调用有参函数:在函数调用阶段括号内也必须传参数>>>:类似于变量值
    index(123)
    
    '''空函数'''
    # 空函数:在定义阶段函数体代码是用pass或者用'...'
    def index():
        pass
     '''
      空函数的作用
      在前期能够通过空函数快速的罗列出程序中大致的功能 
      让整体的功能框架更清晰 
      后续想要再实现对应的功能只要在空函数里加程序代码即可
      空函数大量的使用在项目前期的功能框架搭建
     '''

 

函数的返回值

——------------------------------------------------------------------------

    '''函数的返回值 就是函数被调用后 并不会出错时返回的结果'''
    eg:
    st = 'hello girl'
    res = len(st)  # 相当于把len函数的值(10) 赋给变量名res
    print(res)

    # 如何获取函数的返回值
	变量名 = 函数调用

    # 操作函数的返回值
      '一般情况下函数的返回值用return 空格 返回的类型'
      1.当函数体代码最后没有return关键字时 返回值为空 None 
      def play():
          print('玩个勾吧游戏！')  # 纯属打印并不是返回值
      game = play()
      print(game)  # 结果为None

      2.当函数体代码写了return但是没有跟任何值得时候 返回值也是None
      def play():
          print('玩个勾吧游戏！')  # 纯属打印并不是返回值
          return  # 只写return
      game = play()
      print(game)  # 结果为None

      3.当函数体代码写了return并跟了数据 那么return后写了什么就返回什么
          return返回的只能是值，当你写值的话返回的就是你写的值 
          当你写的是变量名的话返回的则是变量名指向的值
          def play():
              print('玩个勾吧游戏！')  # 纯属打印并不是返回值
              why = '垃圾游戏'
              return why  # 写什么值(变量名)就会返回什么值
          game = play()
          print(game)  # 垃圾游戏
      4.当return后面要跟多个值时 每个值间用逗号隔开 当返回出去时会变成元组的形式
        def play():
            print('玩个勾吧游戏！')  # 纯属打印并不是返回值
            why = '垃圾游戏'
            return why, '狗都不玩', '要学习啊'  # 写多个值(变量名)就会以元组的形式返回
        game = play()
        print(game)  # 结果 ('垃圾游戏', '狗都不玩', '要学习啊')
      5.函数体代码中return后的代码不会被执行，遇到return后会立即结束函数体
        函数体代码中的return相当于循环体代码中的break

 

函数的参数

——------------------------------------------------------------------------

函数的参数分为两大类

• 形参
  在函数的定义时函数名后的括号内要写的参数
  称之为'形式参数' 简称>>>:形参
• 实参
  在调用函数时函数名后的括号内要写的参数
  称之为'实际参数' 简称>>>:实参

   '''  形参与实参的关系
        形参类似于是变量名、实参类似于是变量的值
        	在调用函数的时候传入实参 会与形参临时绑定
        	函数运行结束之后自动解除绑定
    '''
    def info(a, b):  # a和b是形参
        print(a, b)

    info(1, 2)  # 1和2是实参
    info('用户名', '密码')  # 用户名和密码是实参
    """
    1会临时绑定给形参a 2会临时绑定给形参b
        函数体代码运行期间 可以通过形参直接使用到实参
        函数体代码运行完毕之后 解除绑定 
        形参ab处于没有绑定值得状态 等待下一次函数调用传入实参进行绑定
    然后到'用户名'会临时绑定给形参a '密码'会临时绑定给形参b
        接着跟1 2 实参一样执行函数体代码
    """
    m = 1024
    n = 1101
    index(m,n)  # 将变量名m、n指向的1024、1101临时绑定给形参ab

位置参数

    位置形参
	在函数定义阶段括号内从左往右依次填写的变量名
  	def index(name,pwd):  # name和pwd就是位置形参
          pass
    位置实参
	在函数调用阶段括号内从左往右依次传入的真实数据
  	index('jason',123)  # jason和123就是位置实参
  
位置参数的特征
	1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
        2.位置形参与位置实参的个数要一致 多一个不行少一个也不行

    def play(tpey, name):  # 位置形参
        print('玩个勾吧%s游戏！' % tpey)  # 纯属打印并不是返回值
        why = '垃圾游戏'
        return name, why, '狗都不玩', '要学习啊'  # 写多个值(变量名)就会以元组的形式返回
      '''位置实参 传多传少都会报错 要与形参一致'''
    game = play('rpg', '原神')  # 位置实参 实参个数要形参对应
    print(game)   # ('原神', '垃圾游戏', '狗都不玩', '要学习啊')

关键字参数

    出现在实参中
    	指名道姓的给形参传值 不需要遵循位置
        '''
            注意要与位置传参时 关键字传参要写在位置参数后面否则报错 
            当位置实参已经与某个形参绑定了关键字实参就不可与绑定了的形参绑定
        '''
     def play(tpey, name):  # 位置形参
        print('玩个勾吧%s游戏！' % tpey)  # 纯属打印并不是返回值
        why = '垃圾游戏'
        return name, why
    
    

    game = play(name='原神', tpey='rpg')  # 指名道姓的说形参tpey接收数据'rpg' name接收数据'原神'
    game = play(name='王者','联盟')  # 报错 关键字传参要写在位置参数后面否则报错
    game = play('rpg',tpey='原神')  # 报错 形参只能指向一个实参
    game = play('rpg',name='原神')  # 可以 相当于位置参数 

    print(game)

默认参数

    出现在形参中
	在函数定义阶段就已经给一些形参赋值了 
  	后续如果不传值则使用默认的
        后续如果传值则使用传入的
	默认参数的出现也打破了形参与实参之间个数一致的情况
        默认参数必须定义在位置参数的后面 
    eg:
        def user_info(name, sex, age='18'):  # 年龄默认18岁
            print("""
            用户名：%s
            年龄：%s
            性别：%s 
            """ % (name, sex, age))
        user_info('aili', '女',20)  # 按写入的先
        user_info('tom', '男')  # 年龄默认18岁
        user_info('malin', '女',)  # 年龄默认18岁

可变长参数

    "----可变长形参----"
    """
    *号在形参中
        可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
    """
    def index(a, b, *ag):
        print(a, b, ag)
    index(999)  # 会报错  因为形参ab的存在 意味着index最少要给两个参数
    index(1, 2)  # 1 2 ()
    index(1, 2, 3, 4, 5, 6, 7)  # 1 2 (3, 4, 5, 6, 7)
    index(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  # 1 2 (3, 4, 5, 6, 7, 8, 9, 10)
    """

    **在形参中
        用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
    """
    def index(a, b, **k):
        print(a, b, k)
    index(a=1, b=2)  # 1 2 {}
    index(a=1, b=2, c=3, name='jason')  # 1 2 {'c': 3, 'name': 'jason'}
    index(1,2,name='jason',age=18,pwd=123)  # 1 2 {'name': 'jason', 'age': 18, 'pwd': 123}

    '''*与**一起用
        无论接收多少参数和任意类型的参数都不会报错 能正常执行函数
    '''
    def show(*a, **k)
        print(a, **k)
    show(1,2,3,name='aimi',age=18)  # (1, 2, 3,) {'name': 'aimi', 'age': 18}
    '''一般不知道要写几个参数时就可以先用这种方法'''

补充

   ''' * 和 **在实参中的使用 '''
    def index(*args, **kwargs):
      print(args, kwargs)
    """
    *号在实参中 
        可以将列表或者元组打散成位置参数一一传入
    def index(*[11,22,33])  等价于 index(11,22,33)
    def index(*(11,22,33))  等价于 index(11,22,33)
    """
    
    """
    **号在实参中
        可以将字典打散成关键字参数一一传入
    def index(**{'name':'jason'})  等价于  index(name='jason')
    """

——------------------------------------------------------------------------