When importing modules written with tkinter and ttk, stuff doesn't work

Question 1

The root of your problem is that you're creating more than once instance of Tk. A Tkinter app can only have a single instance of of the Tk class, and you must call mainloop exactly once. If you need additional windows you should create instances of Toplevel (http://effbot.org/tkinterbook/toplevel.htm).

If you want to create modules with reusable code, have your modules create subclasses of Frame (or Toplevel if you're creating dialos). Then, your main script will create an instance of Tk, and place these frames in the main window or in subwindows.

If you want to sometimes use your module as a reusable component and sometimes as a runnable program, put the "runnable program" part inside a special if statement:

# module1.py
import Tkinter as tk
class Module1(tk.Frame):
    def __init__(self, *args, **kwargs):
        label = tk.Label(self, text="I am module 1")
        label.pack(side="top", fill="both", expand=True)

# this code will not run if this module is imported
if __name__ == "__main__":
    root = tk.Tk()
    m1 = Module1(root)
    m1.pack(side="top", fill="both", expand=True)

In the above code, if you run it like python module1.py, the code in that final if statement will run. It will create a root window, create an instance of your frame, and make that frame fill the main window.

If, however, you import the above code into another program, the code in the if statement will not run, so you don't get more than one instance of Tk.

Let's assume you have two modules like the above, and want to write a program that uses them, and each should go in a separate window. You can do that by writing a third script that uses them both:

# main.py
import Tkinter as tk
from module1 import Module1
from module2 import Module2

# create the main window; every Tkinter app needs
# exactly one instance of this class
root = tk.Tk()
m1 = Module1(root)
m1.pack(side="top", fill="both", expand=True)

# create a second window
second = tk.Toplevel(root)
m2 = Module2(second)
m2.pack(side="top", fill="both", expand=True)

# run the event loop
root.mainloop()

With the above, you have code in two modules that can be used in three ways: as standalone programs, as separate frames within a single window, or as separate frames within separate windows.

Question 2

You can't create two instances of tkinter.Tk. If you do, one of two things will happen.

Most of the code in the script may just not run, because it's waiting for the module's mainloop to finish, which doesn't happen until you quit.

If you structure things differently, you'll end up with two Tk instances, only one of which is actually running. Some of the code in your script will happen to find the right Tk instance (or the right actual Tk objects under the covers), because there's a lot of shared global stuff that just assumes there's one Tk "somewhere or other" and manages to find. But other code will find the wrong one, and just have no effect. Or, occasionally, things will have the wrong effect, or cause a crash, or who knows what.

You need to put the top-level application in one place, either the module or the script that uses it, and have the other place access it from there.

One way to do this is to write the module in such a way that its code can be called with a Tk instance. Then, use the __main__ trick so that, if you run the module directly as a script (rather than importing it from another script), it creates a Tk instance and calls that code. Here's a really simple example.

tkmodule.py:

from tkinter import *

def say_hi():
    print("Hello, world!")

def create_interface(window):
    hi = Button(window, text='Hello', command=say_hi)
    hi.pack()

if __name__ == '__main__':
    root = Tk()
    create_interface(root)
    root.mainloop()

tkscript.py:

from tkinter import *
import tkmodule

i = 0
def count():
    global i
    i += 1
    print(i)

def create_interface(window):
    countbtn = Button(window, text='Count', command=count)
    countbtn.pack()

root = Tk()
create_interface(root)
window = Toplevel(root)
tkmodule.create_interface(window)
root.mainloop()

Now, when you run tkscript.py, it owns one Tk instance, and passes it to its own create_frame and to tkmodule.create_frame. But if you just run tkmodule.py, it owns a Tk instance, which it passes to its own create_frame. Either way, there's exactly one Tk instance, and one main loop, and everyone gets to use it.

Notice that if you want two top-level windows, you have to explicitly create a Toplevel somewhere. (And you don't want to always create one in tkmodule.py, or when you run the module itself, it'll create a new window and leave the default window sitting around empty.)

Of course an even simpler way to do this is to put all of your GUI stuff into modules that never create their own Tk instance, and write scripts that import the appropriate modules and drive them.