How to switch between variables in nested functions (Also note Tkinter)

Python Help
1

I am in a middle of a complex thing. Look:

frame = tk.Frame(root)
frame.pack()

TabTool = tk.Frame(root)
TabTool.pack(side = tk.TOP)
Bottom = tk.Frame(root)
Bottom.pack(side = tk.BOTTOM)

def Label(Frame, Name, Text):
    Name = tk.Label(Frame, text = Text)
    Name.pack(side = tk.LEFT)

def Button(Frame, Name, Text, Image, Command, Pack):
    Name = tk.Button(Frame, text = Text, image = Image, command = Command)
    Name.pack(side = Pack)

Label(Bottom ,'lab','Welcome!')
Button(Bottom ,'a' , 'NUT', None, quit ,tk.LEFT)

CanvasArea = ttk.Frame(Bottom)
CanvasArea.pack(side = tk.LEFT)

CW = 300
CH = 600
LXM = (CW / 2)
LYM = (CH / 2)

R = 'red'
G = 'green'
B = 'blue'
JB = 'black'

MainCanvas = tk.Canvas(CanvasArea, bg = 'white', height = CH, width = CW)
MainCanvas.pack(side = tk.LEFT)

def Ch1(LX, LY, SX, SY):
    NP = (((-1 * SX) + LX), ((0 * SY) + LY), ((1 * SX) + LX), ((0 * SY) + LY))
    A1 = (((10 * SX) + LX), ((0 * SY) + LY), ((10 * SX) + LX), ((0 * SY) + LY)), ((10 * SX) + LX), ((-10 * SY) + LY))
    A2 = (((-10 * SX) + LX), ((0 * SY) + LY), ((-10 * SX) + LX), ((0 * SY) + LY)), ((10 * SX) + LX), ((10 * SY) + LY))
    def CB(M1, M2, M3, MC1, MC2, MC3, LO, LT, LS):
        MainCanvas.create_polygon(M1, fill = MC1, outline = LO, width = LT, smooth = LS)
        MainCanvas.create_polygon(M2, fill = MC2, outline = LO, width = LT, smooth = LS)
        MainCanvas.create_polygon(M3, fill = MC3, outline = LO, width = LT, smooth = LS)
    def Type(T1, T2, T3, C1, C2, C3, LO, LT, LS):
        CB(T1, T2, T3, C1, C2, C3, LO, LT, LS)
        CB(T1, T3, NP, C3, C2, C1, LO, LT, LS)
    Type(A1, A2, NP, R, G, B, JB, 1, 0)
Ch1(LXM, LYM, 1, 1)

The question is how to switch the variables in the arguments in the “Type” function call, by inputting variables in the additional arguments in the Ch1 (e.g. type A1 into an argument in Ch1 to have the T1 argument input switch to A1 (from the Ch1 argument input)). I cannot just separate the variables into other things, because things like LX, LY, SX, SY need to be defined by arguments to work. Any ideas on what to do? I am running out of options.

2

Your question is not so clear. I think you want to know how to swap actual parameters when calling a function. To get better answers it may be advisable to create a minimal reproducible example.

I created a small example from your code:

R = 'red'
G = 'green'
B = 'blue'
JB = 'black'

def change_order(params):

    return params[1], params[2], params[0]

def Ch1(LX, LY, SX, SY):
    NP = (((-1 * SX) + LX), ((0 * SY) + LY), ((1 * SX) + LX), ((0 * SY) + LY))
    A1 = (((10 * SX) + LX), ((0 * SY) + LY), ((10 * SX) + LX), ((0 * SY) + LY)), ((10 * SX) + LX), ((-10 * SY) + LY)
    A2 = (((-10 * SX) + LX), ((0 * SY) + LY), ((-10 * SX) + LX), ((0 * SY) + LY)), ((10 * SX) + LX), ((10 * SY) + LY)
    def CB(M1, M2, M3, mcs, LO, LT, LS):
        print("In CB with", M1, M2, M3, mcs)
    def Type(T1, T2, T3, C1, C2, C3, LO, LT, LS):
        mcs = (C1, C2, C3)
        for _ in range(3):
            CB(T1, T2, T3, mcs, LO, LT, LS)
            mcs = change_order(mcs)
    Type(A1, A2, NP, R, G, B, JB, 1, 0)

When calling Ch1, it calls the CB function with three permutations of the colours (RGB).

The output:

>>> import poly
>>> poly.Ch1(22, 65, 1, 1)
In CB with ((32, 65, 32, 65), 32, 55) ((12, 65, 12, 65), 32, 75) (21, 65, 23, 65) 
('red', 'green', 'blue')
In CB with ((32, 65, 32, 65), 32, 55) ((12, 65, 12, 65), 32, 75) (21, 65, 23, 65) 
('green', 'blue', 'red')
In CB with ((32, 65, 32, 65), 32, 55) ((12, 65, 12, 65), 32, 75) (21, 65, 23, 65) 
('blue', 'red','green')

I put the colours on a separate line for clarity when copying them from the REPL.

Is this what you are looking for?

Extra
Why are you using the nested function Type here? It is quite unusual in Python and not necessary. You might as well put the code from the Type function inline, which results in easier to read code IMO.