天道酬勤,学无止境

奇怪的行为....Python 类绑定方法在调用后保留关键字参数(Strange Behavior....Python class bound method retaining keyword arguments after call)

问题

我有一个用于 GUI 的简单数据模型类。 在这个类中,我有一个 addPnt 方法,如果没有通过关键字参数“timeDict”传递时间戳,它会附加一个时间戳。 我希望在每次调用 addPnt 开始时将默认值 ({}) 设置为 timeDict。 但是,在调试时,timeDict 保留了对 addPnt 的初始调用的值?!?! 见下面的代码

class LastTSDict(dict):
    def __getitem__( self, name ):
        try:
            return super( LastTSDict, self ).__getitem__( name )
        except KeyError:
            self.__setitem__(name,timestamp.getTimestamp())
            return self.__getitem__( name )

class DataElementDict(dict):
    def __init__(self,maxLen):
        self.maxLen=maxLen
        self.lastTS=LastTSDict()
    def __getitem__( self, name ):
        try:
            return super( DataElementDict, self ).__getitem__( name )
        except KeyError:
            if name==0:
                self.__setitem__(name,defaultdict(partial(defaultdict,partial(deque, maxlen=self.maxLen))))
            else:
                self.__setitem__(name,defaultdict(partial(defaultdict,partial(deque, maxlen=self.maxLen/8))))
            return self.__getitem__( name )

class Model(object):
    def __init__(self,maxLen=8192,extPeriods=[5,60,300,900,3600,86400]):
        self.DATA=DataElementDict(maxLen)
        self.extPeriods=extPeriods

    def addPnt(self,key,value,timeDict={}):
        try:
            pdb.set_trace()
            if 'ts' not in timeDict.keys():
                timeDict['ts']=timestamp.getTimestamp()
            if 'tu' not in timeDict.keys():
                timeDict['tu']=timestamp.unixTime(timeDict['ts'])
            self.DATA[0][key]['v'].append(value)
            for keyt in timeDict.keys():
                self.DATA[0][key][keyt].append(timeDict[keyt])

这里发生了什么?

回答1

默认参数的值仅在函数定义时创建一次。

def addPnt(self,key,value,timeDict={}):

这意味着每次调用都使用相同的字典对象。 每次调用都不是新的。

要修复此用途:

def addPnt(self,key,value,timeDict=None):
    if timeDict is None:
        timeDict = {}
