I appear to be missing some fundamental Python concept that is so simple that no one ever talks about it.  I apologize in advance for likely using improper description - I probably don't know enough to ask the question correctly.
Here is a conceptual dead end I have arrived at:
I have an instance of Class Net, which handles communicating with some things over the internet.
I have an instance of Class Process, which does a bunch of processing and data management
I have an instance of Class Gui, which handles the GUI.
The Gui instance needs access to Net and Process instances, as the callbacks from its widgets call those methods, among other things.
The Net and Process instances need access to some of the Gui instances' methods, as they need to occasionally display stuff (what it's doing, results of queries, etc)
How do I manage it so these things talk to each other?  Inheritance doesn't work - I need the instance, not the class.  Besides, inheritance is one way, not two way.
I can obviously instantiate the Gui, and then pass it (as an object) to the others when they are instantiated.  But the Gui then won't know about the Process and Net instances.  I can of course then manually pass the Net and Process instances to the Gui instance after creation, but that seems like a hack, not like proper practice.  Also the number of interdependencies I have to manually pass along grows rather quickly (almost factorially?) with the number of objects involved - so I expect this is not the correct strategy.
I arrived at this dead end after trying the same thing with normal functions, where I am more comfortable.  Due to their size, the similarly grouped functions lived in separate modules, again Net, Gui, and Process.  The problem was exactly the same.  A 'parent' module imports 'child' modules, and can then can call their methods.  But how do the child modules call the parent module's methods, and how do they call each other's methods?  Having everything import everything seems fraught with peril, and again seems to explode as more objects are involved.
So what am I missing in organizing my code that I run into this problem where apparently all other python users do not?
The answer to this is insanely simple.
Anything that needs to be globally available to other modules can be stored its own module, global_param for instance.  Every other module can import global_param, and then use and modify its contents as needed.  This avoids any issues with circular importing as well.
Not sure why it took me so long to figure this out...
How do I handle communication between object instances, or between modules?