Petar Karan

[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…

[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…

[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…

[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…

[python] Semplice esercizio per riconoscere immagini di frutti con TensorFlow (machine learning)

Vogliamo realizzare un semplice programma in Python che sia in grado di riconoscere, utilizzando TensorFlow e machine learning, delle immagini di frutti. Questo esercizio riprende i medesimi concetti già visti in: [python] Semplice esercizio su TensorFlow e il riconoscimento delle immagini nel gioco del Tris (Machine Learning) Dato il seguente…

[HOI4] Evitare che l’Albania venga annessa dall’Italia automaticamente se si trova in una fazione in Hearts of Iron 4 [BUG risolto]

In Hearts of Iron 4, attorno agli inizi di aprile del 1939 (storicamente il 7 aprile 1939) l’Italia completa il focus Albanian Occupation, al quale segue l’ultimatum italiano all’Albania e la conseguente occupazione. Al giocatore umano compare un messaggio come il seguente, e può scegliere se arrendersi oppure resistere. In…

[chrome] Aggirare il blocco del click col tasto destro tramite javascript

Alcuni siti bloccano (senza alcuna vera utilità) l’utilizzo del tasto destro, ossia l’apertura del menù contestuale che, tra le altre cose, permetterebbe di copiare il testo o le immagini. Questo tipo di blocco può essere aggirato tramite Google Chrome, nel modo seguente: Premere il tasto F12 mentre si è sulla…

[python] Semplice esercizio per creare il gioco del campo minato in Python (da console)

In questo semplice esercizio vogliamo riprodurre in Python, in modo un po’ rudimentale, quello che era il gioco del campo minato (poi campo fiorito) per Windows. Quello che vogliamo ottenere assomiglierà a questo all’avvio: Mentre alla vittoria otterremo qualcosa di simile: Il gioco sarà costruito su una griglia 10×10, di…

Ripristino password admin (webpanel) per accesso web ad allarme FC-7688

L’allarme FC-7688 dispone di un pannello di controllo via web che consente di configurare e gestire l’allarme. Per assurdo alcune opzioni sono disponibili esclusivamente da tale pannello di controllo e qualora si dovesse smarrire la password di amministratore non ci sarebbe nemmeno modo di ripristinare le impostazioni di fabbrica del…

[moodle] Migrazione di Moodle 3.4 su nuovo server e dominio

Questa guida fa riferimento a Moodle 3.4, ma in linea generale dovrebbe essere valida per tutte le versioni di Moodle 3.x. Per determinare la versione del proprio Moodle è sufficiente consultare il file version.php nella root del portale. All’occorenza possiamo impostare Moodle in modalità manutenzione, durante il trasferimento. 1. Backup…