Certo sai giò che sqlite ha uno scarso supporto per i dati temporali ... però non è difficile trattare direttamente stringhe con dati in formato "dd/mm/aaaa", basta utilizzare la funzione sqlite substr e creare una stringa ordinata per anno-mese-giorno ... p.e, ho creato una semplicissima tavola con date di eventi alla rinfusa, per poi ordinarli e selezionare una "data limite" utilizzando tali considerazioni, vedi sotto una sessione in shell sqlite :

sqlite> .schema eventi
CREATE TABLE eventi (
data TEXT,
evento TEXT);
sqlite> select * from eventi;
25/06/1876|battaglia del Little Bighorn
06/04/1453|inizio assedio Costantinopoli
03/08/1492|Cristoforo Colombo parte sa Palos
06/06/1944|Sbarco in Normandia
sqlite> SELECT * FROM eventi
   ...> ORDER BY (substr(data, 7, 4) || '-' || substr(data, 4, 2) || '-' || substr(data, 1, 2));
06/04/1453|inizio assedio Costantinopoli
03/08/1492|Cristoforo Colombo parte sa Palos
25/06/1876|battaglia del Little Bighorn
06/06/1944|Sbarco in Normandia
sqlite> SELECT * FROM eventi
   ...> WHERE (substr(data, 7, 4) || '-' || substr(data, 4, 2) || '-' || substr(data, 1, 2)) > '1500-01-01';
25/06/1876|battaglia del Little Bighorn
06/06/1944|Sbarco in Normandia
sqlite>

Venendo al Tuo "ottimizzare", non ne ho idea, non avendo presenti tanto i dati quanto il contesto ... certo che sarebbe bene registrare i dati temporali direttamente secondo le modalità previste in sqlite, semplificherebbe le query.




CIAO

Ciao @Martinello

Premetto che la programmazione web e lo scraping in se non mi hanno mai interessato, quindi neanche conosco beautifulsoup, perciò prendimi con le molle e perdona eventuali caz...e eventualmente presenti.
Sfruttando il Tuo codice in una sessione idle, e considerando che in una tabella html una cella viene espansa su più colonne tramite la proprietà "colspan" ho ritenuto, per risolvere il problema orari, di manipolare il Tuo codice originale calcolando la colonna della cella con testo interessante e lo span relativo, la soluzione con output nel sottostante blocco di codice mi sembra risolva il quesito :

Python 3.10.12 (main, Jul 29 2024, 16:56:4 8) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
from bs4 import BeautifulSoup
import requests
url = f"https://mrbs.dmi.unipg.it/day.php?year=2024&month=09&day=04&area=1&room=3"
response = requests.get(url)
cont = response.text
soup = BeautifulSoup(cont, 'html.parser')
table = soup.find("table", class_ = "dwm_main")
rows = table.find_all("tr")
headers = [header.get_text(strip=True) for header in rows0.find_all("th")]
headers
['Sala:', '09:00', '10:00', '11:00', '12:00', '13:00', '14:00', '15:00', '16:00', '17:00', '18:00']
messages = []
for r in rows[1:]:
    msg = ''
    tds = [x for x in r.find_all('td')]
    room = f'Aula: {tds[0].get_text(strip=True)}\n'
    col = 1
    for cell in tds[1:]:
        if cell.get_text(strip=True):
            stime = headers[col]
            if not msg: msg += room
            if 'colspan' in cell.attrs:
                span = int(cell['colspan'])
                etime = headers[col + span - 1]
                col += span - 1
            else:
                etime = '     '
            msg += f'🔹 {stime} - {etime} : {cell.get_text(strip=True)}\n'
        col += 1
    if msg: messages.append(msg)

    
print(''.join(messages))
Aula: A0(180)
🔹 09:00 - 10:00 : Architettura degli elaboratoriAlfredo Navarra
🔹 14:00 - 18:00 : Esame Programmazione Procedurale con Lab.Francesco Santini
Aula: A2(180)
🔹 09:00 - 12:00 : Esame Rossi (Discreta - Geometria)F. A. Rossi
Aula: B3(35)
🔹 09:00 - 16:00 : Esami orali di Fisica Matematica 1 e Mathematical Physics 2Francesca Di Patti

