I just cobbled some code together to give you a short introduction in how to use the place geometry manager. For further explanation please see comments in code:

#!/usr/bin/env python3
# coding: utf-8

from tkinter import *


# init our application's root window
root = Tk()
root.geometry('480x480')


# let's provide same sample coordinates with the desired text as tuples in a list
coords = [(30,30,'X'), (90,90,'X'), (120,120,'X'), (240,240,'X'), (270,270,'X'), (360,360,'O')]


# interate through the coords list and read the coordinates and the text of each tuple
for c in coords:
    l = Label(root, text=c[2])
    l.place(x=c[0], y=c[1])


# start a loop over the application
root.mainloop()

I am using Python 3. If you are using Python 2, you need to change tkinter to Tkinter. That should do the trick if you need to port my code to Python 2.

In Tkinter, most configuration functions when used without new value arguments returns the current value(s). Thus root.geometry() (plus a few string parsing) can serve your goal.

winfo_rootx() and winfo_rooty() return the coordinates relative to the screen's upper left corner. winfo_x and winfo_y return the coordinates of a window relative to its parent.

Ok, there are two thing that you are missing. The first, in your first example, is that you need to assure tkinter is getting the right values, and to do this you have to use update_idletasks() method before any winfo.

The second thing, which explains why you have to use -8 to center the full screen window, is that tkinter widows have outer-frames. You can determine the size of this frame by checking for the top left coordinate of the window (winfo_rootx()) and of the outer-frame (winfo_x()). Now the frame width is the difference between both: frame_width = root.winfo_rootx() - root.winfo_x() while the real window width is real_width = root.winfo_width() + (2*frame_width), since you have to consider the frame in both sides.

In summary, to center the window horizontally you do:

width = root.winfo_width()
frame_width = root.winfo_rootx() - root.winfo_x()
real_width = root.winfo_width() + (2*frame_width)
x = root.winfo_screenwidth() // 2 - real_width // 2

(here you can print the frame width and you will see it is 8)

and then use geometry method to place the window at position x.

Off course you can do the same for the vertical alignment

There's the less well known place geometry manager.

In your case you'd simply create the button and place it at the coordinates you want.

b = tk.Button(self.LW,text='Button')
b.place(x=120,y=62)

The reason people typical avoid 'place' is that it isn't automatically responsive to things like design changes or window resizes in the same way that pack and grid are.

You might be better off using relx and rely and the anchor options to express the position in terms of fractions of the window rather than specifying an absolute position to avoid some of these disadvantages.

The method place_info will return all of the information used by place for that widget.

>>> print(label_0.place_info())
{'in': <tkinter.Tk object .>, 'x': '10', 'relx': '0', 'y': '15', 'rely': '0', 'width': '', 'relwidth': '', 'height': '', 'relheight': '', 'anchor': 'nw', 'bordermode': 'inside'}

If you just want the x/y coordinate no matter how it was added to the window, you can use the winfo_x() and winfo_y() methods.

If we subtract the coordinates of the upper left corner from the e.x ,y _root coordinates, then the label remains on the screen.

from tkinter import *


def customMouse(e=None):
    x = e.x_root - root.winfo_x() - 10
    y = e.y_root - root.winfo_y() - 40
    print(x, y)
    label.place_configure(x=x, y=y)


root = Tk()
label = Label(master=root, text="^", bg="grey")
label.place(x=0, y=0)

root.bind('<Motion>', customMouse)

root.mainloop()

Assign the results of c.create_oval to x -- that's the "object ID" of the oval. Then,

c.coords(x)

gives you the (x1, y1, x2, y2) tuple of the oval's coordinates (you call coords with new coordinates following the x to move the oval).