python day09 函数 function

目录：

函数 function

什么是函数:

1. 定义：函数是可以重复执行的语句块，可以重复调用。

2. 作用：

   1. 用于封装可重复执行的语句，提高语句的可重用性
   2. 定义用户级别的函数

3. 函数定义语句 def语句的语法:
   def 函数名(参数列表):
   语句块(代码块)

函数的语法说明：

1. 函数的名字就是语句块的名称
2. 函数名的命名规则与变量名命名规则相同（必须为标识符)
3. 函数名是一个变量（不要轻易对其赋值）
4. 函数的自己的命字空间，在函数内部可以访问外部的变量，但外部的语句不能访问函数内部的变量
5. 函数如果不需要传入参数，则参数列表可以为空
6. 语句部分不能为空，如果为空需要填充pass语句

示例1:

def say_hello():
print(“hello world!”)
print(“hello home!”)
print(“hello everyone!”)

函数调用:

1. 调用格式:函数名(实际调用传递参数)
   注意：实际调用传递参数 简称”实参”
2. 调用说明：
   
   1. 函数调用是一个表达式
   2. 如果没有return语句，函数执行完比后返回None对象
   3. 如果函数需要返回其它的对象，需要用到return语句
3. 示例2:
   # 带有参数的函数的定义
   # 见: 02_def_mymax.py
4. 练习1:
   写一个函数mysum, 此函数带有两个参数x, y.
   此函数功能是打印出两个参数x,y的和, 即 x + y
5. 练习2:
   写一个函数print_even, 传入一个数参n代表终止整数(不包含n)
   打印:
   2 4 6 … n之间所有偶数:
   函数定义格式如下:
   def print_even(n):
   …. <<<— 此处自己完成
   # 测试调用:
   print_even(9)
   2
   4
   6
6. 特别注意：函数内部有独立的运行空间,函数外部不能访问函数内的变量
   示例见:
   function_variable.py

7. return 语句:

   1. 语法:
      return [表达式]
      注: []代表其中的内容可以省略

      1. 作用:
         用于函数中,结束当前函数的执行,返回到调用函数的地方,同时返回一个对象的引用关系
         说明:
         
         1. return语句后跟的表达式可以省略,省略后相当于return None
         2. 如果函数内没有return语句,则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句)
         3. 函数调用能够返回一个对象的引用
            示例见: 03_return.py

      2. 练习:

         1. 写一个函数mymax, 返回两个数的最大值
            如:
            def mymax2(a, b):
            …
            print(mymax(100, 200)) # 200
            print(mymax(“ACD”, “ABCD”)) # ACD

         2. 写一个函数input_number() 此函数用于读取用户输入的多个整数(用户输入负数时结束输入)
            将用户输入的数形成列表返回给调用者
            def input_number():
            … # 此处自己完成

            L = input_number()
            print(“您输入的最大数是:”, max(L))
            print(“您输入的这些数的和是:”, sum(L))

python函数的参数传递

1. 传递方式:
   位置传参
   序列传参
   关键字传参
   字典关键字传参
2. 位置传参:
   
   1. 实际调用参数(实参) 的对应关系与形式参数(形参)的对应关系是按位置来依次对应的
   2. 示意:
      def fx(a, b, c):
      pass
      # ^ ^ ^
      fx( 1, 2, 3)
3. 序列传参:
   
   1. 用法：序列传参是批在函数调用过程中,用 * 将序列拆解后按位置进行传递的传参方式
      实参和形参通过序列传递和匹配
   2. 示例:
      def fx(a, b, c):
      pass
      s1 = [11, 22, 33] # 列表
      fx(*s1) # 将s1序列拆解后按位置传入fx中
4. 关键字传参
   
   1. 用法： 是指传参时,按着形参的名称给形参赋值
      实参和形参按名称进行匹配
   2. 示例:
      def fx(a, b, c):
      pass
      fx(b=22, c=33, a=11) # 11->a, 22->b, 33->c
      注:
      实参和形参按形参名进行匹配,可以不按位置进行匹配
