We Keep Coding

How to initialize whole Python module and import all classes without needing to reference module name for every call?

Suppose I have a module named 'module1', which has many classes. I want to use all of their classes in my main controller main.py . I can import whole module with import module1, however, I assume that the class names in 'module1' are unique and I do not want to reference module1 every time I call its function such as module1.class1().
How can I import the whole contents of a module without explicitly having to state class/function names and still being able to refer to them without stating the module name.
Such as:
# module1.py.
class Class1():
pass
class Class2():
pass
# __main__.py
import module1
# The following will not work.
object1 = Class1()
object2 = Class2()

You can use the * import pattern
from module1 import *
This lets you use everything inside that module without referencing it.
from module1 import *
instance = Class1()
However, this is generally discouraged. For reasons why, some additional reading:
Why is "import *" bad?
https://www.geeksforgeeks.org/why-import-star-in-python-is-a-bad-idea/

Python, when import from module cmd I haven't all attribute

When I import module urllib in cmd I have only magic fuctions but when I import this module from Spyder I have all attribute.
I'm adding printscreen of this.
Why can not I import all attribute?

To import all attributes of a module into the global namespace use from module import *.
While dir() simply lists the attributes of the global namespace, dir(module) lists the ones in the scope of the specific module.
Anyway, when you import urllib you can still reach all attributes if you specify the module name, e.g. urllib.request.

Can't Import Python Class

I am having an issue with Python imports. I created a module to conveniently import a few classes inside of the module with a single statement. I put all of my imports inside of the init of that module, but it doesn't seem to work.
maindir\
- driver.py
- Utility\
- __init__.py
- UtilityClasses.py
My folder structure looks like the above.
Inside of UtilityClasses I have one a class that I have created called MyClass.
Inside of the init file in the Utility folder, I have code that says:
import UtilityClasses
from UtilityClasses import MyClass
Inside of driver.py I have code that says:
import Utility
myVar = MyClass(param1)
However, when I run this, I get an error telling me that name MyClass is not defined.

In __init__.py, you can do
from UtilityClasses import *
from SomeOtherFile import *
This will import everything from UtilityClasses.py and SomeOtherFile.py.
But you still have to access it using the module name
Update: You can access everything like this
In driver.py:
from Utility import *
a = MyClass()
b = ClassInSomeOtherFile()

Your code
import Utility
myVar = MyClass(param1)
of course won't work -- MyClass is nowhere mentioned and it won't come magically from nowhere. Explicit is better than implicit:
from Utility import MyClass
myVar = MyClass(param1)
should work like a charm!

Is it safe in Python to use 'from copy import copy' statement?

Python has complicated namespaces and modules notion, so i unsure about this. Normally python module and something that is imported from it has different names or only module is imported and it's content used by fully qualified name:
import copy # will use copy.copy
from time import localtime # "localtime" has different name from "time".
But what if module has same name as something that i'm importing from it? For example:
from copy import copy
copy( "something" )
Is it safe? Maybe it's some complicated consequences that i can't see?

From PEP8 ( http://www.python.org/dev/peps/pep-0008/#imports):
When importing a class from a class-containing module, it's usually okay to spell this:
from myclass import MyClass
from foo.bar.yourclass import YourClass
If this spelling causes local name clashes, then spell them
import myclass
import foo.bar.yourclass
and use "myclass.MyClass" and "foo.bar.yourclass.YourClass".

how to import only the class methods in python

I have a GP.py file that I am then running a MyBot.py file from.
In the MyBot.py file, I have the line
from GP import *
I have a suspicion it is importing the whole file instead of just the class methods and class descriptions I want. In the GP.py file, There is code in addition to the defintions

You cannot import class methods separately, you have to import the classes. You can do this by enumerating the classes you want to import:
from GP import class1, class2, class3
Note that this will still load the entire module. This always happens if you import anything from the module. If you have code in that module that you do not want to be executed when the module is imported, you can protect it like this:
if __name__ == "__main__":
# put code here
Code inside the block will only be executed if the module is run directly, not if it is imported.

_single_leading_underscore: weak "internal use" indicator. E.g. from M import * does not import objects whose name starts with an
underscore.
Use this instead:
from GP import SomeClass
Have a look at PEP-8 (Python Guidelines) if you want to use import *
Modules that are designed for use via from M import * should use the
__all__ mechanism to prevent exporting globals

It is not recommended to import all from a module. Zen of Python says "Explicit is better than Implicit"
It may have some side effects by overriding an existing name. You should always keep control on the namespace.
You can import your classes and function this way:
from GP import MyClass, my_function
An alternative is to import the module itself
import GP
GP.my_function()
GP.MyClass()
This way, you create a namespace for the GP module and avoid to overwrite something.
I hope it helps

import * indeed import all classes, functions,variables and etc..
if you want to import only specific class use
from GP import class_name
and as far as i know you cannot import only class methods

If you want to import just some methods from class
from GP.MyClass import MyFunction