标签

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 为什么需要在Python方法中显式包含“ self”自变量?(Why do you need explicitly have the “self” argument in a Python method?)
    问题 在Python中的类上定义方法时,它看起来像这样: class MyClass(object): def __init__(self, x, y): self.x = x self.y = y 但是在某些其他语言(例如C#)中,您可以使用“ this”关键字来引用该方法所绑定的对象,而无需在方法原型中将其声明为参数。 这是Python中的有意语言设计决定,还是有一些实现细节需要传递“ self”作为参数? 回答1 我喜欢引用Peters的Python Zen。 “显式比隐式好。” 在Java和C ++中,“ this. 可以推导',除非您有无法推论的变量名。 因此,您有时需要它,而有时则不需要。 Python选择使这种事情变得明确,而不是基于规则。 另外,由于没有暗示或假设,因此公开了部分实现。 self.__class__ , self.__dict__和其他“内部”结构以明显的方式可用。 回答2 这是为了使方法和函数之间的差异最小化。 它使您可以轻松地在元类中生成方法,或在运行时将方法添加到预先存在的类中。 例如 >>> class C(object): ... def foo(self): ... print "Hi!" ... >>> >>> def bar(self): ... print "Bork bork bork!" ... >>> >>> c = C()
  • “最小惊讶”和可变默认参数("Least Astonishment" and the Mutable Default Argument)
    问题 任何对 Python 进行足够长时间修补的人都被以下问题咬(或撕成碎片): def foo(a=[]): a.append(5) return a Python 新手希望这个函数总是返回一个只有一个元素的列表: [5] 。 结果却大不相同,而且非常惊人(对于新手而言): >>> foo() [5] >>> foo() [5, 5] >>> foo() [5, 5, 5] >>> foo() [5, 5, 5, 5] >>> foo() 我的一位经理曾经第一次遇到此功能,并称其为该语言的“戏剧性设计缺陷”。 我回答说这种行为是有内在的解释的,如果你不了解内部原理,确实很令人费解和出乎意料。 但是,我无法回答(对自己)以下问题:在函数定义而不是在函数执行时绑定默认参数的原因是什么? 我怀疑经验丰富的行为是否有实际用途(谁真正在 C 中使用静态变量,而不滋生错误?) 编辑: Baczek 举了一个有趣的例子。 连同你的大部分评论,特别是 Utaal 的评论,我进一步阐述了: >>> def a(): ... print("a executed") ... return [] ... >>> >>> def b(x=a()): ... x.append(5) ... print(x) ... a executed >>> b() [5] >>> b() [5, 5] 对我来说
  • “最少惊讶”和可变的默认参数(“Least Astonishment” and the Mutable Default Argument)
    问题 长时间修改Python的任何人都被以下问题咬伤(或弄成碎片): def foo(a=[]): a.append(5) return a Python新手希望此函数始终返回仅包含一个元素的列表: [5] 。 结果是非常不同的,并且非常令人惊讶(对于新手而言): >>> foo() [5] >>> foo() [5, 5] >>> foo() [5, 5, 5] >>> foo() [5, 5, 5, 5] >>> foo() 我的一位经理曾经第一次遇到此功能,并将其称为“严重的设计缺陷”。 我回答说,这种行为有一个基本的解释,如果您不了解内部原理,那确实是非常令人困惑和出乎意料的。 但是,我无法(对自己)回答以下问题:在函数定义而不是函数执行时绑定默认参数的原因是什么? 我怀疑经验丰富的行为是否具有实际用途(谁真正在C中使用了静态变量,却没有滋生bug?) 编辑: 巴泽克举了一个有趣的例子。 连同您的大多数评论,特别是Utaal的评论,我进一步阐述了: >>> def a(): ... print("a executed") ... return [] ... >>> >>> def b(x=a()): ... x.append(5) ... print(x) ... a executed >>> b() [5] >>> b() [5, 5] 在我看来
  • 零基础入门学Python(十一)—— 类和对象
    零基础入门学Python系列内容的学习目录 → \rightarrow →零基础入门学Python系列内容汇总。1. 简单介绍一下对象2. 对象 = 属性 + 方法3. 面向对象编程3.1 self是什么3.2 Python的魔法方法3.3 公有和私有4. 继承4.1 调用未绑定的父类方法4.2 使用super函数5. 多重继承6. 组合7. 类、类对象和实例对象8. 到底什么是绑定  需要学习的基础知识有:对象、继承、组合、类、类对象、实例对象、绑定等。1. 简单介绍一下对象  我们之前已经听说过封装的概念,把乱七八糟的数据扔进列表里边,是数据层面的封装;把常用的代码段打包成一个函数,是语句层面的封装;对象其实也是一种封装的思想,对象的来源是模拟真实世界,把数据和代码都封装在了一起。   举个例子,乌龟就是真实世界的一个对象,那么通常应该如何来描述这个对象呢?是不是可以把它分为两部分来说?     1)可以从静态的特征来描述,例如绿色的、10kg重、有四条腿,有外壳等,这是静态方面的描述。     2)还可以从动态的行为来描述,例如会爬、会缩头等,这些都是从行为方面进行描述的。2. 对象 = 属性 + 方法  Python 中的对象也是如此,一个对象的特征称为“属性”,一个对象 的行为称“方法”。   如果把“乌龟”写成代码,可以是下边这样:class Turtle: #
  • 泛型类中的Java泛型方法(Java generic methods in generics classes)
    问题 如果在Java中创建泛型类(该类具有泛型类型参数),则可以使用泛型方法(该方法带有泛型类型参数)吗? 考虑以下示例: public class MyClass { public <K> K doSomething(K k){ return k; } } public class MyGenericClass<T> { public <K> K doSomething(K k){ return k; } public <K> List<K> makeSingletonList(K k){ return Collections.singletonList(k); } } 就像您对通用方法所期望的那样,我可以在具有任何对象的MyClass实例上调用doSomething(K) : MyClass clazz = new MyClass(); String string = clazz.doSomething("String"); Integer integer = clazz.doSomething(1); 但是,如果我尝试使用MyGenericClass实例而不指定泛型类型,则无论传入的是什么K ,我调用doSomething(K)返回一个Object : MyGenericClass untyped = new MyGenericClass(); // this doesn't
  • Python中类方法的差异:绑定,未绑定和静态(Class method differences in Python: bound, unbound and static)
    问题 以下类方法有什么区别? 是一个是静态的,另一个不是静态的吗? class Test(object): def method_one(self): print "Called method_one" def method_two(): print "Called method_two" a_test = Test() a_test.method_one() a_test.method_two() 回答1 在Python中,有绑定和非绑定方法之间的区别。 基本上,是对成员函数(如method_one )的调用,即绑定函数 a_test.method_one() 被翻译成 Test.method_one(a_test) 即对未绑定方法的调用。 因此,对您的method_two版本的method_two将失败,并显示TypeError >>> a_test = Test() >>> a_test.method_two() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: method_two() takes no arguments (1 given) 您可以使用装饰器更改方法的行为 class Test(object): def method_one(self)
  • “this”关键字:Java 中的工作机制(“this” keyword: Working mechanism in Java)
    问题 学习Java有一段时间了,第一次使用this关键字让我很困惑。 这就是我感到困惑的方式。 我写了以下代码: class BasicInheritanceTest3Base{ private int x = 0; public int y; public void a() { x++; this.x++; System.out.println("BasicInheritanceTest3Base.a()"); b(); this.b(); System.out.println(x); System.out.println(y); } public void b(){ System.out.println("BasicInheritanceTest3Base.b()"); } } public class BasicInheritanceTest3 extends BasicInheritanceTest3Base { private int x = 3; public int y = 2; public void b() { System.out.println("BasicInheritanceTest3.b()"); } public static void main(String[] args){ BasicInheritanceTest3 bit2 = new
  • 为什么不自动调用超类__init__方法?(Why aren't superclass __init__ methods automatically invoked?)
    问题 为什么Python设计人员为什么决定子类的__init__()方法不像其他某些语言那样自动调用其超类的__init__()方法? Pythonic和推荐的习语真的像下面这样吗? class Superclass(object): def __init__(self): print 'Do something' class Subclass(Superclass): def __init__(self): super(Subclass, self).__init__() print 'Do something else' 回答1 Python的__init__和其他语言的构造函数之间的关键区别在于__init__不是构造函数:它是一个初始化函数(实际的构造函数(如果有,但是请参阅下文;-)是__new__并且再次完全不同。) 虽然构造所有超类(毫无疑问,在继续向下构造之前),这显然是在说您正在构造子类的实例,这显然不是初始化的情况,因为在许多情况下,超类的初始化需要被跳过,更改和控制-发生在子类初始化的“中间”,如果有的话,等等。 基本上,出于完全相同的原因,初始化程序的超类委托在Python中不是自动的,对于任何其他方法,此类委托也不是自动的-请注意,那些“其他语言”对于任何其他方法都不会自动进行超类委托其他方法……只是针对构造函数(如果适用的话,是析构函数),正如我提到的
  • Python - 作为类属性的函数成为绑定方法(Python - function as class attribute becomes a bound method)
    问题 我注意到,如果我在创建该类的实例时定义了一个与函数相等的类属性,则该属性将成为绑定方法。 有人可以向我解释这种行为的原因吗? In [9]: def func(): ...: pass ...: In [10]: class A(object): ....: f = func ....: In [11]: a = A() In [12]: a.f Out[12]: <bound method A.func of <__main__.A object at 0x104add190>> In [13]: a.f() --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-13-19134f1ad9a8> in <module>() ----> 1 a.f() global a.f = <bound method A.func of <__main__.A object at 0x104add190>> TypeError: func() takes no arguments (1 given) 回答1 您为属性Af (类A的属性f )分配了一个函数。
  • Python 27:如何修复/存储方法的值以保留其接口?(Python 27: How to fix/store a value to a method to preserve its interface?)
    问题 如果一切都是python中的对象,那么为什么以下不起作用? class Hello(object): def hello(self): print(x) h = Hello() h.hello.x = "hello world" 这样做时,我得到: AttributeError: 'instancemethod' object has no attribute 'value' 我可以通过使用 partial 来实现这一点,但是我不确定这会对对象产生什么影响。 有没有另一种方法来实现这一目标? from functools import partial class Hello(object): def hello(self, x): print(x) h = Hello() newMethod = partial(h.hello, "helloworld") newMethod() 好的,从下面的评论中,人们想要一个“真实”的场景一个例子,可以被认为如下: file.txt contains the following list ["ItemID1", "ItemID2", "ItemID3", "ItemID4"] def BindMethods(self): # ["ItemID1", "ItemID2", "ItemID3", "ItemID4"] items =
  • 模块函数vs静态方法vs类方法vs没有修饰符:哪个成语更适合pythonic?(Module function vs staticmethod vs classmethod vs no decorators: Which idiom is more pythonic?)
    问题 我是一名Java开发人员,他喜欢开和关Python。 我最近偶然发现了这篇文章,其中提到了Java程序员在选择Python时常犯的错误。 第一个吸引了我的眼球: Java中的静态方法不会转换为Python类方法。 哦,可以肯定,它或多或少会产生相同的效果,但是类方法的目标实际上是要做通常在Java中甚至是不可能的事情(例如继承非默认构造函数)。 Java静态方法的惯用翻译通常是模块级别的函数,而不是类方法或静态方法。 (并且静态final字段应转换为模块级常量。) 这并不是性能问题,但是必须使用此类Java惯用语代码的Python程序员会因键入Foo.Foo.someMethod而应该是Foo.someFunction而感到恼火。 但是请注意,调用类方法涉及一种额外的内存分配,而调用静态方法或函数则不会。 哦,所有那些Foo.Bar.Baz属性链也不是免费提供的。 在Java中,那些点名是由编译器查找的,因此在运行时,实际上有多少个都没有关系。 在Python中,查找是在运行时进行的,因此每个点都很重要。 (请记住,在Python中,“扁平比嵌套更好”,尽管它与“可读性计数”和“简单胜于复杂”有关,而不是与性能有关。) 我发现这有点奇怪,因为staticmethod的文档说: Python中的静态方法类似于Java或C ++中的静态方法。 另请参阅classmethod(
  • 您最不喜欢自己的语言的五件事是什么? [关闭](What are five things you hate about your favorite language? [closed])
    问题 关闭。 这个问题是题外话。 它当前不接受答案。 十年前关闭。 已锁定。 该问题及其答案被锁定,因为该问题是题外话,但具有历史意义。 它目前不接受新的答案或互动。 最近在Stack Overflow上出现了一堆Perl讨厌的东西,所以我想把我的“您最讨厌的五种语言讨厌”问题带给Stack Overflow。 用您最喜欢的语言,告诉我您讨厌的五件事。 这些可能只是让您烦恼,承认设计缺陷,发现性能问题或任何其他类别的事情。 您只需要讨厌它,它就必须是您最喜欢的语言。 不要将其与另一种语言进行比较,也不要谈论您已经讨厌的语言。 不要以您喜欢的语言谈论您喜欢的事情。 我只是想听听您讨厌但可以容忍的事情,以便您可以使用所有其他内容,而且我想听听有关您希望其他人使用的语言的信息。 每当有人试图将自己喜欢的语言强加给我时,有时还是作为面试问题,我都会问这个问题。 如果某人找不到最讨厌的五样东西,那么他对它的倡导或使用它的巨额资金将不甚了解。 他没有在足够不同的情况下充分利用它。 他主张将其作为一种文化或宗教,这意味着如果我不选择他最喜欢的技术,那我就错了。 我不太在乎您使用哪种语言。 不想使用特定的语言? 那不要您经过尽职调查才能做出明智的选择,但仍然不使用它? 美好的。 有时候正确的答案是“您拥有一支强大的编程团队,拥有良好的实践和在Bar方面的丰富经验。改用Foo是愚蠢的。”
  • python学习手册中文版免费下载-Python学习手册
    Python学习手册第4 版将帮助你使用Python快速实现这一点,不管你是编程新手还是Python初学者。本书是易于掌握和自学的教程,根据作者Python专家Mark Lutz的著名培训课程编写而成。 Python学习手册第4版每一章都包含关于Python语言的关键内容的独立的一课,并且包含了一个独特的“练习题”部分,其中带有实际的练习和测试,以便你可以练习新的技能并随着学习而测试自己的理解。你会发现众多带有注释的示例以及图表,它们将帮助你开始学习Python 3.0。 内容简介: 学习Python的主要内建对象类型:数字、列表和字典。 使用Python语句创建和处理对象,并且学习Python的通用语法模型。 使用函数构造和重用代码,函数是Python的基本过程工具。 学习Python模块:封装语句、函数以及其他工具,从而可以组织成较大的组件。 Python的面向对象编程工具,用于组织程序代码。 学习异常处理模型,以及用于编写较大程序的开发工具。 了解包括装饰器、描述器、元类和Unicode处理等高级Python工具。 Python学习手册第4版对比以前的版本: 从以下3个方面做出了修改: ■ 覆盖了Python 3.0和Python 2.6,本书强调Python 3.0,但是对Python 2.6中的不同之处给出了提示。 ■ 包含了一些新的章节,主要介绍高级的核心语言话题。 ■
  • 教你学习: Python-100-Days-08/09合集 类与对象
    教你学习: Python-100-Days-08/09合集 类与对象 本项目是参考项目内容,进行个人理解,和原有项目有出入,如想了解详情,请自行百度去搜索项目 面向对象的支柱 面向对象有三大支柱:封装、继承和多态。 重要的事情说三遍,面试必问,如果这个都不知道面试官只能觉的菜。 类和对象 简单的说,类是对象的蓝图和模板,而对象是类的实例。这个解释虽然有点像用概念在解释概念,但是从这句话我们至少可以看出,类是抽象的概念,而对象是具体的东西。在面向对象编程的世界中,一切皆为对象,对象都有属性和行为,每个对象都是独一无二的,而且对象一定属于某个类(型)。当我们把一大堆拥有共同特征的对象的静态特征(属性)和动态特征(行为)都抽取出来后,就可以定义出一个叫做“类”的东西。 定义类 在Python中可以使用class关键字定义类,然后在类中通过之前学习过的函数来定义方法,这样就可以将对象的动态特征描述出来,代码如下所示。 创建和使用对象 当我们定义好一个类之后,可以通过下面的方式来创建对象并给对象发消息。 @property装饰器 之前我们讨论过Python中属性和方法访问权限的问题,虽然我们不建议将属性设置为私有的,但是如果直接将属性暴露给外界也是有问题的,比如我们没有办法检查赋给属性的值是否有效。我们之前的建议是将属性命名以单下划线开头,通过这种方式来暗示属性是受保护的,不建议外界直接访问
  • Ruby和Python版本的“ self”有什么区别?(What is the difference between Ruby and Python versions of“self”?)
    问题 我已经做了一些Python,但是现在才开始使用Ruby 我可以很好地解释这两种语言中“自我”之间的区别。 乍一看很明显: Self不是Python中的关键字,但是无论您叫什么,它都有一个“类似于自我”的值。 Python方法将self作为显式参数接收,而Ruby没有。 Ruby有时使用点表示法将方法明确定义为self的一部分。 初始谷歌搜索显示 http://rubylearning.com/satishtalim/ruby_self.html http://www.ibiblio.org/g2swap/byteofpython/read/self.html 回答1 Python被设计为不仅支持面向对象的编程。 在方法和函数之间保留相同的接口,可以使两种样式更清晰地互操作。 Ruby是从头开始构建的,是面向对象的。 甚至文字也都是对象(对1.class求值就可以得到Fixnum)。 该语言的构建方式使self是一个保留关键字,无论您身在何处都可以返回当前实例。 如果您在某个类的实例方法中,则self是对该实例的引用。 如果您在类本身的定义中(而不是在方法中),则self是类本身: class C puts "I am a #{self}" def instance_method puts 'instance_method' end def self.class_method
  • “自我”一词的目的是什么?(What is the purpose of the word 'self'?)
    问题 Python中self词的目的是什么? 我知道它是指从该类创建的特定对象,但是我看不到为什么要显式地将其作为参数添加到每个函数中。 为了说明这一点,在Ruby中,我可以这样做: class myClass def myFunc(name) @name = name end end 我很容易理解。 但是在Python中,我需要包含self : class myClass: def myFunc(self, name): self.name = name 有人可以跟我说这个吗? 我的经历(公认有限)并不是我遇到的事情。 回答1 您需要使用self.的原因self. 这是因为Python不使用@语法来引用实例属性。 Python决定以一种使该方法所属的实例自动传递但不会自动接收的方式进行方法:方法的第一个参数是调用该方法的实例。 这使得方法与函数完全相同,并保留实际名称供您使用(尽管self是惯例,当您使用其他东西时,人们通常会对您皱眉。) self并不是代码专用的,它只是另一个对象。 Python可以做一些其他事情来区分普通名称和属性-像Ruby这样的特殊语法,或者像C ++和Java这样的声明都需要,或者也许还有其他不同-但事实并非如此。 Python的全部目的是使事情变得明确,使事情变得显而易见,尽管它并非在所有地方都做到这一点,但它会为实例属性做到这一点。
  • 最奇怪的语言功能(Strangest language feature)
    问题 已锁定。 该问题及其答案被锁定,因为该问题是题外话,但具有历史意义。 它目前不接受新的答案或互动。 您认为您遇到的最令人惊讶,奇怪,奇怪或真正的“ WTF”语言功能是什么? 每个答案只能使用一项功能。 回答1 在C中,可以像这样对数组建立索引: a[10] 这是很常见的。 但是,鲜为人知的形式(确实有效!)是: 10[a] 与上述相同。 回答2 在JavaScript中: '5' + 3 gives '53' 然而 '5' - 3 gives 2 回答3 在JavaScript中,以下结构 return { id : 1234, title : 'Tony the Pony' }; 由于在return之后在换行符上偷偷摸摸的隐式分号插入,返回undefined是语法错误。 尽管您可以期望以下工作: return { id : 1234, title : 'Tony the Pony' }; 更糟糕的是,这个程序也可以正常工作(至少在Chrome中): return /* */{ id : 1234, title : 'Tony the Pony' }; 这是同一问题的变体,不会产生语法错误,只是默默地失败: return 2 + 2; 回答4 JavaScript真值表: '' == '0' // false 0 == '' // true 0 == '0' // true
  • Python基础入门(下)--阿里云天池龙珠计划python训练营
    一、学习内容概况 学习地址:天池龙珠计划python训练营 今天主要学习到的内容有: 函数Lambda表达式类与对象魔法方法 二、具体学习内容 1.函数 1.1函数的定义 还记得 Python 里面“万物皆对象”么?Python 把函数也当成对象,可以从另一个函数中返回出来而去构建高阶函数,比如: 参数是函数、返回值是函数。 我们首先来介绍函数的定义。 函数以def关键词开头,后接函数名和圆括号()。 函数执行的代码以冒号起始,并且缩进。 return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回None。 def functionname (parameters): "函数_文档字符串" function_suite return [expression] 1.2函数的调用 def printme(str): print(str) printme("我要调用用户自定义函数!") # 我要调用用户自定义函数! printme("再次调用同一函数") # 再次调用同一函数 temp = printme('hello') # hello print(temp) # None 1.3函数文档 def MyFirstFunction(name): "函数定义过程中name是形参" # 因为Ta只是一个形式,表示占据一个参数位置 print(
  • 如何在Python中解析对变量的引用(How references to variables are resolved in Python)
    问题 该消息包含很多示例,时间有点长,但是我希望它能帮助我和其他人更好地理解Python 2.7中变量和属性查找的全部内容。 我将PEP 227(http://www.python.org/dev/peps/pep-0227/)的术语用于代码块(例如模块,类定义,函数定义等)和变量绑定(例如作为赋值,参数声明,类和函数声明,for循环等) 我将术语变量用于可以不带点号调用的名称,将属性用于需要使用对象名称进行限定的名称(例如obj.x表示对象obj的属性x)。 Python中所有代码块都有三个作用域,但有以下功能: 当地的全球的内建 Python中只有四个功能块(根据PEP 227): 当地的封闭功能全球的内建 将变量绑定到块中并找到它的规则非常简单: 变量与块中对象的任何绑定都使该变量在此块中成为局部变量,除非将该变量声明为全局变量(在这种情况下,该变量属于全局范围) 对于所有块,使用规则LGB(本地,全局,内置)查找对变量的引用,但函数仅使用LEGB规则(本地,封闭,全局,内置)查找对变量的引用。 让我知道一些验证此规则的示例,并显示了许多特殊情况。 对于每个示例,我都会给出自己的理解。 如果我错了,请纠正我。 对于最后一个示例,我不了解结果。 范例1: x = "x in module" class A(): print "A: " + x #x in module x =
  • python基础知识整理
    1.列表去重 #方法一 def delList(L): L1 = [ ] for i in L: if i not in L1: L1.append(i) return L1 print(delList(L1)) #方法二:去重 L1=list(set(L)) #a = [2,2,2,2,6,84,5,9] #print(delList(a)) #a2 = list(set(a)) #print(a2) 2.Python中如何拷贝一个对象 1).浅拷贝: ​ 使用copy.copy,它可以进行对象的浅拷贝(shallow copy),它复制了对象,但对于对象中的元素,依然使用引用(换句话说修改拷贝对象元素,则被拷贝对象元素也被修改) 2).深拷贝: ​ 使用copy.deepcopy,它可以进行深拷贝,不仅拷贝了对象,同时也拷贝了对象中的元素,获得了全新的对象,与被拷贝对象完全独立,但这需要牺牲一定的时间和空间。 3).特殊拷贝: ​ 如要复制列表L,使用list(L),要复制一个字典d,使用dict(d),要复制一个集合s,使用set(s)。 总结一下的话:如果你要复制某个对象object, 它属于python内建的类型type,那么你可以使用type(object)来 获得一个拷贝。 4) 举例: import copy list = [1, 2, 3, 4, ['a', 'b