Petar Karan

[risolto] Su Chrome appare una banda nera in alto che impedisce di cliccare sulle schede o sui pulsanti della finestra

Problema: Su Windows 10, utilizzando due monitor, su Chrome appare una banda nera in alto che impedisce di cliccare sulle schede, sul menu delle opzioni oppure sui pulsanti della finestra.

Soluzione: Aprire il task manager premendo ALT+CTRL+CANC e andando su Gestione Attività, andare in Dettagli e trovare il processo dwm.exe. Terminare il processo. Il processo dovrebbe riavviarsi da solo, risolvendo il problema.

Più nel dettaglio sembra che si tratti di un bug, già noto dalla seconda metà del 2018, di Windows 10. Nel caso specifico il problema si presenta nella maniera seguente:

Lì dove dovrebbero esserci le schede ed i pulsanti della finestra c’è solo una striscia nera. Il problema si presenta solamente a schermo intero e su un singolo monitor.

Riducendo la finestra, oppure aprendola a schermo intero su un altro monitor, il problema non sembra presentarsi. Dei due o più monitor non c’è uno “preferito” dal problema, avviene in modo casuale su qualunque. L’unica soluzione possibile sembra il riavvio del sistema.

Un’altra soluzione suggerita da Microsoft è quella di disabilitare l’accelerazione hardware in Chrome, ma questo non sembra incidere in alcun modo sulla questione, tanto più che io l’avevo disattivata da principio e la cosa è iniziata a succedere diverso tempo dopo.

In sostanza sembra che al momento, a meno che non correggano questo errore con qualche nuovo aggiornamento, l’unica soluzione concreta, a parte il riavvio, sia quella di terminare il processo dwm.exe (Desktop Windows Manager). Una volta terminato, il processo si riavvierà da solo e il problema non dovrebbe presentarsi, almeno per un po’.

[woocommerce] Nascondere gli attributi senza alcuna variante attiva

In WooCommerce è possibile creare prodotti con diverse varianti. Immaginiamo di avere una situazione come la seguente:

In questo caso la prima variante di colore non è disponibile in alcuna taglia e se la proviamo a selezionare ci compare un avviso che ci dice che non c’è alcun prodotto selezionabile. Per evitare che il cliente debba testare tutte le combinazioni inutilmente WooCommerce, sotto a 10 variazioni per prodotto, tende a nascondere automaticamente le combinazioni inesistenti.

Quando però, come in questo caso, il numero di variazioni aumenta per motivi di prestazioni l’opzione non è attiva. Per aumentare tale limite basta aggiungere a functions.php nel nostro tema le seguenti righe di codice:

function custom_wc_ajax_variation_threshold( $qty, $product ) {
    return 500;
}

add_filter( 'woocommerce_ajax_variation_threshold', 'custom_wc_ajax_variation_threshold', 10, 2 );

function custom_wc_ajax_variation_threshold( $qty, $product ) {

return 500;

}

add_filter( 'woocommerce_ajax_variation_threshold', 'custom_wc_ajax_variation_threshold', 10, 2 );

A questo punto vedremo un risultato come il seguente (abbiamo impostato il limite a 500):

Si può notare come il primo colore, assieme ad altri, è automaticamente sparito.

[python] Recuperare i messaggi cancellati definitivamente da un file *.pst di Outlook

Outlook salva tutto il contenuto dell’account di posta dentro ad un file *.pst che viene trattato similmente ad uno spazio sul disco. Questo significa che quando un messaggio viene cancellato definitivamente (per esempio svuotando il cestino oppure cancellandolo con SHFIT+CANC) in realtà non viene rimosso definitivamente dal file, ma ne rimane traccia finché un nuovo messaggio non andrà a sovrascriverlo. Questa non è una spiegazione perfettamente accurata, ma è quanto ci serve sapere allo scopo.

Per recuperare un messaggio cancellato definitivamente è anzitutto importante non scaricare o inviare nuovi messaggi, non fare cioè alcuna operazione che potrebbe modificare il file *.pst.

Detto questo possiamo tentare di recuperare i dati modificando alcuni byte del file *.pst e utilizzando il programma Scanpst.exe fornito assieme ad Office. Dalla versione Microsoft Office 2016 il programma è eseguibile anche tramite linea di comando.

Vediamo quindi come creare un programma in python che ci permetta di effettuare le due operazioni recuperando quindi i messaggi.

Prima di procedere creiamo una copia del file *.pst per non provocare altri danni.

Quello che dobbiamo fare ora è modificare, mettendoli per esempio a 0, i primi 13 byte a partire dalla 7^ posizione nel file *.pst in questione. Questo farà sì che Scanpst.exe identifichi il file come corrotto e cerchi di recuperare i messaggi perduti. Usando un editor esadecimale, tipo Hex Edit, dovremmo vedere una situazione come la seguente.

Quelli che vogliamo mettere a 0 sono i byte evidenziati. Io lo farò usando python. Creiamo un vettore di byte a zero nel modo seguente:

byte_vuoti = bytes(13)

1	byte_vuoti = bytes(13)

Questo produrrà un vettore di byte che possiamo visualizzare con print( byte_vuoti )

Scriviamo il pezzo di codice necessario per modificare il file *.pst

file_pst = "Outlook.pst"
byte_vuoti = bytes(13)

fp = open( file_pst , "r+b" )
fp.seek(7)
fp.write( byte_vuoti )
fp.close()

file_pst = "Outlook.pst"

byte_vuoti = bytes(13)

fp = open( file_pst , "r+b" )

fp.seek(7)

fp.write( byte_vuoti )

fp.close()

Con fp.seek(7) ci posizioniamo sull’ottavo byte, e poi scriviamo i 13 byte a 0 dalla posizione acquisita.

Adesso passiamo il file a Scanpst.exe, potremmo farlo anche a mano, ma nel mio esempio lo farò tramite linea di comando.

Modifichiamo il codice soprastante nel modo seguente:

import os

dir_path = os.path.dirname(os.path.realpath(__file__))
file_pst = dir_path + "\\Outlook.pst"
byte_vuoti = bytes(13)
scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE"
cmd = "\"%s\" -backupfile \"%s.bck\" -force -file \"%s\" -silent" % (scanpst,file_pst,file_pst)

fp = open( file_pst , "r+b" )
fp.seek(7)
fp.write( byte_vuoti )
fp.close()

output = os.popen(cmd).read()
print(output)
print("Fatto!")

import os

dir_path = os.path.dirname(os.path.realpath(__file__))

file_pst = dir_path + "\\Outlook.pst"

byte_vuoti = bytes(13)

scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE"

cmd = "\"%s\" -backupfile \"%s.bck\" -force -file \"%s\" -silent" % (scanpst,file_pst,file_pst)

fp = open( file_pst , "r+b" )

fp.seek(7)

fp.write( byte_vuoti )

fp.close()

output = os.popen(cmd).read()

print(output)

print("Fatto!")

Per maggiori dettagli sui parametri da passare a Scanpst.exe rimando alla pagina ufficiale sul sito della Microsoft: Lo strumento Manutenzione Posta in arrivo (Scanpst.exe) può eseguire controlli multipli in Outlook 2016

Con os.path.dirname(os.path.realpath(__file__)) prendiamo la posizione del programma in python, laddove io suppongo che il file Outlook si trovi nella medesima cartella del programma. Inutile dire che file_pst = dir_path + "\\Outlook.pst" dipende dalla posizione del file *.pst che potremmo passare anche con il percorso diretto.

Con la riga scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE" prendiamo la posizione del file Scanpst.exe che nel mio caso ha quel percorso. Anche questo dipende dalla nostra specifica installazione di Office. Ricordiamoci che questo procedimento è valido solo per le versioni di Office 2016 e successive.

