Petar Karan

[c#] Semplice classe per gestire connessione e query su un database MySQL

Il nostro scopo è scrivere una semplice classe in C# che permetta di gestire l’inserimento e la lettura dei dati dal database. La caratteristica saliente che ci interessa in questo caso è l’accesso ai dati, in fase di lettura, tramite una List<ListDictionary>, che consente di trattare i risultati come una lista di dizionari.

La classe che vogliamo creare permetterà un utilizzo simile a questo:

using (MySQLdb mysql = new MySQLdb(@"server=localhost;userid=root;password=;database=esempio"))
{
    mysql.setQuery("INSERT INTO studenti(nome,cognome) VALUES(@nome,@cognome)")
        .addParameter("@nome","Gianpiero")
        .addParameter("@cognome","Franchi").In();

    List<ListDictionary> studenti = mysql.setQuery("SELECT * FROM studenti WHERE nome = @nome OR 1")
        .addParameter("@nome","Mario").Out();

    foreach(ListDictionary s in studenti)
    {
        Console.WriteLine(s["nome"]);
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

using (MySQLdb mysql = new MySQLdb(@"server=localhost;userid=root;password=;database=esempio"))

{

mysql.setQuery("INSERT INTO studenti(nome,cognome) VALUES(@nome,@cognome)")

.addParameter("@nome","Gianpiero")

.addParameter("@cognome","Franchi").In();

List<ListDictionary> studenti = mysql.setQuery("SELECT * FROM studenti WHERE nome = @nome OR 1")

.addParameter("@nome","Mario").Out();

foreach(ListDictionary s in studenti)

{

Console.WriteLine(s["nome"]);

}

La classe sarà formata invece nel modo seguente:

namespace DatabaseMySQL
{
    public class MySQLdb : IDisposable
    {
        private bool isDisposed = false;
        private string connectionString { get; set; }
        private MySqlConnection connection;
        private MySqlCommand command;

        public MySQLdb(string connectionString)
        {
            this.connectionString = connectionString;

            this.connect();
        }

        ~MySQLdb()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected void Dispose(bool disposing)
        {
            if(!isDisposed && disposing)
            {
                if(this.command != null) this.command.Dispose();
                if (this.connection != null) this.connection.Close();
            }
            isDisposed = true;
        }

        private void connect()
        {
            this.connection = new MySqlConnection(this.connectionString);
            this.connection.Open();
        }

        public MySQLdb setQuery(string query)
        {
            this.command = new MySqlCommand(query, this.connection);
            return this;
        }

        public MySQLdb addParameter(string name, string value)
        {
            if (this.command != null)
            {
                this.command.Parameters.AddWithValue(name, value);
            }
            return this;
        }

        public List<ListDictionary> Out()
        {
            List<ListDictionary> risultato = new List<ListDictionary>();
            if (this.command != null)
            {
                this.command.Prepare();
                using (MySqlDataReader reader = this.command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        ListDictionary dict = new ListDictionary();
                        for (int col = 0; col < reader.FieldCount; col++)
                        {
                            dict.Add(reader.GetName(col), reader.GetValue(col).ToString());
                        }
                        risultato.Add(dict);
                    }
                }
                this.command.Dispose();
            }
            return risultato;
        }

        public long In()
        {
            if (this.command != null)
            {
                this.command.Prepare();
                this.command.ExecuteNonQuery();
                long lastId = this.command.LastInsertedId;
                this.command.Dispose();
                return lastId;
            }
            return -1;
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

namespace DatabaseMySQL

{

public class MySQLdb : IDisposable

{

private bool isDisposed = false;

private string connectionString { get; set; }

private MySqlConnection connection;

private MySqlCommand command;

public MySQLdb(string connectionString)

{

this.connectionString = connectionString;

this.connect();

}

~MySQLdb()

{

Dispose(false);

}

public void Dispose()

{

Dispose(true);

GC.SuppressFinalize(this);

}

protected void Dispose(bool disposing)

{

if(!isDisposed && disposing)

{

if(this.command != null) this.command.Dispose();

if (this.connection != null) this.connection.Close();

}

isDisposed = true;

}

private void connect()

{

this.connection = new MySqlConnection(this.connectionString);

this.connection.Open();

}

public MySQLdb setQuery(string query)

{

this.command = new MySqlCommand(query, this.connection);

return this;

}

public MySQLdb addParameter(string name, string value)

{

if (this.command != null)

{

this.command.Parameters.AddWithValue(name, value);

}

return this;

}

public List<ListDictionary> Out()

{

List<ListDictionary> risultato = new List<ListDictionary>();

if (this.command != null)

{

this.command.Prepare();

using (MySqlDataReader reader = this.command.ExecuteReader())

{

while (reader.Read())

{

ListDictionary dict = new ListDictionary();

for (int col = 0; col < reader.FieldCount; col++)

{

dict.Add(reader.GetName(col), reader.GetValue(col).ToString());

}

risultato.Add(dict);

}

this.command.Dispose();

}

return risultato;

}

public long In()

{

if (this.command != null)

{

this.command.Prepare();

this.command.ExecuteNonQuery();

long lastId = this.command.LastInsertedId;

this.command.Dispose();

return lastId;

}

return -1;

}

[wordpress] Errore RSS: WP HTTP Error: cURL error 60: SSL certificate problem: certificate has expired

Questo errore si presenta nel feed RSS di WordPress a causa di un certificato intermedio scaduto utilizzato da cURL.

Il problema è spesso causato da LetEncrypt. Per risolvere il problema è sufficiente disabilitare il certificato DST CA X3 scaduto.

Per farlo su Ubuntu digitiamo nel terminale i seguenti due comandi:

sed -i 's/mozilla\/DST_Root_CA_X3.crt/!mozilla\/DST_Root_CA_X3.crt/g' /etc/ca-certificates.conf

update-ca-certificates

[risolto] TekkenGame-Win64-Shipping.exe crash con eccezione 0xc0000005

Problema: Tekken 7 su PC (Steam) va in crash con codice di eccezione 0xc0000005 (nel mio caso succedeva quando si tentava una partita VS in locale)

Soluzione: Da Steam verificare l’integrità dei file di gioco.

Tekken 7, installato sul PC da Steam, comincia a crashare senza motivo apparente quando si sta per avviare una partita VS. Dopo aver provato in vano a modificare la risoluzione (passando anche dalla modalità schermo intero a quella borderless e infine a quella a finestra), modificare l’assetto grafico e perfino disattivare l’antivirus, ho eseguito la verifica di integrità dei file di gioco su Steam e questo ha risolto il problema.

L’errore nel registro di Windows dovrebbe apparire come qualcosa del genere:

Nome dell'applicazione che ha generato l'errore: TekkenGame-Win64-Shipping.exe, versione: 1.0.1.0, timestamp: 0x61fb9339
Nome del modulo che ha generato l'errore: TekkenGame-Win64-Shipping.exe, versione: 1.0.1.0, timestamp: 0x61fb9339
Codice eccezione: 0xc0000005
Offset errore 0x0000000000745b24
ID processo che ha generato l'errore: 0x15fc

Per risolvere il problema è dunque sufficiente andare nella libreria di Steam.

Cliccare col destro sul gioco e poi su Proprietà

Nella finestra delle proprietà spostarsi su File Locali.

Infine cliccare su Verifica integrità dei file di gioco…

Il processo richiederà qualche minuto probabilmente e dopodiché il problema dovrebbe essere risolto.

[apache] Isolare VirtualHost su Apache2

Per isolare un VirtualHost su apache ed impedire che si possa accedere agli altri VirtualHost, è sufficiente aggiungere la direttiva riguardante il PHP php_admin_value open_basedir /var/www/torregatti.it/

In questo caso l’unica cartella accessibile è la /var/www/torregatti.it/

Se si vogliono aggiungere più cartelle per quel VirtualHost si può scrivere /var/www/torregatti.it/:/altra/cartella/

Nel file di configurazione del VirtualHost avremo qualcosa del genere:

<VirtualHost *:80>
        ServerName torregatti.it
        ServerAdmin admin@torregatti.it
        DocumentRoot /var/www/torregatti.it/htdocs
        ErrorLog /var/www/torregatti.it/logs/error.log
        CustomLog /var/www/torregatti.it/logs/access.log combined
        php_admin_value open_basedir /var/www/torregatti.it/
</VirtualHost>

1

2

3

4

5

6

7

8

ServerName torregatti.it

ServerAdmin admin@torregatti.it

DocumentRoot /var/www/torregatti.it/htdocs

ErrorLog /var/www/torregatti.it/logs/error.log

CustomLog /var/www/torregatti.it/logs/access.log combined

php_admin_value open_basedir /var/www/torregatti.it/

</VirtualHost>

Usando chmod o-rw su /var/www possiamo isolare la cartella dall’accesso esterno degli utenti.

[python] Disegnare matrice concentrica in Python data una dimensione arbitraria (e valutare le prestazioni)

Vogliamo scrivere un algoritmo in Python che, dato un lato n-esimo arbitrario, disegni una matrice di valori concentrici. Il risultato che vogliamo ottenere è il seguente:

Questo problema ha molteplici soluzioni e Python ne permette un’estrema sintesi.

Cominciamo dalla soluzione più semplice, ma che richiede il maggior numero di cicli.

Anzitutto calcoliamo la dimensione del quadrato:

n = int(input("lato: "))
dim = n*2-1

1 2	n = int(input("lato: ")) dim = n*2-1

Adesso prepariamo una matrice di dimensione dim fatta di soli 0

m = [[0 for j in range(dim)] for i in range(dim)]

1	m = [[0 for j in range(dim)] for i in range(dim)]

Il procedimento che seguiremo ora sarà quello di stringere la matrice sempre di più, ridisegnando i vari quadrati all’interno della matrice di 0 appena creata.

for k in range(n):
    for i in range(k,dim-k):
        for j in range(k,dim-k):
            m[i][j] = n - k

1

2

3

4

for k in range(n):

for i in range(k,dim-k):

for j in range(k,dim-k):

m[i][j] = n - k

In questo modo disegneremo ad ogni passaggio un quadrato di numeri n-k

Stampiamo infine a video la matrice:

for r in m:
    for c in r:
        print(c,end=" ")
    print()

1

2

3

4

for r in m:

for c in r:

print(c,end=" ")

print()

Possiamo misurare il tempo di calcolo necessario (questo tempo dipende principalmente dal processore in uso, quindi varia da macchina a macchina) utilizzando la libreria time

Il codice diventerebbe il seguente:

import time

n = int(input("lato: "))
dim = n*2-1

start = time.time()

m = [[0 for j in range(dim)] for i in range(dim)]

for k in range(n):
    for i in range(k,dim-k):
        for j in range(k,dim-k):
            m[i][j] = n - k

end = time.time()

print("%s secondi" %(end-start))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

import time

n = int(input("lato: "))

dim = n*2-1

start = time.time()

m = [[0 for j in range(dim)] for i in range(dim)]

for k in range(n):

for i in range(k,dim-k):

for j in range(k,dim-k):

m[i][j] = n - k

end = time.time()

print("%s secondi" %(end-start))

Nel mio caso l’operazione per un lato di dimensione 1000 impiega circa 131.700 ms. Su questo torneremo successivamente.

Possiamo però riscrivere l’algoritmo in un altra forma più sintetica.

import time

n = int(input("lato: "))
dim = n*2-1

start = time.time()

def v(i,j):
    i = i if i < dim / 2 else dim - i - 1
    j = j if j < dim / 2 else dim - j - 1
    return n - (j if j <= i else i)

m = [[v(i,j) for j in range(dim)] for i in range(dim)]

end = time.time()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

import time

n = int(input("lato: "))

dim = n*2-1

start = time.time()

def v(i,j):

i = i if i < dim / 2 else dim - i - 1

j = j if j < dim / 2 else dim - j - 1

return n - (j if j <= i else i)

m = [[v(i,j) for j in range(dim)] for i in range(dim)]

end = time.time()

Questa volta l’algoritmo impiega 1.250 ms circa, sempre per lato di dimensione 1000.

Il risultato è il medesimo, ma il tempo di calcolo è decisamente inferiore.

Un’altra versione potrebbe essere la seguente:

import time

n = int(input("lato: "))
dim = 2*n-1

start = time.time()

m = [[0 for i in range(dim)] for j in range(dim)]

for i in range(n):
    for j in range(i, dim-i):
        m[i][j] = n
        m[dim-i-1][j] = n
        m[j][i] = n
        m[j][dim-i-1] = n
    n -= 1

end = time.time()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

import time

n = int(input("lato: "))

dim = 2*n-1

start = time.time()

m = [[0 for i in range(dim)] for j in range(dim)]

for i in range(n):

for j in range(i, dim-i):

m[i][j] = n

m[dim-i-1][j] = n

m[j][i] = n

m[j][dim-i-1] = n

n -= 1

end = time.time()

Questa volta il tempo di calcolo, per dimensione 1000 di lato, è di circa 490 ms.

Confrontando i tre algoritmi su range di calcoli da 50 a 1000, otteniamo le seguenti performance (il primo algoritmo lo chiamiamo A, l’ultimo lo chiamiamo C):

Che possiamo mettere in un grafico (con scala logaritmica) come il seguente:

[word] Rimuovere “Limita modifica” da un file docx di Word

Problema: Il file word risulta protetto con l’opzione Limita modifica che impedisce anche di copiare il testo dal file.

Soluzione: Rinominare il file docx con estensione zip, decomprimere il file, individuare all’interno della cartella il file word/settings.xml, aprirlo con un editor di testo ed impostare su false il parametro w:enforcement, salvare il file, ricomprimere tutto il contenuto della cartella in un file zip e rinominarlo in docx

Vediamo la procedura nel dettaglio.

Anzitutto individuiamo il file Word che non permette le modifiche. Aprendo il file e andando nella scheda Revisione > Proteggi cliccando sull’opzione Limita modifica si aprirà una finestra simile alla seguente:

Il file potrebbe essere protetto a diversi livelli e non consentire nemmeno la copia del testo.

Per rimuovere la protezione procediamo nella maniera seguente.

A questo punto prendiamo il file e rinominiamolo con l’estensione zip.

Per farlo da Windows 10 dobbiamo attivare la visualizzazione delle estensioni dei file. Se non l’abbiamo già fatto, in Esplora Risorse andiamo su Visualizza > Mostra / Nascondi e spuntiamo Estensioni nomi file.

Una volta rinominato il file in formato zip possiamo decomprimerlo in una cartella, trovando dentro una struttura simile a questa:

Entriamo nella cartella word e individuiamo il file settings.xml

Apriamo il file con un editor di testo (consiglio Notepad++) e individuiamo il parametro w:enforcement

Il parametro sarà probabilmente impostato su true oppure 1.

Modifichiamolo su false.

A questo punto torniamo nella cartella precedente e comprimiamo tutti i file.

Otterremo un nuovo file zip, cambiamo di nuovo l’estensione in docx e il gioco è fatto.

[python] Albero binario in Python

Riporto qui un classico dell’informatica di base: la realizzazione di un albero binario per l’ordinamento.

Quello dell’albero binario è un algoritmo che consente di ordinare dei valori in base al criterio di inserimento e successivamente di lettura.

Per far capire meglio il procedimento vediamo anzitutto come funziona.

Immaginiamo di avere la sequenza di numeri 3, 4, 1, 7, 6, 5, 8, 11, 9. L’algoritmo prevede la creazione di una struttura ad albero, composta di nodi, dove ogni nodo contiene un valore e un ramo di sinistra e uno di destra, che puntano rispettivamente al valore minore e maggiore, rispetto al valore nel nodo. La creazione dell’albero procederà quindi come nel video soprastante.

La lettura avverrà invece a partire dal primo nodo, procedendo anzitutto sul nodo di sinistra, poi stampando il valore del nodo corrente e poi procedendo sul nodo di destra. Come illustrato nella seguente animazione:

Procedendo in questo modo otterremo tutti i valori ordinati.

Questo algoritmo può essere scritto in Python nel modo seguente:

class Nodo:
    def __init__(s,v = None):
        s.valore = v
        s.sx = s.dx = None

def aggiungi(nodo,v):
    if nodo.valore is None:
        nodo.valore = v
        nodo.sx = Nodo()
        nodo.dx = Nodo()
    elif v < nodo.valore:
        aggiungi(nodo.sx,v)
    else:
        aggiungi(nodo.dx,v)

def stampa(nodo):
    if nodo.valore is not None:
        stampa(nodo.sx)
        print(nodo.valore)
        stampa(nodo.dx)

radice = Nodo()


numeri = [3,2,7,4,6,5,9,10]
for n in numeri:
    aggiungi(radice,n)

stampa(radice)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

class Nodo:

def __init__(s,v = None):

s.valore = v

s.sx = s.dx = None

def aggiungi(nodo,v):

if nodo.valore is None:

nodo.valore = v

nodo.sx = Nodo()

nodo.dx = Nodo()

elif v < nodo.valore:

aggiungi(nodo.sx,v)

else:

aggiungi(nodo.dx,v)

def stampa(nodo):

if nodo.valore is not None:

stampa(nodo.sx)

print(nodo.valore)

stampa(nodo.dx)

radice = Nodo()

numeri = [3,2,7,4,6,5,9,10]

for n in numeri:

aggiungi(radice,n)

stampa(radice)

[plesk] Aggiungere manualmente IP alla blacklist di fail2ban

In Plesk purtroppo non è possibile, tramite l’interfaccia grafica, aggiungere manualmente IP alla blacklist di fail2ban.

Lo si può fare esclusivamente, al momento attuale, tramite terminale, interagendo direttamente con fail2ban.

Per bloccare manualmente un IP con fail2ban si può utilizzare il seguente comando:

fail2ban-client set nome-jail banip xx.xx.xx.xx

1	fail2ban-client set nome-jail banip xx.xx.xx.xx

Dove al posto di nome-jail si inserirà una delle jail configurate su fail2ban e al posto di xx.xx.xx.xx l’indirizzo IP che si intende bloccare.

[python] Semplice simulazione dell’espansione di un contagio tipo COVID19 con PyGame e OpenGL

Ripropongo un esercizio in Python simile a quello svolto in JavaScript in Simulazione sull’espansione del contagio da Coronavirus (COVID-19)

Questa volta utilizzeremo PyGame e OpenGL per costruire la simulazione, similmente a quanto fatto nel precedente articolo. Il programma è stato svolto in Python 3.9.

import pygame as pg
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

import math
from copy import copy
import random

import matplotlib.pyplot as plt

dati = [
    {"infetto":False,"velocita":10,"numero":200},
    {"infetto":False,"velocita":0,"numero":10},
    {"infetto":True,"velocita":10,"numero":1}
    ]

class Simulazione:

    def __init__(s, w = 1200, h = 800, dati = []):

        s.posizioni = []

        s.ratio = w / h
        s.w = w
        s.h = h

        pg.init()
        schermo = (w,h)
        pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

        # in movimento
        for d in dati:
            for i in range(d["numero"]):
                x = random.randint(-w/2+10,w/2-10)
                y = random.randint(-h/2+10,h/2-10)
                a = 2*math.pi*random.random()
                s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

        infezioni = []

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    quit()
        
            glClearColor(1.0, 1.0, 1.0, 1.0)
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

            tot_infetti = 0

            for p in s.posizioni:
                p.muovi()
                s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)
                if p.infetto and not p.guarito: tot_infetti += 1

            infezioni.append(tot_infetti)

            s.controllaUrti()

            pg.display.flip()
            pg.time.wait(10)

            if tot_infetti == 0:
                pg.quit()
                break

        plt.plot(range(len(infezioni)),infezioni)
        plt.title("curva contagi")
        plt.xlabel("periodo")
        plt.ylabel("contagi")
        plt.show()
        

    def controllaUrti(s):
        for p in s.posizioni:
            if copy(p) in s.posizioni:
                pass

    def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):
        raggio = 2 * raggio / s.w
        x = 2 * x / s.w
        y = 2 * y / s.h
        r,g,b = colore
        glColor3f(r,g,b)
        glBegin(GL_POLYGON)
        for v in range(lati):
            angolo = float(v) * 2.0 * math.pi / lati
            glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)
        glEnd()

class Punto:

    def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):
        s.x = x
        s.y = y
        s.v = v
        s.alfa = alfa
        s.id = id(s)
        s.colore = colore
        s.raggio = raggio
        s.urtato = False
        s.guarito = False
        s.infetto = infetto
        s.durata_infezione = 120 # cicli

    def __eq__(s,o):
        if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:
            salfa = s.alfa
            oalfa = o.alfa
            if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):
                s.infetto = o.infetto = True
            if not s.urtato: s.urto(oalfa)
            if not o.urtato: o.urto(salfa)
            return True
        else:
            return False

    def muovi(s):

        s.urtato = False

        if s.infetto: s.durata_infezione -= 1
        if s.durata_infezione < 0:
            s.guarito = True
            s.colore=(0.0, 1.0, 0.0)
        if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)
        
        dx = s.v * math.cos(s.alfa)
        dy = s.v * math.sin(s.alfa)

        if s.x+dx >= 600 or s.x+dx <= -600:
            s.alfa = math.pi-s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        if s.y+dy >= 400 or s.y+dy <= -400:
            s.alfa = -s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        s.x += dx
        s.y += dy

        if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:
            s.v = -s.v

    def urto(s,theta):
        s.alfa = s.alfa+theta
        s.urtato = True


Simulazione(dati=dati)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

import pygame as pg

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

from copy import copy

import random

import matplotlib.pyplot as plt

dati = [

{"infetto":False,"velocita":10,"numero":200},

{"infetto":False,"velocita":0,"numero":10},

{"infetto":True,"velocita":10,"numero":1}

]

class Simulazione:

def __init__(s, w = 1200, h = 800, dati = []):

s.posizioni = []

s.ratio = w / h

s.w = w

s.h = h

pg.init()

schermo = (w,h)

pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

# in movimento

for d in dati:

for i in range(d["numero"]):

x = random.randint(-w/2+10,w/2-10)

y = random.randint(-h/2+10,h/2-10)

a = 2*math.pi*random.random()

s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

infezioni = []

while True:

for event in pg.event.get():

if event.type == pg.QUIT:

pg.quit()

quit()

glClearColor(1.0, 1.0, 1.0, 1.0)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

tot_infetti = 0

for p in s.posizioni:

p.muovi()

s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)

if p.infetto and not p.guarito: tot_infetti += 1

infezioni.append(tot_infetti)

s.controllaUrti()

pg.display.flip()

pg.time.wait(10)

if tot_infetti == 0:

pg.quit()

break

plt.plot(range(len(infezioni)),infezioni)

plt.title("curva contagi")

plt.xlabel("periodo")

plt.ylabel("contagi")

plt.show()

def controllaUrti(s):

for p in s.posizioni:

if copy(p) in s.posizioni:

pass

def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):

raggio = 2 * raggio / s.w

x = 2 * x / s.w

y = 2 * y / s.h

r,g,b = colore

glColor3f(r,g,b)

glBegin(GL_POLYGON)

for v in range(lati):

angolo = float(v) * 2.0 * math.pi / lati

glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)

