Day 11 函数对象 + 函数的嵌套 + 名称空间与作用域

目录

• 0 昨日复习
  • 0.1 函数
  • 0.2 定义
  • 0.3 三种形式的函数
    • 0.3.1 无参函数
    • 0.3.2 有参函数
    • 0.3.3 空函数
  • 0.4 函数的返回值
  • 0.5 函数的调用
  • 0.6 函数参数的应用
    • 0.6.1 形参
    • 0.6.2 实参
    • 0.6.3 位置形参
    • 0.6.4 位置实参
    • 0.6.5 默认形参
    • 0.6.6 关键字实参
  • 0.7 可变长参数
    • 0.7.1 *形参
    • 0.7.2 *实参
    • 0.7.3 **形参
    • 0.7.4 **实参
    • 0.7.5 最终
• 1 函数对象
  • 1.1 引用，赋值
  • 1.2 当做函数的返回值
  • 1.3 当作函数的参数
  • 1.4 作为容器元素的元素
  • 1.5 练习
• 2 函数的嵌套
• 3 名称空间与作用域
  • 3.1 内置名称空间
  • 3.2 局部名称空间
  • 3.3 全局名称空间
  • 3.4 执行顺序和查找顺序
  • 3.5 作用域
  • 3.6 global and nonlocal (了解)

0 昨日复习

0.1 函数

• 定义阶段：只识别语法，不执行函数体代码
• 调用阶段：执行函数体代码

0.2 定义

def 函数名():
	代码块

0.3 三种形式的函数

0.3.1 无参函数

def 函数名():
	代码块

0.3.2 有参函数

def 函数名(x,y):
  代码块

0.3.3 空函数

def 函数名():
	pass   #以后再输入

0.4 函数的返回值

返回值是通过return关键字返回的

def 函数名():
	pass  #默认返回none

def self_max(x,y)
	if x > y:
		return x
	else:
		return y

max_num = self_max(10,20)
print(max_num * 2)  # 40

def get_list():
  return [1,2,3],len([1,2,3])
get_list()   #([1,2,3],3)
# 返回多个值的时候，会用元组接收多个值

return 除了返回值的作用，还有终止函数的作用，即不运行return后面的代码，也就是说一个函数可以有多个return，只要遇到第一个return就终止了

0.5 函数的调用

普通的调用：

def f1():
	pass
f1()

调用后做处理：

def self_max(x,y)
	if x > y:
		return x
	else:
		return y

max_num = self_max(10,20)
print(max_num * 2)  # 40

0.6 函数参数的应用

0.6.1 形参

定义阶段的参数叫形参，形参具有描述意义，不是一个具体的值

0.6.2 实参

调用阶段传入的值，是一个具体数据类型的值

0.6.3 位置形参

从左到右放入

0.6.4 位置实参

从左到右与形参一一对应

0.6.5 默认形参

def f1(y,x=1):
  return x+y
z = f1(2)   #y = 2,x = 1
print(z)

一般用于形参经常使用同一个值的时候，默认形参必须在位置形参的后面

0.6.6 关键字实参

def f1(x,y,z):
  return x+y
a = f1(z,y = 2,x = 1)   #y,z = 2,x = 1
print(a)

一般用于参数较多的时候，指定传值，可以打乱顺序传值，关键字实参必须的在位置实参的后面

0.7 可变长参数

0.7.1 *形参

def f1(*args): 
  print(args)  # 以元组的形式输出
  return args		#以元组的形式返回
f1(1,2,3,4)  # 此时数据个数不限

0.7.2 *实参

def f1(x,y,z,u):
  print(f'x:{x},y:{y},z:{z},u:{u}')
args = (1,2,3,4)  #定义一个元组，元组个数必须与形参个数相同才能在下一步用*args当实参
f1(*args) 

0.7.3 **形参

def f1(**kwargs):
  print(kwargs)  #以字典的形势输出 ，kwargs = {'a':1,'b':2,'c':3,'d':4}
f1(a=1,b=2,c=3,d=4)  #此处必须为关键字实参，个数不限

0.7.4 **实参

def f1(a,b,c):
  print(f'a:{a},b:{b},c:{c}')   #输出a:7,b:4,c:2
kwargs = {'b':4,'c':3}
f1(9,**kwargs)

0.7.5 最终

def f1(*args,**kwargs): #这样子定义形参，不论实参怎么输入，函数都能接收到
  print(args,kwargs)
