Checkered flag: a modular usage of Tkinter's geometry management
OOP is not merely creating classes: it is also about a thoughtful design. This becomes even more true when it comes to tkiner. I mean you created 2 separate classes to refer to tk.Label() and tk.Frame() classes. This is not the best option for your context as that design is misleading in that it makes the reader of your code think you are trying to create custom Label() and Frame() widgets (which is not what the application actually does).
Also, from the OOP perspective, the lines of code spanning from mainWindow = tk.Tk() to the end do not comply with the OOP philosophy (they are mere sequential instructions not even wrapped within a function)
You say the goal of your application is to play with the tkinter geometry managers. Actually there are 3 of them: place(), pack() and grid(). You are using only one of them. The ideal  is to use the 3 of them, but in my solution below I will use only 2 of them as the context is not suitable for a smart use of place().
You can use pack() for the frames and grid() to manage the labels.
It is better that you attach your widgets to a parent widget instead of the instance of the class you use. Example: instead of coding something like self.frame1 = tk.Frame(self), it would be more appropriate to write self.frame1 = tk.Frame(self.some_more_specific_parent)
There is an easier way to play with the flag (color) you are using as a background color for the label widgets (see my solution below)
It is hard, when launching your application, to see where is the main window and stretch it to make it visible. So for the sake of a better user experience, you should set default dimension to it and keep it resizable (see my solution below)
No need to use the pack() geometry manager the way you did.


Based on the elements stated above, and based on some of Tkinter best practices, I would like to suggest you the solution below which requires, logically, only one class, and refactors your code in a cleaner way:

import tkinter as tk


class SimpleGeometryManagersDemo(tk.Frame):

    def __init__(self, master):
        self.master = master
        super().__init__(self.master)
        self.configure_gui()
        self.create_widgets()

    def configure_gui(self):
        self.master.title('Simple Geometry Managers Demo')
        self.master.geometry('400x200')

    def create_widgets(self):
        self.create_two_frames()
        self.create_two_labels_per_frame()

    def create_two_frames(self):
        self.frame1 = tk.Frame(self.master)
        self.frame2 = tk.Frame(self.master)        
        self.frame1.pack(fill=tk.BOTH, expand=1)
        self.frame2.pack(fill=tk.BOTH, expand=1)        

    def create_two_labels_per_frame(self):
        self.create_two_labels(self.frame1, 'black')
        self.configure_columns_and_rows(self.frame1)
        self.create_two_labels(self.frame2, 'white')
        self.configure_columns_and_rows(self.frame2)

    def create_two_labels(self, parent, color):
        self.label1 = tk.Label(parent, bg=color) 
        bg_color = 'white' if color == 'black' else 'black'
        self.label2 = tk.Label(parent, bg=bg_color)        
        self.label1.grid(row=0, column=0, sticky='nswe')
        self.label2.grid(row=0, column=1, sticky='nswe')

    def configure_columns_and_rows(self, parent):
        parent.rowconfigure(0, weight=1)
        parent.columnconfigure(0, weight=1)
        parent.columnconfigure(1, weight=1)

def main():
   root = tk.Tk()
   geometry_managers_demo = SimpleGeometryManagersDemo(root)
   root.mainloop()


if __name__ == '__main__':
   main()