Skillbook Logo
foto profilo

Tutte le categorie


Impariamo Python giocando al "Solitario del Ferroviere" - Lezione 3

Gino Visciano | Skill Factory - 27/12/2019 09:24:31 | in Tutorials

Nella prima lezione abbiamo descritto le regole per giocare al "Solitario del ferroviere" ed implementato la  funzionalità per scegliere la carta da pensare, nella seconda lezione abbiamo implementato la funzionalità che permette di creare il mazzo di carte e girare le carte.

In questa nuova lezione implementeremo le seguenti funzionalità:

1) mischiare le carte 

2) visualizzare l'ora ed il tempo trascorso

3)  visualizzare il numero di volte che si mischiano le carte: tentativi

Come mischiare le carte

Per mischiare le carte è necessario invertire diverse volete, in modo casuale, i valori delle carte nella lista mazzo_carte, in questo modo cambiano anche le posizioni delle immagini associate alle carte, come mostra l'esempio seguente:

L'esempio prevede 6 iterazioni (loop), con inversione casuale di due valori nella lista mazzo_carte. Questo lavoro produce  il risultato seguente:

mazzo_carte=[1,2,3,4,5,6,7,8,9,10]  => mazzo_carte=[6,4,5,2,7,1,9,10,3,8]


Associando ai valori della lista mazzo_carte le rispettive immagini si ottiene:

       6           4         5          2           7         1          9       10        3          8

La funzione Python seguente inverte 99 volte, in modo casuale, due valori della lista mazzo_carte:  
 

 

Come visualizzare l'ora e misurare il tempo in secondi 

In Python per ottenre l'ora del sistema occorre importare la classe time ed usare la funzione strftime(...), come mostra l'esempio seguente:

# Che ora è?
import time
orario=time.strftime('%H:%M:%S')
print (orario)

>>>15:10:20

Per ottenere l'ora di sistema in un frame, potete utilizzare l'esempio seguente:

# Che ora è?
import time
import tkinter as tk
orario=time.strftime('%H:%M:%S')
root = tk.Tk()
root.wm_title('Orologio')
root.resizable(False, False)
label_orologio=tk.Label(root, text=orario,font=("Helvetica", 20))
label_orologio.pack()
root.mainloop()

Per trasformare la visualizzazione dell'ora di sistema in un vero orologio, dovete aggiornare ogni secondo l'etichetta label_orologio, con l'ora corrente, utilizzando la funzione after(...) come mostra l'esempio seguente:

# Orologio
import time
import tkinter as tk

# Questa funzione aggiorna ogni secondo l'ora visualizzata nell'etichetta label_orologio, utilizzando la finzione after(ogni_milliscondi, esegui_funzione)
def aggiorna_orario():
    orario=time.strftime('%H:%M:%S')
    label_orologio.config(text=orario)
    label_orologio.pack()
    label_orologio.after(1000,aggiorna_orario)

root = tk.Tk()
root.wm_title('Orologio')
root.resizable(False, False)
label_orologio=tk.Label(root, text="",font=("Helvetica", 20))
aggiorna_orario()
root.mainloop()

Possiamo usare l'esempio dell'orologio per visualizzare anche i secondi trascorsi, utilizzando la funzione time(), che restituisce l'ora di sistema in secondi:

# Orologio con secondi
import time
import tkinter as tk

# Questa funzione aggiorna ogni secondo l'ora visualizzata nell'etichetta label_orologio ed i secondi trascorsi nell'etichetta label_secondi, utilizzando la finzione after(ogni_milliscondi, esegui_funzione)
def aggiorna_orario():
    global time_inizio
    orario=time.strftime('%H:%M:%S')
    time_fine=time.time()
    secondi=int(time_fine-time_inizio)
    label_orologio.config(text=orario)
    label_secondi.config(text=secondi)
    label_orologio.pack()
    label_secondi.pack()
    label_orologio.after(1000,aggiorna_orario)

root = tk.Tk()
root.wm_title('Orologio')
root.resizable(False, False)
label_orologio=tk.Label(root, text="",font=("Helvetica", 20))
label_secondi=tk.Label(root, text="",font=("Helvetica", 20))
time_inizio=time.time()
aggiorna_orario()
root.mainloop()

 

Come visualizzare il numero di volte che si mischiano le carte

Per visualizzare il numero di volte che si mischiano le carte, dovete usare un contatore che s'incrementa ogni volta che le carte vengono mischiate. Il contatore deve essere inserito nella funzione mischia_carte(mazzo),  come mostra l'esempio seguete:

tentativi=tentativi+1,

