If I understand your question correctly, you should be able to reference class A within class A by putting the type annotation in quotes. This is called forward reference.

class A:
  # do something
  def some_func(self, a: 'A')
  # ...

See ref below

1. https://github.com/python/mypy/issues/3661
2. https://www.youtube.com/watch?v=AJsrxBkV3kc

Before I go into answering your question, I want to mention some things about terminology. Your myclass value is an instance, not a class. You do have a class in your code, named AddSub. When you called AddSub() you created an instance of that class. It's important to learn the right terminology for things like this, so you can ask good questions and understand the answers you get back.

Your code comes close to working because you're saving an instance of the AddSub class to a global variable named myclass. Later, you call some methods on that global variable from the try_block function. This is legal in Python, though generally not recommended.

Instead, you should pass the object as an argument:

def try_block(value):
    try:
        value.set_x(whatever())
    except ValueError:
        pass

You'd call it by passing an instance of your AddSub class to the function:

myAddSub = AddSub() # create the instance
try_block(myAddSub) # pass it to the function

This is much nicer because it doesn't depend on a global variable having a specific value to work and you can call it with many different AddSub instances, if you want.

One part of your code that's currently broken is the AddSub class's constructor. There's no need to declare variables. You can just assign to them whenever you want. If you want to have default values set, you can do that too:

def __init__(self):
    self._x = 0
    self._y = 0

If instead you want to be able to set the values when you construct the object, you can add additional parameters to the __init__ method. They can have default values too, allowing the caller to omit some or all of them:

def __init__(self, x=0, y=0):
    self._x = x
    self._y = y

With that definition, all of these will be valid ways to construct an AddSub instance:

a = AddSub()     # gets default 0 value for both _x and _y
b = AddSub(5)    # gets default 0 value for _y
c = AddSub(y=5)  # gets default 0 value for _x
d = AddSub(2, 3) # no defaults!

Finally a point that is mostly independent of your main question: Your try_block function is both poorly named, and implemented in a more complicated way than necessary. Instead of being recursive, I think it would make more sense as a loop, like in this psuedocode version:

def exception_prone_task():
    while True: # loops forever, or until a "return" or "break" statement happens
         try:
             result = do_stuff_that_might_raise_an_exception()
             return result # you only get here if no exception happened

         except WhateverExceptions as e:
             report_about_about_the_exceptions(e)

To answer the question posed in the title (in case that is still bringing people to this question):

Python objects are passed in and out of functions by pointer value. That's a lot like being passed by reference, but it's not exactly the same as how references work in other languages (like C++). You can mutate a value being passed in, as long as you do it in-place. You cannot, however, rebind the value of the object and see the same rebinding outside the function.

Here are some examples that demonstrate the differences:

value = [1, 2, 3]

def foo(x):
    x.append(4)           # mutate x in place
    print('inside', x)

foo(value)                # prints 'inside [1, 2, 3, 4]'
print('outside', value)   # prints 'outside [1, 2, 3, 4]'

def bar(x):
    x = [9, 8, 7]         # this rebinding is allowed, but may not do what you want
    print('inside', x)

bar(outside_value)        # prints 'inside [9, 8, 7]'
print('outside', value)   # still prints 'outside [1, 2, 3, 4]'

That reference isn't describing a special case of the language rules, it's a natural result of everything being an object.

The special case is that MyClass(args...) is wired up to create a new object and call MyClass.__init__ (among other things).

It allows you to change the state of the class after it is defined. This can be as simple as changing "static" data based on some configuration.

class EggsApiClient:
    default_url = "example.com"
    def connect(self):
        # do stuff with default_url

if __name__ = "main":
    EggsApiClient.default_url = parse_args("default_url")

Try:

class Person(object):
    def __init__(self, fn, ln, address):
        self.uid    = Id_Class.new_id("Person")
        self.f_name = fn
        self.l_name = ln
        self.address = address

class Address(object):
    def __init__(self, st, sub):
        self.uid    = Id_Class.new_id("Address")
        self.street = st
        self.suburb = sub

hm = Address('Queen St.', 'Sydney')

s = Person('John', 'Doe', hm)

Whatever is associated with a variable name has to be stored in the program's memory somewhere. An easy way to think of this, is that every byte of memory has an index-number. For simplicity's sake, lets imagine a simple computer, these index-numbers go from 0 (the first byte), upwards to however many bytes there are.

