Rileggendo il post mi son reso conto di aver travisato il quesito posto a @Kolmogorov Scale, che probabilmente non verteva sul come ottenere la super-diagonale bensì su come variarne i valori con metodi propri di numpy ... chiedo venia per la mia risposta fuori logo.

In merito ai metodi di numpy (eventualmente mi si corregga) dalle ricerche effettuate non sembra sia possibile essendo il parametro "offset" implementato in funzioni tipo fill_diagonal e simili, è un argomento su cui si discute in merito ma di la da venire.




Pur non essendo l'algebra lineare materia a me familiare, giusto per chiedere scusa della mia precedente cattiva interpretazione, ho implementato una piccola funzione per la sostituzione dei valori diagonali e/o super/sub-diagonali tramite una funzione manipolatrice od anche un iterabile, segue il codice :

import numpy as np
from typing import Any

def my_fill_diag(a: np.array,  val: Any, o: int=0, w: bool=True) -> None:
    ''' Emulazione di numpy.fill_diagonal con applicazione delle
        sostituzioni a super e sub diagonali.
        Parametri:
        - a   : array multidimensionale cui applicare le sostituzioni;
        - val : iterabile o funzione per la definizione delle sostituzioni;
        - o   : offset rispetto alla diagonale base, se positivo sarà
                applicato sulle colonne, se negativo sulle righe di "a",
                nel caso superi le colonne o le righe disponibili non
                sarà applicato;
        - w   : se vero il ciclo di sostituzione si interromperà in caso
                si raggiunga l'ultima colonna, altrimenti si riposiziona
                sulla prima e continua.
                In ogni caso la sostituzione termina raggiunta l'ultima
                riga.
        Nota: Qualora "val" sia un iterabile ed abbia dimensioni inferiori
              a quelle della diagonale i valori saranno riproposti
              ciclicamente.
    '''
    rows, cols = a.shape
    c = 0
    r = 0
    if o > 0 and o < cols:
        c = o
    elif o < 0 and abs(o) < rows:
        r = abs(o)
    if 'function' in repr(type(val)):
        while r < rows:
            a[r, c] = val(a[r, c])
            r += 1
            c += 1
            if c == cols:
                if w:
                    break
                else:
                    c = 0
    else:
        i = 0
        while i < len(val):
            a[r, c] = val
            r += 1
            c += 1
            if r == rows:
                break
            if c == cols:
                if w:
                    break
                else:
                    c = 0
            i += 1
            if i == len(val):
                i = 0

Nella doc-string della funzione ho cercato di farne comprendere i parametri ed il funzionamento, eventuali suggerimenti per migliorarla (anche come stesura e/o elasticità) sono ben accetti




Segue una sessione shell di test per esemplificarne l'uso :

Python 3.12.3 (main, Sep 11 2024, 14:17:37) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
from prova_01 import my_fill_diag
import numpy as np
A = np.arange(1, 17).reshape(4, 4)
A
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])
def my_func(value):
    return value * 2

my_fill_diag(A, my_func, 1)
A
array([[ 1,  4,  3,  4],
       [ 5,  6, 14,  8],
       [ 9, 10, 11, 24],
       [13, 14, 15, 16]])
A = np.arange(1, 17).reshape(4, 4)
B = [100, 200]
A = np.arange(1, 17).reshape(4, 4)
my_fill_diag(A, B, 1, False)
A
array([[  1, 100,   3,   4],
       [  5,   6, 200,   8],
       [  9,  10,  11, 100],
       [200,  14,  15,  16]])
A = np.arange(1, 17).reshape(4, 4)
my_fill_diag(A, B, -1, False)
A
array([[  1,   2,   3,   4],
       [100,   6,   7,   8],
       [  9, 200,  11,  12],
       [ 13,  14, 100,  16]])

Spero possa essere utile a qualcuno e rinnovo le mie scuse per la precedente interpretazione.

I miei saluti

Intendi qualcosa tipo questo?:

Python 3.12.3 (main, Jul 31 2024, 17:43:48) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
import numpy as np
A = np.array([[1,2,3],[4,5,6],[7,8,9]])
A
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
np.diagonal(A, 1)
array([2, 6])

Non è farina del mio sacco, suggerimento ricevuto in questa pagina documentale, è sufficiente porre un ofset di una posizione rispetto alla diagonale ordinaria.




Ciao

Intrigato, ho cercato un po'. Suppongo sia un "qualcosa" individuabile nell'ambito dei così detti "type hints", un tipo di notazione complesso (vedi il link per avere idea) non obbligatorio ma sempre più utilizzato e sul quale, purtroppo, personalmente non ho conoscenze adeguate, speriamo in utenti più esperti.

Comunque, cercando in giro il tipo di errore lo ho trovato per lo più collegato alla libreria "mypy" per la quale sono stati aperte delle segnalazioni di bug in merito.

Ad occhio e croce penserei che la segnalazione possa derivare da una incoerente definizione di tipo, del genere discusso qui, ma sarebbe tutto da vedere.




Ora, con notizie scarne come quelle che Hai fornito, credo che ben poco si possa dire, riporta lo backtrace che ricevi e lo stralcio di codice che causa l'errore perché ci si possa ragionare su, magari non io (non essendo all'altezza) ma qualche utente più capace potrebbe dare una dritta in materia.




Ciao

È piuttosto semplice, guarda sotto :

Python 3.12.3 (main, Jul 31 2024, 17:43:48) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
A = [1, 2, 3, 4]
B = [3, 4, 5, 6, 7]
C = [6, 7, 8, 9]
print() if [print(f'elemento in comune: {i}') for i in A if i in B] else print('niente in comune')
elemento in comune: 3
elemento in comune: 4

print() if [print(f'elemento in comune: {i}') for i in A if i in C] else print('niente in comune')
niente in comune
print() if [print(f'elemento in comune: {i}') for i in B if i in C] else print('niente in comune')
elemento in comune: 6
elemento in comune: 7

Ottenuto semplicemente sfruttando le definizioni base del linguaggio python, roba che val sempre la pena di approfondire




Ciao

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