tentativi è una variabile globale, che s'incrementa di uno ogni volta che vengono mischiate le carte.

 Per visualizzare i tentativi sul pannello di gioco, dovete creare un'etichetta e gestirla come mostra il codice seguente:

# Dichiarazione dell'etichetta per visualizzare il titolo del contatore
label_titolo_tentativi=tk.Label(root, text="TENTATIVI",font=("times", 12,"italic"),fg="black")

# Dichiarazione dell'etichetta per visualizzare il valore del contatore
label_tentativi=tk.Label(root, font=('arial', 14, 'normal'), bg='orange',fg='white')

# Formattazione della stringa da associare all'etichetta che visualizza i tentativi
spazi="          "[:(10-len(str(tentativi)))] # Imposta il numero di spazi da aggiungere a sinistra del valore del contatore, per ottenere sempre una stringa di 10 caratteri
# Assegna la stringa di 10 caratteri all'etichetta per vusializzare i tentativi
label_tentativi.config(text=spazi+str(tentativi)+" ")

 

# Posiziana e visualizza le etichette sul pannello di gioco
label_titolo_tentativi.place(x=153,y=455)
label_tentativi.place(x=160,y=515)

Per vedere dove deve essere posizionato il codice Python descritto in questa sezione, consultate la sezione Analisi del codice Python

L'immagine seguente mostra come si presenta il pannello di gioco, dopo il posizionamento di tutte le etichette create.

  

 

Analisi del codice Python

# Solitario del ferroviere (Lezione 3)
import pygame                                  # Importa classe pygame per gestire i suoni
import tkinter as tk                           
# Importa classe tkinter con alias tk per gestire il pannello di gioco
import time                                        # Importa classe time per gestire l'orologio di sistema 
import random                                  # Importa classe random che permette di ottenere gli indici casuali usati per mischiare le carte
from PIL import Image, ImageTk    # Dalla libreira Pillow importa le classi Image e ImageTk per gestire le immagini del gioco 

mazzo_carte=[1,2,3,4,5,6,7,8,9,10] # Lista con i valori delle carte 
immagini_carte=[]                             
# Lista che contiene le immagini delle carte
indice_carta_girata=0
time1=''                                               
# Questa variabile viene usata per il calcolo dei secondi trascorsi
time_start=''                                       # Questa variabile viene usata per il calcolo dei secondi trascorsi
tentativi=0                                          # Questa variabile viene usata per contare quante volte vengono mischiate le carte 

# Questa funzione viene eseguita ogni 200 millisecondi ed aggiorna il contenuto di tutte le etichette del pannello di gioco
def tick():
    global time1
    global time_start
    global tentativi
    # legge ora locale del pc
    time2 = time.strftime('%H:%M:%S')
    if time2 != time1:
       time1 = time2
       
# Etichetta con orologio in alto a destra del pannello di gioco
       label_clock.config(text=time2)
       secondi=int(time.time()-time_start)
       spazi="          "[:(10-len(str(secondi)))]
       str_secondi=spazi+str(secondi)+" "
       label_secondi.config(text=str_secondi)
       spazi="          "[:(10-len(str(tentativi)))]
       label_tentativi.config(text=spazi+str(tentativi)+" ")

    # La funzione after avvia la funzione tick ogni 200 millisecondi
    label_clock.after(200, tick)


# Questa funzione permette di mischiare le carte, l'argomento mazzo, è un riferimento, contiene l'indirizzo (posizione in memoria) della lista mazzo_carte 

def mischia_carte(mazzo):
    global tentativi
    tentativi=tentativi+1 
# Questa variabile viene ha il ruolo di contatore, conta quante volte le carte vengono mischiate
    temp=0
    max=len(mazzo)-1    
# Questa variabile indica l'indice massimo che punta all'ultimo valore contenuto nella liata mazzo_carte
    for i in range(1,100):
        prima=random.randint(0,max)       
# Questa variabile indica il primo indice casuale che punta al valore da invertire per mischiare le carte
        seconda=random.randint(0,max)  # Questa variabile indica il secondo indice casuale che punta al valore da invertire per mischiare le carte
        if prima!=seconda:
            
# SWAP, inverte la posizione dei valori nella lista mazzo_carte
            temp=mazzo[prima]
            mazzo[prima]=mazzo[seconda]
            mazzo[seconda]=temp

# Questa funzione permette di scegliere il suona da emettere (sound) e la durata (tempo) 
def suono(sound,tempo):
    if sound==1:
       pygame.mixer_music.load("TickSound.mp3")
    elif sound==2:
       pygame.mixer_music.load("ElectronicSound.wav")
    else:
       pygame.mixer_music.load("ComputerSound.wav")
    pygame.mixer_music.play()   
# Emette il suono richiesto
    time.sleep(tempo)                   # Pausa
    
