Hai provato con Pypi? Lato python viene richiesto genericamente la versione 3, perciò "dovrebbe" essere Ok.




Se i problemi vengono dalla versione di windows (spesso incompatibile con il pregresso) passo, non uso quel s.o. dagli anni '90




Ciao e auguri

Ciao ... beh, forse esiste

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.
import itertools
data = ['a', 'b', 'c']
result = itertools.combinations_with_replacement(data, 4)
for c in result:
    print(''.join(c))

    
aaaa
aaab
aaac
aabb
aabc
aacc
abbb
abbc
abcc
accc
bbbb
bbbc
bbcc
bccc
cccc

Leggendo meglio, forse vorresti ottenere "Tutte" le possibili combinazioni, dato che quella sopra non è completa ... in tal caso combinando con itertools.permutations e smanettando un pochino si potrebbe (occhio sono TANTE)

comp = []
result = itertools.combinations_with_replacement(data, 4)
for e in result:
    per = itertools.permutations(e)
    for c in per:
        comp.append(''.join(c))

        
final = sorted(list(set(comp)))
for v in final:
    print(v)

    
aaaa
aaab
aaac
aaba
aabb
aabc
aaca
aacb
aacc
abaa
abab
abac
abba
...
accc
baaa
baab
baac
baba
...
etc ...

--- Ultima modifica di nuzzopippo in data 2024-10-14 09:43:20 ---

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