Declaring a variable in a class (outside of a function): all class functions can access it (basically a public variable)

Declaring a variable inside a function inside a class: only that function can access it (it’s in that function’s scope)

Declaring a variable with self.(variable name) inside a function inside a class: all class functions can access it (how is this different from global (variable name)?)

And since there is no private/protected, everything is public, so everything accessible from inside a class is accessible from outside the class.

Are there any other nuances I should know, or have I pretty much got it?

Since the listing in your question is not 100% clear, I’ve decided to explain it with a simple example. It also includes some things like __something variables you did not mention in your list.

class Test:
    a = None
    b = None

    def __init__(self, a):
        print self.a
        self.a = a
        self._x = 123
        self.__y = 123
        b = 'meow'

At the beginning, a and b are only variables defined for the class itself – accessible via Test.a and Test.b and not specific to any instance.

When creating an instance of that class (which results in __init__ being executed):

  • print self.a doesn’t find an instance variable and thus returns the class variable
  • self.a = a: a new instance variable a is created. This shadows the class variable so self.a will now reference the instance variable; to access the class variable you now have to use Test.a
  • The assignment to self._x creates a new instance variable. It’s considered “not part of the public API” (aka protected) but technically it has no different behaviour.
  • The assignment to self.__y creates a new instance variable named _Test__y, i.e. its name is mangled so unless you use the mangled name it cannot be accessed from outside the class. This could be used for “private” variables.
  • The assignment to b creates a local variable. It is not available from anywhere but the __init__ function as it’s not saved in the instance, class or global scope.

Declaring a variable at the top level of the class is like declaring a static or class variable. Qualifying it with self is declaring an instance variable. Class variables can be modified by referring to them by class name (e.g. Class.x = 5) and all instances will inherit these changes. Instance variables are private to an instance and can only be modified by that instance.

You can achieve some level of access control using underscores. See private variables in the Python tutorial. By convention, variables starting with one underscore, e.g. _foo are non-public parts of an API, and names starting with two underscores e.g. __foo will have it’s name mangled to be _classname__foo.

Although answered, let me add some comments to your questions:

declaring a variable in a class (outside of a function) : all class functions can access it (basically a public variable):
comment:this is like a static variable and can be called using the class name. These variables are available to all functions, any functions can modify it and print it.

declaring a variable inside a function inside a class : only that function can access it (its in that functions scope):
comment: if the variable is declared without self then it is accessible within that function only, kinda local variable. However if it declared using self like self.var=”somevalue”,, then it is accessible via any object but not via the class name.

declaring a variable with self.(variable name) inside a function inside a class : all class functions can access it (how is this different from global (variable name)?):
comment: see asnswer in the above part.

and since there is no private / protected, everything is public, so everything accessible from inside a class is accessible from outside the class.:
comment: yes, but we can use single underscore to tell world this variable is private but technically that actually doesnt make it private.

we can use the scope in this for as :
case 1: In the Class

class test:
     def __init__(self, a):
          self.__elements = a
     def change_a(self): self.__elements = 5

case 2 : Outside class

t = test(5)

This will access by as object._classname__privatevaribalename

print(t._test__elements)

this will print the change value of a