Can you write code for a basic calculator with an interface?
Yes, I can help you write a basic calculator program with a graphical user interface using Python's built-in tkinter library. Here's an example code that you can use:
``` 
import tkinter as tk

class Calculator:
    def __init__(self, master):
        self.master = master
        master.title(Basic Calculator)

        # Entry widget to display calculations
        self.display = tk.Entry(master, width=40, borderwidth=5)
        self.display.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

        # Buttons for numbers
        self.button_1 = tk.Button(master, text=1, padx=40, pady=20, command=lambda: self.button_click(1))
        self.button_2 = tk.Button(master, text=2, padx=40, pady=20, command=lambda: self.button_click(2))
        self.button_3 = tk.Button(master, text=3, padx=40, pady=20, command=lambda: self.button_click(3))
        self.button_4 = tk.Button(master, text=4, padx=40, pady=20, command=lambda: self.button_click(4))
        self.button_5 = tk.Button(master, text=5, padx=40, pady=20, command=lambda: self.button_click(5))
        self.button_6 = tk.Button(master, text=6, padx=40, pady=20, command=lambda: self.button_click(6))
        self.button_7 = tk.Button(master, text=7, padx=40, pady=20, command=lambda: self.button_click(7))
        self.button_8 = tk.Button(master, text=8, padx=40, pady=20, command=lambda: self.button_click(8))
        self.button_9 = tk.Button(master, text=9, padx=40, pady=20, command=lambda: self.button_click(9))
        self.button_0 = tk.Button(master, text=0, padx=40, pady=20, command=lambda: self.button_click(0))

        # Buttons for mathematical operations
        self.button_add = tk.Button(master, text=+, padx=39, pady=20, command=self.button_add)
        self.button_subtract = tk.Button(master, text=-, padx=41, pady=20, command=self.button_subtract)
        self.button_multiply = tk.Button(master, text=*, padx=40, pady=20, command=self.button_multiply)
        self.button_divide = tk.Button(master, text=/, padx=41, pady=20, command=self.button_divide)
        self.button_equal = tk.Button(master, text==, padx=91, pady=20, command=self.button_equal)
        self.button_clear = tk.Button(master, text=Clear, padx=79, pady=20, command=self.button_clear)

        # Grid buttons
        self.button_1.grid(row=3, column=0)
        self.button_2.grid(row=3, column=1)
        self.button_3.grid(row=3, column=2)

        self.button_4.grid(row=2, column=0)
        self.button_5.grid(row=2, column=1)
        self.button_6.grid(row=2, column=2)

        self.button_7.grid(row=1, column=0)
        self.button_8.grid(row=1, column=1)
        self.button_9.grid(row=1, column=2)

        self.button_0.grid(row=4, column=0)

        self.button_clear.grid(row=4, column=1, columnspan=2)
        self.button_add.grid(row=5,column=0)
        self.button_subtract.grid(row=6, column=0)
        self.button_multiply.grid(row=6, column=1)
        self.button_divide.grid(row=6, column=2)
         self.button_equal.grid(row=5, column=1, columnspan=2)

        # Initialize variables for calculations
        self.num1 = None
        self.num2 = None
        self.operator = None

def button_click(self, number):
    current = self.display.get()
    self.display.delete(0, tk.END)
    self.display.insert(0, str(current) + str(number))

def button_clear(self):
    self.display.delete(0, tk.END)
    self.num1 = None
    self.num2 = None
    self.operator = None

def button_add(self):
    self.num1 = float(self.display.get())
    self.operator = +
    self.display.delete(0, tk.END)

def button_subtract(self):
    self.num1 = float(self.display.get())
    self.operator = -
    self.display.delete(0, tk.END)

def button_multiply(self):
    self.num1 = float(self.display.get())
    self.operator = *
    self.display.delete(0, tk.END)

def button_divide(self):
    self.num1 = float(self.display.get())
    self.operator = /
    self.display.delete(0, tk.END)

def button_equal(self):
    if self.operator == +:
        self.num2 = float(self.display.get())
        result = self.num1 + self.num2
    elif self.operator == -:
        self.num2 = float(self.display.get())
        result = self.num1 - self.num2
    elif self.operator == *:
        self.num2 = float(self.display.get())
        result = self.num1 * self.num2
    elif self.operator == /:
        self.num2 = float(self.display.get())
        result = self.num1 / self.num2
    else:
        result = None

    self.display.delete(0, tk.END)
    self.display.insert(0, result)
#Create the GUI and start the main loop
root = tk.Tk()
my_calculator = Calculator(root)
root.mainloop()
```
Can you explain me the code shortly?
Sure! We are using the built in python 'tkinter' library which enables us to create a graphical user interface (GUI).

First, we create a class 'Calculator'. The '__init__' is the constructor function. It creates the entry widget and the necessary buttons. Finally the constructor places the buttons in the appropriate places on the grid. 

After this we define all the methods that are responsible for the functionality of the buttons such as adding and multiplying. Please note that we used these functions while creating the buttons (the 'command' parameter).

Finally we create the 'Calculator' object and start the main loop.