End a running function using inner function with tkinter input GUI form, and display a warning message when exiting the GUI in between

One way can be to raise an exception from f2, then catch that exception in f1 and then return early:

def f1():
    # do something
    def f2():
        print('Hello')
        # need a command here
        raise StopIteration()
        print('World!')

    try:
        f2()
    except StopIteration:
        return

    print('World')
    # do something

f1()

Outputs:

Hello

I'm not exactly sure where you're defining the while loop mentioned. If it's outside of f1 entirely, I'd delegate handling of the error within such a loop itself - or you could even wrap the while loop with a try-except if absolutely needed. If you go with latter approach, I'd suggest creating a custom exception class and then catching that specific error; this way you can be sure you're handling only the error that you've raised from within f2 for example.

Never mind folks, I found the solution I needed:

import tkinter as tk
from tkinter import messagebox as msgbox
from PIL import ImageTk

lst = []


black = '#%02x%02x%02x' % (50, 50, 50)
white = '#%02x%02x%02x' % (240, 240, 240)
red = '#%02x%02x%02x' % (255, 80, 80)
yellow = '#%02x%02x%02x' % (255, 220, 80)
green = '#%02x%02x%02x' % (120, 255, 150)
blue = '#%02x%02x%02x' % (0, 220, 240)
purple = '#%02x%02x%02x' % (120, 80, 255)

window_icon = 'icon.jpg'


def root_win():
    global lst

    root = tk.Tk()  # create only one instance for Tk()

    w_root = 500
    h_root = 320

    pos_right = round(root.winfo_screenwidth() / 2 - w_root / 2)
    pos_down = round(root.winfo_screenheight() / 2 - h_root / 2)

    root.iconphoto(True, ImageTk.PhotoImage(file=window_icon))
    root.attributes("-topmost", True)
    root.title('Enter the values')
    root.resizable(width=False, height=False)
    root.geometry('{}x{}+{}+{}'.format(w_root, h_root, pos_right, pos_down))
    root.configure(bg=white)

    tk.Label(root, text='Enter the values', font=('bold', 30), bg=white, fg=black).place(x=70, y=20)
    tk.Label(root, text='Enter width here:', font=('bold', 15), bg=white, fg=black).place(x=50, y=100)
    tk.Label(root, text='Enter height here:', font=('bold', 15), bg=white, fg=black).place(x=50, y=140)

    val1 = tk.Entry(root, bd=0, font=('bold', 15))
    val1.place(x=280, y=102, width=170)

    val2 = tk.Entry(root, bd=0, font=('bold', 15))
    val2.place(x=280, y=142, width=170)

    lbl = tk.Label(root, text='Min: 5, Max: 100', font=('bold', 15), bg=white, fg=purple)
    lbl.place(x=170, y=260)

    def enter():
        global lst
        if val1.get() == '' and val2.get() == '':
            lbl.config(text='Please enter width and height!')
            lbl.place(x=80, y=260)

        elif val1.get() == '':
            lbl.config(text='Please enter a width!')
            lbl.place(x=145, y=260)

        elif val2.get() == '':
            lbl.config(text='Please enter a height!')
            lbl.place(x=140, y=260)

        else:
            wid, hit = 0, 0
            try:
                wid = round(float(val1.get()))
                hit = round(float(val2.get()))
            except:
                pass

            if not 5 <= wid <= 100 or not 5 <= hit <= 100:
                lbl.config(text='Please enter value from 5 to 100!')
                lbl.place(x=70, y=260)

            else:
                # lbl.config(text='INPUT ACCEPTED !!!!')
                # lbl.place(x=130, y=260)
                lst = [wid, hit]
                root.destroy()

    def clr():
        val1.delete(0, 'end')
        val2.delete(0, 'end')
        lbl.config(text='Min: 5, Max: 100')
        lbl.place(x=170, y=260)

    def closing():
        if msgbox.askyesno(title='Exit prompt', message='Are you sure you want to exit?',
                           icon='warning', default='no'):
            root.destroy()
            print('Have a nice day!')
            quit()

    ext = tk.Button(root, text='Cancel', font=('bold', 15), bd=0, fg=black, bg=red, activebackground=yellow,
                    command=closing)
    ext.place(x=60, y=200)
    ext.configure(width=7)

    clear = tk.Button(root, text='Clear', font=('bold', 15), bd=0, fg=black, bg=yellow, activebackground=red,
                      command=clr)
    clear.place(x=200, y=200)
    clear.configure(width=7)

    enter = tk.Button(root, text='Enter', font=('bold', 15), bd=0, fg=black, bg=green, activebackground=blue,
                      command=enter)
    enter.place(x=340, y=200)
    enter.configure(width=7)

    root.protocol("WM_DELETE_WINDOW", closing)
    root.mainloop()


root_win()
print(lst)

The key was this line set:

    def closing():
        if msgbox.askyesno(title='Exit prompt', message='Are you sure you want to exit?',
                           icon='warning', default='no'):
            root.destroy()
            print('Have a nice day!')
            quit()

There are a couple of ways I would tackle this - and it depends on the complexity of the problem.

Simple calculations can be achieved like so:

def foo(*args,**kwargs):
    bar = lambda ... : ...
    do something
    final = bar(x)
    return final   

foo()

If the function has added complexity, it makes sense to use a class (or classes depending on the complexity) like so:

class thing_youre_classifying(object):
    def __init__(self):
        ...

    def __any_other_boilerplate_methods_needed__(self):
        ...

    def foo(self):
        do something

    def bar(self):
        do something
        x = f1()

thing = thing_youre_classifying()
thing.bar()

This is mostly for readability (and probably other important things).

Or, if foo and bar are wildly different (say in foo you're parsing a database and bar you're doing statistical analysis), you'll want to check out class inheritance.

class foo(object):
    def __init__(self, *args, **kwargs)
        initialize each instance of foo with args and kwargs

class bar(foo):
    def __init__(self):
        foo.__init__(self, *args, **kwargs)

instance = bar()
instance.foo()

I want to point out that I did not include *args or **kwargs in bar's boilerplate init function. That could also underline the difference between foo and bar.

The last thing that comes to mind is using decorators.

"One of the main uses of decorators is that they allow us to add functionality to existing functions, without modifying the original function. This capability extends to class methods as well." -anonymous professor

def foo():
    def modifier():
        return foo.method_you_want()
    return modifier

@foo
def bar():
    do something

My gut tells me decorators are going to be the cleanest way to do this.