Infine con output = os.popen(cmd).read() mettiamo il programma in attesa finché non verrà completata l’esecuzione del comando. (verrà scritto Fatto!)

Alla fine, se tutto è andato bene, dovremmo vedere qualcosa di questo genere nella cartella del file:

Per visualizzare di nuovo il contenuto del file *.pst è sufficiente collegarlo tra i File dati di Outlook.

[apps script] Inviare tramite Gmail un’email con allegato da Drive

Questo esempio è la prosecuzione di quanto già visto in [apps script] Inviare tramite Gmail un’email ad un elenco di contatti in Spreadsheet

Voglio apportare solo una piccola modifica al codice per inviare un allegato salvato su Google Drive a tutti i soggetti nella lista. Per i riferimenti di programmazione rimando alla pagina della guida ufficiale.

Per prelevare un file da Google Drive dobbiamo anzitutto ottenere il suo riferimento univoco. Per farlo ci sono diversi modi, nel mio esempio utilizzerò un file pdf come questo qua. Anzitutto lo carico su Drive e poi cliccandoci sopra col destro scelgo Anteprima.

Dal menu in alto a destra seleziono Apri in un’altra finestra.

A questo punto nella barra dell’indirizzo vedrò qualcosa come https://drive.google.com/file/d/1234567890abcdefghijklmnopqrstuvwxyz/view

Copio il codice alfanumerico che ho evidenziato in rosso, che è l’identificativo univoco per ciascun file. Una volta copiato vado a modificare il mio codice nel modo seguente.

function InviaEmailAllaLista() {
  
  var foglio = SpreadsheetApp.getActiveSheet();
  var indirizzi = foglio.getRange("A:A").getValues();
  var oggetti = foglio.getRange("B:B").getValues();
  var messaggi = foglio.getRange("C:C").getValues();
  
  var riga = 1;
  
  while( true ) {
   
    if( indirizzi[riga] == "" ) {
      break;
    }
    
    var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');
    GmailApp.sendEmail(indirizzi[riga], oggetti[riga], messaggi[riga], {
      attachments: [file.getAs(MimeType.PDF)],
      name: 'File di prova'
    });
    
    riga++;
    
  }
  
  Browser.msgBox("Tutte le email sono state inviate!");
  
}

function InviaEmailAllaLista() {

var foglio = SpreadsheetApp.getActiveSheet();

var indirizzi = foglio.getRange("A:A").getValues();

var oggetti = foglio.getRange("B:B").getValues();

var messaggi = foglio.getRange("C:C").getValues();

var riga = 1;

while( true ) {

if( indirizzi[riga] == "" ) {

break;

}

var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

GmailApp.sendEmail(indirizzi[riga], oggetti[riga], messaggi[riga], {

attachments: [file.getAs(MimeType.PDF)],

name: 'File di prova'

});

riga++;

}

Browser.msgBox("Tutte le email sono state inviate!");

}

In particolare con la prima istruzione aggiunta prelevo il file da Drive, cosa che richiederà dei permessi aggiuntivi.

var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

1	var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

Mentre con file.getAs(MimeType.PDF) creo il blob del file in formato PDF.

Fatto questo il mio nuovo script invia un’email a ciascun membro della lista con allegato il suddetto file.

[python] Esercizio su wxPython e PyOpenGL per disegnare un poligono dato il numero di lati

Quello che voglio realizzare oggi è un semplice programma in Python 2.7, con interfaccia grafica e che permetta di disegnare un poligono regolare dato il numero di lati. In questo esercizio vedremo quindi due cose:

L’utilizzo di wxPython per creare un rudimentale programma con interfaccia grafica
L’utilizzo di PyOpenGL per disegnare dentro ad un canvas una figura geometrica

Il programma che andremo a creare avrà alla fine questo aspetto, con uno spazio per inserire il numero di lati ed un canvas su cui disegnare:

Anzitutto assicuriamoci di disporre di entrambe le librerie, per farlo installiamole con pip eseguendo i seguenti due comandi da terminale:

pip install wxPython
pip install PyOpenGL

1 2	pip install wxPython pip install PyOpenGL

Una volta installate le librerie possiamo cominciare a creare il nostro programma.

Per prima cosa creiamo una classe per la nostra applicazione, utilizzando wx.Frame e avviando la finestra principale. Il codice di cui avremo bisogno sarà il seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        s.Show(True)


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

s.Show(True)

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

In questo modo creiamo una finestra di dimensione 800 x 600 px con titolo Disegnatore. La nostra applicazione è un’estensione di wx.Frame, laddove un Frame è una finestra le cui dimensioni e posizione possono essere modificate dall’utente (insomma la classica finestra in Windows). Inoltre essa può contenere una barra del titolo, dei menu, dello stato e degli strumenti.

Con wx.App avviamo invece l’applicazione vera e propria, questa classe ci serve per lanciare il contenitore principale dell’applicazione e passiamo come argomento False (che sarebbe così anche di predefinito) per non reindirizzare lo sys.stdout e lo sys.stderr. Per maggiori informazioni rimando alla guida ufficiale su App.

A questo punto voglio aggiungere la casella di testo e il pulsante per impostare il numero di lati. Per farlo dobbiamo usare un wx.Panel, che sostanzialmente è il contenitore degli elementi di controllo e si trova tipicamente dentro un Frame. Per maggiori informazioni leggere qui su Panel.

Modifico quindi il codice nella maniera seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ molto importante che il Panel venga istanziato prima del metodo aggPulsanti che poi aggiunge elementi al Panel. Arrivati a questo punto lanciamo il nostro programma e verifichiamo che abbia il seguente aspetto.

A questo punto è l’ora di aggiungere anche il Canvas che ci permetterà di mostrare grafica in OpenGL. Per farlo includiamo anzitutto le librerie necessarie:

from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

Modifichiamo poi il codice nel modo seguente:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ importante stabilire le dimensioni del canvas in due variabili s.width e s.height per delle correzioni che apporteremo successivamente, per ora prendiamola per buona così.

A questo punto inizializziamo il canvas aggiungendo le seguenti istruzioni:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Faccio notare che il metodo glClearColor(1, 1, 1, 1) imposta il colore dello sfondo su bianco, mentre il metodo glClearColor(0, 0, 0, 1) lo imposta su nero. I primi tre parametri sono i valori di RGB da 0 a 1.

Siamo arrivati a buon punto e siamo praticamente pronti a disegnare il nostro poligono. Il nostro riferimento è uno spazio cartesiano con gli assi che attraversano a metà il canvas e il punto (0, 0) al centro del canvas stesso. Un poligono regolare ha tanti vertici quanti i lati e ogni vertice poggia su una circonferenza di raggio r.

Questo significa che un angolo α che passa da un vertice all’altro è dato dalla seguente equazione:

$\alpha = 2 * \pi / n$

Dove n è il numero di lati (o vertici) del poligono. Traduciamo questa formula in Python nel modo seguente:

angolo_lato = 2.0*math.pi/s.n

1	angolo_lato = 2.0*math.pi/s.n

Avremo bisogno della libreria math che importiamo con:

import math

1	import math

L’angolo di partenza è arbitrario, però per far sì che il lato superiore del poligono sia parallelo all’asse delle ascisse voglio prendere come angolo di partenza:

$\beta = \pi / 2 - \pi / n$

Quindi la nostra formula sarà:

angolo_partenza = math.pi/2.0 - math.pi/s.n

1	angolo_partenza = math.pi/2.0 - math.pi/s.n

Attenzione ad inserire i numeri con almeno una cifra decimale, anche se zero, per assicurarci che Python esegua tutti i calcoli con valori decimali e non tronchi ad interi.

