标签: scope

[免责声明:可能有更多pythonic方式做我想做的事情,但我想知道python的范围如何在这里工作]

我正在尝试找到一种方法来制作一个装饰器,它可以将名称注入到另一个函数的范围内(这样名称不会泄漏到装饰器的范围之外).例如,如果我有一个函数说要打印一个名为var尚未定义的变量,我想在调用它的装饰器中定义它.这是一个打破的例子:

c = 'Message'

def decorator_factory(value):
    def msg_decorator(f):
        def inner_dec(*args, **kwargs):
            var = value
            res = f(*args, **kwargs)
            return res
        return inner_dec
    return msg_decorator

@decorator_factory(c)
def msg_printer():
    print var

msg_printer()

我想要打印" Message",但它给出了:

NameError: global name 'var' is not defined

回溯甚至指向wher var定义:

<ipython-input-25-34b84bee70dc> in inner_dec(*args, **kwargs)
      8         def inner_dec(*args, **kwargs):
      9             var = value
---> 10             res = f(*args, **kwargs)
     11             return res
     12         return inner_dec

所以我不明白为什么找不到var.

有没有办法做这样的事情？

我正在构建一个提供JSON或XML格式数据的API的Go库.

此API要求我session_id每15分钟左右请求一次,并在通话中使用它.例如:

foo.com/api/[my-application-id]/getuserprofilejson/[username]/[session-id]
foo.com/api/[my-application-id]/getuserprofilexml/[username]/[session-id]

在我的Go库中,我正在尝试在main()func 之外创建一个变量,并打算对每个API调用的值执行ping操作.如果该值为nil或空,请求新的会话ID,依此类推.

package apitest

import (
    "fmt"
)

test := "This is a test."

func main() {
    fmt.Println(test)
    test = "Another value"
    fmt.Println(test)

}

什么是惯用的Go方式来声明一个全局可访问的变量,但不是necesarilly常量？

我的test变量需要:

• 可以从它自己的包装中的任何地方访问.
• 变化多端

下面的代码片段在编译过程中会产生一个"foo的foo调用"错误,我想知道如果没有完全限定对foo的调用,是否有任何方法解决这个问题:

#include <iostream>

struct Base1{
    void foo(int){
    }
};

struct Base2{
    void foo(float){
    }
};

struct Derived : public Base1, public Base2{
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}

所以,问题就像标题所说的那样.想法？我的意思是,以下工作完美无瑕:

#include <iostream>

struct Base{
    void foo(int){
    }
};

struct Derived : public Base{
    void foo(float){
    }
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}

是否在"if"语句中声明和赋值变量仅在"if"块内或整个函数内可见？

