Python函数

函数的定义与调用

  # 1.函数一定要遵循先定义后调用的原则
	大白话:定义函数的代码一定要比调用函数的代码先执行
  # 2.函数在定义阶段只检测语法不执行代码
  # 3.函数体代码只有在调用函数的时候才会执行
  	调用函数的方式>>>:函数名加括号  # 如果有参数则传递参数
  # 4.函数名其实相当于是变量名指向的是内存中函数体代码所在的位置
  #######################################
  func()  # 报错  name 'func' is not defined
  # 定义函数
  def func():
      print('hello world')
  # 调用函数
  # func()  就是去内存中找到函数体代码并执行

函数的分类

  1.内置函数
    python解释器提前定义好可以直接调用的函数
    eg:len、open...  # 如何查看代码的内部源码ctrl+鼠标左键
2.自定义函数
	程序员自己编写的函数
    2.1.无参函数
    2.2.有参函数
    2.3.空函数
    # 无参函数:在函数定义阶段括号内没有参数
     def index():
         print('色即是空 空即是色')
    # 调用无参函数:括号内也不需要写参数
    # index()

    # 有参函数:在函数定义阶段括号内有参数>>>:类似于变量名
     def index(a):
         print('你好天天上向 好好学习',a)
    # 调用有参函数:在函数调用阶段括号内也必须传参数>>>:类似于变量值
     index(123)

    # 空函数:在定义阶段函数体代码是用pass或者...占位
     def index():
         pass
    """
    空函数感觉一点用都没有啊 但是非常有用
        前期能够通过空函数快速的罗列出程序中大致的功能
        让程序整体框架清晰  空函数大量的使用在项目前期的功能框架搭建
    eg:编写一套钢铁侠程序
        功能也可以看成是函数 函数也可以看成是功能
    """
    def fight():
        pass
    def run():
        pass
    def study():
        pass
    def communication():
        pass

函数的返回值

  # 函数的返回值其实就是在调用函数之后返回的结果
    eg:
    s = 'hello world'
    res = len(s)  # 将len函数的返回值赋值给变量res
    print(res)

  # 如何获取函数的返回值
	变量名 = 函数调用
 
  # 如何操作返回值
  1.当函数体代码没有return关键字的时候 返回值是None
    def index():
      print('春困秋乏夏打盹儿')
    res = index()
    print(res)  # None

  2.当函数体代码写了return但是没有跟任何值得时候 返回值也是None
    def index():
    	print('春困秋乏夏打盹儿')
    	return 
	res = index()
	print(res)  # None

   3.当函数体代码写了return并且跟了数据 那么写什么就返回什么
  	如果写的是值那么直接返回值(任意数据类型)
    	如果写的是变量名那么返回变量名指向的值
    def index():
    	print('春困秋乏夏打盹儿')
    	name = 'jason'
    	return name
    res = index()
    print(res)  # jason

  4.return后面还可以跟多个值 逗号隔开  会自动组织成元组返回出去后
    def index():
    	print('春困秋乏夏打盹儿')
    	return 111,'jason',222
    res = index()
    print(res)  # (111,'jason',222)

  5.函数体代码遇到return会立刻结束函数运行
    函数体代码里面写return相当于循环体代码里面写break
    遇到了就立刻结束函数和循环的执行

函数的参数(重要知识点)

  1.函数的参数可以分为两大类
      1.1函数在定义阶段括号内写的参数
            我们称之为“形式参数” 简称为>>>:形参
      1.2函数在调用阶段括号内写的参数
            我们称之为“实际参数” 简称为>>>:实参
  
  2.形参与实参的关系
      形参类似于是变量名，实参类似于是变量的值
          在调用函数的时候传入实参 会与形参临时进行一个绑定
          函数运行结束之后自动解除绑定

  def index(a, b):  # a和b就是index函数的形参
      print(a, b)
  # index(1,2)  # 1和2就是index函数的实参

  '''
    1会临时绑定给形参a  2会临时绑定给形参b
        函数体代码运行期间  可以通过形参直接使用到实参
        函数体代码运行完毕之后  解除绑定
        形参ab处于没有绑定值得状态  等待下一次函数调用传入实参进行绑定
  '''

  # index('jason', 123)  #jason和123就是index函数的实参

  '''
     jason会临时绑定给形参a  123会临时绑定给形参b
        函数体代码运行期间  可以通过形参时间使用到实参
        函数体代码运行完毕之后  解除绑定
        形参ab处于没有绑定值得状态  等待下一次函数调用传入实参进行绑定 
  '''

  a = 1000
  b = 9999
  index(a, b)  # 将变量名a, b指向的1000,9999临时绑定给形参ab

