Oggi ho avuto la necessità di utilizzare questo comando perchè avevo rilasciato una modifica che non dovevo far vedere su GitHub. L’esigenza era anche quella di eliminare della history il rilascio (era un dato sensibile che per errore era rimasto su un file di configurazione). Le operazioni sono abbastanza semplici ed ho usato GitHub Desktop per verificare quello che stavo facendo (ovviamente avrei potuto usare semplicemente la shell di Git).

Nel percorso in locale del nostro repository su cui abbiamo sincronizzato il repository su GitHub ho aperto la GitBash ed eseguito questo comando:

git reset –soft HEAD~2

in 2 finale è relativo a quanto commit indietro volete andare, nel mio caso dovevo eliminarne due.

A questo punto però se andate su GitHub Desktop e provate a fare un push sul vostro repository in remote, lo strumento vi dice che il vostro branch è avanti di due commit rispetto al remote e dovete fare prima un pull per poi effettuare un push.

Ovviamente non è questo quello che desideriamo perchè altrimenti non risolviamo il problema del commit nella history ed anzi ne aggiungeremmo un altro alla storia. Per questo motivo e per forzare il push dobbiamo eseguire il seguente comando:

git push origin +main –force

A questo punto possiamo eseguire il commit delle modifiche realmente desiderate, come nel mio caso.

Segnalo questo link che secondo me è un ottimo punto di partenza per approfondire il linguaggio, infatti, oltre ad essere presenti le sezioni dedicate alle caratteristiche di base, ci sono degli interessanti rimandi alle funzionalità più avanzate. 

Proseguendo nelle intenzioni dichiarate nel precedente post , oggi mi voglio dedicare ad una delle funzionalità più utilizzate in Python: le list comprehension.

Queste funzionalità in verità sono applicabili non sono alle liste, come vedremo, ma anche agli oggetti di tipo dictionary e rappresentano un modo per scrivere meno codice, comunque efficiente e leggibile.

Quello che otterremo al termine dell’esecuzione del comando per la generazione di liste(o dictionary) saranno liste contenenti dati che avremo opportunamente lavorati secondo degli specifici criteri, scrivendo una sola riga di codice.

Come sempre un esempio è meglio di tante parole.

Immaginiamo di avere una lista di parole che compongono una frase e da essa dobbiamo estrapolare una nuova lista restituendoci solo le parole la cui lunghezza è minore di 8 caratteri.

Utilizzando un approccio classico avremmo creato un ciclo che itera sulla lista tante volte quante sono le parole che la compongono ed, applicando il controllo richiesto, avrebbe alimentato, in caso positivo, una lista esterna con i risultati ottenuti.

phrase = "Oggi pomeriggio studieremo Python"
word_list = phrase.split()
result = []
for i in range(len(word_list)):
  if len(word_list[i]) > 8:
    result.append(word_list[i])
print (result)

Vediamo invece come, con una list comprehension, è possibile scrivere la stessa cosa con una sola riga:

phrase = "Oggi pomeriggio studieremo Python"
word_list = phrase.split()
result_with_list= [item for item in word_list if len(item) > 8]
print(result_with_list)

L’uso di questa funzionalità ovviamente si presta ad operazioni a volte più complesse,  ne sono esempio infatti i casi in cui, lavorando con le frasi e con le tematiche inerenti, potrebbe servire avere a disposizione un modo altrettanto rapida per rendere flat una lista di liste (caso per esempio di un topic contenente più frasi).

Con il classico metodo, che non riporterò per brevità, avrei dovuto fare due iterazioni una interna all’altra, con le list comprehension invece il lavoro diventa molto più semplice e leggibile:

phrases = ["Oggi studio Python", "Domani studierò Java", "Non studierò mai il cirillico"]

flatten_list = [word
                  for phrase in phrases
                  for word in phrase.split()
]
print (flatten_list)

Come vediamo il meccanismo è molto potente ma nello stesso tempo abbastanza semplice da capire, quanto detto per le liste è ovviamente valido per i dictionary, magari argomento di un altro post.

Stay tuned.

Per motivi lavorativi sono tornato a sviluppare alcune cose in Python e, per motivi didattici ma anche per la memoria che ormai fa cilecca sempre più spesso, 

voglio scrivere dei piccoli post per le cose che ritengo man mano utili, con la speranza che magari ad alcuni possano tornare utili.

Per i miei studi, uso l’ottimo Ide Pycharm in versione community edition, oppure l’altrettanto ottimo Visual Studio Code.

Il primissimo snippet di codice che ritengo utile, è qualcosa che serve quando non si sanno a priori il numero di parametri da passare ad una funzione.

# funzione somma elementi 
def sum_item(*args,**kwargs): 
  print(args,kwargs) 
  totale = sum(args) 
  print(totale) 
  totale_kwargs = sum(kwargs.values()) 
  print(totale_kwargs)  
# richiamo la funzione 
sum_item(2,4,6, a=3,b=4)

L’esempio è molto semplice ma ci aiuta a capire come l’uso dei due parametri “*args” e “**kwargs” che hanno “*” e “**” rispettivamente che indicano dei parametri 

speciali che prendono tutto quello che viene immesso come parametri normali nel primo e tutti quelli con una chiave nel secondo.