f1(1,2,3,,4,5,x=1,t=9) 

1 函数对象

1.1 引用，赋值

def f1():
    print(123)
a = f1  # 此时a与f1有一样的功能，是一个函数
print(id(f1))   # 输出f1的位置
print(type(f1))  #输出f1的类型，function
a()   # 等价于 f1()
print(a)  # 输出

1.2 当做函数的返回值

def f2():
    return(f1())  #返回的是f1()运行后的结果
    return(f1)  #返回的是f1的内存地址
def f1():
    print(147)

1.3 当作函数的参数

def f2(m):
    m()  #此时要求形参必须是一个函数的名称，不然会报错的吧

def f1():
    print(147)
f2(f1)

1.4 作为容器元素的元素

def f1():
    print(1450) 
list = [1,2,f1]  
list[2]()   #此时list[2]即为f1

1.5 练习

def weixin():
    print("微信支付成功！")
def zhifubao():
    print("支付宝支付成功！")

dict = {'0':weixin,'1':zhifubao,'2':'跑单'}
dict_print = {'0':'weixin','1':'zhifubao','3':'跑单'}
while True:
    print(dict_print)
    choice = input("请选择你的支付方式--->").strip()
    if choice == '0' or choice == '1':
        dict[choice]()

    elif choice == '2':
        print("2b，那你还不快跑！")
    else:
        print('傻逼，看不懂人话？')
    break

2 函数的嵌套

# # 定义阶段只检查语法，不执行代码
def f1():
    def f2():
        print(125)
    f2()
f1()


# 通过输入指令来输出圆的周长和面积  (傻逼采用嵌套）
from math import pi
def circle(r,action):
    if action == 'p':
        def perimeter():
            return 2*pi*r
        res = perimeter()
    elif action == 'a':
        def area():
            return pi*r**2
        res = area()
    else:
        res = '傻逼，输错了'
    return res

r_choice = int(input("请输入半径>>>").strip())
action_choice =input("选择你所需要的功能，计算面积：'p',计算周长：'a'>>>")
res=circle(r_choice,action_choice)
print(res)

3 名称空间与作用域

名称空间：存放名字的空间

3.1 内置名称空间

定义：python自带的（有点像小整数池）

生命周期：python启动的时候就活了，python关闭了就死了

'str'.strip()  # 之前所学的内置方法都是一个个被封装好的函数，被封装后具有了某种功能
list = [1,2,3,4]
len(list)

# len是python的内置方法，python启动的时候，就会定义len函数，并把len丢入到内存空间中去
# 这个内存空间叫做内置名称空间 （有点像小整数池）

3.2 局部名称空间

定义：函数内部的都叫局部，也就是说函数内部定义的名字都放入了局部名称空间中

生命周期：函数运行的时候会活，运行完就死了

def f1():
    def f2():
        pass
    f2()

3.3 全局名称空间

定义：除了内置和局部，剩下的都是全局名称空间

生命周期：程序/文件运行的时候才会活，运行完就死了

3.4 执行顺序和查找顺序

• 执行顺序：内置名称空间 ---> 全局名称空间 ---> 局部内置空间
• 查找顺序：从当前名称空间开始查找，然后逐步往上，如果当前为局部，则顺序为 局部--->全局--->内置

x = 1
def f1():
    x = 2
    print(2,x)  # 输出2，2

x = 3
print(1,x)  #输出1，3
f1()

3.5 作用域

• 全局作用域：适用于全局+内置，也就是全局可以修改内置的，内置的可以修改全局的
• 局部作用域：只适用于局部范围
• 作用域关系在函数定义阶段就已经确定了
• 函数与函数之间可能存在相同的变量名，但他们是毫无关系的，作用域不同

def f1():
    x = 1
    def f2():
        print(1,x)
    return f2
#  f1()  #f2
f2 = f1() #f2()
x = 10
def f3():
    x = 15
    print(2,x)
    f2()
f3()

3.6 global and nonlocal (了解)

# global:局部修改全局
x = 100
def f1():
    global x
    x = 1
    print(1,x)  #输出 1，1
f1()
print(2,x)  # 输出2，1

# nonlocal:把局部改成外部
x = 10
def f1():
    x = 1
    def f2():
        nonlocal x   #声明x是外部，嵌套函数的内部的外部,不能修改全局
        x = 3
    f2()
    print(1,x)
print(2,x)
f1()