精华内容
下载资源
问答
  • 顾名思义就是存放名字的地方,比如,若变量x=1,1存放在内存里,那x存在哪里?名称空间就是存放名字x与1绑定关系的地方 x:内存地址 1所在的内存 名称空间共3种,分别如下: locals:是函数内的名称空间,包括...

    名称空间

    顾名思义就是存放名字的地方,比如,若变量x=1,1存放在内存里,那x存在哪里?名称空间就是存放名字x与1绑定关系的地方

    x:内存地址                               1所在的内存

    名称空间共3种,分别如下:

    locals:是函数内的名称空间,包括局部变量和形参

    globals:全局变量,函数定义所在模块的名字空间

    builtins:内置模块的名字空间

    作用域的查找空间

    作用域的查找顺序

    LEGB

    L:locals :函数的名字空间,包括局部变量和形参

    E:enclosing 相邻的上一级 外部嵌套函数的名字空间

    G:globls 全局变量,函数定义所在的模块名字空间

    B:builtins 内置模块的名字空间

    闭包

    举例:

    def func():
        n = 10
        def func2():
            print("n=",n)
        return func2
    
    f = func()
    f()

    从理论上说,当f = func()时候,func已经关闭,那么n = 10这个内部局部变量就应该释放了,但是f()仍能够打印出10,这是为什么呢?

    这就是闭包的概念

    整改代码发生的现象就是一个闭包

    f2是放在f里面,原来是根本拿不到f2,如果要执行只能在f里面执行

    但是现在 f返回了f2名称 相当于在外部拿到了里面的函数。

    即 func如果返回了内部的一个东西,并且还在使用中,那么他的内存空间不会释放的。

    我们在外部可以执行内部的函数,并且可以用内部函数作用域里面的所有值,这就是闭包

     

    原来f2放在func里面,在外面是不知道f2存在,只能在外面执行,但是把内层函数名称返回,在外部拿到了里面的函数,那其实func返回内部东西,还在使用中,内存空间没被释放。效果:我们在外部可以执行内部函数,并且可以用他内部函数作用域里的所有的值。

     

     

    装饰器

    代码有两个原则

    开放-封闭原则:开放 对现有功能的扩展开放  封闭:已实现的功能代码块不应该被修改

    不改变调用方式

    在符合开放封闭原则的情况下,给代码加新功能

    # -*- coding:utf-8 -*-
    def login(func):
        def inner():
            _username = '111'
            _password = '222'
            global user_status
            if user_status == False:
                username = input("user:")
                password = input("pasword:")
    
                if username == _username and password == _password:
                    print("welcom login...")
                    user_status = True
                else:
                    print("wrong!")
            if user_status == True:
                func()
        return inner
    
    def home():
        print("---首页----")
    #home = login(home())
    @login
    def america():
        print("----欧美----")
    
    def japan():
        print("----日本----")
    @login
    def henan():
        print("----河南----")
    
    user_status = False
    
    home()
    america()
    henan()

    个人理解:通过高阶嵌套函数,将原来的代码块进行包装

    home = login(home()) 此home非旧home, 

    如果遇到传参情况,为了方便装饰器能用多个代码块上,则需要传入非固定参数 *args **args,注意返回方法同样用**
    # -*- coding:utf-8 -*-
    def login(func):
        def inner(*args,**kwargs):
            _username = '111'
            _password = '222'
            global user_status
            if user_status == False:
                username = input("user:")
                password = input("pasword:")
    
                if username == _username and password == _password:
                    print("welcom login...")
                    user_status = True
                else:
                    print("wrong!")
            if user_status == True:
                func(*args,**kwargs)
        return inner
    
    def home():
        print("---首页----")
    #home = login(home())
    @login
    def america():
        print("----欧美----")
    
    def japan():
        print("----日本----")
    @login
    def henan(style):
        print("----河南----")
    
    user_status = False
    
    home()
    america()
    henan('3p')

    如果装饰器带参数,那么需要再套一层函数

    # -*- coding:utf-8 -*-
    def login(auth_type):
        def outer(func):
            def inner(*args,**kwargs):
                _username = '111'
                _password = '222'
                global user_status
                if user_status == False:
                    username = input("user:")
                    password = input("pasword:")
    
                    if username == _username and password == _password:
                        print("welcom login...")
                        user_status = True
                    else:
                        print("wrong!")
                if user_status == True:
                    func(*args,**kwargs)
            return inner
        return outer
    def home():
        print("---首页----")
    #home = login(home())
    def america():
        print("----欧美----")
    
    def japan():
        print("----日本----")
    @login('qq')
    def henan(style):
        print("----河南----")
    
    user_status = False
    
    home()
    america()
    henan('3p')

    银角大王的解释我觉得很容易懂

    @login
    def henan():
        pass
    
    #在这里 @ 相当于把下面的函数henan当做一个参数,传给了login这个方法,那么
    
    @login('qq')
    def henan():
        pass
    #这里 就相当于将函数henan当做参数,传给了login('qq')这个执行后的return的函数

     

    装饰器需要重点复习

     

    列表生成

    a = [2,3,4,5,6,7,8,9]
    b = a.copy()
    c=a.copy()
    for i in range(len(a)):
        a[i]+=1
    print(a)
    
    #列表生成式
    b = [i+1 for i in b ]
    print(b)
    #高级一点例子
    
    c = [i if i<6 else i*i for i in a]
    print(c)

    继续用银角大王的总结:

    for i in a 做一个循环,前面相当于循环缩进下面得每一个i 每循环一次前面都会执行一次,结果会当做元素挨个存放,这时候,a 就可以循环任何东西,列表元组字典字符串等等。

    这个只能写到列表里和元组里

     

     

     

     

     生成器

     假设一个场景,我需要从一个列表中取数据,而这个列表可能长度是10或者100万,这样的话难道要预先生成一个100万长度的列表吗?不会的,因为非常占用内存空间

    解决办法:生成器

    如果我知道一个列表的规律,那么我就可以制定一个规则,当我需要什么值时候,我再通过规则去生成这个值,这样就避免了空间浪费。

    a = (i for i in range(5))
    >>> < generator object<genexpr> at 0xkasjdfljals>
    #这就是一个生成器generato
    #如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值:
    next(a)
    #1.只能往后输出,不能回头
    #2.超出边界,报错
    #生成器保存的是一个算法,超出边界就会跑出stopIteration错误

      


    生成器调用方式
    用next()一个一个调很不现实,一般用for循环调

    a = (i for i in range(5))
    for i in a3:
      print(i)

    与next区别,超过范围不报错,直接跳出循环

     

    这个会报错

    while True:
        next(a3)

     

    range(100) <<底层就是生成器 python2里打印,python3里就是> range(0,100) python2里替代range的:xrange()

     

    斐波那契数列

    小注意点:

    a = 1,b = 2
    a,b= b,a+b

    此时a和b是多少?答案是 2,和3

    为什么呢 ?不知道

     

    函数调用

    def fib(max):
      n,a,b = 0,0,1
      while n < max:
        yield b #通过函数生成了一个生成器 这个语法相当于 :出现了yield,就相当于将这个函数变成了生成器 函数执行到这里就返回了(冻结,函数没有结束) 通过next(f) 函数才能继续往下走。。把函数的执行过程冻结在这一步,并且把b的值返回给外面的next()
        a,b = b,a+b
        n = n+1
    return 'done'
    print(fib(15))
    f = fib(15)
    >><generator ...>

    变成了一个生成器

    print(next(f))
    ...
    0 0 1 2 3 5..

     

    刚开始执行时候,f = fib(15) python将他变成一个生成器
    只有next(f) 从函数开始,到yield结束
    下一次next(f) ,则从上一次yield后面开始,执行到这一次yield之前。
    好处是,函数执行-等结果
    如果这样 函数执行一小会儿,把函数执行过程中的某个状态,返回出来。原来只能到结束,现在可以函数执行过程中返回到外部,多次

    总结:
    1。函数内加了yield 函数名加括号,函数根本不执行,只是生成了一个生成器对象
    2.yield把函数的执行过程冻结在这一步(没有结束)
    3。并且把b的值返回给外面的next()

    for i in a:
    循环这个生成器,不用next方法,不会报错
    while...
    用next方法,会报错

    range(10) python2 :[0,1,2,3,4,5,6,7,8,9]
    python3:range(0,10)
    python2中有个方法跟python3中range一样:xrange

    生成器的创建方式
    1.类似列表生成式    []>>>()    最复杂的方式只能写一个三元运算
    2.函数生成器

    def range2(n):
        count = 0
        while count < n:
            print(count)
            count += 1
    range2(10)        

     

     

    next(f) 就等于 f.__next__()

    如果这样

    def range2(n):
        count =0
        while count<n 
            count+=1
            yield count
            print(----)
        return x >>>>>会报错                                

     

    总结:
    python2
      range = list
      xrange = 生成器generator
    python3
      range = 生成器generator
      xrange 没有

    yield vs return
      return 返回并终止function
      yield 返回数据,并冻结当前的执行过程

      next 唤醒冻结的函数执行过程,继续执行,直到遇到下一个yield


    1.函数有了yield之后,函数名加()就得到了一个生成器,生成器就必须next(开始执行,如果终结了还能唤醒
    2 return在生成器里代表生成器的终止,直接报错


    如果需要中断,range.send("xxx") 传给yield
    sign = yield asef
    通过判断sign 可以break可以return退出

     

    迭代器
    理解:迭代一次=循环一次

    可以直接作用于for循环的数据类型
    一类是集合类型:list tuple dict set str
    一类是生成器,包裹开yield的generator function
    可以直接作用于for循环的对象统称为可迭代对象 Iterable()注意这是可迭代对象 Able
    可以使用.isinstance()判断一个对象是否是Iterable对象 isinstance('abc',Iterable)>>>>True

    一切皆对象

    :::可以被next()调用并且返回下一个值的对象成为迭代器Iterator 这个是迭代器 Tor
    (生成器 是 迭代器的一种)
    迭代器都是可迭代对象
    可迭代对象不都是迭代器
    集合类就不是
    如何将可迭代对象转化为迭代器?
    通过iter方法
    isinstance('abc',Iterator)>>>>False
    str = iter('abc')
    这样 str 就是迭代器,可以使用next()方法,

    str.__next__()>>
    'a'
    'b'
    'c'
    traceback....

    迭代器对象是一个数据流,迭代器对象可以被next()函数调用并不断返回下一个数据,知道没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序的序列,但我们却不知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以迭代器的对象都是惰性的,只有在需要返回下一个数据时他才会计算
    迭代器甚至可以表示一个无限大的数据流,列入全体自然数,而list永远不可能存储所有自然数。。
    总结:迭代器和可迭代

    总结:
    凡是可以for循环的 都是可迭代对象 iterable
    凡是可作用于next()的 都是Iterator对象 迭代器对象
    集合数据类型 list tuple dict str 是可迭代对象,但不是迭代器,可以通过iter()获得一个迭代器对象
    Python3的for循环本质上就是通过不断调用next()函数来实现的

     

    转载于:https://www.cnblogs.com/alexstraze/p/9274343.html

    展开全文
  • 3-17 函数-命名空间

    2019-08-02 16:17:00
    举例说明,若变量x =1,1存放在内存中,那名字x存放在哪里呢?名称空间正是存放x与1绑定关系的地方。 名称空间共3种,分别如下: locals: 是函数内的名称空间,包括局部变量和形参 globals:全局变量,函数定义...

    命名空间

    又名name space ,顾名思义就是存放名字的地方,存什么名字呢?举例说明,若变量x =1,1存放在内存中,那名字x存放在哪里呢?名称空间正是存放x与1绑定关系的地方。

    名称空间共3种,分别如下:

    • locals: 是函数内的名称空间,包括局部变量和形参
    • globals:全局变量,函数定义所在模块的名字空间
    • builtins:内置模块的名字空间

    不同变量的作用域不同就是由这个变量所在的命名空间决定的。

    作用域即范围:

    • 全局范围:全局存活,全局有效
    • 局部范围:临时存活,局部有效

    查看作用域方法:globals()  locals()

    >>> x = 1
    >>> globals()
    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <cl
    ass '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {
    }, '__builtins__': <module 'builtins' (built-in)>, 'x': 1}
    
    >>> locals() #现在所在的位置命名空间中的内容
    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <cl
    ass '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {
    }, '__builtins__': <module 'builtins' (built-in)>, 'x': 1}
    >>> __builtins__
    <module 'builtins' (built-in)>
    >>> dir(__builtins__)
    ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Blocki
    ngIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError
    ', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'Conne
    ctionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentErro
    r', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPoint
    Error', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarni

     

    转载于:https://www.cnblogs.com/echo-kid-coding/p/11289250.html

    展开全文
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量 builtins:...

    名称空间

    又名name space, 顾名思义就是存放名字的地方,存什么名字呢?举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方

    名称空间共3种,分别如下

    • locals: 是函数内的名称空间,包括局部变量和形参
    • globals: 全局变量
    • builtins: 内置模块的名字空间

    不同变量的作用域不同就是由这个变量所在的命名空间决定的。

    作用域即范围

    • 全局范围:全局存活,全局有效
    • 局部范围:临时存活,局部有效

    查看作用域方法 globals(),locals()

    作用域查找顺序

    level = 'L0'
    n = 22
    
    
    def func():
        level = 'L1'
        n = 33
        print(locals())
    
        def outer():
            n = 44
            level = 'L2'
            print(locals(),n)
    
            def inner():
                level = 'L3'
                print(locals(),n) #此外打印的n是多少?
            inner()
        outer()
    
    
    func()

     

    问题:在inner()里的打印的n的值是多少?

    LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__

    • locals 是函数内的名字空间,包括局部变量和形参
    • enclosing 外部嵌套函数的名字空间
    • globals 全局变量,函数定义所在模块的名字空间
    • builtins 内置模块的名字空间 

    闭包

    关于闭包,即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且,这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时,就会形成闭包。也就是说,内部函数会在外部函数返回后被执行。而当这个内部函数执行时,它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明(最初时)的值是外部函数返回时的值,但也会受到内部函数的影响。

    def outer():
        name = 'alex'
    
        def inner():
            print("在inner里打印外层函数的变量",name)
    
        return inner
    
    
    f = outer() 
    
    f()

     

    闭包的意义:返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域

    匿名函数

    匿名函数就是不需要显式的指定函数名

    #这段代码
    
    def calc(x,y):
        return x**y
    
    print(calc(2,5))

     

    
    #换成匿名函数
    
    calc = lambda x,y:x**y
    print(calc(2,5))

     

    你也许会说,用上这个东西没感觉有毛方便呀, 。。。。呵呵,如果是这么用,确实没毛线改进,不过匿名函数主要是和其它函数搭配使用的呢,如下

    res = map(lambda x:x**2,[1,5,7,4,8])
    for i in res:
        print(i)

     

    输出

    1
    25
    49
    16
    64

     

    高阶函数

    变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

    def add(x,y,f):
        return f(x) + f(y)
    
    
    res = add(3,-6,abs)
    print(res)

     

    只需满足以下任意一个条件,即是高阶函数

    • 接受一个或多个函数作为输入
    • return 返回另外一个函数

     

    递归

    在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。

    def calc(n):
        print(n)
        if int(n/2) ==0:
            return n
        return calc(int(n/2))
    
    calc(10)

     

    输出

    10
    5
    2
    1

     

    来看实现过程,我改了下代码

    def calc(n):
        v = int(n/2)
        print(v)
        if v > 0:
            calc(v)
        print(n)
    
    calc(10)

     

    输出

    5
    2
    1
    0
    1
    2
    5
    10

     

     

    列表生成式

    现在有个需求,看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],要求你把列表里的每个值加1,

     

    In [56]: a = [i+1 for i in range(10)]
    
    In [57]: a
    Out[57]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    这样的写法就叫做列表生成式

    生成器

    通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。

    所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。

    要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:

    In [58]: L = [x * x for x in range(10)]
    
    In [59]: L
    Out[59]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    
    In [60]: g = (x * x for x in range(10))
    
    In [61]: g
    Out[61]: <generator object <genexpr> at 0x7f0dc1fc5eb0>

    创建Lg的区别仅在于最外层的[]()L是一个list,而g是一个generator。

    我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?

    如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值:

    In [62]: next(g)
    Out[62]: 0
    
    In [63]: next(g)
    Out[63]: 1
    
    In [64]: next(g)
    Out[64]: 4
    
    In [65]: next(g)
    Out[65]: 9
    
    In [66]: next(g)
    Out[66]: 16
    
    In [67]: next(g)
    Out[67]: 25
    
    In [68]: next(g)
    Out[68]: 36
    
    In [69]: next(g)
    Out[69]: 49
    
    In [70]: next(g)
    Out[70]: 64
    
    In [71]: next(g)
    Out[71]: 81
    
    In [72]: next(g)
    ---------------------------------------------------------------------------
    StopIteration                             Traceback (most recent call last)
    <ipython-input-72-5f315c5de15b> in <module>()
    ----> 1 next(g)
    
    StopIteration: 

    generator保存的是算法,每次调用next(g)就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。

    当然,上面这种不断调用next(g)实在是太变态了,正确的方法是使用for循环,因为generator也是可迭代对象:

    In [76]:  g = (x * x for x in range(10))
    
    In [77]: for n in g:
       ....:     print(n)
       ....:     
    0
    1
    4
    9
    16
    25
    36
    49
    64
    81

    所以,我们创建了一个generator后,基本上永远不会调用next(),而是通过for循环来迭代它,并且不需要关心StopIteration的错误。

    generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。

     

    迭代器

    我们已经知道,可以直接作用于for循环的数据类型有以下几种:

    一类是集合数据类型,如listtupledictsetstr等;

    一类是generator,包括生成器和带yield的generator function。

    这些可以直接作用于for循环的对象统称为可迭代对象:Iterable

    可以使用isinstance()判断一个对象是否是Iterable对象:

    In [90]: from collections import Iterable
    
    In [91]: isinstance([], Iterable)
    Out[91]: True
    
    In [92]: isinstance({}, Iterable)
    Out[92]: True
    
    In [93]: isinstance('abc', Iterable)
    Out[93]: True
    
    In [94]: isinstance((x for x in range(10)), Iterable)
    Out[94]: True
    
    In [95]: isinstance(100, Iterable)
    Out[95]: False

    而生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了

    *可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。

    可以使用isinstance()判断一个对象是否是Iterator对象:

    In [97]: isinstance((x for x in range(10)), Iterator)
    Out[97]: True
    
    In [98]: isinstance([], Iterator)
    Out[98]: False
    
    In [99]: isinstance({}, Iterator)
    Out[99]: False
    
    In [100]: isinstance('abc', Iterator)
    Out[100]: False

    生成器都是Iterator对象,但listdictstr虽然是Iterable,却不是Iterator

    listdictstrIterable变成Iterator可以使用iter()函数:

    In [101]: isinstance(iter([]), Iterator)
    Out[101]: True
    
    In [102]: isinstance(iter('abc'), Iterator)
    Out[102]: True

    你可能会问,为什么listdictstr等数据类型不是Iterator

    这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

    Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

    小结

    凡是可作用于for循环的对象都是Iterable类型;

    凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;

    集合数据类型如listdictstr等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

    Python3的for循环本质上就是通过不断调用next()函数实现的,例如:

    for x in [1, 2, 3, 4, 5]:
        pass

    实际上完全等价于:

    # 首先获得Iterator对象:
    it = iter([1, 2, 3, 4, 5])
    # 循环:
    while True:
        try:
            # 获得下一个值:
            x = next(it)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break

    转载于:https://www.cnblogs.com/caimengzhi/p/8323837.html

    展开全文
  • 举例说明,若变量x=1,1存放在内存中,那名字x存放在哪里呢? 名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下:  locals:是函数内的名称空间,包括局部变量和形参  globals:全局变量,函数...

    命名空间又称名称空间

    又名name space,顾名思义就是存放名字的地方,存声明名字呢?举例说明,若变量x=1,1存放在内存中,那名字x存放在哪里呢?

    名称空间正是存放名字x与1绑定关系的地方

    名称空间共3种,分别如下:

      locals:是函数内的名称空间,包括局部变量和形参

      globals:全局变量,函数定义所在模块的名字空间

      builtins:内置模块的名字空间

    不同变量的作用域不同就是由这个变量所在的命名空间决定的。

    作用域即范围

      全局范围:全局存活,全局有效

      局部范围:临时存活,局部有效

     

    转载于:https://www.cnblogs.com/kingforn/p/10906256.html

    展开全文
  • python函数进阶

    2018-11-28 14:38:36
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义所在...
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方。 名称空间共3种,分别如下: locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数...
  • 函数进阶

    2019-04-18 18:27:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • 举例说明,若变量x=1,1存放于内存,那名字x存放在哪里呢?名称空间正式存放名字x与1绑定关系的地方 名称空间共有3种,分别如下: locals:是函数内的名称空间,包括局部变量和形参 globals:全局变量,函数定义...
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • Python之路 函数进阶

    2018-08-17 21:34:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • 命名空间又名name space, 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 ...
  • python-函数进阶

    2019-09-24 02:22:04
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数...
  • py-函数进阶

    2018-05-16 08:46:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • Python-函数进阶

    2018-04-11 19:46:56
    名称空间正是存放名字x与1绑定关系的地方名称空间共3种,分别如下locals: 是函数内的名称空间,包括局部变量和形参globals: 全局变量,函数定义所在模块的名字空间builtins: 内置模块的名字空间不同变量的作用域不同...
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,...
  • 第三章| 3.3 函数进阶

    2018-06-09 21:06:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方   名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,...
  • 装饰器函数

    2018-05-15 21:19:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • 举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下 locals: 是函数内的名称空间,包括局部变量和形参 globals: 全局变量,函数定义...
  • python----函数进阶

    2019-04-06 17:48:00
    举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方 名称空间共3种,分别如下: 1.locals: 是函数内的名称空间,包括局部变量和形参 2.globals: 全局变量,函数...
  • 2.1.3 全局变量和局部变量在内存中是否有区别?如果有,是什么区别? 2.1.4 什么是平衡二叉树? 2.1.5 堆栈溢出一般是由什么原因导致的? 2.1.6 什么函数不能声明为虚函数? 2.1.7 冒泡排序算法的时间复杂度是...
  • 世界500强面试题.pdf

    2019-11-01 14:33:26
    1.2.5. 二元树中找出为某一值的所有路径 .............................................. 22 1.2.6. Top K 算法详细解析---百度面试 ......................................................... 29 1.2.7. ...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

局部变量和全局变量分别存放在哪里