欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python——day11 函数(对象、名称空间、作用域、嵌套、闭包)

程序员文章站 2022-05-25 17:31:15
一、函数对象 函数名就是存放了函数的内存地址,存放了内存地址的变量都是对象,即 函数名 就是 函数对象 函数对象的应用 1、 可以直接被引用 fn = cp_fn 2 、可以当作函数参数传递 computed(cp_fn, 100, 20) 3、 可以作为函数的返回值 get_cp_fn(cmd): ......

一、函数对象

 

 函数名就是存放了函数的内存地址,存放了内存地址的变量都是对象,即 函数名 就是 函数对象
 函数对象的应用
 1、 可以直接被引用  fn = cp_fn
 2 、可以当作函数参数传递 computed(cp_fn, 100, 20)
 3、 可以作为函数的返回值  get_cp_fn(cmd): return add
 4、 可
以作为容器类型的元素  method_map: 对应关系中的值
函数名存放的就是函数的地址,所以函数名也是对象,称之为函数对象

a=10
def  fn():
    num=10
print('fn function run')
print(fn)

b=  a
print(b)
1、可以直接被引用
func=fn
print(func)
fn()
func()
2、可以当作函数参数传递
def add(a,b):    # +
  return a+b
def low(a,b):       # -
    return a - b
def jump(a,b):
    return a * b    # *
def full(a,b):
    return a / b    # /

 

计算:通过该函数可以完成对任意两个数的四则运算
def computed(fn,n1,n2):
    # fn 代表四则运算中的一种
    # res代表运算结果
    res=fn(n1,n2)
    return res  
完成两个数的某一运算,拿到结果:

方法一:
result=computed(add,100,20)
print(result)

方法二:
while true:
cmd=input('cmd:')
if cmd=='add':
    result=computed(add,100,20)
elif cmd=='low':
    result=computed(low,100,20)
else:
    print('输入有误')
print(result)
 3、可以作为容器类型的元素

def add(a,b):  # +
  return a+b
def low(a,b):   # -
    return a - b
def jump(a,b):
    return a * b         # *
def full(a,b):
    return a / b        # /
def quyu(a,b):
    return a%b           # %
def computed(fn,n1,n2):
    res=fn(n1,n2)
    return  res
method_map={
    'add':add,
    'low':low,
    'jump':jump,
    'full':full,
    'quyu':quyu,
}
while true:
    cmd=input('cmd:')
    # 用户输入的指令只有有对应的关系,就会自动去走对应的计算方法
    # 这样外界就不能失去关系到底有哪些计算方法
    if cmd in method_map:
        cp_fn=method_map[cmd]  #拿到计算方法
        result=computed(cp_fn,100,20) # 通过计算方法得到计算 结果
        print(result)
    else:
        print('输入有误,退出')
        break

 

 4、 可以作为函数的返回值
def add(a,b):  # +
  return a+b
def low(a,b):   # -
    return a - b
def jump(a,b):
    return a * b         # *
def full(a,b):
    return a / b        # /
def quyu(a,b):
    return a %b
def computed(fn,n1,n2):
    res=fn(n1,n2)
    return  res
method_map={
    'add':add,
    'low':low,
    'jump':jump,
    'full':full,
    'quyu':quyu,
}
# 根据指令获取计算方法
def get_cp_fn(cmd):
    if cmd in method_map:
        return  method_map[cmd]
    return  add   #  输入有误默认方法处理


while true:
    cmd=input('cmd:')

    if cmd in method_map:
        if cmd=='quit':
            break
        cp_fn=get_cp_fn(cmd)
        result=computed(cp_fn,100,20)
        print(result)

二、名称空间

名称空间:存放名字与内存空间地址对应关系的容器
作用:解决由于名字有限,导致名字重复发送冲突的问题