# Questa funzione carica nella lista immagini_carte le immagini delle carte 
def carica_immagini_carte():
    immagini_carte=[]
    immagini_carte.append(ImageTk.PhotoImage(Image.open('Carte_Napoletane_retro.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('1coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('2coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('3coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('4coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('5coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('6coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('7coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('8coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('9coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('10coppe.png')))
    return immagini_carte

# Questa funzione permette di girare le carte
def gira():
    global indice_carta_girata
    global mazzo_carte
    global flag
    label_carta_girata.config(image=immagini_carte[mazzo_carte[indice_carta_girata]])
    label_carta_girata.place(x=240,y=40)
    girate="   "+str(indice_carta_girata+1)+"/10 "
    label_girate.config(text=girate)
    label_girate.place(x=285,y=370)
    if indice_carta_girata<9:
       indice_carta_girata=indice_carta_girata+1
       suono(1,0.1)
    else:
       pulsante_gira.place_forget()
       label_girate.place_forget()
       indice_carta_girata=0
       label_mazzo_di_carte.place_forget()
       pulsante_nuova_partita.place(x=270,y=370)
       suono(2,0.1)


    
# Questa funzione si attiva quando si clicca sul pulsante_nuova_partita, permette di mischiare le carte e riprendere il gioco
def nuova_partita():
   global indice_carta_girata
   label_carta_girata.place_forget()
   pulsante_nuova_partita.place_forget()
   suono(3,2.5)
   label_girate.config(text="   0/10  ")
   start()

# Questa funzione permette di inizializzare il pannello di gioco
def start():
    global indice_carta_girata
    global mazzo_carte
    global time_start
    time_start = time.time()  
# Legge l'ora di sistema espressa in secondi
    label_clock.place(x=360,y=5)
    label_titolo_mazzo_di_carte.place(x=45,y=5)
    label_mazzo_di_carte.place(x=25,y=40)
    pulsante_gira.place(x=70,y=370)
    label_girate.place(x=285,y=370)
    label_titolo_tempo.place(x=35,y=455)
    label_secondi.place(x=30,y=515)
    label_tentativi.place(x=160,y=515)
    label_titolo_tentativi.place(x=153,y=455)
    label_secondi.place(x=30,y=480)
    label_tentativi.place(x=160,y=480)
    tick()    
# Esegue la funzione tick() che aggiorna il contenuto di tutte le etichette del pannello di gioco
    pygame.init() # Inizializza le funzionalità pygame per la gestione dei suoni
    indice_carta_girata=0
    mischia_carte(mazzo_carte)  # Mischia i valori della lista mazzo_carte

# Inizializzazione ed impostazione caratteristiche pannello di gioco
root = tk.Tk()
root.wm_title('Solitario del ferroviere')
root.geometry("460x520")
root.resizable(False, False)
label_titolo_mazzo_di_carte=tk.Label(root, text="MAZZO DI CARTE",font=("Helvetica", 14))
pulsante_gira=tk.Button(root,text="GIRA", width=10, height=2, bd = 3,command=gira, bg="green",font=("Helvetica", 12))
pulsante_nuova_partita=tk.Button(root,text="NUOVA PARTITA", width=15, height=2, bd = 3,command=nuova_partita, bg="orange",font=("Helvetica", 12))
label_girate=tk.Label(root, text="   0/10  ",font=("Helvetica", 25),fg="white",bg="orange")
label_clock = tk.Label(root, font=('arial', 14, 'italic'), bg='gray',fg='black')
label_titolo_tempo=tk.Label(root, text="TEMPO",font=("times", 12,"italic"),fg="black")
label_titolo_tentativi=tk.Label(root, text="TENTATIVI",font=("times", 12,"italic"),fg="black")
label_secondi=tk.Label(root, font=('arial', 14, 'normal'), bg='blue',fg='white')
label_tentativi=tk.Label(root, font=('arial', 14, 'normal'), bg='orange',fg='white')
immagini_carte=carica_immagini_carte()
label_mazzo_di_carte=tk.Label(root, image=immagini_carte[0])
label_carta_girata=tk.Label(root, image=immagini_carte[0])
start() # Inizializza 
il pannello di gioco
root.mainloop()

 

Nella prossima lezione implementeremo la funzionalità  per controllare se la carta pensata e uguale alla carta girata dal mazzo, in questo modo già potrete iniziare a giocare.

Arrivederci ...


<< Lezione precedente           Lezione successiva >>



 Per scaricare le risorse di questa lezione clicca sul link seguente:risorse_lezione_03

 



 

Share Button

Impariamo Python giocando al "Solitario del Ferroviere" - Lezione 2

Gino Visciano | Skill Factory - 21/12/2019 10:02:13 | in Tutorials

Come creare il mazzo di carte

Nella lezione precedente abbiamo descritto le regole del gioco per giocare al "Solitario del ferroviere" ed implementato la  funzionalità per scegliere la carta da pensare.

In questa seconda lezione implementeremo la funzionalità che permette di girare le carte del mazzo.

 

Per iniziare serve il  mazzo di carte, per crearlo abbiamo usato la lista mazzo_carte a cui sono stati aggiunti i valori delle 10 carte da gioco, come mostra il comando seguente:

mazzo_carte=[1,2,3,4,5,6,7,8,9,10]

Successivamente, per associare i valori delle carte alle ripsettive immagini, abbiamo usato come indice della lista immagini_carte, i valori della lista mazzo_carte, come mostra il comando seguente:

immagini_carte[mazzo_carte[indice_carta_girata]]

La variabile indice_carta_girata è l'indice che ci permette di scegliere uno dei 10 valori presenti nella lista mazzo_carte a cui viene associata l'immagine della carta da visualizzare.   

Ad esempio, se indice_carta_girata è uguale a 4, il valore corrispondente alla carta da visualizzare  è 5, come mostra l'esempio seguente:

mazzo_carte=[1,2,3,4,5,6,7,8,9,10] 

Utilizzando il valore ottenuto come indice della lista immagini_carte, che contiene le immagini delle carte da gioco, si ottine la carta da gioco corrispondente:

 

Come abbiamo già visto nella lezione precedente, le immagini nella lista immagini_carte vengono caricate con la funzione carica_immagini_carte(), nell'ordine seguente:
 

Per visualizzare le carte da gioco sul pannello di gioco, abbiamo usato le etichette seguenti:

label_mazzo_di_carte=tk.Label(root, image=immagini_carte[0])
label_carta_girata=tk.Label(root, image=immagini_carte[0])

Per cambiare l'immagine associata all'etichetta label_carta_girata, abbiamo usato la funzione config(...), come mostra il comando seguente :

label_carta_girata.config(image=immagini_carte[mazzo_carte[indice_carta_girata]])

 

Come girare le carte mazzo

Per girare le carte del mazzo, è sufficiente incrementare ogni volta di uno la variabile indice_carta_girata, naturalmente la variabile deve essere azzerata ogni volta che il suo valore va oltre il limite massimo consentito, per evitare che venga generato l'errore:

IndexError: list index out of range  

Per gestire questa funzionalità abbiamo creato il  pulsante gira associato alla funzione gira(), come mostra il comando seguente:

pulsante_gira=tk.Button(root,text="GIRA", width=10, height=2, bd = 3,command=gira, bg="green",font=("Helvetica", 12))

Ogni volta che si clicca sul pulsante gira, la funzione gira() incrementa di 1 la variabile indice_carta_girata, in questo modo, di volta in volta, vengono visualizzate tutte le carte del mazzo, come mostra l'immagine seguente:
 

 

Quando la variabile indice_carta_girata diventa uguale a 8,  la funzione gira(), gestisce le seguenti attività:

1) visualizza il dieci di coppe

2) elimina dal pannello di gioco, l'ultima carta del mazzo 

3) elimina dal pannello di gioco il pulsante gira

4) permette  di iniziare una nuova partitta, visualizzando il pulsante nuova partita.

L'immagine seguente mostra il pannello di gioco quando la variabile indice_carta_girata diventa uguale ad 8.

 Cliccando sul pulsante nuova partita, viene eseguita la funzione nuova_partita(), che svolge le attività necessarie per riprendere il gioco.
 

Analisi del codice Python

# Solitario del ferroviere (Lezione 2)
import pygame 
# Importo la libreria pygame per gestire i suoni
import tkinter as tk  # Importo la libreria tkinter con alias (abbreviazione) tk, per gestire il pannello su cui giocare
import time #Importo la libreria time per gestire il tempo attraverso l'orologio di sistema
from PIL import Image, ImageTk # Importo da PIL le librerie per gestire le immagini 
from tkinter import messagebox 
 Importo da tkinter la libreria per gestire una finestra modale per gestire la fine del programma (game over)

 # Lista per gestire il mazzo di carte
mazzo_carte=[1,2,3,4,5,6,7,8,9,10]
# Lista in cui caricare i riferimenti alle immagini delle carte
immagini_carte=[]
# Indice che punta al valore della carta girata
indice_carta_girata=0

# Questa funzione gestisce i suoni, sound permette di scegliere il suono, tempo indica pa pausa richiesta dopo il suono  
def suono(sound,tempo):
    if sound==1:
       pygame.mixer_music.load("TickSound.mp3")
    elif sound==2:
       pygame.mixer_music.load("ElectronicSound.wav")
    else:
       pygame.mixer_music.load("ComputerSound.wav")
    pygame.mixer_music.play()
    time.sleep(tempo)    
    

# Questa funzione permette di aggiungere le immagini del gioco nella lista immagini_carte 
def carica_immagini_carte():
    immagini_carte=[]
    immagini_carte.append(ImageTk.PhotoImage(Image.open('Carte_Napoletane_retro.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('1coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('2coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('3coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('4coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('5coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('6coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('7coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('8coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('9coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('10coppe.png')))
    return immagini_carte

# Questa funzione permette di girare le carte del mazzo  
def gira():
    global indice_carta_girata
    global mazzo_carte
    global flag
   
# Visualizza la carta girata
     label_carta_girata.config(image=immagini_carte[mazzo_carte[indice_carta_girata]])
    label_carta_girata.place(x=240,y=40)
    girate="   "+str(indice_carta_girata+1)+"/10 "
    label_girate.config(text=girate)
    label_girate.place(x=285,y=370)
    if indice_carta_girata<9:
       indice_carta_girata=indice_carta_girata+1
       suono(1,0.1)
    else:

       # Questo blocco gestisce le attività richieste quando finiscono le carte del mazzo
       pulsante_gira.place_forget()
       label_girate.place_forget()
       indice_carta_girata=0
       label_mazzo_di_carte.place_forget()
       pulsante_nuova_partita.place(x=270,y=370)
       suono(2,0.1)
    

# Questa funzione avvia una nuova partita
def nuova_partita():
   global indice_carta_girata
   label_carta_girata.place_forget()
   pulsante_nuova_partita.place_forget()
   suono(3,2.5)
   label_girate.config(text="   0/10  ")
   start()

# Questa funzione inizializza il pannello di gioco
def start():
    global indice_carta_girata
    label_titolo_mazzo_di_carte.place(x=45,y=5)
    label_mazzo_di_carte.place(x=25,y=40)
    pulsante_gira.place(x=70,y=370)
    label_girate.place(x=285,y=370)
    pygame.init()
    indice_carta_girata=0

# Preparazione dei componenti del pannello di gioco
root = tk.Tk()
root.wm_title('Solitario del ferroviere')
root.geometry("460x450")
root.resizable(False, False)
label_titolo_mazzo_di_carte=tk.Label(root, text="MAZZO DI CARTE",font=("Helvetica", 14))
pulsante_gira=tk.Button(root,text="GIRA", width=10, height=2, bd = 3,command=gira, bg="green",font=("Helvetica", 12))
pulsante_nuova_partita=tk.Button(root,text="NUOVA PARTITA", width=15, height=2, bd = 3,command=nuova_partita, bg="orange",font=("Helvetica", 12))
label_girate=tk.Label(root, text="   0/10  ",font=("Helvetica", 25),fg="white",bg="orange")
immagini_carte=carica_immagini_carte()
label_mazzo_di_carte=tk.Label(root, image=immagini_carte[0])
label_carta_girata=tk.Label(root, image=immagini_carte[0])
start()
root.mainloop()

 

Nella prossima lezione implementeremo la funzione per mischiare le carte del mazzo centrale.

Arrivederci ...


<< Lezione precedente           Lezione successiva >>



 Per scaricare le risorse di questa lezione clicca sul link seguente:risorse_lezione_02

 



 

Share Button

Impariamo a programmare in Python, giocando al "Solitario del Ferroviere" - Lezione 1

Gino Visciano | Skill Factory - 18/12/2019 20:28:16 | in Tutorials

Regole del gioco

Il Solitario del Ferroviere è un passatempo che si può giocare con le carte napoletane, le regole del gioco sono le seguenti:

1) Mischiare le carte e metterle al centro; 

2) Pensare ad una carta del mazzo;

3) Alzare una carta dal mazzo;

4) Se la carta alzata è uguale a quella pensata, mettere la carta a sinistra, altrimenti metterla a destra;

5) Continuare a giocare mentre ci sono carte nel mazzo centrale;

6) Quando le carte del mazzo centrale finiscono, mentre ci sono carte a destra (carte non indovinate), mischiare le carte, metterle al centro e ricominciare a giocare.


