函数基础(二)(day11整理)

目录

• 昨日内容
  • 函数的定义
  • 函数的三种定义方式
    • 空函数
    • 有参函数
    • 无参函数
  • 函数的调用
  • 函数的返回值
  • 函数的参数
    • 形参
    • 实参
• 今日内容
  • 可变长参数
    • 可变长形参
    • 可变长实参(仅作了解)
  • 函数对象
  • 函数嵌套
  • 名称空间和作用域
    • 名称空间
    • 作用域

昨日内容

函数的定义

只检测语法,不执行代码

def 函数名():
    代码

函数的三种定义方式

空函数

有参函数

无参函数

函数的调用

函数的返回值

1. return可以返回值,默认返回None,rentun后面不加东西也返回None
2. return可以终止函数,有多个return,执行到第一个就终止
3. return可以返回多个值,以元组形式返回

函数的参数

形参

接受实参,具有描述意义

位置形参

从左到右依次接收位置实参

默认形参

1. 默认值,如果传参,使用传参的值,否则使用默认值(形参会多次使用同一个值)
2. 默认形参必须放在位置形参后面

实参

具体的值,传参给形参

位置实参

从左到右依次传参给位置形参

关键字实参

1. 按照形参名传参(参数较多使用)
2. 关键字实参必须得在位置实参的后面

今日内容

可变长参数

可变长形参

*形参名

def f1(*a): # 调用函数时,有多少个位置实参,就接受多少个参数
    print(a)

f1()  # a是空元组
f1(1) # (1, )
f1(1,2)  # (1,2)

*args(约定俗成),用元组接收多余的位置实参

**形参

def f1(**kwargs): #
    print(kwargs)

f1()  # 空字典
f1(x = 1) # {x:1}
f1(1,2)  # (1,2)

**kwargs,用字典接受多余的关键字实参

def f1(*args,**kwargs):
    print(args,kwargs)

f1(11,1,12,x = 1,x=2)

可变长实参(仅作了解)

*实参

def f1(a,b,c,d,e,f):
    print(a,b,c,d,e,f)

lt= [1,2,3,4,5,6]
# f1 = (lt[0],lt[1],lt[2],lt[3],lt[4],lt[5],lt[6])
f1(*lt)  # *lt把列表中的元素打散成位置实参依次传给位置实参

**实参

def f1(*args,*kwargs):  # 可接受所有类型
    print(args,kwargs)

def g1(a,b):
    print(a,b)

dic = {'a':1,'b'=2}
g1(**dic)  # a = 1,b = 2
f1(**dic)  # **dic把字典打散成关键字实参传给函数

函数对象

python中一切皆对象

s = '12'

1. 引用

   s1 = s

2. 容器元素

   lt = [s]

3. 作为函数的实参

   def f1(x):
       print(x)
   
   f1(s)    

4. 作为函数的返回值

   def f1(s):
       return s 
   
   s2 = f1(s)

字典/列表/元组/集合/布尔值,所有对象都可以以上四件事情

1. 引用

   def f1():
       print('from f1')
   
   # 函数对象 = 函数名
   
   func = f1
   func()  # f1()

2. 当作容器元素

   lt = [f1,1,2,3]
   
   lt[0]()  # f1()

3. 当作函数实参

   def f2(f2_f1):
       print(f2_f1)
       f2_f1()
   
   f2(f1)
   
   print(f1)
   

4. 做函数的返回值

   def f2(f2_f1):
       return(f2_f1)
   
   res = f2(f1)  #f1
   
   res()  # f1()

函数嵌套

函数内部定义的函数,外部不能用

名称空间和作用域

名称空间

变量名/函数名都叫名称

名称空间:专门存储名称

1. 内置名称空间(存储内置方法名称)

   数据自带内置方法,python解释器自带内置方法(print/len)

2. 全局名称空间:除了内置和局部

   def f1():
       x =10
   
   y = 10
   lt = [1,2,3]

3. 局部名称空间:函数内部定义的

• 名称空间的执行(生成)顺序

  1. 内置名称空间：python解释器启动就会有
  2. 全局名称空间：执行代码时候才会有
  3. 局部名称空间：函数调用的时候才会有局部

• 搜索顺序：先从当前所在位置搜索，找不到再按照局部>全局>内置>报错的顺序，不会逆向寻找

作用域

全局作用域

内置名称空间+全局名称空间

局部作用域

局部名称空间

1. 全局作用域的x和局部作用域的x没有关系

2. 局部作用域1的x和局部作用域2的x也没有关系，即使局部作用域1和局部作用域2在同一个局部

了解

1. global：打破了上述第一点规则

   x= 10 
   
   def f1():
       global x  # 让global以下局部的x变成全局
       x = 20
   
   f1()
   print(x)  # 20

2. nonlocal：打破上述第二点规则

   def f1():
       def f2():
           def f3():
               nonlocal x  # nonlocal让x成为顶层函数的局部，但是不能成为全局
   
               x = 1
           x = 2
           f3()
       f2()            

python3中，所有可变数据类型均可打破上述一切规则

lt = [10]

def f1():
    lt[0] = 11

f1()
print(lt)   # [11]
    

• 拓展(面试题)

def f1(i,lt=[]):
    lt.append(i)
    print(lt)

for i in range(3):
    f1(i)

[0]

[0,1]

[0,1,2]

def f1(i,lt):
    lt.append(i)
    print(lt)

fori in range(10):
    f1(i,[])

[0]

[1]

[2]