位置参数

  位置形参
      在函数定义阶段括号内从左往右依次填写的变量名
      def index(name, pwd):  # name和pwd就是位置形参
          pass  # 没有任何的效果
  
  位置实参
      在函数调用阶段括号内从左往右依次传入的真实的数据
      index('jason', 123)  # jason和123就是位置的实参

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

  def index(a, b):
      print(a, b)  # 外界传入什么实参这里就打印什么

  # index(1, 2)
  # index('jason', 123)
  # index()   # 调用的时候不传实参不可以
  # index(111)  # 传少了也不行
  index(111, 222, 333)   # 传多了也不行

关键字参数

  出现在实参中
      指名道姓的给形参传值  不需要遵循位置
    
  def index(a, b):
      print(a, b)
  index(b=111, a=222)  # 指名道姓的说形参a接收数据222  b接收数据111
  index(b=333, 222)  # 报错  关键字参数必须放在位置参数的后面
  index(222, a=111)  # 报错  形参只能指向一个实参
  index(222, b=111)  # 可以  相当于位置参数

  '''
    实参222会按照位置绑定给形参a  然后又通过关键字参数给形参a重复绑值
    这种情况是不被允许的！！！
  '''

默认参数

  出现在形参中
    在函数定义阶段就已经给一些形参赋值了
    后续结果不传值则使用默认的
    后续如果传值则使用传入的
    默认参数的出现也打破了形参与实参之间个数一致的情况
    默认参数必须定义在位置参数的后面  # 至于顺序问题  后面有口诀

  '''
      默认参数的实际案例
          eg：很多软件的注册页面  默认会帮助我们勾选一些选项
                默认头像
              如果男孩子喜欢使用的软件默认性别可能是男性
              如果女孩子喜欢使用的软件默认性别可能是女性
  '''
    def register(name, age, gender='猛男'):
    '''函数的形参在命名的时候也应该见名知意'''

    print("""
      学员姓名:%s
      学员年龄:%s
      学员性别:%s
      % (name, age, gender)
    """)

  register('jason', 18)  # 不传就使用默认的
  register('kevin', 22)
  register('jerry', 23, '美女')  # 传了就使用自己的

可变长参数(重要)

    """需求:定义一个函数 无论传多少位置实参都可以正常执行"""
    def func(*a):
        print(a)
    func()  # ()
    func(1,2)  # (1, 2)
    func(1,2,3,4,5,6)  # (1, 2, 3, 4, 5, 6)
    """
    *号在形参中
        可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
    """
    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)
    # 结合print方法 理解*号的含义 暂时不要管self形参


    """
    **在形参中
        用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
    """
    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 func(**k):
        print(k)
    func()  # {}
    func(a=1,b=2)  # {'a': 1, 'b': 2}
    func(a=1,b=2,c=3,d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

可变长形参

    """
      思考题:如何定义一个无论接收多少个任意类型的参数都可以正常执行的函数
    """
    def func(*a,**k):
        print(a,k)
    func()  # () {}
    func(1,2,3,4,name='jason',age=18)  # (1, 2, 3, 4) {'name': 'jason', 'age': 18}

    # 以后在定义函数的时候 如果不确定这个函数将来需要多个实参 那么可以采用上述的方法
    """*和**在形参中的使用 后面的变量名并不是关键 但是针对这两个特殊符号后面的变量名 有推荐的写法"""

    def index(*args, **kwargs):
        pass

知识的补充说明

    *和**不单单可以在形参中使用 还可以在实参中使用
    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)
    如果真的理解不了 可以看成是*号会将列表和元组的括号去除 暴露出里面一个个元素
    """
    # index(*['jason', 'kevin', 'tony', 'oscar', 'jerry'])  # ('jason', 'kevin', 'tony', 'oscar', 'jerry') {}
    # index(*('jason', 'kevin', 'tony', 'oscar', 'jerry'))  # ('jason', 'kevin', 'tony', 'oscar', 'jerry') {}
    # index(['jason', 'kevin', 'tony', 'oscar', 'jerry'])  # (['jason', 'kevin', 'tony', 'oscar', 'jerry'],) {}

    # print(*[1,2,3])  # print(1,2,3)

    """
    **号在实参中
        可以将字典打散成关键字参数一一传入
    def index(**{'name':'jason'})  等价于  index(name='jason')
    """
    index(**{'name':'jason','age':18,'pwd':123})  # () {'name': 'jason', 'age': 18, 'pwd': 123}
    index({'name':'jason','age':18,'pwd':123})  # ({'name': 'jason', 'age': 18, 'pwd': 123},) {}