Per semplificare la realizzazione del gioco con Python, utilizzeremo solo 10 carte napoletane , come mostra l'immagine seguente:
 



Il Diagramma di Flusso segunte descrive l'Algoritmo per giocare al Solitario del Ferroviere:
 

La pseudo-codifica  seguente descrive meglio le strutture logiche dell'Algoritmo per giocare al Solitario del Ferroviere, soprattutto perché permette di riconoscere i cicli che spesso nei Diagrammi di Flusso vengono confusi con le selezioni

#Algoritmo in pseudo-codifica, per giocare al solitario del ferroviere

Inizio
    Inizio Mentre
         Mischia le carte e mettile al centro
         Inizio Mentre
              Pensa ad una carta
              Alza una carta
              Se carta pensata==carta alzata allora
                   Metti la carta a sinistra
              Altrimenti
                   Metti la carta a destra
              Fine Se
         Mentre carte al centro !=0
    Mentre carte a destra !=0
Fine


In questa prima lezione implementeremo la funzione Python che permette di scegliere la carta pensata, come mostra l'immagine seguente:



 

Cosa serve per iniziare

Per iniziare dovete installare Python (almeno la versione 3.8), per scrivere il codice,  vi suggerisco di usare come ide (integrated development environment ) Visual Studio Code.

