函数--基本使用

函数--基本使用

• 函数--基本使用
  • 名称空间概念
  • 名称空间的作用域
  • global与nonlocal关键字使用
  • 函数对象（函数名）
  • 函数的嵌套定义
  • 函数的嵌套调用
  • 名字的查找 顺序
  • 闭包函数
  • 装饰器

名称空间概念

用于存放变量名与变量值绑定关系的地方

名称空间的分类
	1.内置名称空间
    	python解释器提前定义好的
        	print()
            len()
            ...
    2.全局名称空间
    	在Py文件中定格编写的代码运行后都会存入全局名称空间
        	name = 'jaosn' 	# name全局
            
            def func():		# func全局
                	pass
            if 1:
                a = 123		# a全局
                
            for i in renge(10):
            	print(i)	# i全局
            
            while True:
                a = 123		# a全局
    3.局部名称空间
    	函数体代码运行产生后的都是局部名称空间
    
#存活周期
	1.内置名称空间
    	python解释器启动与关闭而创建和销毁
    2.全局名称空间
    	随着Py文件的运行与结束而创建和销毁
    3.局部名称空间
    	随着函数整体代码的的执行与结束而创建和销毁
        

名称空间的作用域

作用域
	名称空间所能够作用的范围
    
内置名称空间
	程序任何阶段任何位置均可使用(全局有效)
全局名称空间
	程序任何阶段任何位置均可使用(全局有效)
局部名称空间
	一般情况下只在各自的局部名称空间中有效

global与nonlocal关键字使用

#局部修改全局变量 使用global关键字声明
x = 133
def inedex():
    global x
    x = 23
inedex()
print(x)

如果数据为可变类型那么不需要关键字global声明
如果为不可变类型那么需要关键字声明
name_list = ['jjj', 'bbb']
def index():
    name_list.append('hhhhhh!')
index()
print(name_list)

'''
如果想要在内部的局部修改外部局部的不可变类型数据
需要关键字nonlocal声明
'''

函数对象（函数名）

'''函数名遇到括号就会调用'''
用法一：函数名可以当作变量名赋值
def index():
    print('fronm index')
a = index
a()		#本质就是在调用index函数

用法二：函数命名还可以当作函数的实参
def index():
    print('from index')
def func(a):
    print(a)
    a()
    print('from func')
func(index)

用法三：函数名还可以当做函数返回值
def index():
    print('from index')
def func():
    print('from func')
    return index
res = func()		#调用func并接受func的返回值
res()

用法四：函数名可以当做容器的类型(内部可以存放多个数据)的元素
 def index():
        print('from index')
 1 = [11, 222, 333, index()]
print(1)

函数的嵌套定义

函数体内定义其他函数
将复杂的功能全部隐藏起来 暴露一个简单的接口
def all_func(type):
    def register():        
        print('注册功能')    
    def login():        
        print('登录功能')    
    def transfer():        
        print('转账功能')    
    def shopping():        
        print('购物功能')    
        # 这里仅仅是延时嵌套定义的现象 暂不考虑优化    
    if type == '1':        
        register()   
    elif type == '2':        
        login()    
    elif type == '3':        
        transfer()    
    elif type == '4':        
        shopping()    
    else:        
        print('不知道啥功能')?all_func('3')

函数的嵌套调用

内部函数调用其他函数

def index():
    print('from index')
def func():
    index()
    print('from func')
func()

def my_max(a, b):
    if a > b :
        return a
    return b
def many_max(x, y, z, m,):
    res = my_max(x,y)
    res1 = my_max(res ,z)
    res2 = my_max(res1,m)
    return res2
ret = many_max(1,2,3,4)
print(ret)7

名字的查找 顺序

# 在查找名字的时候 要先确定自己当前在哪
	1.如果你在局部
    	局部 >>> 全局 >>> 内置
    2.如果你在全局
    	全局 >>> 内置
     
# 局部名称空间的嵌套 
'''函数在定义阶段名字的查找顺序就已经固定死了(特例)'''
x = 111
def f1():
    x = 222
    def f2():
        x = 333
        def f3():
            x = 444
            def f4():
                x = 555
                print(x)
                # x = 555  特例
            f4()
        f3()
    f2()
# 通过调用f1 执行所有的函数
f1()

闭包函数

闭：定在函数内部的函数
包：内部函数使用了外部函数名称空间中的名字
#只有符合上述两个特征的函数才可以称之为"闭包函数"


def outer():
    x = 22
    def index():
        print('from index', x)
    return index       

闭包函数其实是给函数传参的第二种方式

方式一：函数体代码需要用到数据	直接在括号内定义形参即可
def index(username):
    print(username)
def my_max(a,b):
    if a > b:
        return a
    return b
方式二：利用闭包函数
def outer(x, y):
    x = 2
    y = 40
    def my_max():
        if x > y:
            return x
        return y
    return my_max
res = outer(2, 40)
print(res())

装饰器

由名称空间 函数对象 闭包函数组合而来

原则：

? 开放封闭原则

? 开放：对扩展开放

? 封闭：会修改封闭

核心思想：

? 在不改变 " 装饰对象内部代码 "和 ” 原有调用方式 “ 的基础之上添加额外功能

器：指的是工具
装饰：给被装饰对象添加额外的功能

def index():
    print('from index')
index()
#统计index函数的执行时间

 import time

#pirnt(time.time())		#1637036293.0609405
#获取的结果叫时间戳(运行代码的那一刻距离1970-1-1所经历的秒数)
time .sleep(3)		#让程序原地等待3秒
print('睡饱了')

def index()
	time.sleep(3)
    print('from index')

#统计index函数的执行时间
#在函数运行之前统计一次时间
start_time = time.time()
index()
#在函数运行完毕之后在统计
end_time = time.time()
#计算差值
print(end_time - start_time)