5. 字典关键字传参:
   
   1. 用法：实参为字典,用**拆解字典后再进行关键字传参
   2. 示例:
      def fx(a, b, c):
      pass
      d = {‘c’: 33, ‘b’: 22, ‘a’: 11}
      fx(**d) # 拆解字内再依次按关键字传参
   3. 说明:
      字典的键名和形参名必须一致
      字典的键名必须为字符串
      字典的键名要在形参中存在
6. 综合传参:
   
   1. 用法： 函数的传参方式在能确定形参能唯一匹配到相应实参的情况下可以任意组合
      注:
      通常位置传参和序列传参先传递,其次是关键字传参和字典关键字传参
   2. 示例:
      def fx(a, b, c, d, e, f):
      pass
      fx(10, [20, 30], e=50, *{‘d’:40, ‘f’:60})
      # 以下是错误做法
      fx(e=50, *{‘d’:40, ‘f’:60}, 10, [20, 30])

函数的缺省参数( 以下讲函数的形参)

1. 语法:
   def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
   语句

2. 示例:
   def info(name, age=1, address=”不详”):
   print(“我叫”, name, ‘我今年:’, age, ‘岁, 家庭住址:’, address)
   info(“张飞”, 30, “中原”)
   info(“home”, 10)
   info(“赵云”)

   1. 说明:
      缺省参数必须自右至左依次存在
      缺省参数可以有0个,1个,多个,甚至全部都有缺省参数
      缺省参数的绑定对象存在于函数内,同函数的生命周期一致
   2. 示例:
      def fn(a, lst=[]):
      lst.append(a)
      print(lst)

   L = [1,2,3,4]
   fn(5, L)

   fn(1.1)
   fn(2.2)

函数的形参定义方式:

所有的方式：

1. 位置形参
2. 星号元组形参
3. 命名关键字形参
4. 双星号字典形参

具体：

1. 位置形参:
   def 函数名(形参名1, 形参名2, ….):
   语句块

2. 星号元组形参:

   1. 语法:
      def 函数名(*元组形参名):
      语句块
   2. 作用:
      收集多余的位置传参

   3. 示例见:

      
      # 此示例示意 星号元组形参
      
      def func(*args):
          print("实参个数是:", len(args))
          print("args的值是:", args)
      func(1, 2, 3)
      func("ABCD", 3.14, 100, True, None)
      

3. 命名关键字形参

   1. 语法:
      def 函数名(*, 命名关键字形参):
      语句块
      或
      def 函数名(*args, 命名关键字形参):
      语句块
   2. 作用:
      所有的命名关键字形参都强制调用者采用关键字传参或字典关键字传参的方式传递

   3. 示例见:
      “`
      def myfun(a, *, k):
      print(‘a =’, a)
      print(‘k =’, k)

      # myfun(100, 200) # 错误
      myfun(100, k=200)  # k强制使用关键字传参
      myfun(10, **{'k': 20})  # 字典关键字传参
      print('===================')
      def myfun2(b, *args, c, d):
          print("b=", b)
          print("args=", args)
          print("c=", c)
          print("d=", d)
      myfun2(100, 200, 300, 400, d=600, c=500)
      ```
      

4. 双星号字典形参:
   
   1. 语法:
      def 函数名(**字典形参名):
      语句块
   2. 作用:
      收集多余的关键字传参
      注:
      字典形参名通常叫 kwargs
      
      1. 示例见:
         
# 此示例示意双星号字典形参的用法:
def func(**kwargs):
print("关键字传参的个数是:", len(kwargs))
print("kwargs=", kwargs)
func(name='home', age=15)
func(a=1, b="BBBB", c=[2, 3, 4], d=True)


函数参数说明:

1. 位置形参,缺省参数,星号元组形参,命名关键字形参,双星号字典形参可以混合使用
2. 函数参数自左至右的顺序为:
   
   1. 位置形参
   2. 星号元组形参
   3. 命名关键字形参
   4. 双星号字典形参
3. 示例:
   def fn(a, b, *args, c, **kwargs):
   pass
   fn(100, 200, 300, 400,“AB”, *{‘d’:”D”}, c=100)
   fn(100, 200, 300, 400,“AB”, *{‘d’:”D”, “c”:”C”}, e=100)
