python笔记(9)--函数（参数，作用域，函数嵌套）

今日内容

• 参数
• 作用域
• 函数嵌套

内容：

time.sleep()的用法：

import time                     #使用time模块

result = [1,1]
while True:
   num = result[-1] + result[-2]
   result.append(num)
   if result[-1] >= 100:
       break
   print(result)
   time.sleep(1)                # 设置time睡眠时间，每隔一秒打印一次

1.参数

基本参数

• 任意个数
• 任意类型

def func(a1,a2,a3):
    print(a1,a2,a3)

func(1,"sadf",True)

位置传参

• 调用函数并传入参数

def func(a1,a2)
    print(a1,a2)
func(1,2)

关键字传参

• 关键字传参数可以和位置参数混合使用
• 位置传入的参数在前 > 关键字参数在后 == 总参数个数 (永远遵循此规则)

def func(a1,a2):
    print(a1,a2)
func(a2=1,a1=2)

#示例：
def func(a1,a2,a3):
    print(a1,a2,a3)
#func(a2=1,a1=2,a3=3)
#func(1,a2=2,a3=3)
#func(a1=1,a2=2,3)   错误，位置参数应在前，关键字参数应在后，
#func(1,a2=2,3)      错误，位置参数应在前，关键字参数应在后，

默认参数

• 调用函数时，默认参数可传可不传
• 默认参数规则放后面

def func(a1,a2=2,a3=3):
    print(a1,a2,a3)
#func(a1=1,a2=2,a3=333)
#func(1)

万能参数（参数打散）

1. *args(规范使用此变量命名)

• 可接收任意个数的位置参数，并将参数转换成元组。
  • 函数调用有*，传参会把值打散了传入args元组内，变成元组的各个元素
  • 函数调用无*，传参会把值作为args的第0个元素传入
• 只能用位置参数传参

def func(*args):
    print(args)
#func(1,22,33,(1,2,3),["asf",789],"oiquwer")   都可传入一个值的args，args为（传入值组成的元组tuple）
#func(*(11,22,33))        结果为(11,22,33)
#func((11,22,33))         结果为((11,22,33))

def func(a1,*args):
    print(a1,args)
# func(1,(11,22,33))          结果为1，(11,22,33)
# func(1,2,3,4,5,6)          结果为1,(2,3,4,5,6)

1. **kwargs（规范使用此变量命名）

• 可接收任意个数的关键字参数，并将参数转换为键值对放入字典中
  • 函数调用有*(必须为两个*)，只能传字典，值为传入的字典
  • 函数调用无*，根据关键字传参，会直接生成键值对加入字典
• 只能用关键字参数传参

def func(**kwargs):
    print(kwargs)
func(k1=1,k2="asdf")        #结果为  {'k1': 1, 'k2': 'asdf'}
func(**{"k1":1,"k2":"asdf"})        #结果为  {'k1': 1, 'k2': 'asdf'}

1. 混合使用

• 可接收任意参数（位置参数+关键字参数）

  def func(*args,**kwargs):
      print(args,kwargs)
  
  func(1,2,3,k1=55,k2=89)               #结果为(1,2,3) {'k1':55,'k2':89}
  func(*[1,2,3],k1=55,k2=89)                #结果为(1,2,3) {'k1':55,'k2':89}
  func(*[1,2,3],**{"k1":55,"k2":89})        #结果为(1,2,3) {"k1":55,"k2":89}
  func(11,22,*[1,2,3],k1=55,k2=89,**{"k11":55,"k12":89})
                                #结果为(11, 22, 1, 2, 3) {'k1': 55, 'k2': 89, 'k11': 55, 'k12': 89}

参数重点（掌握）

1. 定义函数(以后常见的函数样式)

def func1(a1,a2):
    pass
    
def func2(a1,a2=None):
    pass

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

1. 调用函数（传参）

   一定要记住，位置参数在前，关键字参数在后

2.作用域

python中：

• py文件：全局作用域

• 函数：局部作用域

  a=1
  def func():
      x1=666
      print(x1)
      print(a)
      print(b)
  b=2
  func()                # 666,1,2
  
  print("----------分界线1----------")
  a = 8888
  def func2():
      print(a,b)      #从上往下执行，如果函数体内有变量在全局更改了，则执行到调用函数的前面才重新赋值
      func()
  
  func2()              #报错，因为从上往下执行中，b没有值
  b=2222
  print("----------分界线2----------")

  #从上往下执行，如果函数体内有变量在全局更改了，则执行到调用函数的前面才重新赋值
  a=1
  def func():
      x1=666
      print(x1)
      print(a)
      print(b)
  b=2
  b=222
  func()            #调用函数时，输出结果为x1=666,a=1,b=222
  b=8888
  print(b)      #输出结果为8888

  #错误示例
  def func():
      x1=666
      print(x1)
  
  func()
  print(x1) #因为x1的作用域在函数体中，全局调用不了函数体内局部作用域的赋值

• 总结：

  • 一个函数就是一个作用域

  • 作用域中查找数据规则：优先在自己的作用域找数据，自己没有就去 "父级" -> 全局作用域 去找，全局里没有就报错

    • 注意：父级作用域中的值到底是什么

    x = 11
    def func():
        x = 8
        print(x)   #8
        def x1():
            print(x) #8
    
        x1()  
        x = 9
        x1()  #9
        x = 10
        print(x)   #10
    func()

    • 子级作用域中重新赋值，不会影响到父级和全局的变量赋值

    • 子级作用域中修改可变类型变量，则会影响到父级和全局的可变变量值

      info = [11,22]
      def func():
          info.append(33)
          print(info)
      func()    #结果为[11,22,33]

    • global：在局部变量中强制赋值，修改全局变量

      name = "yanan"
      def func():
          global name
          name = "alec"
      func()
      print(name)           #输出结果为name = alec
      #######################################
      name = ['wo','yanan']
      def func():
          global name
          name = "alec"
      func()
      print(name)           #输出结果为name = alec
      ########嵌套内的函数中，global修改的也是全局变量
      name = "yanan"
      def func():
          name = "centos"
          def inner():
              global name
              name = 999
              print("inner",name)       #name = 999
          inner()
          print("func",name)            #name = centos
      func()
      print("全局变量",name)            #name = 999（被global修改过的变量）

    • nolocal：只能用在嵌套函数中，嵌套函数中只修改上层的赋值

      name = "yanan"
      def func():
          name = "centos"
          def inner():
              nonlocal name
              name = 999
              print("inner",name)       #name = 999
          inner()
          print("func",name)            #name = 999（被nonlocal修改过的变量）
      func()
      print("全局变量",name)            #name = "yanan"（全局未被修改）

    • 全局变量由大写字母组成，函数体内部可由小写字母组成。类似于以下代码

      USER_LIST = [11,22,33]
      def func():
          USER_LIST.append(44)
          USER_LIST.append(550)
      
      func()
      print(USER_LIST)