函数定义与使用

上周内容回顾

• 函数的语法结构

def 函数名(形参)：
	'''函数注释'''
  函数体代码
	return 返回值
res = return

• 函数的定义与调用

1.一定是先定义后使用
定义函数使用关键字def
调用函数使用关键字加括号（有参数得传参数）
2.定义函数与调用函数
定义函数只检测语法不执行函数体代码

• 函数的分类

内置函数
python解释器提前定义的函数
自定义函数
需要人为定义
			空函数
  		无参函数
    	有参函数
      

• 函数的返回值

调用函数之后产生的结果
'''
如何接受返回值(统一语法)'''
变量名 = 函数
1.函数体代码没有return默认返回None
2.函数体代码有return 后写什么反回什么
	1.不写  None
  2写一个
  3.写多个
3.函数体代码遇到return会立刻结束

• 函数的参数

'''
形参
函数定义阶段括号内写的变量名
实参
函数调用阶段括号内写的数据值

在函数调用阶段形参会与实参临时绑定
在函数体代码结束之后会立刻解除绑定关系
动态绑定 动态解除

'''

1.位置参数
位置形数
def func(a,b):pass
位置实参
func(1,2) # a对应1，b对应2
2.关键字参数
关键字实参
func(b=1,a=2) # 赋值的关系
3.默认值参数
默认值形参
def func(a,b=1):pass. # 默认b等于1只需要给一个实参实参传数据填数据不传默认就是1
4.可变长参数
可变长形参
def func(*args,**kwargs):pass #可以传值也可以不传 ，多余的位置实参会被args接收并组成元组返回，多余的默认实参会被kwargs接收组成字典返回，有形参则先满足需要的参数没有则不需要
'''
无论是形参还是实参 都遵循简单的靠左 复杂的靠右
函数调用阶段同一个形参不能多次传值简单的就是数据类型 复杂的是表达式比如什么=什么

今日内容概要

• *与**在实参中的作用

• 命名关键字参数(冷门了解)

• 名称空间

• 作用域

• global与nonlocal关键字

• 函数的嵌套定义与调用

• 闭包函数(给函数体传参的第二种方式)

  今日内容详细

  *与**在实参中的作用

  def func(*args,**kwargs):
    print(args)
    print(kwargs)
  func()  #(){}
  func([1,2,3,4,])  # ([1,2,3,4,]){}
  l1=[1,2,3,4,5]
  func(l1[0],l1[1],l1[2],l1[3],l1[4]) #(1,2,3,4,5) {}
  func(*l1) *等与for循环一个个数据拿出来然后一次性传值
  '''func('h','e','l','l','o')'''
  d = {'1': 'jason', '2': 18}
  # func(*d)  # ('1', '2') {}
  '''func('1','2')'''
  d1={'username':'jason','age':18}  # 将此字典换成关键字实参给形参传值可使用**
  func(**d1)
  func('username'='jason','age'=18)
  
  * 将数据for循环后一次性传给位置形参
  ** 将数据转为关键字实参传给关键字形参
  
  
  

  命名关键字参数(冷门了解)

  def func(a,b,*args):pass
  func(1,2)
  func(a=1,b=2)
  '''需要在传实参的时候必须按关键字才可以'''
  def func(a,b,*args,c)
  func(1,2,3,4,5)  # 报错
  func(1,2,3,4,5,6,7,c=4)  # (1,2,(3,4,5,6,7),4)
  #如果形参中有**kwargs必须在它前面
  def func(a,b,*args,c,**kwargs):
      pass
  func(1,2,3,4,5,6,c=123,name='jason')
  
  
  

  命名空间

  就是用来存放变量名与数据值之间绑定关系的地方
  '''
  回忆
  name = 'jason'
  在内存空间申请一快内存空间存储jason然后用变量名绑定jason
  变量名与jason的绑定关系就会被存储到名称空间中，之后使用变量名都是取名称空间中查找并锁定对应的数据值
  del name 删除的不是数据值而是变量名与变量名与数据值绑定的关系
  
  '''
  
  名称空间分类
  1.内置名称空间
  python解释器运行就会离开创建的空间
  写代码过程中可以直接使用的名字都在该空间
  len() print() input()
  2.全局名称空间
  py文件运行代码过程中产生的名字都会存入该空间
  谱图代码里的变量名
  3.局部名称空间
  函数体代码运行过程中产生的名字都会存入该空间
  名称空间的存活周期
  内部名称空间
  解释器运行创建，解释器关闭销毁
  全局名称空间
  py文件运行创建，py文件关闭销毁
  局部名称空间
  函数体代码运行创建，函数体代码结束销毁
  
  
  

  名字的查找顺序

  '''查找名字之前一定要先看自己在哪个名称空间'''
  1.当亲在全局名称空间
  全局名称空间>>>内置名称空间
  2.当前在局部空间>>>全局名称空间>>>内置名称空间
  名字查找顺序默认情况下不能颠倒只能局部到全局到内置
  
  

  名称空间的作用域

  1.内置名称空间
  在程序任意位置都可用
  2.全局名称空间
  在程序任意位置可用
  3.局部名称空间
  在各自的局部空间可用使用
  
  

  局部空间复杂情况

  1.各自局部空间默认情况下不能彼此共享名字
  def func1()
  	name = 'jason'
    print(age)
  def func2()
   age = 18
    print(name)
    
    
  func1()
  func2()
  
  
  
  2.特殊情况
  def func1():
       x = 2
      def func2():
           x = 3
           def func3():
               x = 4  特例
             	 print(x)
  				  print(x)
           func3()
       func2()
   func1()
  函数在定义就定好了名字的查找顺序
  

  global域nonlocal关键字

  name = 'jason'
  def func():
    global name  # 声明变量名name使用全局的不重新创建
    name = 'tony'
    print(name)
    
    
    """
  正常情况下 局部名称空间里面出现新的名字会在局部名称空间中存储
  但是有时候需要在局部名称空间中修改全局名称空间的名字"""
    
    
    l1 [1, 2, 3, 4]
    def func():
    l1.append(123)
  func()  
  print(l1)  # 直接修改
  
  
  s = '$jason$'
  def func():
      global s
      res = s.strip('$')
      print(res)
  
  func()
  修改后需要用变量接收不可变类型
  """局部修改全局名称空间中不可变类型的数据 需要使用关键字global声明
  如果是可变类型 则无需关键字声明
  """
  def func1():
      x = 1
      l1 = [1,2]
      def func2():
          nonlocal x  #通过局部空间修改外层局部空间的不可变类型
          x = 999
          l1.append(666)
      func2()
      print(x)
      print(l1)
  func1()
  """
  nonlocal 在内存局部名称空间修改外层局部名称空间中的不可变类型
  """
  

  函数名的多种使用方式

  def func():
      print('from func')
  
  # 1.函数名也可以被用来多次赋值(函数名与变量名使用一致)
  name = func
  name()
  name1 = name
  name1()
  
  # 2.函数名还可以当做函数的实参
  def index(a):
      print(a)
      a()
  index(123)
  name = 'jason'
  index(name)
  index(func)
  
  # 3.函数名还可以当做函数的返回值
  def index():
      return func
  res = index()
  print(res)
  res()
  
  # 4.函数名还可以当做容器类型里面的数据值
  l1 = [1,2,3,4,func]
  print(l1)
  l1[-1]()  # 索引到函数名然后调用