Say we have a sequence of 37 bytes, that a human might interpret as some words:

"The Owl and the Pussy-cat went to sea"

The computer is storing them in a contiguous block, starting at some index-position in memory. This index-position is most often called an "address". Obviously this address is absolutely just a number, the byte-number of the memory these letters are residing in.

@12000 The Owl and the Pussy-cat went to sea

So at address 12000 is a T, at 12001 an h, 12002 an e ... up to the last a at 12037.

I am labouring the point here because it's fundamental to every programming language. That 12000 is the "address" of this string. It's also a "reference" to it's location. For most intents and purposes an address is a pointer is a reference. Different languages have differing syntactic handling of these, but essentially they're the same thing - dealing with a block of data at a given number.

Python and Java try to hide this addressing as much as possible, where languages like C are quite happy to expose pointers for exactly what they are.

The take-away from this, is that an object reference is the number of where the data is stored in memory. (As is a pointer.)

Now, most programming languages distinguish between simple types: characters and numbers, and complex types: strings, lists and other compound-types. This is where the reference to an object makes a difference.

So when performing operations on simple types, they are independent, they each have their own memory for storage. Imagine the following sequence in python:

>>> a = 3
>>> b = a
>>> b
3
>>> b = 4
>>> b
4
>>> a
3      # <-- original has not changed

The variables a and b do not share the memory where their values are stored. But with a complex type:

>>> s = [ 1, 2, 3 ]
>>> t = s
>>> t
[1, 2, 3]
>>> t[1] = 8
>>> t
[1, 8, 3]
>>> s
[1, 8, 3]  # <-- original HAS changed

We assigned t to be s, but obviously in this case t is s - they share the same memory. Wait, what! Here we have found out that both s and t are a reference to the same object - they simply share (point to) the same address in memory.

One place Python differs from other languages is that it considers strings as a simple type, and these are independent, so they behave like numbers:

>>> j = 'Pussycat'
>>> k = j
>>> k
'Pussycat'
>>> k = 'Owl'
>>> j
'Pussycat'  # <-- Original has not changed

Whereas in C strings are definitely handled as complex types, and would behave like the Python list example.

The upshot of all this, is that when objects that are handled by reference are modified, all references-to this object "see" the change. So if the object is passed to a function that modifies it (i.e.: the content of memory holding the data is changed), the change is reflected outside that function too.

But if a simple type is changed, or passed to a function, it is copied to the function, so the changes are not seen in the original.

For example:

def fnA( my_list ):
    my_list.append( 'A' )

a_list = [ 'B' ]
fnA( a_list )
print( str( a_list ) )
['B', 'A']        # <-- a_list was changed inside the function

But:

def fnB( number ):
    number += 1

x = 3
fnB( x )
print( x )
3                # <-- x was NOT changed inside the function

So keeping in mind that the memory of "objects" that are used by reference is shared by all copies, and memory of simple types is not, it's fairly obvious that the two types operate differently.

Assignment statements in Python don't copy objects, they create bindings between the target and an object.

An easy to understand guide on how this different from other languages is available here.

When you need to change an assigned object so it does not affect other assigned objects you can use the copy module. (https://docs.python.org/3.4/library/copy.html)

import copy

class A:

    def __init__(self):
        self.x = 1

    def changeX(self,num):
        self.x = num


class B:

    def __init__(self,classA):
        self.x = classA

class C:
    def __init__(self,classA):
        self.x = classA

    def ChangeA(self,num):
        self.x.changeX(num)

c_a = A()
c_b = B(c_a)
c_c = copy.deepcopy(C(c_a))


c_c.ChangeA(2)

c_a.x #1
c_b.x.x #1
c_c.x.x #2

You need to store a reference to the object which has the instance of a Y object:

class X(object):
    def __init__(self):
        self.count = 5
        self.y = Y(self) #create a y passing in the current instance of x
    def add2(self):
        self.count += 2

class Y(object):
    def __init__(self,parent):
        self.parent = parent #set the parent attribute to a reference to the X which has it
    def modify(self):
        self.parent.add2()

Example usage:

>>> x = X()
>>> x.y.modify()
>>> x.count
7