glEnd()

class Punto:

def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):

s.x = x

s.y = y

s.v = v

s.alfa = alfa

s.id = id(s)

s.colore = colore

s.raggio = raggio

s.urtato = False

s.guarito = False

s.infetto = infetto

s.durata_infezione = 120 # cicli

def __eq__(s,o):

if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:

salfa = s.alfa

oalfa = o.alfa

if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):

s.infetto = o.infetto = True

if not s.urtato: s.urto(oalfa)

if not o.urtato: o.urto(salfa)

return True

else:

return False

def muovi(s):

s.urtato = False

if s.infetto: s.durata_infezione -= 1

if s.durata_infezione < 0:

s.guarito = True

s.colore=(0.0, 1.0, 0.0)

if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.x+dx >= 600 or s.x+dx <= -600:

s.alfa = math.pi-s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.y+dy >= 400 or s.y+dy <= -400:

s.alfa = -s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

s.x += dx

s.y += dy

if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:

s.v = -s.v

def urto(s,theta):

s.alfa = s.alfa+theta

s.urtato = True

Simulazione(dati=dati)

Il risultato produrrà qualcosa di simile a questo:

[python] Calcolare la dimensione delle cartelle sul computer e trovare quelle più grandi

Ecco un veloce script in python per ricavare la dimensione delle cartelle sul computer (vale sia per Windows che Mac e Linux) e stampare l’elenco ordinato (dalla più grande alla più piccola) di tutte quelle trovate sopra una certa dimensione.