Usando la guida seguente potete installare sia Python che Visual Studio Code: guida_installazione.

Inoltre dovete installare  le seguenti librerie Python:

- pygame

- pillow

- time
 

con i comandi seguenti:

pip install pygame

pip install Pillow

pip install time

Se il comando pip non è installato, procedete nel modo seguente:

1) Scaricate il file get-pip.py;

2) Eseguite il comando: python get-pip.py.

 

Cosa dovete sapere

In Python non esistono comandi per dichiarare i tipi di variabili, le  variabili vengono tipizzate quando si assegna il primo valore, come mostra l'esempio seguente:

a=10 # Variabile intera
b=2.5 # Variabile Decimale
nome='Mario' # Variabile Stringa
flag=True # Variabile Booleana 

Le liste sono insiemi dinamici di valori, per dichiarare una lista si usa la sintassi seguente:

valori=[10,20,30] # Lista di valori di tipo intero 
nominativi=['Mario','Clara','Paolo','Roberta'] # Lista di valori di tipo Stringa
elenco=[] 
# Lista di valori vuota non ancora tipizzata

Per aggiungere un elemento ad una lista si usa il metodo append, come mostra l'esempio seguente:

elencoValori=[] # Lista di valori vuota non ancora tipizzata
# Aggiungo tre valori alla lista
elencoValori.append(10)
elencoValori.append(20)
elencoValori.append(30)
# Ciclo usato per visualizzare il contenuto della lista, i assume ad ogni ripetizione i valori seguenti: 0,1 e 2
for i in range(0,3):
      print(elencoValori[i]) 

