函数的嵌套,名称空间,以及作用域

函数的嵌套,名称空间,以及作用域

1、调用函数的三种形式

def func():
    print('from func')
func()#第一种函数名加括号

def max_2(x,y):
    if x > y:
        return x
    else:
        return y
res = max_2(10,3)
print(res)#表达式去调用

def max_2(x,y):
    if x > y:
        return x
    else:
        return y
res = max_2(10,max(2,3))
print(res)#函数作为参数的形式

2、函数的嵌套

def func1():
    print('from func1')

def func2():
    func1()
    print('from func2')

func2()
>>>from func1
from func2

3、函数的名称空间

  • 什么是名称空间?

    名称空间就是用来存放名字的空间。

  • 名称空间的作用

    如果你想访问一个变量值,必须先访问对应的名称空间,拿到对应的内存地址的绑定关系

  • 名称空间的分类

    1、内置名称空间:

    就是python解释器一启动就可以使用的名字,比如print,len,max,input等等我们之前也并没有定义过,可以直接拿来使用的名字,这些名字就存储在内置名称空间中

    2、全局的名称空间:

    存放文件级别的名字,就是全局名称空间,是在程序从上到下被执行的过程中依次加载进内存的,放置了我们设置了所有变量名和函数名,if,while,for,内部定义的名字执行之后都存放在全局名称空间

    3、局部名称空间

    就是在函数内部定义的所有名字,注意的是当调用函数的时候,才会产生这个名称空间,随着函数执行的结束,命名空间就消失

  • 生命周期:

    1、内置名称空间

    在python解释器启动的时候生效,关闭python解释器的时候失效

    2、全局名称空间

    当你启动这个py 文件的时候生效,当前页面代码执行结束之后失效

    3、局部名称空间

    当你调用函数的时候生效,函数一旦调用完毕就失效

  • 名称空间的使用范围

    1、在局部可以全局名称,内置名称

    x = 1
    def func():
        print(x)#使用了全局名称x,以及使用了内置名称print
    
    func()
    >>>1

    2、在全局可以使用内置名称空间,但不可使用局部名称空间

    x = 1
    def func():
        a = 1
        print(x)#使用了全局名称x,以及使用了内置名称print
    
    func()
    print(a)#NameError: name 'a' is not defined
            #此时a已经消失了
    

    3、在内置不可使用局部和全局的名称

    x = 1
    def func():
        x = 2
        print(x)#使用了局部名称x
        def func1():
            x = 3#我自己有就用我自己的,没有就去找上一级,如果上一级都没去找内置,如果内置都没有那就保存
            print(x)
        func1()
    
    func()
    >>>2
    >>>3
    
    x = 1
    def func():
        x = 2
        print(x)#使用了局部名称x
        def func1():
            print(x)#我自己没有就用上一级的x=2
        func1()
    
    func()
    >>>2
    >>>2
    
    x = 1
    def func():
        print(x)
        def func1():
            print(x)#我自己没有就用上一级的,上一级也没有就再找上一级
        func1()
    
    func()
    >>>1
    >>>1
    
    x = 1
    
    def index(arg = x):#默认参数,此时已经将x=1赋值给arg
        print(x)
        print(arg)
    
    x = 2
    index()
    >>>2
    >>>1

4、作用域的分类

1、全局作用域

全局可以调用的名字就存在于全局作用域

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

2、局部作用域

局部可以调用的名字就存放于局部作用域

局部名称空间

对于不可变类型,在局部可以查看全局作用域中的变量。但是不能直接修改,

如果想要修改,需要在程序中添加一个global变量,那么这个变量在局部的所有操作将对全局的变量有效

x = 1
def func():
    global x#声明此时的x就是全局变量
    x =2
    print(x)

func()
print(x)
>>>2
>>>2

#在局部修改外部函数的变量

def func():
    x = 1
    def func1():
        nonlocal x
        x = 3

    func1()
    print(x)#通过nonlocal就可以修改离他当前最近的一个外层变量的值,此时不会打印x=1,会打印x=3