A me è stato molto utile per svuotare C: che si era riempito di cartelle temporanee, di cache e cose totalmente dimenticate.

import os
import math

class CalcolaDimensione:

    def __init__(s):
        s.cartelle = []

    def leggi_cartella(s,path):
        try:
            dim = 0
            for file in os.listdir(path):
                tmp = path + "\\" + file
                if os.path.isdir(tmp):
                    dim += s.leggi_cartella(tmp)
                else:
                    dim += os.path.getsize(tmp)
            s.cartelle.append({
                "path": path,
                "bytes": dim,
                "size": s.dimensione(dim)
                })
            return dim
        except:
            print("Errore: %s" % path)
            return 0

    def ordina(s):
        s.cartelle.sort(key=lambda e: e["bytes"],reverse=True)

    def dimensione(s,dim):
        if dim == 0: return "0B"
        nomi = ("B","KB","MB","GB","TB")
        i = int(math.floor(math.log(dim,1024)))
        p = math.pow(1024,i)
        s = round(dim / p,2)
        return "%s %s" % (s,nomi[i])

cd = CalcolaDimensione()
cd.leggi_cartella("C:\\")
cd.ordina()
for c in cd.cartelle:
    if c["bytes"] > 1024*1024*200:
        print(c["size"],c["path"])

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

