Ciao ti allego un programma python basilare al quale dobbiamo fare delle modifiche migliorative:
Note iniziali, poi dovremo stampare su un foglio a4 quindi mantieni le proporzioni con un foglio A4;
Le modifiche sono le seguenti:
Chiama il programma "COMPUTO METRICO 1.00
sopra alla tabella metti due entry "Scheda" e "Oggetto";
ti da le larghezze delle colonne in cm poi vedi tu come proporzionarle: colonna (A) 11cm (B) 2cm (c) 1,5 cm (D) 2 cm (E) 2,5 cm;
tutti i dati dovranno essere memorizzati in un file json per la prossima apertura
dalla terza riga in poi dell'interfaccia mettici la tabella che è presente nel programma che ti ho allegato;
Sotto la tabella, nell'ultima riga metti 5 pulsanti e chiamali "P1"  P2 etc. Lo script da migliorare è il seguente:import tkinter as tk
from tkinter import ttk
import string

class ExcelLikeApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Foglio Excel")
        
        # Massimizza la finestra
        self.root.state('zoomed')
        
        # Gestione ridimensionamento
        self.root.bind('<Configure>', self.on_resize)
        
        # Frame principale
        self.main_frame = ttk.Frame(root)
        self.main_frame.pack(fill=tk.BOTH, expand=True)
        
        # Creazione canvas con scrollbar
        self.canvas = tk.Canvas(self.main_frame)
        self.v_scrollbar = ttk.Scrollbar(self.main_frame, orient="vertical", command=self.canvas.yview)
        self.h_scrollbar = ttk.Scrollbar(self.main_frame, orient="horizontal", command=self.canvas.xview)
        
        # Frame interno per la tabella
        self.table_frame = ttk.Frame(self.canvas)
        
        # Configurazione scrollbar
        self.canvas.configure(yscrollcommand=self.v_scrollbar.set, xscrollcommand=self.h_scrollbar.set)
        
        # Posizionamento scrollbar
        self.v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # Creazione finestra nel canvas
        self.canvas.create_window((0, 0), window=self.table_frame, anchor="nw")
        
        # Dati delle celle
        self.cells = {}
        self.rows = 50
        self.cols = 5
        
        # Creazione tabella
        self.create_table()
        
        # Bind per ridimensionamento
        self.table_frame.bind("<Configure>", lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all")))
        
        # Bind per copia/incolla
        self.root.bind('<Control-c>', self.copy_cells)
        self.root.bind('<Control-v>', self.paste_cells)
        
    def create_table(self):
        # Stile per le celle
        style = ttk.Style()
        style.configure('Cell.TEntry', padding=2)
        
        # Header colonne (A, B, C, ...)
        for col in range(self.cols):
            col_name = string.ascii_uppercase[col]
            label = ttk.Label(self.table_frame, text=col_name, font=('Arial', 10, 'bold'),
                            borderwidth=1, relief="solid", width=12, anchor='center',
                            background='#f0f0f0')
            label.grid(row=0, column=col+1, sticky='nsew')
        
        # Header righe (1, 2, 3, ...)
        for row in range(self.rows):
            label = ttk.Label(self.table_frame, text=str(row+1), font=('Arial', 10, 'bold'),
                            borderwidth=1, relief="solid", width=5, anchor='center',
                            background='#f0f0f0')
            label.grid(row=row+1, column=0, sticky='nsew')
        
        # Celle vuote
        for row in range(self.rows):
            for col in range(self.cols):
                var = tk.StringVar()
                entry = ttk.Entry(self.table_frame, textvariable=var, width=12,
                                font=('Arial', 10), style='Cell.TEntry')
                entry.grid(row=row+1, column=col+1, sticky='nsew', padx=1, pady=1)
                
                # Salva riferimento alla cella
                cell_key = f"{string.ascii_uppercase[col]}{row+1}"
                self.cells[cell_key] = {'widget': entry, 'var': var}
                
                # Bind per selezione
                entry.bind('<FocusIn>', lambda e, k=cell_key: self.on_cell_focus(k))
                entry.bind('<Button-1>', lambda e, k=cell_key: self.on_cell_click(k, e))
        
        # Configurazione ridimensionamento
        for i in range(self.cols + 1):
            self.table_frame.grid_columnconfigure(i, weight=1)
        for i in range(self.rows + 1):
            self.table_frame.grid_rowconfigure(i, weight=1)
            
        # Variabili per copia/incolla
        self.selected_cells = []
        self.copied_data = []
        
    def on_resize(self, event):
        # Gestione ridimensionamento proporzionale
        if hasattr(self, '_after_id'):
            self.root.after_cancel(self._after_id)
        self._after_id = self.root.after(100, self.resize_cells)
        
    def resize_cells(self):
        # Calcola nuove dimensioni in base alla finestra
        width = self.root.winfo_width()
        height = self.root.winfo_height()
        
        # Aggiorna larghezza colonne proporzionalmente
        col_width = max(8, (width - 100) // (self.cols + 1))
        for row in range(self.rows):
            for col in range(self.cols):
                cell_key = f"{string.ascii_uppercase[col]}{row+1}"
                self.cells[cell_key]['widget'].configure(width=col_width//8)
                
    def on_cell_focus(self, cell_key):
        self.current_cell = cell_key
        
    def on_cell_click(self, cell_key, event):
        if event.state & 0x0001:  # Shift premuto
            if hasattr(self, 'last_clicked'):
                self.select_range(self.last_clicked, cell_key)
            else:
                self.selected_cells = [cell_key]
        else:
            self.selected_cells = [cell_key]
            self.last_clicked = cell_key
            
    def select_range(self, start, end):
        # Seleziona un range di celle
        start_col = ord(start[0]) - ord('A')
        start_row = int(start[1:]) - 1
        end_col = ord(end[0]) - ord('A')
        end_row = int(end[1:]) - 1
        
        self.selected_cells = []
        for row in range(min(start_row, end_row), max(start_row, end_row) + 1):
            for col in range(min(start_col, end_col), max(start_col, end_col) + 1):
                cell_key = f"{string.ascii_uppercase[col]}{row+1}"
                self.selected_cells.append(cell_key)
    
    def copy_cells(self, event=None):
        if self.selected_cells:
            self.copied_data = []
            for cell_key in self.selected_cells:
                value = self.cells[cell_key]['var'].get()
                self.copied_data.append(value)
            print(f"Copiati {len(self.copied_data)} valori")
            
    def paste_cells(self, event=None):
        if self.copied_data and self.selected_cells:
            # Incolla i dati nelle celle selezionate
            for i, cell_key in enumerate(self.selected_cells):
                if i < len(self.copied_data):
                    self.cells[cell_key]['var'].set(self.copied_data[i])
            print(f"Incollati {len(self.copied_data)} valori")

if __name__ == "__main__":
    root = tk.Tk()
    app = ExcelLikeApp(root)
    root.mainloop()