Infine vogliamo definire un raggio fisso per i nostri poligoni, per farlo userò come riferimento l’apotema a (anche se sarebbe sufficienti lato e raggio) nel modo seguente:

$apotema = 0.5$

$lato = apotema * ( 2.0 * \tan( \pi / n ) )$

$raggio = \sqrt{ (lato/2)^2+apotema^2 }$

Il primo vertice avrà quindi coordinate:

$( raggio * \cos( \beta ) , raggio * \sin( \beta ) )$

Il secondo vertice sarà:

$( raggio * \cos( \beta + \alpha ) , raggio * \sin( \beta + \alpha ) )$

Il terzo vertice sarà:

$( raggio * \cos( \beta + 2 * \alpha ) , raggio * \sin( \beta + 2 * \alpha ) )$

E così via.

Traduciamo il tutto nel seguente metodo:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Spostiamoci sul metodo onDraw e modifichiamolo nel modo seguente:

    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

Nel costruttore __init__ della classe aggiungiamo una variabile s.n per il numero di lati, subito dopo le dimensioni del canvas, nel modo seguente:

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        #numero di lati
        s.n = 5

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

#numero di lati

s.n = 5

Se abbiamo fatto tutto correttamente dovremmo vedere qualcosa come questo:

Notiamo subito che il pentagono è deformato ed inoltre manca la possibilità di definire una dimensione a piacere.

Anzitutto occupiamoci della deformazione, essa dipende dal fatto che il canvas ha una dimensione fissa di 1 x 1, che poi viene ripartita in parti decimali. Quindi tale dimensione si adatta poi alle proporzioni del canvas. Per ottenere un pentagono regolare anzitutto dobbiamo introdurre un fattore correttivo, che nel nostro caso sarà dato da:

s.ratio = 1.0 * s.height / s.width

1	s.ratio = 1.0 * s.height / s.width

Aggiungiamo la variabile subito dopo larghezza e altezza impostate in __init__.

Modifichiamo il metodo per disegnare il poligono nel modo seguente:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Adesso il poligono risulta regolare:

Infine attribuiamo un valore personalizzato al numero di lati s.n del poligono. Aggiungiamo i seguenti due metodi alla nostra classe:

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

E dove abbiamo istanziato s.pulsante aggiungiamo:

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

1	s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

In questo modo colleghiamo il metodo s.btn_calcola all’evento wx.EVT_BUTTON che corrisponde alla pressione del pulsante. Con il metodo verificaIntero controlliamo se il valore passato dall’utente sia intero. Se non è intero mostriamo, grazie a wx.MessageBox, un messaggio a video con notifica di errore.

Se abbiamo fatto tutto correttamente otterremo il seguente codice finale:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *
import math

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        s.ratio = 1.0 * s.height / s.width
        #numero di lati
        s.n = 5

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))
        s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

import math

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

s.ratio = 1.0 * s.height / s.width

#numero di lati

s.n = 5

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Se lo eseguiamo abbiamo il nostro programma che ci permetterà di disegnare qualunque poligono regolare:

[FIFA19] La connessione con l’avversario si è interrotta

Problema: Quando si cerca di giocare una partita online con un altro giocatore amico dopo l’invito ed una breve attesa appare il messaggio “La connessione con l’avversario si è interrotta“.

Soluzione: Una possibile soluzione consiste nel disabilitare il protocollo IPv6 e attivare l’UPnP sul router ed infine riavviare il gioco

Premetto che come ISP ho Fastweb e la soluzione è stata testata sul router in dotazione e Windows 10. Procediamo nel modo seguente.

Cerchiamo il Pannello di controllo nel menu principale:

Andiamo su Rete e Internet:

Poi su Centro connessioni di rete e condivisione

Clicchiamo su Modifica impostazioni scheda nel menu sulla sinistra.

Individuiamo la nostra scheda di rete, nel mio caso Ethernet, e clicchiamo col destro, poi spostiamoci su Proprietà e clicchiamo.

Cerchiamo la voce Protocollo Internet versione 6 (TCP/IPv6) e togliamo la spunta.

Per precauzione impostiamo il DNS sui Google DNS spostandoci su Protocollo Internet versione 4 (TCP/IPv4), selezioniamolo (ma attenzione a NON TOGLIERE la spunta) e poi clicchiamo su Proprietà.

Impostiamo il DNS su 8.8.8.8 e 8.8.4.4

Premiamo OK su tutto quanto.

Adesso controlliamo che sul router sia attivo l’UPnP. Nel caso del router Fastweb andiamo su Home > Casella degli strumenti > Condivisione giochi e applicazioni

Verifichiamo che l’UPnP sia attivo nel modo seguente:

Su un router Netgear D6300 l’opzione si trova tra le impostazioni avanzate:

E dev’essere impostata nel modo seguente:

Fatte tutte queste belle cose riavviamo la connessione cliccando su Disabilita

E poi di nuovo Abilita sulla scheda di rete.

Adesso riavviamo il gioco. Fatto tutto questo il problema dovrebbe essersi risolto e potremo tornare a giocare.

In caso di altri problemi suggerisco anche l’articolo ufficiale Risoluzione dei problemi per connessione per PC

Jordan Pickford, uno dei miei giocatori preferiti, oltre che portiere dell’Everton

Installazione Ubuntu 18.04.2 LTS webserver pronto all’uso [per esordienti totali]

Abbiamo già visto come installare Ubuntu 16.04.2 LTS e predisporlo per fare da webserver. Stavolta voglio ripetere la procedura, utilizzando però l’ultima distribuzione a lungo termine ovvero Ubuntu 18.04.2 LTS.

Come al solito eseguiremo l’operazione utilizzando VirtualBox. Per chi lo volesse installare su una macchina fisica la procedura sarebbe comunque analoga.

1. Configurazione Ubuntu Server 18.04.2 LTS

Anzitutto procuriamoci la ISO dal sito ufficiale.

Selezioniamo la seguente configurazione e premiamo download.

A questo punto cominciamo a creare la macchina virtuale sulla quale faremo girare il nostro webserver. Dentro VirtualBox premiamo CTRL+N. Si avvierà la seguente schermata che prepariamo nel modo seguente:

Premiamo su Successivo. Ci verrà chiesto quanta RAM intendiamo assegnare, mettiamo almeno 1024MB (ossia 1GB).

Procediamo e scegliamo di creare un nuovo disco fisso virtuale.

Proseguiamo selezionando VDI e per lo spazio diciamo Allocato dinamicamente (questo vuol dire che il disco virtuale non occuperà immediatamente tutto lo spazio assegnato, ma solo via via che il sistema operativo ne avrà bisogno).

Lasciamo 10 GB di spazio.

A questo punto avviamo la macchina virtuale.e ci verrà chiesto di selezionare un disco di avvio. Se fosse stata una macchina fisica si sarebbe trattato del supporto di installazione, per esempio un CD oppure una penna USB. Nel nostro caso clicchiamo sulla cartellina gialla e andiamo a selezionare il file ISO che abbiamo scaricato in precedenza dal sito ufficiale.

Se abbiamo fatto tutto correttamente dovremmo vedere qualcosa di simile:

Premiamo su Avvia.

A questo punto inizierà il caricamento del programma di installazione finché non ci si presenterà la schermata dove scegliere la lingua.

Selezioniamo inglese. A quanto pare ancora non lo hanno tradotto in italiano.

Premiamo il tasto INVIO.

Usando le frecce direzionali, nella schermata successiva, posizioniamoci sui menu a tendina della lingua e premendo INVIO apriamolo. Selezioniamo la tastiera italiana e premiamo di nuovo INVIO. A questo punto torniamo, premendo la freccia verso il basso, su [Done].

