函数名存放的就是函数的地址，所以函数名也是对象，称之为函数对象

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    # /

完成两个数的某一运算，拿到结果：

方法一：
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)

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