func()
>>>3

加油吧,亚峰gogogo

原文地址:https://www.cnblogs.com/yafeng666/p/11837177.html

时间: 2024-10-07 05:38:01

函数的嵌套,名称空间,以及作用域的相关文章

函数对象,函数的嵌套,名称空间与作用域,闭包,装饰器,迭代器,内置函数

一,函数对象 函数对象:函数是第一类对象,即函数可以当做数据传递 1,可以被引用 2,可以做参数的传递 3,返回值可以是函数 4,可以当作容器类型的元素 二,函数嵌套 1,函数的嵌套调用 2,函数的嵌套定义 三,名称空间与作用域 名称空间:存放名字的地方叫名称空间,存放这些值与名字的绑定关系 查看内置名称的两种方法: 三种名称空间 1,内置名称空间:随着python解释器的启动而产生 2,全局名称空间:文件的执行会产生全局名称空间,指的是文件级别定义的名字都会放入该空间 3,局部名称空间:调用函

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

python_day04 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式

本节课重要知识点内容如下: 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式 1.函数嵌套 函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数 def bar(): print('from nbar')def foo(): print('from foo') bar()foo()def max2(x,y): if x > y: return x else: return ydef max4(a,

python基础(3):函数对象、函数嵌套、名称空间与作用域、装饰器

函数对象 函数嵌套 名称空间与作用域 闭包函数 装饰器 练习 一 函数对象 #1 可以被引用 def max(x, y): return x if x > y else y func = max print(func(1, 2)) #2 可以当作参数传递 def max(x, y): return x if x > y else y def max_1(x, func): return func(x, 1) print(max_1(2, max)) #3 返回值可以是函数 #4 可以当作容器类

python--函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套、函数对象

今天学习内容有函数的返回值.函数参数的使用.名称空间与作用域.函数嵌套. 下来我们一一查看. 函数的返回值 看几个栗子: def func(x): return x**2 y=func(10) print(y) def foo(): return None res=foo() print(res) def foo(): return{'a':1} res=foo() print(res['a']) def foo(): return {'a':1},1,'a',[1,2] res=foo() p

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

一.函数对象 函数对象,函数是第一类对象,即函数可以当做数据传递 具体特点: 1.可以被引用: 1 def foo(): 2 print('from foo') 3 4 func=foo 5 6 print(foo) 7 print(func) 8 func() 2.可以当作参数传递 1 def foo(): 2 print('from foo') 3 4 def bar(func): 5 print(func) 6 func() 7 8 bar(foo) 3.返回值可以是函数 1 def fo

Day19_名称空间和作用域_函数的嵌套_函数第一类对象的使用_闭包函数

一. 上节课复习 为何要使用函数 解决代码重用问题 统一维护 程序的组织结构清晰,可读性强 定义函数 !!!先定义后使用 def funcname(arg1,arg2,....) #funcname = 函数体 '''描述信息''' 函数体 return value 定义无参函数 定义有参函数 定义空函数 调用函数 语句形式:foo() 表达式形式:foo(1,2) 函数调用作为另外一个函数的参数:print(foo(1,2)) 函数返回值 不写return--->None return 一个值

函数对象、函数嵌套、名称空间与作用域、装饰器

一 函数对象 1.函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 2.利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input('>>: ').strip() if choice in dic: dic[choice]()

python基础之====函数对象、函数嵌套、名称空间与作用域、装饰器

阅读目录 一 函数对象 二 函数嵌套 三 名称空间与作用域 四 闭包函数 五 装饰器 六 练习题 一 函数对象 一 函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 二 利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input(

python之旅:函数对象、函数嵌套、名称空间与作用域、装饰器

一.函数对象 函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 # 利用该特性,优雅的取代多分支的if 二.函数嵌套 三.名称空间与作用域 四丶装饰器 原文地址:https://www.cnblogs.com/moyand/p/8667266.html