Nel nostro caso, come vedete, essendo **kwargs dei dizionari, per sommarne il valore, dando per scontato che vengano immessi dei numeri, dobbiamo usare “kwargs.values”. 

Per applicare la modalità “Database First” Visual Studio 2013, anche versione Express per Web, offre un comodo designer per generare un data model completo di classi con proprietà a partire dallo schema di un database con le relative tabelle e relazioni, il tutto salvato in un file xml avente estensione .edmx.

Per la creazione del database possiamo utilizzare un DbLocal creando un progetto Database Project:

il quale si presenterà come un progetto vuoto dove potremo aggiungere le tabelle del nostro database e uno script di post deployment che ci permetterò di aggiungere dei dati di test per il nostro database dopo aver fatto il deploy del progetto, attraverso l’esecuzione del progetto, che si occuperà della creazione del database.

MERGE INTO Category AS Target
USING (VALUES 
        (1, 'PRI'), 
        (2, 'PEN')
)
AS Source (IdCategoria, Descrizione)
ON Target.IdCategoria = Source.IdCategoria
WHEN NOT MATCHED BY TARGET THEN
INSERT (IdCategoria, Descrizione)
VALUES (IdCategoria, Descrizione);

MERGE INTO Contracts AS Target 
USING (VALUES 
        (1,GETDATE(), GETDATE(), 1)
) 
AS Source (IdContratto,DataContratto,DataScadenza,IdCategoria) 
ON Target.IdContratto = Source.IdContratto 
WHEN NOT MATCHED BY TARGET THEN 
INSERT (IdContratto,DataContratto,DataScadenza,IdCategoria) 
VALUES (IdContratto,DataContratto,DataScadenza,IdCategoria);

MERGE INTO Customers AS Target 
USING (VALUES 
        (1,'MRORSS69E27H501L', 'MARIO','ROSSI', '1969-05-27','M')
) 
AS Source (IdContratto,CodiceFiscale,Nome,Cognome,DataNascita,Sesso) 
ON Target.CodiceFiscale = Source.CodiceFiscale 
WHEN NOT MATCHED BY TARGET THEN 
INSERT (IdContratto,CodiceFiscale,Nome,Cognome,DataNascita,Sesso) 
VALUES (IdContratto,CodiceFiscale,Nome,Cognome,DataNascita,Sesso);

N.B. attenzione che ogni qualvolta eseguite il progetto lo script post deploy viene eseguito

Di seguito la struttura del progetto dopo aver aggiunto le tabelle e lo script di deploy

Dal Sql Server Objects Explorer possiamo notare la struttura del database creato nel database server locale, in questo caso (localdb)ProjectsV12:

A questo punto siamo pronti per creare la nostra applicazione web MVC 5 per lo scopo prefissato. Una volta creata la soluzione si dovrà scaricare, tramite Nuget, Entity Framework giunto alla versione 6.1, in questo modo sarà possibile creare un modello dati sulla base del database appena creato. Per far questo aggiungiamo nella cartella Model un file di tipo .edmx

alla finestra successiva scegliamo di farci creare la nostra classe model dal database, quindi definiamo la stringa di connessione e via via gli altri parametri .

Quindi scegliamo le tabelle che saranno le nostre entità e salviamo la nostra classe model con un namespace a piacere

La nostra solution conterrà adesso diversi file in più mentre in automatico apparirà il designer di EF con le classi appena create.

In particolare la classe BankDataModelContext, che eredita dalla classe DbContext , fornisce una proprietà di tipo DbSet per ogni modello collegato alle tabelle scelte per la generazione. Prima di proseguire dobbiamo effettuare la build del progetto altrimenti per la prossima attività di creazione automatica del codice CRUD in seguito alla attività di scaffolding che faremo non otterremo nulla.

I passaggi per terminare l’attività sono semplici e si possono riassumere nel seguente modo:

• aggiungere un controller di tipo Scaffolded come da esempio:

• nella maschera successiva proseguire :

• quindi scegliere la classe che fungerà da controller presa dal datacontext appena generato

Ripetere l’operazione per tutte le classi per cui si devono fare operazioni CRUD, nel nostro caso Customers e Category e otterremo una solution del genere:

  Come possiamo vedere all’interno dei controllers troviamo tutte le operazioni CRUD sul model scelto, inoltre è stata creata per noi la view corrispondente, non ci rimane che agganciarle al nostro menu

@Html.ActionLink("Contracts", "Index", "Contracts")
@Html.ActionLink("Customers", "Index", "Customers")
@Html.ActionLink("Categories", "Index", "Categories")

Siamo pronti per lavorare!

Dovete riaggiornare la libreria WebHelpers di Microsoft.AspNet tramite il comando sulla console manager di Nuget:

Install-Package Microsoft.AspNet.WebHelpers

Se poi doveste trovarvi ancora l’errore seguente:

Allora dovete applicare, sempre tramite Nuget, il seguente comando:

Install-Package Microsoft.AspNet.WebPages.Data

Avete in mente di iniziare ad utilizzare uno storage NoSql? Ne avete abbastanza dei db relazionali? No, tranquilli non sto facendo pubblicità a nessuno ma un’occhiata a DocumentDb di Microsoft disponibile fra le offerte di Azure la darei, partendo dall’ introduzione.