我是否在以下代码中执行此操作？(似乎工作,但多次声明"var结构"似乎很尴尬)任何更清洁的解决方案？

    function actionPane(state) {
    if(state === "ed") {
        var structure = {
            "element" : "div",
            "attr" : {
                "class" : "actionPane"
            },
            "contains" : [{
                "element" : "a",
                "attr" : {
                    "title" : "edit",
                    "href" : "#",
                    "class" : "edit"
                },
                "contains" : ""
            }, {
                "element" : "a",
                "attr" : {
                    "title" : "delete",
                    "href" : "#",
                    "class" : "delete"
                },
                "contains" : ""
            }]
        }
    } else {
        var structure = {
            "element" : "div",
            "attr" : …

这个消息有点长,有很多例子,但我希望它能帮助我和其他人更好地掌握Python 2.7中变量和属性查找的全部故事.

我正在使用PEP 227(http://www.python.org/dev/peps/pep-0227/)的条款来代码块(例如模块,类定义,函数定义等)和变量绑定(例如作为赋值,参数声明,类和函数声明,for循环等)

我使用的术语变量,可以在不点叫名字,并需要与对象名称限定(如obj.x的属性x对象obj的)名称属性.

Python中有三个范围用于所有代码块,但功能如下:

• 本地
• 全球
• 内建

Python中只有四个块用于函数(根据PEP 227):

• 本地
• 封闭功能
• 全球
• 内建

变量绑定到块并在块中找到它的规则非常简单:

• 任何变量绑定到块中的对象都会使此变量本地为此块,除非该变量被声明为全局变量(在这种情况下变量属于全局范围)
• 使用规则LGB(本地,全局,内置)为所有块查找对变量的引用,但是函数
• 使用规则LEGB(本地,封闭,全局,内置)仅为函数查找对变量的引用.

让我知道验证这条规则的例子,并展示许多特殊情况.对于每个例子,我都会给出我的理解.如果我错了,请纠正我.对于最后一个例子,我不明白结果.

例1:

x = "x in module"
class A():
    print "A: "  + x                    #x in module
    x = "x in class A"
    print locals()
    class B():
        print "B: " + x                 #x in module
        x = "x in class B"
        print locals()
        def f(self):
            print "f: " + x             #x in module
            self.x = "self.x in f"
            print …

声明类中的变量(在函数外部):所有类函数都可以访问它(基本上是一个公共变量)

在类中的函数内声明一个变量:只有该函数可以访问它(它在该函数范围内)

在类中的函数内声明一个带有self(变量名)的变量:所有类函数都可以访问它(这与全局(变量名)有什么不同？)

并且由于没有私有/受保护,所以一切都是公共的,因此可以从课堂外访问从课堂内部访问的所有内容.

我应该知道还有其他细微差别吗,还是我几乎得到了它？

如何处理函数声明？

var abc = '';
if(1 === 0){
    function a(){
        abc = 7;
    }
}else if('a' === 'a'){
    function a(){
        abc = 19;
    }
}else if('foo' === 'bar'){
    function a(){
        abc = 'foo';
    }
} 
a();
document.write(abc); //writes "foo" even though 'foo' !== 'bar'

此示例在Chrome和Firefox中生成不同的输出.fooFF输出时输出Chrome 19.

我正在尝试在我的javascript中添加所有卡路里内容,如下所示:

$(function() {
    var data = [];

    $( "#draggable1" ).draggable();
    $( "#draggable2" ).draggable();
    $( "#draggable3" ).draggable();

    $("#droppable_box").droppable({
        drop: function(event, ui) {
            var currentId = $(ui.draggable).attr('id');
            var total = 0;
            data.push($(ui.draggable).attr('id'));

            if(currentId == "draggable1"){
            var myInt1 = parseFloat($('#MealplanCalsPerServing1').val());
            }
            if(currentId == "draggable2"){
            var myInt2 = parseFloat($('#MealplanCalsPerServing2').val());
            }
            if(currentId == "draggable3"){
            var myInt3 = parseFloat($('#MealplanCalsPerServing3').val());
            }
        if ( typeof myInt1 === 'undefined' || !myInt1 ) {
        myInt1 = parseInt(0);
        }
        if ( typeof myInt2 === 'undefined' || !myInt2){
        myInt2 = parseInt(0);
        } …

我想记住这个:

def fib(n: Int) = if(n <= 1) 1 else fib(n-1) + fib(n-2)
println(fib(100)) // times out

所以我写了这个,这令人惊讶地编译和工作(我很惊讶,因为fib在其声明中引用自己):

case class Memo[A,B](f: A => B) extends (A => B) {
  private val cache = mutable.Map.empty[A, B]
  def apply(x: A) = cache getOrElseUpdate (x, f(x))
}

val fib: Memo[Int, BigInt] = Memo {
  case 0 => 0
  case 1 => 1
  case n => fib(n-1) + fib(n-2) 
}

println(fib(100))     // prints 100th fibonacci number instantly

但是当我尝试在a中声明fib时def,我得到一个编译器错误:

def foo(n: …

使用Python函数语法def f(**kwargs),在函数kwargs中创建一个关键字参数字典,并且字典是可变的,所以问题是,如果我修改kwargs字典,是否有可能在函数范围之外产生一些影响？

根据我对字典解包和关键字参数打包如何工作的理解,我认为没有理由相信它可能不安全,而且在我看来Python 3.6中没有这种危险:

def f(**kwargs):
    kwargs['demo'] = 9

if __name__ == '__main__':
    demo = 4
    f(demo=demo)
    print(demo)     # 4

    kwargs = {}
    f(**kwargs)
    print(kwargs)   # {}

    kwargs['demo'] = 4
    f(**kwargs)
    print(kwargs)    # {'demo': 4}

但是,这是特定于实现的,还是它是Python规范的一部分？我是否忽略了任何情况或实现(除非修改参数本身是可变的,如此kwargs['somelist'].append(3))这种修改可能是一个问题？