import os

import math

class CalcolaDimensione:

def __init__(s):

s.cartelle = []

def leggi_cartella(s,path):

try:

dim = 0

for file in os.listdir(path):

tmp = path + "\\" + file

if os.path.isdir(tmp):

dim += s.leggi_cartella(tmp)

else:

dim += os.path.getsize(tmp)

s.cartelle.append({

"path": path,

"bytes": dim,

"size": s.dimensione(dim)

})

return dim

except:

print("Errore: %s" % path)

return 0

def ordina(s):

s.cartelle.sort(key=lambda e: e["bytes"],reverse=True)

def dimensione(s,dim):

if dim == 0: return "0B"

nomi = ("B","KB","MB","GB","TB")

i = int(math.floor(math.log(dim,1024)))

p = math.pow(1024,i)

s = round(dim / p,2)

return "%s %s" % (s,nomi[i])

cd = CalcolaDimensione()

cd.leggi_cartella("C:\\")

cd.ordina()

for c in cd.cartelle:

if c["bytes"] > 1024*1024*200:

print(c["size"],c["path"])

Lo script è stato scritto per Python 3.9

L’ouput finale genera qualcosa di simile (nel mio caso vedo che le macchine virtuali di Android occupano da sole 24GB!)

Faccio notare che nella stampa finale ho ridotto l’elenco a cartelle maggiori di 200MB.