Alla prossima schermata premiamo nuovamente INVIO.

A questo punto ci verrà chiesto come vogliamo configurare la scheda di rete. Se stiamo usando una macchina virtuale come VirtualBox la scheda di rete sarà identificata dal dispositivo enp0s3 (normalmente sarebbe eth0, eth1, ecc…). Premiamo nuovamente INVIO.

Alla richiesta di configurare il proxy lasciamo tutto così com’è e premiamo di nuovo INVIO.

Selezioniamo il mirror predefinito per le repository di Ubuntu premendo semplicemente INVIO.

Nella prossima schermata scegliamo come formattare il disco. In questo esempio voglio utilizzare LVM per la gestione dei dischi, quindi mi sposto sulla seconda voce e premo nuovamente INVIO.

Per maggiori approfondimenti sull’utilizzo del LVM suggerisco questo articolo.

Selezioniamo il disco da partizionare, che è anche l’unico disco di cui disponiamo in questo momento.

Arrivati a questo punto possiamo verificare l’intera configurazione ed apportare, eventualmente, delle modifiche. Nel nostro caso lasciamo tutto tale e quale e procediamo premendo INVIO.

Ci chiederà se siamo sicuri di proseguire. Proseguiamo 🙂

Adesso compiliamo i campi con il nostro nome, il nome del server, lo username e la password. Memorizziamo questi dati perché ne avremo bisogno per accedere al server una volta pronto.

Alla schermata successiva selezioniamo la casella di Installa OpenSSH server premendo la barra spaziatrice. Spostiamoci poi con le frecce su Done e proseguiamo premendo INVIO.

Nella schermata successiva spostiamoci immediatamente su Done premendo il tasto della tabulazione e poi di nuovo INVIO.

A questo punto inizierà l’installazione, non ci resta che aspettare pazientemente che finisca.

Quando sarà tutto finito ci troveremo di fronte ad una schermata come questa, dove ci viene chiesto di riavviare. Premiamo INVIO e riavviamo il sistema.

Poco dopo ci verrà chiesto di rimuovere il dispositivo di installazione. Premiamo semplicemente INVIO e aspettiamo.

ATTENZIONE: Normalmente ci si dovrebbe trovare di fronte alla seguente schermata:

ma operazioni in differita su questa ultima versione di Ubuntu fanno sì che si sovrappongano degli output oltre la schermata di login. Se compare qualcosa di simile a questo è sufficiente premere INVIO per avere accesso alla schermata di login.

A questo punto effettuiamo il login con le credenziali che abbiamo creato in precedenza.

Una volta dentro il sistema digitiamo ifconfig e dovremmo vedere un risultato simile a questo.

Come possiamo notare il server si trova sull’indirizzo 10.0.2.15 che è l’indirizzo automatico assegnato dalla rete virtuale NAT di VirtualBox alla macchina virtuale.

Quello che vogliamo fare adesso è creare una nostra rete NAT personalizzata sulla quale spostare il server. VirtualBox ci permette infatti di creare una rete interna che, rispetto al nostro computer host, sarà raggiungibile all’indirizzo 192.168.56.1. Tale indirizzo sarà, rispetto al server, l’indirizzo esterno con il quale la rete virtuale nella quale si trova il server si affaccerà alla rete nella quale si trova il computer host.

Andiamo perciò sul panello di controllo di VirtualBox, spostiamoci su File > Preferenze (raggiungibile anche premendo CTRL+G).

Spostiamoci su Rete e poi premiamo il pulsante con la scheda di rete e il simbolo più verde . Questo aggiungerà una nuova rete virtuale chiamata NatNetwork (nel mio caso ci sono già altre reti configurate). Restando su NatNetwork premiamo il terzo pulsante a destra con il simbolo dell’ingranaggio .

Impostiamo la rete nel modo seguente scegliendo come ID di rete 10.0.2.0/24:

Con l’IP Calculator possiamo testare i dettagli della rete, ma per quello che ci interessa avremo 254 host dal 10.0.2.1 al 10.0.2.254.

Premiamo OK e spostiamoci nelle impostazioni della nostra macchina virtuale.

Andiamo su Rete e impostiamo come tipo di rete Rete con NAT e il nome Rete Ubuntu, che abbiamo creato prima.

A questo punto torniamo dentro la nostra macchina virtuale e aggiorniamo lo stato della connessione di rete.

Per farlo digitiamo: sudo netplan apply

Digitiamo ifconfig e verifichiamo l’IP al quale è connesso adesso il nostro server. Nel mio caso è sempre 10.0.2.15

Adesso torniamo nelle Preferenze > Rete e andiamo ad impostare l’inoltro delle porte sulla rete che abbiamo creato.

Dal momento che vogliamo testare il server web con Apache e usare l’SSH per connetterci, dobbiamo inoltrare le porte 80, 443 e la 22. Per aggiungere nuove regole di inoltro premiamo sul tasto col più verde e compiliamo l’elenco nel modo seguente.

L’indirizzo 192.168.56.1 rappresenta l’indirizzo della scheda di rete virtuale creata da VirtualHost, con la quale possiamo collegarci dal nostro PC alla rete virtuale creata poc’anzi. Fatto tutto questo diamo OK a tutto e proviamo a collegarci alla nostra macchina utilizzando Putty.

Se abbiamo fatto tutto a dovere adesso la macchina dentro la rete NAT virtuale è raggiungibile dall’indirizzo esterno 192.168.56.1.

Configuriamo Putty e premiamo Open.

Se tutto è andato bene ci verrà chiesto di acquisire la chiave per la connessione. Diciamo di sì:

A questo punto entriamo dentro il sistema usando Putty.

Procediamo con l’installazione di Apache e degli altri componenti del server LAMP.

2. Installazione e configurazione Apache

Per installare Apache anzitutto aggiorniamo la repository di Ubuntu digitando:

sudo apt-get update

1	sudo apt-get update

Quando finisce l’operazione procediamo installando Apache e digitiamo:

sudo apt-get install apache2

1	sudo apt-get install apache2

Se tutto è andato bene possiamo andare all’indirizzo http://192.168.56.1/ e verificare che si veda una pagina come la seguente:

Questa è la pagina default del nostro server Apache. La possiamo anche modificare andando nella cartella /var/www/html che è la root default del server.

Proviamo a farlo digitando:

sudo nano /var/www/html/index.html

1	sudo nano /var/www/html/index.html

Dentro Putty dovremmo vedere qualcosa come questo:

A questo punto usciamo dall’editor nano premendo CTRL+X e poi rimuoviamo il file e mettiamone uno nuovo digitando.

sudo rm /var/www/html/index.html
sudo nano /var/www/html/index.html

1 2	sudo rm /var/www/html/index.html sudo nano /var/www/html/index.html

Dentro il file scriviamo semplicemente:

E salviamo premendo CTRL+O. Premiamo INVIO per confermare e CTRL+X per uscire.

Tornando su http://192.168.56.1/ dovremmo vedere qualcosa di analogo a questo:

3. Installazione e configurazione MySQL

Per installare il database MySQL digitiamo:

sudo apt install mysql-server

1	sudo apt install mysql-server

Premiamo Y alla richiesta di conferma dell’installazione e poi aspettiamo che sia ultimata. Una volta completata digitiamo:

sudo mysql_secure_installation

1	sudo mysql_secure_installation

Questo avvierà una procedura di configurazione del nostro database, durante la quale ci verranno richieste diverse cose. Alle varie domande rispondiamo rispettivamente:

Press y|Y for Yes, any other key for No: Y

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2

(dove: STRONG Length >= 8, numeric, mixed case, special characters and dictionary file)