4. 可以接收任意位置传参和关键字传参的函数:
   def fn(*args, **kwargs):
   psss

5. 练习:

   1. 写一个函数,mysum,可以传入任意个实参的数字,返回所有实参的和
      def mysum(….):
      ….
      print(mysum(1,2,3,4)) # 10
      print(mysum(5,6,7,8,9)) # 35

   2. 已知内建函数 max的帮助文档为:
      max(…)
      max(iterable) -> value
      max(arg1, arg2, *args) -> value
      访造max,写一个mymax函数,实现功能与max完全相同
      测试用例:
      print(mymax([6,8,3,5])) # 8
      print(mymax(100, 200)) # 200
      print(mymax(1,3,9,7,5)) # 9

   3. 写一个函数minmax, 可以给出任意个数字实参,返回这些实参的最小数和最大数,
      要求两个数字形成元组后返回(最小数在前,最大数在后)
      调用此函数,能得到实参的最小值和最大值
      def minmax(…):
      ….
      xiao, da = minmax(5,7,9,3,1)
      print(“最小数是:”, xiao)
      print(“最大数是:”, da)
      注:
      因函数只能反

函数变量

函数名是变量,它在创建时绑定一个函数

1. 示例:
   
def f1(lst=[]):
print("f1函数被调用")
f1()
f1 = None
f1() # 出错,f1 绑定的是None


2. 示例:

    def f1():
           print("hello")
   
       def f2():
           print("world")
   
       f1, f2 = f2, f1
       f1()  # world

一个函数可以作为另一个函数的参数(实参)传递

  1. 示例:
    ```
    def f1():
              print("f1函数被调用")

          def f2():
              print("f2函数被调用")

          def fx(fn):
              print("fn绑定的函数是:", fn)
              # 在fx内调用fn绑定的函数
              fn()
          fx(f1)  # 调用fx,把f1作为实参传数
          fx(f2)
    ```


  2. 看懂下列代码在做什么?为什么?
    ```
    def goodbye(L):
            for x in L:
                print("再见:", x)

        def hello(L):
            for x in L:
                print("欢迎:", x)

        def fx(fn, L):
            print("fx被调用")
            fn(L)

        fx(hello, ['Tom', 'Jerry', 'Spike'])
        fx(goodbye, ['小张', '小李'])
    ```

函数可以做为另一个函数的返回值:

函数可以返回另一个函数

1. 示例:
```
 def get_op():
            s = input("请输入您的操作: ")
            if s == "求最大":
                return max
            elif s == '求最小':
                return min
            elif s == '求和':
                return sum

        L = [2,4,6,8,10]
        print(L)
        f = get_op()
        print(f(L))
```

函数嵌套定义:

1. 用法：
   def 语句的作用是用来创建一个函数
   def 语句可以写在函数内部,在函数执行时可以动态创建一个函数

   1. 示例:
      

       def get_func(value):
              if value == 1:
                  def myadd(x, y):
                     return x + y
                  return myadd
              elif value == 2:
                  def mysub(x, y):
                     return x - y
                  return mysub
          fx = get_func(1)
          print(fx(400, 300))  # 700
          fx = get_func(2)
          print(fx(400, 300))  # 100

全局变量和局部变量

1. 局部变量:
   
   1. 定义在函数内部的变量称为局部变量(函数的形参也是局部变量)
   2. 局部变量只能在函数内部使用
   3. 局部变量在函数调用时才能够被创建,在函数调用之后会自动销毁
2. 全局变量:
   定义在函数外部,模块内部的变量称为全局变量
   全局变量,所有函数都可以直接访问(但函数内部不能直接修改全局变量的绑定关系)

3. 示例:

     a = 100
       b = 200
       def fn(c):
           d = 300
           print(a, b, c d)
   
       fn(300)
       print('a =', a)
       print('b =', b)

4. 局部变量说明:
   
   1. 在函数内首次对变量赋值是创建局部变量,再次为变量赋值是修改局部变量的绑定关系
   2. 在函数内部的赋值语句不会对全局变量造成影响