In this example, a user can still access and set the variable using:  obj = C() obj._x=10 varA  = obj._x   Even if we use __x instead of _x in below code, x still doesn't become private. So the only purpose of _x is to let the programmers know that it is not meant to be set directly via obj._x?  class C:     def __init__(self):         self._x = None      @property     def x(self):         """I'm the 'x' property."""         return self._x      @x.setter     def x(self, value):         self._x = value      @x.deleter     def x(self):         del self._x
2890
Python gives us the ability to create 'private' methods and variables within a class by prepending double underscores to the name, like this: __myPrivateMethod(). How, then, can one explain this  >>> class MyClass: ...     def myPublicMethod(self): ...             print 'public method' ...     def __myPrivateMethod(self): ...             print 'this is private!!' ...  >>> obj = MyClass() >>> obj.myPublicMethod() public method >>> obj.__myPrivateMethod() Traceback (most recent call last):   File "", line 1, in  AttributeError: MyClass instance has no attribute '__myPrivateMethod' >>> dir(obj) ['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod'] >>> obj._MyClass__myPrivateMethod() this is private!!   What's the deal?!  I'll explain this a little for those who didn't quite get that.  >>> class MyClass: ...     def myPublicMethod(self): ...             print 'public method' ...     def __myPrivateMethod(self): ...             print 'this is private!!' ...  >>> obj = MyClass()   What I did there is create a class with a public method and a private method and instantiate it.  Next, I call its public method.  >>> obj.myPublicMethod() public method   Next, I try and call its private method.  >>> obj.__myPrivateMethod() Traceback (most recent call last):   File "", line 1, in  AttributeError: MyClass instance has no attribute '__myPrivateMethod'   Everything looks good here; we're unable to call it. It is, in fact, 'private'. Well, actually it isn't. Running dir() on the object reveals a new magical method that python creates magically for all of your 'private' methods.  >>> dir(obj) ['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod']   This new method's name is always an underscore, followed by the class name, followed by the method name.  >>> obj._MyClass__myPrivateMethod() this is private!!   So much for encapsulation, eh?  In any case, I'd always heard Python doesn't support encapsulation, so why even try? What gives?
9571
I realize that it seems to be a duplicate of  but my question has a slight difference (from my point of view):  Once I know that   I will not use my class with "techniques that only works on properties" and  I will not use validation code in the getter/setter.   Is there any difference (except the style/future development ones), like some type of control in setting the property?  Is there any additional difference between:  public string MyString { get; set; }   and   public string myString;   (I am aware that, that the first version requires C# 3.0 or above and that the compiler does create the private fields.)
91303
The following seems strange.. Basically, the somedata attribute seems shared between all the classes that inherited from the_base_class.  class the_base_class:     somedata = {}     somedata['was_false_in_base'] = False   class subclassthing(the_base_class):     def __init__(self):             print self.somedata   first = subclassthing() {'was_false_in_base': False} first.somedata['was_false_in_base'] = True second = subclassthing() {'was_false_in_base': True} &gt;&gt;&gt; del first &gt;&gt;&gt; del second &gt;&gt;&gt; third = subclassthing() {'was_false_in_base': True}   Defining self.somedata in the __init__ function is obviously the correct way to get around this (so each class has it's own somedata dict) - but when is such behavior desirable?
18032
I have been using classes for only a short while and when I write a method, I make all variables reference self, e.g. self.foo.  However, I'm looking through the wxPython in Action book and notice that "self" isn't used all the time. For example:   import wx  class TextFrame(wx.Frame):     def __init__(self):         wx.Frame.__init__(self, None, -1, 'Text Entry Example',             size=(300, 100))         panel = wx.Panel(self, -1)         basicLabel = wx.StaticText(panel, -1, "Basic Control:")         basicText = wx.TextCtrl(panel, -1, "I've entered some text!",             size=(175, -1))         basicText.SetInsertionPoint(0)         pwdLabel = wx.StaticText(panel, -1, "Password:")         pwdText = wx.TextCtrl(panel, -1, "password", size=(175, -1),             style=wx.TE_PASSWORD)         sizer = wx.FlexGridSizer(cols=2, hgap=6, vgap=6)         sizer.AddMany([basicLabel, basicText, pwdLabel, pwdText])         panel.SetSizer(sizer)   The one below does use "self".  import wx class ButtonFrame(wx.Frame):     def __init__(self):         wx.Frame.__init__(self, None, -1, 'Button Example',             size=(300, 100))         panel = wx.Panel(self, -1)         self.button = wx.Button(panel, -1, "Hello", pos=(50, 20))         self.Bind(wx.EVT_BUTTON, self.OnClick, self.button)         self.button.SetDefault()     def OnClick(self, event):         self.button.SetLabel("Clicked")   If I remember correctly, "self" is reference to a particular instance of the class, so when is it not necessary? Is there a general rule of thumb?
28265
I need to hide (make private) the -init method of my class in Objective-C.  How can I do that?
18453
Is it more efficient for a class to access member variables or local variables? For example, suppose you have a (callback) method whose sole responsibility is to receive data, perform calculations on it, then pass it off to other classes. Performance-wise, would it make more sense to have a list of member variables that the method populates as it receives data? Or just declare local variables each time the callback method is called?  Assume this method would be called hundreds of times a second...  In case I'm not being clear, here's some quick examples:  // use local variables class thisClass {     public:         void callback( msg&amp; msg )         {             int varA;             double varB;             std::string varC;             varA = msg.getInt();             varB = msg.getDouble();             varC = msg.getString();              // do a bunch of calculations          }  };  // use member variables class thisClass {     public:         void callback( msg&amp; msg )         {              m_varA = msg.getInt();              m_varB = msg.getDouble();              m_varC = msg.getString();               // do a bunch of calculations         }      private:         int m_varA;         double m_varB;         std::string m_varC;  };
60984
If you want to use global functions and variable dynamically you can use:  window[functionName](window[varName]);   Is it possible to do the same thing for variables in the local scope?  This code works correctly but currently uses eval and I'm trying to think of how else to do it.  var test = function(){     //this = window     var a, b, c; //private variables      var prop = function(name, def){         //this = window         eval(name+ ' = ' + (def.toSource() || undefined) + ';');              return function(value){             //this = test object             if ( !value) {                 return eval('(' + name + ')');             }             eval(name + ' = value;')             return this;         };      };      return {         a:prop('a', 1),         b:prop('b', 2),         c:prop('c', 3),         d:function(){             //to show that they are accessible via to methods             return [a,b,c];         }     }; }();  &gt;&gt;&gt;test Object &gt;&gt;&gt;test.prop undefined &gt;&gt;&gt;test.a function() &gt;&gt;&gt;test.a() 1 //returns the default &gt;&gt;&gt;test.a(123) Object //returns the object &gt;&gt;&gt;test.a() 123 //returns the changed private variable &gt;&gt;&gt;test.d() [123,2,3]
110574
So, I want to define a singleton method for an object, but I want to do it using a closure.  For example,  def define_say(obj, msg)   def obj.say     puts msg   end end  o = Object.new define_say o, "hello world!" o.say   This doesn't work because defining a singleton method via "def" is not a closure, so I get an exception that "msg" is an undefined variable or method.  What I would like to do is something like using the "define_method" method in the Module class, but as far as I can tell, this can only be used to define a method on a class... but I want a Singleton Method...  So, I would love to write it something like this:  def define_say(obj, msg)   obj.define_singleton_method(:say) {     puts msg   } end   Does anyone know how I can achieve this without having to create a method to store a Proc and then use the Proc within a singleton method? (basically, I want a clean, non-hacky way of doing this)
51484
Python has two ways to define your own properties.    Via bpy.propsAccessible from data-editor, or via buttons defined in scripts:  # define the property bpy.types.Scene.my_prop = bpy.props.BoolProperty() # set the property bpy.context.scene.my_prop = True     Via Python's __getitem__/__setitem__Accessible from custom-properties panel:  # no need to declare it.  # set the property bpy.context.scene["my_prop"] = True     What should be considered when choosing which one to use?
5798
Is there any meaningful distinction between:  class A(object):     foo = 5   # some default value   vs.  class B(object):     def __init__(self, foo=5):         self.foo = foo   If you're creating a lot of instances, is there any difference in performance or space requirements for the two styles? When you read the code, do you consider the meaning of the two styles to be significantly different?
82657
I want to override access to one variable in a class, but return all others normally.  How do I accomplish this with __getattribute__?  I tried the following (which should also illustrate what I'm trying to do) but I get a recursion error:  class D(object):     def __init__(self):         self.test=20         self.test2=21     def __getattribute__(self,name):         if name=='test':             return 0.         else:             return self.__dict__[name]  &gt;&gt;&gt; print D().test 0.0 &gt;&gt;&gt; print D().test2 ... RuntimeError: maximum recursion depth exceeded in cmp
89137
What would be better practice when giving a function the original variable to work with:  unsigned long x = 4;  void func1(unsigned long&amp; val) {      val = 5;             } func1(x);   or:  void func2(unsigned long* val) {      *val = 5; } func2(&amp;x);   IOW: Is there any reason to pick one over another?
20286
I have quickly read over the  documentation.  This kind of example has helped me to understand better, though:   delegate int del(int i); del myDelegate = x =&gt; x * x; int j = myDelegate(5); //j = 25   Still, I don't understand why it's such an innovation. It's just a method that dies when the "method variable" ends, right? Why should I use this instead of a real method?
114660
Is it better to have all the private members, then all the protected ones, then all the public ones?  Or the reverse?  Or should there be multiple private, protected and public labels so that the operations can be kept separate from the constructors and so on?  What issues should I take into account when making this decision?
17203
I need to know if a variable in Python is a string or a dict.  Is there anything wrong with the following code?  if type(x) == type(str()):     do_something_with_a_string(x) elif type(x) == type(dict()):     do_somethting_with_a_dict(x) else:     raise ValueError   Update: I accepted avisser's answer (though I will change my mind if someone explains why isinstance is preferred over type(x) is).  But thanks to nakedfanatic for reminding me that it's often cleaner to use a dict (as a case statement) than an if/elif/else series.  Let me elaborate on my use case.  If a variable is a string, I need to put it in a list.  If it's a dict, I need a list of the unique values.  Here's what I came up with:  def value_list(x):     cases = {str: lambda t: [t],              dict: lambda t: list(set(t.values()))}     try:         return cases[type(x)](x)     except KeyError:         return None   If isinstance is preferred, how would you write this value_list() function?
7441
Was there any reason why the designers of Java felt that local variables should not be given a default value? Seriously, if instance variables can be given a default value, then why can't we do the same for local variables?  And it also leads to problems as explained in :     Well this rule is most frustrating when trying to close a resource in a finally block. If I instantiate the resource inside a try, but try to close it within the finally, I get this error. If I move the instantiation outside the try, I get another error stating that a it must be within a try.      Very frustrating.
8134
The  says that public class SomeObject {   public void SomeOperation()   {     lock(this)     {       //Access instance variables     }   } }  is &quot;a problem if the instance can be accessed publicly&quot;. I'm wondering why? Is it because the lock will be held longer than necessary? Or is there some more insidious reason?