L'esempio seguente, si differenzia da quello precedente, perchè per visualizzare il contenuto della lista usa un foreach.
Questa struttura di programmazione permette di leggere il contenuto di una lista senza usare l'indice dell'elemento da visualizzare, perché automaticamente ad ogni iterazione (loop) legge il valore seguente e lo assegna alla variabile del ciclo. 

elencoValori=[] # Lista di valori vuota non ancora tipizzata
# Aggiungo tre valori alla lista
elencoValori.append(10)
elencoValori.append(20)
elencoValori.append(30)
# Ciclo foreach, ad ogni ripetizione ad a viene assegnato un valore della lista elencoValori
for a in elencoValori:
      print(a) 

 
In Python l'indent assume un ruolo molto importante, perché si usa per indicare il bloccho d’istruzioni all'interno di una struttura di programmazione o di una funzione, come mostra l’esempio:
 
 
 
 

Analisi del codice Python

Per implemetare la specifica funzionale richiesta in questa prima lezione, dovete prima di tutto caricare le librerie per gestire i suoni, le immagini, il tempo ed il pannello (frame) su cui poggiare le carte da gioco. Successivamente bisogna creare (istanziare) il pannello da gioco, con il comando root = tk.Tk() e tutti i componenti che servono, principalmente le etichette ed il pulsante cambia.
 
La funzione carica_immagini_carte(), crea la lista che contiene le immagini delle carte, mentre la funzione cambia(), associata al pulsante cambia, permette di visialuzzare ad ogni click un carta diversa della lista immagini_carte.
 
Infine la funzione start() serve per visualizzare e posizionare tutti i componeti del pannello di gioco.
 