三种名称空间
built-in:内置名称空间;系统级,一个;随解释器执行而产生,解释器停止而销毁
global:全局名称空间;文件级,多个;随所属文件加载而产生,文件运行完毕而销毁
local:局部名称空间;函数级,多个;随所属函数执行而产生,函数执行完毕而销毁
注:
del 名字:可以移除查找最近的名字与内存空间地址的对应关系
加载顺序:built-in > global > local
print(len('abcd'))

len=len('asdbnmm')
print(len)

del len  # 删除上面赋值的len那最下面的'ndknwk'就可以打印出长度
print(len('ndknwk'))

 

def fn1():
    len=10
    print(len)
def fn2():
    len=20
    print(len)
fn1()
fn2()

 

三、作用域

作用域:名字起作用的范围
作用:解决同名字可以共存问题
四种作用域
built-in:内置作用域,所有文件所有函数
global:全局作用域,当前文件所有函数
enclosing:嵌套作用域,当前函数与当前函数的内部函数
local:局部作用域,当前函数

不同作用域之间名字不冲突,以达到名字的重用
 查找顺序:local > enclosing > global > built-in
len=10
def outer():
    len=20
    def inner():
        len=30
        print('1:',len) # 输出30  inner -> outer -> global -> built-in
        inner()
        print('2:',len) # 输出20 outer -> global -> built-in
outer()
print('3:',len) # 输出10 lobal -> built-in

del len
print('4:',len)  # 输出的是内部地址 built-in

 

四、嵌套使用

将函数直接定义到另一个函数内部,就可以使用外部函数的中的名字
def outer():
    num = 20
    def inner():
        print(num)  # inner就可以直接使用outer中的名字
    inner()
outer()

 

1、global关键词
def fn():
    global  num
    num=20
    print(num)
global关键词可以将local的名字提升为global的名字
 一个文件中的global名字就是一个,所以函数内部外部使用的名字都是一个
fn ()  #:一定要调用函数,才能产生名字,并提升
print(num)

 

2、 函数的嵌套定义
 将函数直接定义到另一个函数内部,就可以使用外部函数中的名字
def outer():
    num=20
    def inner():
        print(num)  # inner就是可以直接使用outer中的名字
outer()
传值方向:内置地址——内部的值——外部的值

 

方法一

print(len)
len(10)
def fn():
    len=20
    print(len)
fn()
print(len)

 

方式二:
ls=[]
def fn1():
    ls=[]
    ls.append(100)
    print(ls)
fn1()
print(ls)

定义一个函数,函数中有一个变量

def fn2():
    num=20
    return num  # 如果下一个要运行成功

    
在定义一个函数,该函数要使用上一个函数中的变量
def fn3():
    print(num)   # 报错因为上个函数运行后变量就被销毁了
num=fn2()  # 定义一个新的num然后赋值给上一个函数,fn3则就可以运行成功
fn3()

 

方法三
num=10
def fn2():
    global num # local:num=>>golbal:num
    num=20 #将20
    num=30
local的名字一旦golbal,就变成global的名字,一个文件中的global名字就是一个
def fn3():
    global num  # 全局作用域作用全局,并将两个文件中的值变为同一个值输出
    num=40
    print(num) # 输出20  20
fn2()
print(num) # 输出30 20 20
fn3()
print(num) # 输出30 40 40 20 20

 

将函数直接定义到另一个函数的内部,就可以使用外部函数中的名字
def fn4():
    num=20
    def fn5():
        print(num)
    fn5()
fn4()  #输出结果为20

 

五、闭包

 1、定义:closure:被包裹的函数,称之为闭包
 2、完整的闭包结构:1.将函数进行闭包处理;2.提升函数名的作用域,将内部函数对象作为外部函数的返回值
def outer(url):
    def get_html():
        html = requests.get(url)
        print(html.text)
    return get_html
先预定义多个爬虫方法,爬页面操作并未执行
baidu = outer('https://www.baidu.com')
python = outer('https://www.python.org')
sina = outer('https://www.sina.com.cn')
# 什么时候想爬什么页面就调用指定页面的爬虫方法
baidu()
sina()
baidu()