Le variabili stime ed etime servono per individuare l'indice da leggere negli headers, collspan viene letto dagli attributi dell'oggetto "td" in esame (vedere documentazione "attrs" di beartiful; la logica applicata mi sembra abbastanza semplice ma se hai dubbi, chiedi

Riguardo al nome dell'insegnante appiccicato all'esame, ho estratto il contenuto di una riga con voci valide lette

<td class="I" colspan="2">
<div class="celldiv slots1" data-id="101857">
<a href="view_entry.php?id=101857&amp;area=1&amp;day=4&amp;month=9&amp;year=2024" title="Corso di Laurea Informatica I Anno
E' un esame
Architettura degli elaboratori">Architettura degli elaboratori</a><sub style="color:blue;font-size:xx-small">Alfredo Navarra</sub>
</div>
</td>
<td class="I" colspan="5">
<div class="celldiv slots1" data-id="101642">
<a href="view_entry.php?id=101642&amp;area=1&amp;day=4&amp;month=9&amp;year=2024" title="Corso di Laurea Informatica I Anno
E' un esame
">Esame Programmazione Procedurale con Lab.</a><sub style="color:blue;font-size:xx-small">Francesco Santini</sub>
</div>
</td>

Qualora il formato sia costante si potrebbe separare il titolo dell'esame da quello del docente, analizzando i tags "a" e "sub", un po' troppo macchinoso per una sessione ifle, però.


Fai sapere, ciao

EDIT : corretti artefatti dell'editor




--- Ultima modifica di nuzzopippo in data 2024-08-20 17:11:28 ---

Intanto precisiamo una cosa riguardo al Tuo

le stringhe finali scritte sono:

# La palla collide con le racchette
if palla.colliderect(racchetta_sinistra) or palla.colliderect(racchetta_destra):
velocita_palla_x = -velocita_palla_x
punteggio += 1

cIò che hai esposto non sono "stringhe" (ossia oggetti di classe "str") bensì istruzioni python, ossia "codice", medita su questo punto e chiarisci cosa intendi nella Tua domanda, perché è fondamentale parlare la stessa lingua tra noi o non riusciremo a capirci.

Venendo alla successiva richiesta

quali variabili dovrei inserire e dove effettivamente?

È ancora impossibile darti indicazioni pertinenti perché le tre righe di codice non dicono nulla tanto sull'algoritmo applicato (come tratti la componente verticale? e i rimbalzi di sponda? e gli incrementi vanno applicati alle componenti x/y od al solo vettore "velocità"?) quanto al paradigma utilizzato nella stesura del codice (imperativo? funzionale? ad oggetti?) oltre che alla tipologia di variabili adottate nella Tua implementazione

Supposto, tanto per dialogare Tu stia implementando il Tuo codice con modalità funzionali e Tu voglia definire due variabili condivise dalle varie funzioni a livello di modulo una di tipo intero (definiamola RIMBALZI) per conteggiare i rimbalzi tra un incremento di velocità e l'altro ed una di tipo float (definiamola AMPLIFICA) che rappresenta un fattore di amplificazione da applicare ad un vettore "velocità" iniziale, anch'esso condiviso tra le funzioni del modulo, potremmo dichiarare PRIMA della definizione delle varie funzioni le variabili

velocita = 5.0
RIMBALZI = 0
AMPLIFICA = 1.0

ovviamente, tali variabili andrebbero dichiarate quali globali nelle funzioni che le utilizzano, supposto di voler incrementare il detto vettore di velocità iniziale del 10% solo ogni 10 rimbalzi orizzontali, potremmo porre nella funzione che contiene le tre righe da Te prima esposte:

global RIMBALZI
global AMPLIFICA

if palla.colliderect(racchetta_sinistra) or palla.colliderect(racchetta_destra):
    velocita_palla_x = -velocita_palla_x
    RIMBALZI += 1
    if RIMBALZI >= 10:
        AMPLIFICA *= 1.1
        RIMBALZI = 0
punteggio += 1

e, quindi trattare la velocità iniziale incrementata con il fattore di incremento raggiunto nelle varie funzioni di calcolo e/o rappresentazione che dovresti aver definito.
Intendiamoci, questo è solo uno dei numerosi scenari possibili, uno dei più semplici da esporre, in realtà cosa fare dipende tutto dalla Tua implementazione.

Ciao



--- Ultima modifica di nuzzopippo in data 2024-08-16 08:46:51 ---

Ciao @BitoSauro, ben venuto




In merito alle "stringhe" sono incerto su quale link indicarTi, quello più valido, a mio parere, porterebbe alla documentazione ufficiale ma è forse una trattazione un po' ostica per iniziandi, forse più adatto sarebbe il più discorsivo capitolo del manuale di python, restando fermo che quando serve è sempre la documentazione lo strumento per approfondire.




Riguardo a "pong", difficile dare indicazioni valide per ciò che Tu hai realizzato senza vedere il codice, chiacchierando in linea generale per effettuare un incremento di velocità ad ogni tot di rimbalzi sarebbe sufficiente utilizzare due variabili, una che conteggi i rimbalzi e raggiunto il tot si azzeri ed incrementi un'altra variabili da utilizzare quale fattore per il calcolo della velocità.




Ciao

Non ho esperienza diretta con il microdoft word, ho abbandonato windows nwgli anni '90, ma san google aiuta, da una ricerca in rete questa pagina mi sembra possa aiutarti.




Per altro in libreoffice writer, sotto linux, per inserire blocchi di codice personalmente uso definire uno stile utilizzante un carattere a passo fisso, allinamento a sinistra e numerazione dei paragrafi ripartente da "1", per evidenziare il codice mi affido a dei plug-in (COOder, attualmente).




Dai sapere, ciao

I miei saluti

Nel corso del tempo ho preso l'abitudine di strutturare le mie applicazioni secondo una struttura da "modulo standard", articolata in sub-moduli specializzati per tipologia d'uso, giusto per esempio segue l'articolazione di una cosetta correntemente in saltuaria implementazione

NzP:~$ tree
.
├── lanmessage
│   ├── gui
│   │   ├── confgui.py
│   │   ├── groupgui.py
│   │   ├── __inity__.py
│   │   ├── login.py
│   │   ├── messagesgui.py
│   │   ├── panels.py
│   │   ├── pwdchanger.py
│   │   └── winmain.py
│   ├── __init__.py
│   ├── starter.py
│   ├── utility
│   │   ├── __init__.py
│   │   └── utility.py
│   └── work
│       ├── data_manager.py
│       ├── __init__.py
│       ├── linux_manager.py
│       ├── notifiers.py
│       └── windows_manager.py
└── start.py

4 directories, 18 files
NzP:~$

Tale tipo di implementazione da alcune "complicazioni" nello spazio dei nomi che malgrado abbia letto un po' di documentazione ed alcune PEP (tra cui la 420, che ho deciso di non utilizzare) non mi riesce di superare, probabilmente per mia incapacità di comprensione, confesso che spazio dei nomi ed uso dei files "__init__.py" mi confonde un po'.

Dette complicazioni, essenzialmente, corrispondono alla circostanza che se utilizzo, per l'avvio della applicazione, un file interno alla struttura del pacchetto, l'assegnazione del "__main__" quale "nome" fa perdere allo stesso modulo lo spazio dei nomi del "pacchetto" ... mi spiego: supposto un file di inizializzazione (lanmessage.starter.py) della applicazione così composto:

# -*- coding: utf-8 -*-

# imports da libreria base
import os

# imports da virtual environment
import appdirs

# import locali
from lanmessage.gui.winmain import WinMain


def def_dirs() -> dict:
    '''
    Definisce le directory da utilizzarsi nella applicazione.
    Nella eventualità non esistano, le crea.
    '''
    app_name = 'lan_message'
    app_author = 'nuzzopippo'
    app_dirs = {}
    app_dirs['data'] = appdirs.user_data_dir(app_name, app_author)
    app_dirs['cache'] = appdirs.user_cache_dir(app_name, app_author)
    app_dirs['log'] = appdirs.user_log_dir(app_name, app_author)
    app_dirs['state'] = appdirs.user_state_dir(app_name, app_author)
    app_dirs['config'] = appdirs.user_config_dir(app_name, app_author)
    try:
        for key in app_dirs.keys():
            if not os.path.exists(app_dirskey) or not os.path.isdir(app_dirskey):
                os.makedirs(app_dirskey)
    except OSError as e:
        print(repr(e))
        exit(1)
    return app_dirs


def go() -> None:
    app_dirs = def_dirs()
    win = WinMain(app_dirs)
    win.mainloop()


if __name__ == '__main__':
    go()

Eseguendolo direttamente viene perso lo spazio dei nomi del modulo

NzP:~$ source /home/nuzzopippo/venvs/tests_v/bin/activate
(tests_v) NzP:~$ /home/nuzzopippo/venvs/tests_v/bin/python3.10 /home/nuzzopippo/
                 src/my_work/LanMessage/src/lanmessage/starter.py
Traceback (most recent call last):
  File "/home/nuzzopippo/src/my_work/LanMessage/src/lanmessage/starter.py", line
       8, in <module>
    from lanmessage.gui.winmain import WinMain
ModuleNotFoundError: No module named '\lanmessage'
(tests_v) NzP:~$

A ciò ovvio implementando un semplice punto di avvio (start.py) al di fuori del pacchetto applicativo, nrl caso in specie è così fatto:

# -*- coding: utf-8 -*-

from lanmessage import starter

'''
TODO

DIRAMAZIONI X NOTIFICHE :

Per Linux   : Studiare ed implementare notify2 - python-dbus
Per Windows : Studiare ed implementare Windows-Toasts

'''

starter.go()

Ora, tal modo di procedere, seppur funzionante non mi sembra "giusto", ogni tanto mi pongo il problema ma, come detto, non mi è riuscito, al momento, di trovare modalità altre ... la domanda è : è possibile utilizzare lanmessage.starter.py quale punto di avvio della applicazione conservando lo spazio dei nomi del modulo? Se si, come si può fare?




Grazie dell'attenzione

Che ne penso? : che così non vai da nessuna parte!




Gli esempi che Ti faccio sono, giust'appunto esempi per cercare di farTi intuire come funzionano le cose perché Tu possa indirizzarti per approfondire gli argomenti; se Ti limiti a copiincollare il codice non risolvi nulla.

Ennesima esemplificazione :

1° modifica nel Tuo codice la riga del bind inserita nel gruppo adsrv in questo modo :

...
            sc.set(0)
            sc.bind("<ButtonRelease>", self._on_sc_adsrv)       #bind 
            print(self._scales['adsrv'])                   #print
...

2° inserisci dopo la funzione _on_open(self) questo codice :

    def _on_sc_adsrv(self, evt):
        ''' Stampa l'indice ed il valore dello scale del gtuppo "adsrv" manipolato. '''
        w = evt.widget
        try:
            index = self._scales['adsrv'].index(w)
            value = w.get()
            print(index, '=>', value)
        except ValueError as e:
            return            

avrai così collegato a tutti i widget "scale" del gruppo "adsrv" (e solo a loro) una funzione di callback che al verificarsi dell'evento di rilascio del bottone sinistro del mouse su uno di loro individua lo scale interessato, ne estrae l'indice e stampa l'indice ed il valore assunto dallo scale.

Spero che questo esempio Ti permetta di intuire come affrontare un evento e, approfondendo con la documentazione, di arrivare a gestirli.




La documentazione che ho messo in link, pur se della versione precedente di tkinter, è quella secondo me più chiara esistente, troverai gli eventi al capitolo 54 ... purtroppo, temo che ciò che per me è chiaro possa non esserlo per retroterra diversi dal mio, credo Ti occorra un testo introduttivo, se sei anglodono forse potrebbe esserTi utile il testo "Python and Tkinter Programming (2000).pdf" mooolto datato ma di cui si trovano copie pirata in rete e, forse, versioni più aggiornate da acquistare.

Se non sei anglofono, potrebbe esserTi utile un "work in progress", forse ora abbandonato, scritto da @RicPol (utente che non cesserò mai di ringraziare per l'enorme aiuto che mi ha dato) che verte sul framework wxpython ma i cui concetti di base si applicano più o meno a tutti gli ambianti grafici, con le ovvie differenze, si tratta di "Capire wxPython", è a pagamento ma dal costo irrisorio e secondo me vale la pena di leggerlo.




Il consiglio che mi sento di darTi è di sospendere un attimo lo sviluppo che hai in corso e di studiare il funzionamento dei framework grafici, senza i concetti base non sarai in grado di progettare una tua applicazione (si, ci vuole un pogetto, prima di "fare")




Ciao

Ovviamente, devi scrivere la riga indicata quando si verificano le condizioni perché venga letta ... le interfacce grafiche si basano sugli "eventi", a livello di codice bisogna gestire gli eventi quando si verifica un evento di interesse, cioè bisogna effettuare il così detto "binding" dell'evento collegando lo stesso evento ad un widget e ad una funzione di "callback" (cioè funzione di gestione dello evento).

Se guardi nello esempio che Ti proposi due anni fa troverai due esempi di binding che collegavano le due categorie di strumenti ai relativi callback per aggiornamento dell'array di etichette li previsto

            sc.bind("<ButtonRelease>", self.on_struments)
...
            sc.bind("<ButtonRelease>", self.on_frequences)

i metodi relativi Ti forniranno un possibile esempio di gestione.

... Naturalmente, quanto sopra è solo la punta dell'iceberc, diverse categorie di widget possono avere gestibili diverse categorie di eventi, possono anche gestire degli "eventi virtuali" specializzati

... insomma, si cade in quello che mi faceva anticipare come dubbia l'utilità di scriverti il codice funzionante, bisogna acquisire familiarità con gli eventi delle GUI per poter andare avanti, esistono moltissime varianti di approccio secondo ciò che vorresti e per la Tua problematica fare lo sai soltanto Tu, Ti è necessario affrontare la problematica approfonditamente, temo.




Ciao

Riferisci al codice di "sintetizer2.py" che Ti ho postato prima? Lo ho già scritto, è il dizionario

        self._scales = {'adsrv': [],
                        'freqs': [],
                        'mixer': [],
                        'lfo1' : []}

Le cui chiavi corrispondono ai "nomi" delle liste di etichette da Te definite

    adsrv = ['A', 'D', 'S', 'R','V',]
    freqs = ['1','2','3','4','5']
    mixer = ['1','2','3','4','5']
    lfo1 = ['lfo1']

ed i cui valori sono liste di oggetti tkinter.Scale costruiti nello stesso ordine delle etichette da Te impostate, puoi accedere agli specifici scale per nome ed indice, come puoi constatare nei metodi "MainWin._on_save()" e "MainWin._on_save_as()"
Ti preciso che, in quel codice, l'accesso ai valori degli scale avviene per i soli salvataggi o per il caricamento di dati già salvati, operazioni che vengono effettuate in cicli su chiavi del dizionario ed indici di lista corrispondente.
Supposto il Tuo problema correntemente posto sia di accedere ad uno specifico elemento delle liste da Te impostate, p.e. l'elemento "D" della lista "adsrv", banalmente, dovrai accedere allo scale di indice "1" della chiave "adsrv" del dizionario "self._scales", tipicamente useresti:

self._scales['adsrv'][1].get()
self._scales['adsrv'][1].set(valore)

per, rispettivamente, leggere ed impostare il valore corrente di detto specifico scale.

Analogamente, i "modelli", una volata caricati, non sono altro che un dizionario con le medesime chiavi nelle cui liste sono contenuti i valori degli scale corrispondenti.

In sostanza, banalmente, si opera con i metodi standard di dizionari e liste, niente di difficile imho.




EDIT: corretti artefatti introdotti dall'editor dei post



--- Ultima modifica di nuzzopippo in data 2024-06-18 06:10:44 ---

L'errore

\NameError: name 'letteraGiocatore' is not defined

è quello che al momento blocca il Tuo script, questo errore è prodotto dalla circostanza che nel codice la funzione "letteraGiocatore()" è una funzione interna della funzione "disegna_tabella(tabella)", quindi NON È visibile nello spazio dei nomi del modulo.
... quando risolverai questo specifico problema, Ti si ripresenterà alla invocazione delle funzioni "chi_inizia()", "crea_copia_tabella(tabella)", etc ... tutte interne a disegna_tabella.

Per il resto, non ho valutato l'insieme del codice però mi chiedo se sia Tuo e perché Tu lo stia scrivendo.

La difficoltà da Te esposta tocca uno degli aspetti basilari di python, il che mi fa ritenere che Tu sia nuovo al linguaggio e consigliarTi la lettura almeno del capitolo 9.2 del tutorial (trovi il link nella sezione documentazione, vi è anche per la versione in italiano)




EDIT: corretto il riferimento al capitolo, in precedenza era errato.




--- Ultima modifica di nuzzopippo in data 2024-06-13 08:49:54 ---

--- Ultima modifica di nuzzopippo in data 2024-06-13 08:50:28 ---