s21day10 python笔记

s21day10 python笔记

一、函数补充

1.1 参数

1. 基本参数知识

def get_list_date(aaa):       #aaa：形式参数(形参)  任意个数
    v = [11,22,33,44]
    print(v[aaa])

get_list_date(1)             #1：实际参数(实参)   任意类型

1. 位置传参(传参：调用函数并传入参数)

   • 要求：严格按照位置进行传参

   • 位置参数：positional argument

   • 基本形式

     def func(a,b):
         print(a,b)
     
     func(11,22)               #位置都是一一对应的，a = 11，b = 22

2. 关键字传参

   • 关键字参数：keyword argument

   • 基本形式

     def func(a,b):
         print(a,b)
     
     func(b = 11,a = 22)        #按照关键字进行传参，可以交换位置

   • 注意：open(打开文件)是python内部写好的一个函数，运用的就是关键字传参

   • 关键字传参和位置传参可以混合使用

     • 位置参数必须在关键字参数的前面
     • 位置参数的个数 + 关键字参数的个数 = 总参数个数
     • 一个参数不能传多次

3. 默认参数：可传可不传

   • 基本形式

     def func(a,b = 9):          #b就是默认参数，默认值为9
     #func函数接受两个参数，调用函数进行传值时，默认参数可传可不传，不传则使用默认值，传则使用传的值
         print(a,b)
     
     func(123)                   #a = 123，b使用默认值，即b = 9
     func(11,22)                 #a = 11，b = 22

   • 对于默认值，如果是可变类型(明日补充)

4. 万能参数

   • *args

     • 可以接受任意个数的参数，并将参数转化为元组(注意实参里有*和没有的区别)
     • 只能使用位置传参
     • 基本形式

     def func(*args):
         print(args)
     
     func(1,2)                #args = (1,2)
     func((11,22,33))         #args = ((11,22,33),)
     func(*(11,22,33))        #args = (11,22,33)       循环元组里的元素，加入到元组中
     func(*[11,22,33,44])     #args = (11,22,33,44)    循环列表里的元素，加入到元组中
     #注意实参里有*和没有的区别
     
     #特殊情况：
     def func(a,*args,b):     #a只能使用位置参数，b只能使用关键字参数
         print(a,args,b)
     
     func(1,2,3,4,b = 5)      #a = 1,args = (2,3,4),b = 5  

   • **kwargs

     • 可以接受任意个数的参数，并将参数转化为字典(注意实参里有**和没有的区别)
     • 只能使用关键字传参
     • 基本形式

     def func(**kwargs):
         print(kwargs)
     
     func(k1 = 1,k2 = 'alex')          #kwargs = {'k1':1,'k2':'alex'}
     func(**{'k1':'v1','k2':'v2'})     #kwargs = {'k1':'v1','k2':'v2'}
     #注意实参里有**和没有的区别  

   • 综合运用(*args和**kwargs一起使用)

   def func(*args，**kwargs):
       print(args，kwargs)
   
   func(1,2,3,4,k1 = 1,k2 = 2)              #args = (1,2,3,4),kwargs = {'k1':1,'k2':2}
   func(*[1,2,3],**{'k1':'v1','k2':'v2'})   #args = (1,2,3),kwargs = {'k1':'v1','k2':'v2'} 

5. 参数相关重点

   • 定义函数

     #情况一：
     def func(a,b):
         pass
     
     #情况二：
     def func(a,b = None):
         pass
     
     #情况三：
     def func(*args，**kwargs):
         pass

   • 调用函数：位置参数 > 关键字参数

1.2 返回值

1. 作用
   • 返回值
   • 终止函数的执行
2. 基本形式

def func(arg):
    代码             #函数内容
    return 9         #返回值为9，默认：return None

val = func('ads')    #设置一个变量接收返回值

#特殊情况：
def func():
    return 2,3,'alex'     #返回是一个元组

val = func()
print(val)                #(2,3,'alex')

1. 返回值相关重点
   • 函数没有返回值，默认返回：None
   • 函数内部执行过程中一旦遇到return就终止
   • return可以返回任意类型

二、作用域

2.1 分类

• 全局作用域：在python中，相当于一个py文件

  • 全局作用域中的变量称为全局变量
  • 全局变量必须全用大写

• 局部作用域：在python中，相当于一个函数

  • 局部作用域中的变量称为局部变量
  • 局部变量则用小写

  USER_LIST = [11,22,3]         #全局变量
  def func():
      name = 'asdf'             #局部变量
      USER_LIST.append(12)
      USER_LIST.append(name)
  func()
  print(USER_LIST)

2.2 总结

• 在python中，一个函数就是一个作用域

• 作用域中查找数据规则：

  • 优先在自己的作用域里找数据
  • 自己没有就去 '父级' 中找，没有就去 '父级' 的 '父级' 中找，直到找至全局作用域
  • 如果最后全局作用域中也没有，就会报错
  • 寻找时注意：父级作用域中的值到底是什么

  #示例一：
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 8
          print(x)
  func()               # 9
  
  #示例二：
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 8
          print(x)
      x1()
  func()               # 9   8
  
  #示例三：
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 8
          print(x)
      print(x)
      x1()
  func()               # 9   9   8   
  
  #示例四：
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          x = 8
          print(x)
      x1()
      print(x)
  func()               # 9   8   9 
  
  #示例五：
  x = 10
  def func():
      x = 9
      print(x)
      def x1():
          print(x)
      x1()
      print(x)
  func()               # 9   9   9
  
  #示例六：
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          print(x)
      x = 9
      x1()
      x = 10
      print(x)
  func()               # 8   9   10
  
  #示例七：
  x = 10
  def func():
      x = 8
      print(x)
      def x1():
          print(x)
      x1()
      x = 9
      x1()
      x = 10
      print(x)
  func()               # 8   8   9   10

• 对于子作用域：

  • 只能找到 '父级' 中的值，默认无法重新为 '父级' 的变量进行赋值

  • 如果非要对变量进行重新赋值，使用 global / nonlocal 进行强制赋值

    • global：直接找到全局的变量，再进行重新赋值，其他的不更改
    • nonlocal：只找到 '父级' 的变量，进行重新赋值，其他的不更改
    • 建议：一般不要使用，以免造成代码混乱

    #global示例：
    name = 'oldboy'
    def func():
        name = 'alex'
        def inner():
            global name      #直接找到全局的name
            name = 'abc'     #再进行重新赋值
        inner()
        print(name)          #'alex'
    func()
    print(name)              #'abc'
    
    #nonlocal示例：
    name = "oldboy"
    def func():
        name = 'alex'
        def inner():
            nonlocal name    #找到上一级的name
            name = 'abc'     #再进行重新赋值
        inner()
        print(name)          #'abc'
    func()
    print(name)              #"oldboy"