New password: )9@JZ21@pam)KUfB)2hc{n[vrK?BAeTU (questo è un esempio di password che possiamo mettere, questa password ha una qualità di 187bit e una lunghezza di 32 caratteri)

Se la passowrd è buona ci verrà detto qualcosa come:

Estimated strength of the password: 100

Proseguiamo:

Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y

Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y

Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y

Fatto questo il database è pronto per l’utilizzo.

4. Installazione e configurazione PHP

Procediamo installando il PHP e digitando:

sudo apt install php libapache2-mod-php php-mysql

1	sudo apt install php libapache2-mod-php php-mysql

Confermiamo sempre con Y quando ci viene richiesto.

Una volta finito verifichiamo che sotto Apache le pagine index.php siano configurate come pagine predefinite:

sudo nano /etc/apache2/mods-enabled/dir.conf

1	sudo nano /etc/apache2/mods-enabled/dir.conf

Se tutto va bene vedremo qualcosa come:

Notiamo la presenza di index.php quindi possiamo procedere tranquillamente.

Per concludere riavviamo il server Apache.

sudo service apache2 restart

1	sudo service apache2 restart

5. Ulteriori configurazioni

A questo punto dovremmo fare ancora qualche implementazione, configurando alcune cose come:

Sistemare il Firewall
Mettere in sicurezza Apache
Configurare fail2ban ed altri eventuali servizi

Io procederò con un esempio su come configurare un nuovo VirtualHost e installarci sopra WordPress.

6. Configurazione VirtualHost e installazione WordPress

Quello che vogliamo fare adesso è aggiungere un dominio al nostro server, affinché alla richiesta di un sito web su tale dominio esso risponde.

In poche parole voglio aggiungere il sito torregatti.com al mio server. Per farlo dobbiamo aggiungere un host virtuale. (qui un esempio della solita procedura)

Per farlo voglio creare, dentro a /var/www/ una cartella dedicata al dominio e poi aggiungerlo ai VirtualHost di Apache.

Procediamo quindi nel modo seguente creando anzitutto la suddetta cartella che, per motivi di ordine, chiamerò come il dominio:

sudo mkdir /var/www/torregatti.com

1	sudo mkdir /var/www/torregatti.com

Adesso assegniamo la cartella ad Apache modificando i permessi e digitando:

sudo chown www-data:www-data /var/www/torregatti.com

1	sudo chown www-data:www-data /var/www/torregatti.com

Aggiungiamo il VirtualHost in sites-available copiando un modello esistente:

cd /etc/apache2/sites-available/
sudo cp 000-default.conf torregatti.com.conf
sudo nano torregatti.com.conf

cd /etc/apache2/sites-available/

sudo cp 000-default.conf torregatti.com.conf

sudo nano torregatti.com.conf

Modifichiamo il file che abbiamo appena copiato ed aperto fino ad ottenere qualcosa di simile:

<VirtualHost *:80>
        ServerName torregatti.com
        ServerAlias www.torregatti.com

        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/torregatti.com

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

ServerName torregatti.com

ServerAlias www.torregatti.com

ServerAdmin webmaster@localhost

DocumentRoot /var/www/torregatti.com

ErrorLog ${APACHE_LOG_DIR}/error.log

CustomLog ${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

In questo modo il nostro server risponderà sia al dominio torregatti.com che al sottodominio www.torregatti.com

Salviamo con CTRL+O e confermiamo premendo INVIO.

Abilitiamo il host digitando:

sudo a2ensite torregatti.com.conf

1	sudo a2ensite torregatti.com.conf

Ricarichiamo Apache digitando:

sudo service apache2 reload

1	sudo service apache2 reload

A questo punto possiamo testare la nostra configurazione da dentro Windows modificando il file hosts in C:\Windows\System32\drivers\etc\ impostandolo nel modo seguente:

# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost

192.168.56.1 torregatti.com

# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.

# This file contains the mappings of IP addresses to host names. Each

# entry should be kept on an individual line. The IP address should

# be placed in the first column followed by the corresponding host name.

# The IP address and the host name should be separated by at least one

# space.

# Additionally, comments (such as these) may be inserted on individual

# lines or following the machine name denoted by a '#' symbol.

# For example:

# 102.54.94.97 rhino.acme.com # source server

# 38.25.63.10 x.acme.com # x client host

# localhost name resolution is handled within DNS itself.

# 127.0.0.1 localhost

# ::1 localhost

192.168.56.1 torregatti.com

Salviamo e verifichiamo dal browser che il risultato sia simile a questo:

7. Installazione e configurazione di WordPress

Adesso voglio concludere installando WordPress sul nostro nuovo dominio appena creato.

Anzitutto spostiamoci dentro la cartella del dominio e scarichiamo WordPress digitando i seguenti comandi:

cd /var/www/torregatti.com/
sudo wget https://it.wordpress.org/latest-it_IT.zip

1 2	cd /var/www/torregatti.com/ sudo wget https://it.wordpress.org/latest-it_IT.zip

Installiamo zip e scompattiamo il pacchetto:

sudo apt-get install zip
sudo unzip latest-it_IT.zip

1 2	sudo apt-get install zip sudo unzip latest-it_IT.zip

Spostiamo tutti i file da dentro la cartella wordpress alla radice del dominio digitando:

sudo mv wordpress/* .

1	sudo mv wordpress/* .

Rimuoviamo la cartella wordpress:

sudo rmdir wordpress

1	sudo rmdir wordpress

Assegniamo tutti i file ad Apache, altrimenti avremo problemi durante l’utilizzo del portale (per esempio nel caricamento delle immagini).

sudo chown -R www-data:www-data .

1	sudo chown -R www-data:www-data .

Creiamo ora un database con utente per la torregatti.com

Accediamo al database digitando:

sudo mysql -u root

1	sudo mysql -u root

Creiamo un nuovo database digitando:

CREATE DATABASE torregatti_com;

1	CREATE DATABASE torregatti_com;

Creiamo un utente per il database e diamogli tutti i privilegi.

CREATE USER 'torregatti'@'localhost' IDENTIFIED BY 'HGOqXovUhyZJ4}08}eg-lAiOM])}@lYt';
GRANT ALL PRIVILEGES ON torregatti_com.* TO 'torregatti'@'localhost';
FLUSH PRIVILEGES;

CREATE USER 'torregatti'@'localhost' IDENTIFIED BY 'HGOqXovUhyZJ4}08}eg-lAiOM])}@lYt';

GRANT ALL PRIVILEGES ON torregatti_com.* TO 'torregatti'@'localhost';

FLUSH PRIVILEGES;

A questo punto andando su http://torregatti.com dovremmo vedere l’installazione di WordPress.

Completiamo tutti i dati che abbiamo già configurato:

Completiamo l’installazione seguendo le istruzioni a video ed abbiamo finito.

[python] Esercizio su utilizzo di socket e database

Proviamo a realizzare questo semplice esercizio: vorrei avere un server ed un client che possano comunicare tramite socket, in modo tale che il client possa richiedere al server dei dati, il server preleverà tali dati da un database MySQL e li invierà al client.

Lo schema dell’esercizio è approssimativamente questo:

Per svolgere l’esercizio utilizzerò un database con una tabella clienti costruita nel modo seguente:

--
-- Struttura della tabella `clienti`
--

CREATE TABLE `clienti` (
  `id` int(255) NOT NULL,
  `nome` varchar(100) NOT NULL,
  `indirizzo` varchar(1024) NOT NULL,
  `telefono` varchar(100) NOT NULL,
  `agente` int(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

--
-- Dump dei dati per la tabella `clienti`
--

INSERT INTO `clienti` (`id`, `nome`, `indirizzo`, `telefono`, `agente`) VALUES
(1, 'Mario Rossi', 'Via Roma 1', '00569865', 3),
(2, 'Luigi Verdi', 'Via Milano 12', '00495233', 3),
(3, 'Gianni Bianchi', 'Via Genova 123', '00683581', 3),
(4, 'Chiara Rossi', 'Via Pescara 54', '00401299', 2),
(5, 'Luisa Neri', 'Via Ottima 77', '00279150', 3),
(6, 'Giovanni Celesti', 'Via Belli 16', '00515977', 2),
(7, 'Marco Bruni', 'Via Neri 10', '00161097', 3),
(8, 'Sergio Sereni', 'Via Savona 15', '00121871', 2),
(9, 'Paolo Lumi', 'Via Novara 19', '00554018', 3),
(10, 'Paola Neri', 'Via Padova 199', '00249472', 3),
(11, 'Pietro Chiari', 'Via Pietra 290', '00600550', 2),
(12, 'Fabio Rossi', 'Via Venezia 2', '00270185', 2),
(13, 'Giuseppe Blandi', 'Via Napoli 8', '00462208', 3),
(14, 'Aldo Valdi', 'Via Vesuvio 200', '00572389', 2),
(15, 'Piero Storni', 'Via Otranto 9', '00278110', 3),
(16, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3),
(17, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3);

--
-- Indici per le tabelle scaricate
--

--
-- Indici per le tabelle `clienti`
--
ALTER TABLE `clienti`
  ADD PRIMARY KEY (`id`);

--
-- AUTO_INCREMENT per le tabelle scaricate
--

--
-- AUTO_INCREMENT per la tabella `clienti`
--
ALTER TABLE `clienti`
  MODIFY `id` int(255) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=18;COMMIT;

-- Struttura della tabella `clienti`

CREATE TABLE `clienti` (

`id` int(255) NOT NULL,

`nome` varchar(100) NOT NULL,

`indirizzo` varchar(1024) NOT NULL,

`telefono` varchar(100) NOT NULL,

`agente` int(255) NOT NULL

) ENGINE=InnoDB DEFAULT CHARSET=latin1;

-- Dump dei dati per la tabella `clienti`

INSERT INTO `clienti` (`id`, `nome`, `indirizzo`, `telefono`, `agente`) VALUES

(1, 'Mario Rossi', 'Via Roma 1', '00569865', 3),

(2, 'Luigi Verdi', 'Via Milano 12', '00495233', 3),

(3, 'Gianni Bianchi', 'Via Genova 123', '00683581', 3),

(4, 'Chiara Rossi', 'Via Pescara 54', '00401299', 2),

(5, 'Luisa Neri', 'Via Ottima 77', '00279150', 3),

(6, 'Giovanni Celesti', 'Via Belli 16', '00515977', 2),

(7, 'Marco Bruni', 'Via Neri 10', '00161097', 3),

(8, 'Sergio Sereni', 'Via Savona 15', '00121871', 2),

(9, 'Paolo Lumi', 'Via Novara 19', '00554018', 3),

(10, 'Paola Neri', 'Via Padova 199', '00249472', 3),

(11, 'Pietro Chiari', 'Via Pietra 290', '00600550', 2),

(12, 'Fabio Rossi', 'Via Venezia 2', '00270185', 2),

(13, 'Giuseppe Blandi', 'Via Napoli 8', '00462208', 3),

(14, 'Aldo Valdi', 'Via Vesuvio 200', '00572389', 2),

(15, 'Piero Storni', 'Via Otranto 9', '00278110', 3),

(16, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3),

(17, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3);

-- Indici per le tabelle scaricate

-- Indici per le tabelle `clienti`

ALTER TABLE `clienti`

ADD PRIMARY KEY (`id`);

-- AUTO_INCREMENT per le tabelle scaricate

-- AUTO_INCREMENT per la tabella `clienti`

ALTER TABLE `clienti`

MODIFY `id` int(255) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=18;COMMIT;

In aggiunta utilizzerò una classe MySQLdb personalizzata, sviluppata nel modo seguente e messa nel file database.py:

import mysql.connector

class MySQLdb():

    def __init__(s,dbhost,dbuser,dbpass,dbname):
        s.__dbhost = dbhost
        s.__dbuser = dbuser
        s.__dbpass = dbpass
        s.__dbname = dbname
        s.__db = None

        s.connect()

    def connect(s):
        s.__db = mysql.connector.connect(
            host = s.__dbhost,
            user = s.__dbuser,
            passwd = s.__dbpass,
            database = s.__dbname
            )

    def In(s,sql,*vals):
        cursor = s.__db.cursor()
        cursor.execute(sql,vals)
        s.__db.commit()
        return cursor.lastrowid

    def Out(s,sql,*vals):
        cursor = s.__db.cursor(dictionary=True)
        cursor.execute(sql,vals)
        result = cursor.fetchall()
        return result

    def __del__(s):
        s.__db.close()

import mysql.connector

class MySQLdb():

def __init__(s,dbhost,dbuser,dbpass,dbname):

s.__dbhost = dbhost

s.__dbuser = dbuser

s.__dbpass = dbpass

s.__dbname = dbname

s.__db = None

s.connect()

def connect(s):

s.__db = mysql.connector.connect(

host = s.__dbhost,

user = s.__dbuser,

passwd = s.__dbpass,

database = s.__dbname

)

def In(s,sql,*vals):

cursor = s.__db.cursor()

cursor.execute(sql,vals)

s.__db.commit()

return cursor.lastrowid

def Out(s,sql,*vals):

cursor = s.__db.cursor(dictionary=True)

cursor.execute(sql,vals)

result = cursor.fetchall()

return result

def __del__(s):

s.__db.close()

La cartella dell’intero progetto sarà organizzata nella maniera seguente:

client.py
librerie
└── database.py
└── __init__.py
server.py

Fatte queste premesse andiamo anzitutto a creare il nostro file server.py. Nel codice ho inserito i commenti ai vari passaggi:

from librerie.database import MySQLdb
import socket

#indirizzo di connessione
HOST = '127.0.0.1'
PORT = 8100

#con questa funzione estraiamo i dati
def estrai_dati():
    #colleghiamoci al database
    mysql = MySQLdb("localhost","root","","torregatti")
    #leggiamo tutti i clienti
    clienti = mysql.Out("SELECT * FROM clienti")
    #impostiamo una variabile, che alla fine restituiremo, su vuoto
    risultato = ""
    #leggiamo tutti i clienti
    for c in clienti:
        #aggiungiamo ciascun cliente ad una stringa
        risultato += "%s\t%s\t\t%s\n" % (c["id"],c["nome"],c["telefono"])
    return risultato

#creiamo la connessione al socket
#con AF_INET usiamo il protocollo TCP/IPv4
#SOCK_STREAM tipo di socket, l'unico veramente utile con SOCK_DGRAM
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#mettiamoci in ascolto sull'indirizzo locale e la porta scelta
s.bind((HOST, PORT))
s.listen(1) # 1 = numero massimo di connessioni in coda

#avviamo il ciclo di ascolto e chiamata
print "server avviato..."
while True:

    #mettiamo in attesa di connessione
    conn, addr = s.accept()
    #per avviare la lettura ci aspettiamo il codice LEGGI7711
    #non usiamo il ciclo while visto che il codice non supera i 1024Byte
    codice = conn.recv(1024)
    #se il codice e' giusto inviamo i dati del db
    if codice == "LEGGI7711":
        print "invio dati a", addr
        conn.sendall(estrai_dati())
    conn.close()
    #in caso di codice = CHIUDI chiudiamo il server
    if codice == "CHIUDI":
        print "chiudo server..."
        break

s.close()
print "server chiuso"

from librerie.database import MySQLdb

import socket

#indirizzo di connessione

HOST = '127.0.0.1'

PORT = 8100

#con questa funzione estraiamo i dati

def estrai_dati():

#colleghiamoci al database

mysql = MySQLdb("localhost","root","","torregatti")

#leggiamo tutti i clienti

clienti = mysql.Out("SELECT * FROM clienti")

#impostiamo una variabile, che alla fine restituiremo, su vuoto

risultato = ""

#leggiamo tutti i clienti

for c in clienti:

#aggiungiamo ciascun cliente ad una stringa

risultato += "%s\t%s\t\t%s\n" % (c["id"],c["nome"],c["telefono"])

return risultato

#creiamo la connessione al socket

#con AF_INET usiamo il protocollo TCP/IPv4

#SOCK_STREAM tipo di socket, l'unico veramente utile con SOCK_DGRAM

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#mettiamoci in ascolto sull'indirizzo locale e la porta scelta

s.bind((HOST, PORT))

s.listen(1) # 1 = numero massimo di connessioni in coda

#avviamo il ciclo di ascolto e chiamata

print "server avviato..."

while True:

#mettiamo in attesa di connessione

conn, addr = s.accept()

#per avviare la lettura ci aspettiamo il codice LEGGI7711

#non usiamo il ciclo while visto che il codice non supera i 1024Byte

codice = conn.recv(1024)

#se il codice e' giusto inviamo i dati del db

if codice == "LEGGI7711":

print "invio dati a", addr

conn.sendall(estrai_dati())

conn.close()

#in caso di codice = CHIUDI chiudiamo il server

if codice == "CHIUDI":

print "chiudo server..."

break

s.close()

print "server chiuso"

Adesso è il momento del client.py.

import socket

#indirizzo di connessione, lo stesso del server
HOST = '127.0.0.1'
PORT = 8100

#dichiaro alcune variabili che potro' usare dopo
#nel menu di scelta, senza dover scrivere le opzioni da le virgolette
s = S = True
n = N = False
esci = -1
chiudi = -2

#iniziamo il ciclo di programma
while True:

    #controlliamo che non ci siano errori
    try:
        print "Leggi? (s/n/esci/chiudi): ",
        scelta = input()

        if scelta == esci: break

        if scelta:
            #colleghiamoci al socket
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((HOST,PORT))
            # INVIO IL CODICE AL SERVER
            s.sendall("LEGGI7711")
            #leggiamo qello che ci restituisce
            data = s.recv(1024)
            s.close()

            print data
        else:
            print "Lettura saltata"

        if scelta == chiudi:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((HOST,PORT))
            # INVIO IL RICHIESTA CHIUSURA SERVER
            s.sendall("CHIUDI")
            s.close()

    #in caso di lettera o carattere non codificato
    except NameError:
        print "Opzione non valida"
    #in caso di pressione di invio
    except SyntaxError:
        print "Opzione non valida"

import socket

#indirizzo di connessione, lo stesso del server

HOST = '127.0.0.1'

PORT = 8100

#dichiaro alcune variabili che potro' usare dopo

#nel menu di scelta, senza dover scrivere le opzioni da le virgolette

s = S = True

n = N = False

esci = -1

chiudi = -2

#iniziamo il ciclo di programma

while True:

#controlliamo che non ci siano errori

try:

print "Leggi? (s/n/esci/chiudi): ",

scelta = input()

if scelta == esci: break

if scelta:

#colleghiamoci al socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST,PORT))

# INVIO IL CODICE AL SERVER

s.sendall("LEGGI7711")

#leggiamo qello che ci restituisce

data = s.recv(1024)

s.close()

print data

else:

print "Lettura saltata"

if scelta == chiudi:

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST,PORT))

# INVIO IL RICHIESTA CHIUSURA SERVER

s.sendall("CHIUDI")

s.close()

#in caso di lettera o carattere non codificato

except NameError:

print "Opzione non valida"

#in caso di pressione di invio

except SyntaxError:

print "Opzione non valida"

I risultati che dovremmo vedere sono rispettivamente:

1. Per il server vedo quando è stato avviato, da dove e da quale porta

2. Sul client vedo l’elenco presente sul database.

[python] Esercizio su funzioni ricorsive e calcolo tratte dei treni

Facciamo un piccolo programma in Python che ci permetta di gestire le distanze da percorrere tra due stazioni, di partenza ed arrivo.

Abbiamo le seguenti tratte:

Stazione A	Stazione B	Distanza
Firenze	Bologna	100km
Firenze	Roma	250km
Roma	Napoli	200km
Bologna	Milano	220km
Bologna	Venezia	150km

Ogni tratta è percorribile sia in andata che in ritorno. Quello che vogliamo è che il programma ci permetta di inserire due città e calcolare la distanza minima da percorrere e le stazioni da attraversare.

Anzitutto vediamo come sono disposti i nodi dell’intero percorso:

Notiamo che in questa configurazione elementare solo Bologna ha 3 rami, mentre tutte le altre città hanno solo 2 rami ciascuna.

Potremmo affrontare l’esercizio lavorando sui nodi oppure sulle tratte. In questa soluzione lavorerò sulle tratte.

Cominciamo quindi creando anzitutto una classe che ci permetta di descrivere ogni tratta come abbiamo visto nel mandato dell’esercizio.

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

In questo modo dichiariamo 3 variabili private per registrare le due città della tratta e la rispettiva distanza.

Adesso registriamo tutte le tratte in una lista, nel modo seguente:

tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

Ora cominciamo a pensare all’algoritmo che potrebbe permetterci di calcolare il percorso.

Immaginiamo anzitutto la soluzione più semplice, dove io penso di andare da Firenze a Napoli. Su questa tratta non ci sono diramazione e sostanzialmente il percorso che dovrà venire fuori sarà Firenze – Roma – Napoli.

Fase 1:

Faccio un ciclo su ogni elemento della lista tratte[] e cerco anzitutto dove è presente la città di partenza. Siccome la città può essere sia in A che in B, per ogni oggetto Tratta dovrò implementare un metodo all’interno dell’oggetto stesso che mi permetta di valutare se la città sia presente in modo comodo. Implementiamo quindi la classe nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

Il metodo presente(citta) mi permette di valutare se la città sia presente nella tratta.

Fase 2:

Se trovo la città di partenza su una tratta allora controllo se l’altra città della tratta sia quella di arrivo. Allo stesso tempo registro la città di partenza all’interno di una lista percorso[] in modo da metterla come partenza del percorso complessivo.

Quindi se l’altra città è quella di arrivo posso chiudere il percorso, altrimenti passo il controllo sull’altra città.

def calcolatore(da,a,percorso=[]):
    # aggiungo la partenza al percorso
    percorso.append(da)
    # comincio a controllare tutte le tratte
    for t in tratte:
        # se la città di partenza è sulla tratta allora analizzo la tratta
        if t.presente(da):
            # se l'altra città è presente allora la aggiungo al percorso
            if t.presente(a):
                percorso.append(a)
            # altrimenti controllo la partenza e l'arrivo sull'altra città
            else:
                calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

Quando mi trovo nella riga 10 capisco anche che ho trovato la fine del percorso, quindi posso salvare l’intero percorso da qualche parte. Siccome potrei avere molteplici percorsi possibili decido di salvare il percorso in una lista globale chiamata percorsi = []

Modifichiamo quindi il codice nel modo seguente:

def calcolatore(da,a,percorso=[]):
    # aggiungo la partenza al percorso
    percorso.append(da)
    # comincio a controllare tutte le tratte
    for t in tratte:
        # se la città di partenza è sulla tratta allora analizzo la tratta
        if t.presente(da):
            # se l'altra città è presente allora la aggiungo al percorso
            if t.presente(a):
                percorso.append(a)
                percorsi.append(percorso)
            # altrimenti controllo la partenza e l'arrivo sull'altra città
            else:
                calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

Adesso analizziamo due aspetti dell’ultima istruzione, quella dove richiamo la funzione.

calcolatore(t.altra(da),a,[]+percorso)

1	calcolatore(t.altra(da),a,[]+percorso)

Anzitutto voglio tirare fuori dalla tratta l’altra città, rispetto alla città di partenza. Per farlo implemento la classe principale nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

In questo modo quando mi trovo per esempio sulla tratta Firenze – Roma posso passare all’oggetto tratta Firenze, che conosco essendo il punto di partenza e chiedergli di darmi l’altra città della tratta, in questo caso Roma.

Il secondo aspetto che voglio evidenziare è che passo la lista percorso[] alla funzione medesima in partenza dall’altra città, per farlo utilizzo l’istruzione []+percorso, in caso contrario percorso passerebbe per riferimento e qualora fosse passato su più rami verrebbe elaborato contemporaneamente da più rami. Io invece voglio che resti un oggetto singolo e lineare per ogni percorso.

Arrivati a questo punto del codice la situazione è la seguente:

Prendo in input partenza DA = Firenze e A = Napoli
Aggiungo DA (Firenze) al percorso[]
Passo a setaccio la lista delle tratte[]
In posizione 0 trovo la tratta Firenze – Bologna a cui DA appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Bologna e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Bologna) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 0 sulla tratta Firenze – Bologna
LOOP INFINITO!

Fase 3:

Devo evitare il loop infinito in cui il percorso possa tornare indietro. Per farlo modifico la mia funzione aggiungendo il seguente controllo all’inizio:

def calcolatore(da,a,percorso=[]):
    # interrompo la funzione qualora la destinazione sia già nel percorso
    if da not in percorso:
        # aggiungo la partenza al percorso
        percorso.append(da)
        # comincio a controllare tutte le tratte
        for t in tratte:
            # se la città di partenza è sulla tratta allora analizzo la tratta
            if t.presente(da):
                # se l'altra città è presente allora la aggiungo al percorso
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                # altrimenti controllo la partenza e l'arrivo sull'altra città
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# interrompo la funzione qualora la destinazione sia già nel percorso

if da not in percorso:

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

In questo modo controllo che il punto di partenza DA non sia già presente nel percorso[].

Adesso ricomincio a controllare il mio algoritmo da capo:

Prendo in input partenza DA = Firenze e A = Napoli
Aggiungo DA (Firenze) al percorso[]
Passo a setaccio la lista delle tratte[]
In posizione 0 trovo la tratta Firenze – Bologna a cui DA appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Bologna e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Bologna) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 0 sulla tratta Firenze – Bologna
L’altra città (Firenze) è uguale ad A? No, quindi ripasso l’altra città come nuovo DA alla funzione medesima
La funzione si interrompe, perché DA (Firenze) è già presente in percorso[]
Torno al punto 9
In posizione 3 trovo Bologna – Milano dentro tratte[] dove appartiene il mio DA
Questo pezzo di codice adesso si ripete uguale a quello tra 10 e 12 fino a chiudersi su Milano e Venezia che terminano il percorso
Trono al punto 3
In posizione 1 trovo la tratta Firenze – Roma a cui DA (Firenze) appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Roma e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Roma) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 1 sulla tratta Firenze – Roma
L’altra città (Firenze) è uguale ad A? No, quindi ripasso l’altra città come nuovo DA alla funzione medesima
La funzione si interrompe, perché DA (Firenze) è già presente in percorso[]
Torno al punto 20
Trovo che DA nella posizione 2 sulla tratta Roma – Napoli
Controllo se A (Napoli) appartiene alla tratta
Napoli appartiene alla tratta nel pezzo di codice if t.presente(a)
A questo punto aggiungo A (Napoli) alla fine di percorso[]
Aggiungo il percorso[] ai percorsi[] con l’istruzione percorsi.append(percorso)

Fase 4:

Apporto ancora un paio di correzioni tecniche alla mia funzione per evitare inutili duplicati.

def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

A questo punto posso scrivere la parte principale del mio programma con:

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

Per stampare il percorso faccio una join su ogni percorso che trovo dentro a percorsi[]

Fase 5:

Aggiungo soltanto un metodo per calcolare le distanze. Potrei farlo anche in modi più ottimizzato, ma per le finalità di questo esercizio ci accontentiamo di percorrere tutte le stazioni, esclusa l’ultima, e di calcolare la distanza tra la stazione corrente e la successiva sommandole tutte insieme.

A tale proposito aggiunto un metodo che mi permetta di valutare se 2 città appartengono entrambe alla tratta ed un getter per la distanza.

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

La funzione quindi sarà:

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

Fatto tutto questo posso completare il mio programma nella sua versione finale nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]


tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))

def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)
        print "Distanza: %.2fkm" % distanziatore(p)

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

print "Distanza: %.2fkm" % distanziatore(p)

Se volessimo complicare un po’ lo schema potremmo aggiungere altre tratte:

tratte.append(Tratta("Milano","Venezia",260))
tratte.append(Tratta("Milano","Torino",140))
tratte.append(Tratta("Bologna","Torino",340))
tratte.append(Tratta("Firenze","Livorno",90))
tratte.append(Tratta("Firenze","Pisa",90))
tratte.append(Tratta("Livorno","Pisa",30))
tratte.append(Tratta("Grosseto","Pisa",160))
tratte.append(Tratta("Roma","Grosseto",190))

tratte.append(Tratta("Milano","Venezia",260))

tratte.append(Tratta("Milano","Torino",140))

tratte.append(Tratta("Bologna","Torino",340))

tratte.append(Tratta("Firenze","Livorno",90))

tratte.append(Tratta("Firenze","Pisa",90))

tratte.append(Tratta("Livorno","Pisa",30))

tratte.append(Tratta("Grosseto","Pisa",160))

tratte.append(Tratta("Roma","Grosseto",190))

Ed ottenere una versione finale del programma in questo modo:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]


tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))
tratte.append(Tratta("Milano","Venezia",260))
tratte.append(Tratta("Milano","Torino",140))
tratte.append(Tratta("Bologna","Torino",340))
tratte.append(Tratta("Firenze","Livorno",90))
tratte.append(Tratta("Firenze","Pisa",90))
tratte.append(Tratta("Livorno","Pisa",30))
tratte.append(Tratta("Grosseto","Pisa",160))
tratte.append(Tratta("Roma","Grosseto",190))


def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)
        print "Distanza: %.2fkm" % distanziatore(p)

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

tratte.append(Tratta("Milano","Venezia",260))

tratte.append(Tratta("Milano","Torino",140))

tratte.append(Tratta("Bologna","Torino",340))

tratte.append(Tratta("Firenze","Livorno",90))

tratte.append(Tratta("Firenze","Pisa",90))

tratte.append(Tratta("Livorno","Pisa",30))

tratte.append(Tratta("Grosseto","Pisa",160))

tratte.append(Tratta("Roma","Grosseto",190))

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

print "Distanza: %.2fkm" % distanziatore(p)

Il nostro nuovo programma genererà un output come questo:

[Excel] Sommare tariffe giornaliere diverse per data usando le matrici in Excel

Per chiunque fosse interessato a lavorare sulla matrici in Excel ho pubblicato un simpatico esercizio sul sito di Mummu Academy al seguente link:

https://www.mummuacademy.it/2019/07/02/excel-sommare-tariffe-giornaliere-diverse-per-data-usando-le-matrici-in-excel/