从入门到入狱-------函数（二）

入门 N day

----比较重要的部分来了，喜欢的欢迎收藏！----

• 函数的返回值

  返回值就是从函数内部传送到外部的数据，默认情况下，函数内部产生的新数据在函数外部不能使用

  def func1(a, b):
      c = a + b
      print(c)
  n(1, 2)   #3
  '''
  print(c) # NameError: name 'c' is not defined
  '''
  

  怎么确定函数返回值？

  python中每个函数都有返回值，返回值是什么就看执行函数体的时候遇到的return关键字后面的数据是什么，如果没有遇到return，返回值就是None。希望作为返回值的数据在函数结束的时候放在return的后面，函数调用表达式的值就是函数的返回值

  def func1(a, b):
      print(a + b)
  
  
  c = func1(1, 20)   # 没有遇到return  
  print(f'函数返回值是：{c}')  # 函数返回值是：None
  

  return的作用：遇到return会确定函数返回值并且直接结束函数，在函数外部接收return的返回值，在函数外部获取函数调用表达式的值就是在获取函数的返回值

  def func2(a, b):
      return a + b
      print(a + b)  # 不会执行
  
  
  c = func2(10, 2)
  print(f'函数返回值是：{c}')  # 函数返回值是：12
  
  
  def func3(a, b):
      return a + b, a * b
  
  
  c = func3(10, 2)
  print(f'函数返回值是：{c}')  # 函数返回值是：(12, 20)
  
  

  本质上返回的值是一个元组，但是可以用多个变量获取元组里面多个元素

  def func3(a, b):
      return a + b, a * b
  
  
  c, d = func3(10, 2)
  print(f'函数返回值是：{c}和{d}')  # 函数返回值是：12和20
  
  

  练习：定义一个函数，可以求多个数的和以及平均值

  def sums(*args):
      if not args:
          return None, None
      return sum(args), sum(args) / len(args)
  
  
  sums1, mean1 = sums(1, 2, 3, 4, 56)
  print(f'它们的和是{sums1},它们的平均值是{mean1}')
  

  用*打包和解包

  # 打包
  a, *b = 1, 2, 3, 4, 5
  print(a, b)  # 1 [2, 3, 4, 5]  通过*将b打包为列表
  # 解包
  b = [1, 2, 3, 4, 5]
  print(*b)  # 1 2 3 4 5  通过*将b列表解包
  

• 全局变量

  定义在函数和类外面的变量就是全局变量，全局变量的作用域是从定义开始到程序结束的任意位置都可以使用

  # 例如
  a = 100
  for i in range(1):
      print(f'循环内部{a}')  # 循环内部100
  
  
  def x():
  
      a='0000000000'
  
      print(f'函数内部{a}')
  
  x()  # 函数内部100
  
  # 注意：这里的j和m 都是全局变量，因为它们都在函数和类的外面定义的
  for j in range(3):
      m = 1
      print(f"循环内部{j}和{m}")
  print(f"循环外部{j}和{m}")  # 循环外部2和1
  
  
  def x1():
      print(f"函数内部{j}和{m}")
  
  
  x1()  # 函数内部2和1
  

• 局部变量

  定义在函数内部的变量是局部变量（定义在类里面的变量不是局部变量是属性）作用域是从定义开始到函数结束

  def func1(x, y=100):
      d = 123  # d,x,y 为局部变量
      print(f'函数内部{d}，{x}，{y}')
  
  
  func1(1)  # 函数内部123，1，100
  # print(d,x,y)     # NameError: name 'd' is not defined  不能在外部使用局部变量d
  

  函数调用过程内存的变化：每次调用函数的时候，系统会自动在栈区间开辟一个临时的内存空间用来保存在函数中产生的数据（定义的变量）当函数调用结束后，这块内存会自动释放。查看执行过程每一步的变化（网址打开比较慢）
  http://pythontutor.com/visualize.html#mode=edit

• global：在函数里面定义全局变量，只能在函数体中使用

  # 定义一个全局变量
  m = 100
  n = 1
  def func():
      # 定义一个新的局部变量m
      m = 200
      global n
      n = 100  # 将全局变量n的值变为100 n依然是全局变量
      global p
      p = 10  # 在函数内部定义一个全局变量p
      print(f"局部变量m：{m}，n:{n}")
  
  
  func()  # 局部变量m：200 n:100
  print(f"全局变量m:{m}，使用global后的n:{n}")  # 全局变量m:100，使用global后的n:100
  

• nonlocal：函数体内的函数重工修改第一层局部变量的值

  def func5():
      t = 1
      s = 1
  
      def func6():
          nonlocal s
          s = 200
  
      func6()
      print(f'函数中的变量t：{t},s:{s}')  # 函数中的变量t：1,s:200
  
  
  func5()
  

• 匿名函数

  匿名函数本质是函数，在定义的时候不需要函数名（一般情况下不会使用）在调用实参高阶函数的时候用得比较多。

  语法：lambda 形参列表 : 返回值

  相当于：def a(形参列表) :

  ​ return返回值

  def _(a, b):
      return max(a,b)
  
  
  re = _(1, 2) #获取函数的返回值
  print(re)  # 3
  re=lambda m, n: m + n
  re1 = re(1, 3)
  print(re1)  # 4
  
  # 练习：写一个匿名函数，获取两个数中最大的那个数
  a = lambda *args: None
  a1 = a(1, 50, 132, 4556)
  print(a1)
  

• 函数即是变量

  python中定义函数就是定义类型是function的变量，函数名就是变量名。

  普通变量能做的事情函数都能做

  a = lambda i: i * 2
  print(f'a的类型{type(a)}')  # a的类型<class 'function'>
  
  
  def b(x):
      return x * 2
  
  
  print(f'b的类型{type(b)}')  # b的类型<class 'function'>
  c = b  # 不加括号是给变量c赋值，加括号是获取返回值
  print(c(2))  # 4
  
  list1 = [1, 2, 3, c(2), b(3)]  # 将函数放入列表
  print(list1)  # [1, 2, 3, 4, 6]
  
  
  def func4(f):
      print(f(10, 20) * 2)
  
  
  func4(lambda *a: 12)
  
  
  
  def b(*x):
  
      return '*'
  
  a=b(123,2,5,6)*2
  print(a)
  
  
  list2=[i if i < 10 else i for i in range(0,100,3)]
  print(list2)
  
  
  list2=[]
  for i in range(0,100,3):
      if i <10:
          list2.append(i)
      else:
  
          list2.append(i)
  
  print(list2)