Studiate il codice seguente, con attenzione, anche facendo uso dei commenti e successivamente scaricate le risorse allegate alla lezione per ottenere tutto quello che vi serve per provare la prima funzionalità che serve per creare il "Solitario del ferroviere".
 
   
# Solitario del ferroviere (Lezione 1)
import pygame # Importo la libreria pygame per gestire i suoni
import tkinter as tk  
# Importo la libreria tkinter con alias (abbreviazione) tk, per gestire il pannello su cui giocare
from PIL import Image, ImageTk # Importo da PIL le librerie per gestire le immagini
from tkinter import messagebox # Importo da tkinter la libreria per gestire una finestra modale per gestire la fine del programma (game over)
import time #Importo la libreria time per gestire il tempo attraverso l'orologio di sistema
indice_carta_pensata=0
flag=True

 
# Questa funzione permette di aggiungere le immagini del gioco nella lista immagini_carte    
def carica_immagini_carte():
    immagini_carte=[]
    immagini_carte.append(ImageTk.PhotoImage(Image.open('Carte_Napoletane_retro.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('1coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('2coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('3coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('4coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('5coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('6coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('7coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('8coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('9coppe.png')))
    immagini_carte.append(ImageTk.PhotoImage(Image.open('10coppe.png')))
    return immagini_carte
 

 

# Questa funzione incrementa la variabile indice_carta_pensata, per cambiare la carta visualizzata, viene eseguite ogni volta che si esegue un click sul pulsante cambia
def cambia():
   
# indica che la variabile indice_carta_pensata è una variabile globale, creata all'esterno della funzione 
    global indice_carta_pensata
    # Imposta l'immagine della carta corrente 

    label_carta_pensata.config(image=immagini_carte[indice_carta_pensata])
    # Visualizza la carta corrente alla posizione indicata 

    label_carta_pensata.place(x=5,y=40)
    if indice_carta_pensata<10:
       indice_carta_pensata=indice_carta_pensata+1
    else:
       indice_carta_pensata=1
    # Emette un suono ed imposta una pausa 0.1 secondi
    pygame.mixer_music.load("TickSound.mp3")
    pygame.mixer_music.play()
    time.sleep(0.1)    

# Questa funzione inizializza il pannello di gioco
def start():
    global indice_carta_pensata
    # Visualizza il pulsante cambia, che ad ogni click esegue la funzione cambia() 

    pulsante_cambia.place(x=60,y=370)
    label_titolo_carta_pensata.place(x=25,y=5)
    label_carta_pensata.place(x=5,y=40)
    # Inizializza la gestione dei suoni
    pygame.init()
    indice_carta_pensata=2

# Crea il pannello di gioco
root = tk.Tk()
root.wm_title('Solitario del ferroviere') # Imposta il titolo del 
 pannello di gioco 
root.geometry("215x450") # Imposta le dimensioni del 
 pannello di gioco 
root.resizable(False, False) # Disabilità il ridimensionamento del 
 pannello di gioco

# Preparazione pulsanti ed etichette, l'attributo commad permette di indicare la funzione eseguita quando si clicca sul pulsante
pulsante_cambia=tk.Button(root,text="CAMBIA", width=10, height=2, bd = 3,command=cambia, bg="green",font=("Helvetica", 12))
label_titolo_carta_pensata=tk.Label(root, text="CARTA PENSATA",font=("Helvetica", 14))

# Prepara il vettore con i riferimenti alle immagini delle carte
immagini_carte=carica_immagini_carte()

# Carica nell'etichetta la prima carta del mazzo
label_carta_pensata=tk.Label(root, image=immagini_carte[1])

# Inizializza l'applicazione e visualizza l'etichetta ed il bottone cambia
start()
root.mainloop() # Rende il pannello di gioco interattivo

 

Nella prossima lezione implementeremo la funzione per girare le carte del mazzo centrale.

Arrivederci ...

 


Lezione successiva >>



 Per scaricare le risorse di questa lezione clicca sul link seguente: risorse_lezione_01

 



 

Share Button

la formazione di qualità

Concettina Ricca | MOBILITY HIRPINIA LABOR - 23/07/2019 11:08:06 | in Home

La regione campania deve avere il coraggio di investire in maniera seria sulla formazione di qualità, preoccupandosi di dare al settore una svolta qualitativamente importante affinchè si possa effettivamente incrociare le esigenze del mondo del lavoro.Una formazione di qualità presuppone fare degli investimenti in uomini e professionalità, occorre che gli enti di formazione siano messi in condizione di garantire anche sotto il profilo delle competenze il massimo possibile nel contrattualizzare figure professionali di qualità da utilizare in ambito didattico.

Il settore ha bisogno di rivivere una nuova stagione per fare questo occorrono investimenti anche materiali che riguardano sia le strutture che le attrezzature, occorre che la regione consideri gli enti di formazione delle vere e proprie aziende identificandole come PMI alle quali consentire di partecipare anche ai bandi regionali per trovare forme di finanziamento necessari ad ammodernizzare il settore.

Share Button

Agic Technology, Gold Partner Microsoft, assume a Napoli laureati e diplomati per svolgere il ruolo di Microsoft Dynamics CRM Junior Developer

Gino Visciano | Skill Factory - 12/04/2019 10:12:46 | in Formazione e lavoro

Agic Technology per consolidare il gruppo di lavoro per la sede di Napoli, assume giovani laureati e diplomati per svolgere il ruolo di Microsoft Dynamics CRM Junior Developer.

Si tratta sicuramente di un'offerta di formazione e lavoro molto interessante perché, le risorse selezionate, oltre ad apprendere le conoscenze tecniche  per lo sviluppo e la manutenzione di applicazioni Microsoft Dynamics CRM,  acquisiranno anche le competenze di programmazione per lavorare con ASP.NET Core, il nuovo framework MIcrosoft, completamente Open Source, che permette di creare applicazioni C# trasportabili su qualunque sistema operativo.

Per le 12 risorse selezionate la formazione sarà gratuita, avrà una durata di 40 giorni e si svolgerà nelle aule della nostra sede di Napoli, presso il Centro Polifunzionale INAIL di via Nuova Poggioreale. 

Se siete interessati a questa attività di  formazione e lavoro clccate sul link seguente: come partecipare alle selezioni per svolgere il ruolo di Microsoft Dynamics CRM Junior Developer (Napoli)


Per ulteriori informazioni di seguito pubblichiamo l'intervista fatta alla Dott.ssa Laura Petrini, responsabile Risorse Umane (HR) della società Agic Technology

SF - Può descriverci brevemente la sua azienda?
LP - Agic Technology è uno dei principali partner di Microsoft in Italia, conosciuto per innovazione, competenze e servizi a valore aggiunto. Agic Technology implementa soluzioni e progetti al servizio delle Organizzazioni e degli Utenti Aziendali basati sulle tecnologie Microsoft. Business Applications (ERP e CRM), Data Analytics, Artificial Intelligence, Cloud Platform, IOT, Mobile, Machine Learning, Web, App, Portal & Collaboration sono soltanto alcune delle piattaforme sulle quali basiamo le nostre soluzioni. Professionisti esperti di Governance, Risk e Compliance intervengono a fianco degli specialisti di tecnologie per accompagnare il rilascio delle soluzioni nel rispetto della sicurezza e del nuovo GDPR.

Cinque sedi in Italia e un HUB di sviluppo a Tirana consentono una capacità di consulenza, supporto e sviluppo di progetti locali e internazionali, rilasciando soluzioni specializzate per i principali settori industriali e di servizi, quali: Finance, PA, Associazioni ed Enti, Professional Services, Manufacturing, Engineering & Construction, Telco, Media & Gaming, Pharma.

Con un parco clienti di oltre 400 aziende e un team di più di 200 professionisti, Agic Technology si propone come partner tecnologico specializzato sulle piattaforme Microsoft per le medie e grandi imprese.

SF -  A breve quali sono i vostri obiettivi di crescita?

LP - Il nostro obiettivo è di crescere ulteriormente e di guardare sempre all’innovazione grazie alla nostra Partnership con Microsoft!

SF -  Quante risorse intendete assumere a Napoli?

LP - Stiamo puntando sulla sede di Napoli, saranno almeno 20 gli ingressi programmati per il 2019.

SF - Che ruolo dovranno svolgere le risorse che state cercando?

LP - Conoscere tecnicamente e/o funzionalmente la tecnologia Microsoft Dynamics 365.

SF -  Quali sono le caratteristiche peculiari dei vostri dipendenti?

LP - Aperti al cambiamento, devono codividere la propria esperienza con gli altri colleghi del team,  essere concreti e sempre focalizzati sugli obiettivi da raggiungere.

SF -  Qual è il candidato ideale per la vostra offerta di lavoro?

LP - Motivato ed appassionato, con voglia di intraprendere un percorso di crescita sfidante, predisposto all’innovazione!

SF -  Per formare i candidati che non sono in possesso di tutte le competenze richieste, avete previsto un percorso di formazione?

LP - Certo! Il nostro intento è di formare le risorse con un academy di 8 settimane (5 devolute alla spiegazione del framework .net e 3 per la spiegazione del Dynamics 365).

SF -  Dopo aver terminato il percorso di formazione, quali sono le modalità d'inserimento  in azienda?

LP - Il nostro intento è di formare le risorse e arricchire il percorso con la formazione on the job.

SF -  Coloro che sono interessati alla vostra offerta di lavoro, dove devono inviare il proprio cv?

LP - Possono inviarlo anche sul nostro sito: lavora con noi.

SF -  Qual è il termine ultimo per inviare la propria candidatura e partecipare ai test di ammissione?

LP - Entro il 15 maggio.

SF -  Grazie per il tempo concesso alla nostra intervista e per l'opportunità di formazione e lavoro offerta.

Share Button
TOP