Domande di intervista sul dizionario Python

Tempo di lettura stimato: 6 minuti

Nel nostro primo video sulle domande dei colloqui di lavoro in python abbiamo discusso alcune delle domande di alto livello che possono essere poste durante un colloquio.

In questo post, discuteremo le domande di intervista sui dizionari di python.

Cosa sono i dizionari Python e le loro proprietà?

Prima di tutto, sono mutabili, cioè possono essere modificati; continuate a leggere per vedere gli esempi.

Di conseguenza, è possibile aggiungere o togliere coppie chiave-valore a seconda delle esigenze.

Inoltre, i nomi delle chiavi possono essere modificati.

Un'altra proprietà da notare è che sono sensibili alle maiuscole e alle minuscole, il che significa che lo stesso nome di chiave può esistere anche con lettere maiuscole diverse.

Come si crea un dizionario vuoto in Python?

Come si può vedere qui di seguito, il processo è semplice: basta dichiarare una variabile uguale a due parentesi graffe e subito il gioco è fatto.

Un'alternativa è dichiarare una variabile uguale a dict() e in un'istanza si ha un dizionario vuoto.

Il seguente blocco di codice dovrebbe essere un buon esempio di come farlo:

# How do you create an empty dictionary?
empty_dict1 = {}
empty_dict2 = dict()
print(empty_dict1)
print(empty_dict2)
print(type(empty_dict1))
print(type(empty_dict2))

Output:
{}
{}
<class 'dict'>
<class 'dict'>

Come si aggiungono valori a un dizionario Python?

Se volete aggiungere valori al vostro dizionario Python, ci sono diversi modi possibili; il codice seguente può aiutarvi a farvi un'idea più precisa:

#How do add values to a python dictionary
empty_dict1 = {}
empty_dict2 = dict()

empty_dict1['Key1'] = '1'
empty_dict1['Key2'] = '2'
print(empty_dict1)

#Example1 - #Appending values to a python dictionary
empty_dict1.update({'key3': '3'})
print(empty_dict1)

#Example2 - Use an if statement
if "key4" not in empty_dict1:
    empty_dict1["key4"] = '4'
else:
    print("Key exists, so not added")
print(empty_dict1)

Output:
{'Key1': '1', 'Key2': '2'}
{'Key1': '1', 'Key2': '2', 'key3': '3'}
{'Key1': '1', 'Key2': '2', 'key3': '3', 'key4': '4'}

Come si ordina un dizionario Python?

Una delle proprietà dei dizionari è che non sono ordinati; di conseguenza, se è grande, trovare ciò che serve può richiedere un po' di tempo.

Fortunatamente Python ha fornito la possibilità di ordinare come segue:

#How to sort a python dictionary?
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
print("Your unsorted by key dictionary is:",empty_dict1)
print("Your sorted by key dictionary is:",dict(sorted(empty_dict1.items())))

#OR - use list comprehension
d = {a:b for a, b in enumerate(empty_dict1.values())}
print(d)
d["Key2"] = d.pop(0) #replaces 0 with Key2
d["Key1"] = d.pop(1) #replaces 1 with Key1
d["Key3"] = d.pop(2) #replaces 2 with Key3
print(d)
print(dict(sorted(d.items())))

Output:
Your unsorted by key dictionary is: {'Key2': '2', 'Key1': '1', 'Key3': '3'}
Your sorted by key dictionary is: {'Key1': '1', 'Key2': '2', 'Key3': '3'}
{0: '2', 1: '1', 2: '3'}
{'Key2': '2', 'Key1': '1', 'Key3': '3'}
{'Key1': '1', 'Key2': '2', 'Key3': '3'}

Come si cancella una chiave da un dizionario Python?

Di tanto in tanto alcune chiavi potrebbero non essere più necessarie. In questo caso, è necessario eliminarle. In questo modo si elimina anche il valore associato alla chiave.

#How do you delete a key from a dictionary?
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
print(empty_dict1)

#1. Use the pop function
empty_dict1.pop('Key1')
print(empty_dict1)

#2. Use Del

del empty_dict1["Key2"]
print(empty_dict1)

#3. Use dict.clear()
empty_dict1.clear() # Removes everything from the dictionary.
print(empty_dict1)

Output:
{'Key2': '2', 'Key1': '1', 'Key3': '3'}
{'Key2': '2', 'Key3': '3'}
{'Key3': '3'}
{}

Come si fa a cancellare più di una chiave da un dizionario Python?

A volte potrebbe essere necessario rimuovere più chiavi e i relativi valori. L'uso ripetuto del codice precedente potrebbe non essere il modo più efficiente per raggiungere questo obiettivo.

A tal fine, Python ha previsto una serie di modi per raggiungere questo obiettivo:

#How do you delete more than one key from a dictionary
#1. Create a list to lookup against
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
empty_dict1['Key4'] = '4'
empty_dict1['Key5'] = '5'
empty_dict1['Key6'] = '6'

print(empty_dict1)

dictionary_remove = ["Key5","Key6"] # Lookup list

#1. Use the pop method

for key in dictionary_remove:
  empty_dict1.pop(key)
print(empty_dict1)

#2 Use the del method
dictionary_remove = ["Key3","Key4"]
for key in dictionary_remove:
  del empty_dict1[key]
print(empty_dict1)

Come si cambia il nome di una chiave in un dizionario Python?

Ci saranno scenari in cui i nomi delle chiavi non sono quelli giusti e quindi dovranno essere modificati.

Si noti che quando si cambiano i nomi delle chiavi, il nuovo nome non deve esistere già.

Di seguito sono riportati alcuni esempi che illustrano i diversi modi in cui è possibile ottenere questo risultato.

# How do you change the name of a key in a dictionary
#1. Create a new key , remove the old key, but keep the old key value

# create a dictionary
European_countries = {
    "Ireland": "Dublin",
    "France": "Paris",
    "UK": "London"
}
print(European_countries)
#1. rename key in dictionary
European_countries["United Kingdom"] = European_countries.pop("UK")
# display the dictionary
print(European_countries)

#2. Use zip to change the values

European_countries = {
    "Ireland": "Dublin",
    "France": "Paris",
    "United Kingdom": "London"
}

update_elements=['IRE','FR','UK']

new_dict=dict(zip(update_elements,list(European_countries.values())))

print(new_dict)

Output:
{'Ireland': 'Dublin', 'France': 'Paris', 'UK': 'London'}
{'Ireland': 'Dublin', 'France': 'Paris', 'United Kingdom': 'London'}
{'IRE': 'Dublin', 'FR': 'Paris', 'UK': 'London'}

Come si ottengono la chiave e i valori min e max in un dizionario Python?

Infine, potreste avere un dizionario di grandi dimensioni e avere bisogno di vedere i confini o i limiti dei valori in esso contenuti.

Nel codice sottostante, alcuni esempi di ciò che si può parlare dovrebbero aiutare a spiegare le proprie conoscenze.

#How do you get the min and max keys and values in a dictionary?
dict_values = {"First": 1,"Second": 2,"Third": 3}

#1. Get the minimum value and its associated key
minimum = min(dict_values.values())
print("The minimum value is:",minimum)
minimum_key = min(dict_values.items())
print(minimum_key)

#2. Get the maximum value and its associated key
maximum = max(dict_values.values())
print("The maximum value is:",maximum)
maximum_key = max(dict_values.items())
print(maximum_key)

#3. Get the min and the max key
minimum = min(dict_values.keys())
print("The minimum key is:",minimum)

#2. Get the maximum value and its associated key
maximum = max(dict_values.keys())
print("The maximum key is:",maximum)

Output:
The minimum value is: 1
('First', 1)
The maximum value is: 3
('Third', 3)
The minimum key is: First
The maximum key is: Third

Domande di intervista sulla panoramica di Python

Tempo di lettura stimato: 4 minuti

Avete ottenuto un colloquio e avete lavorato sodo per migliorare le vostre conoscenze di Python . Ci saranno alcune domande su Python e sui diversi aspetti di cui dovrete essere in grado di parlare e che non riguardano solo la codifica!

Qui discutiamo alcuni degli elementi chiave che dovreste essere in grado di spiegare.

Quali sono le caratteristiche principali di Python?

Nella schermata qui sotto, che apparirà nel nostro video, se vi viene posta questa domanda vi aiuteranno a discuterne.

Di seguito ho illustrato alcuni dei principali vantaggi che dovreste essere in grado di discutere.

È ottimo perché è open source e ben supportato, troverete sempre una risposta alla vostra domanda da qualche parte.

Inoltre, essendo facile da codificare e da capire, la capacità di specializzarsi rapidamente e di fornire programmi validi rappresenta un enorme vantaggio.

Poiché esistono molte piattaforme diverse, è stato adattato per funzionare facilmente su qualsiasi piattaforma con un minimo sforzo. Questo è un grande vantaggio per poterlo utilizzare in diversi ambienti di sviluppo senza troppe modifiche.

Infine, alcuni linguaggi richiedono la compilazione dell'applicazione, mentre Python non la esegue e basta.

Quali sono i limiti di Python?

Sebbene si parli molto di Python, esso presenta anche alcuni inconvenienti, che dovreste essere in grado di affrontare.

Una delle prime cose da discutere è che la sua velocità può inibire le prestazioni di un'applicazione. Se avete bisogno di dati in tempo reale e utilizzate Python, dovete considerare quanto le prestazioni saranno inibite da questo sistema.

Ci sono scenari in cui un'applicazione è scritta con una vecchia versione di codice e si desidera introdurre nuove funzionalità, con una versione più recente. Questo potrebbe portare a problemi di non funzionamento del codice attualmente esistente, che deve essere riscritto. Di conseguenza, potrebbe essere necessario prevedere un tempo di programmazione aggiuntivo per risolvere i problemi di compatibilità riscontrati.

Infine, poiché Python utilizza molta memoria, è necessario che sia installato su un computer o un server in grado di gestire le richieste di memoria. Questo è particolarmente importante quando l'applicazione viene utilizzata in tempo reale e deve fornire risultati molto rapidamente all'interfaccia utente.

A cosa serve Python?

Come illustrato di seguito, gli usi di Python sono molteplici, ma non si tratta di un elenco esaustivo.

Un tema comune ad alcuni dei punti che seguono è che Python può elaborare dati e fornire informazioni di cui non si è a conoscenza e che possono aiutare a prendere decisioni.

In alternativa, può anche essere utilizzato come strumento per automatizzare e o prevedere il comportamento dei soggetti a cui si riferisce; a volte questi comportamenti possono non essere evidenti, ma aiutano a velocizzare l'esecuzione di alcuni compiti ripetitivi.

Quali sono i tipi di dati supportati da Python?

Infine, di seguito è riportato un elenco dei tipi di dati che dovreste conoscere ed essere in grado di discutere. Alcuni di questi sono utilizzati di frequente.

Queste provengono dalla pagina web sui tipi di dati di Python, quindi sono un buon punto di riferimento se avete bisogno di approfondire o migliorare le vostre conoscenze.

ValueError: Le colonne devono avere la stessa lunghezza della chiave

Tempo di lettura stimato: 3 minuti

State cercando di imparare python e nel frattempo vi imbattete in questo errore e cercate di capire perché si verifica?

In sostanza, ciò si verifica quando si dispone di più frame di dati e nel processo di scrittura del programma si cerca di utilizzare i frame di dati e i relativi dati, ma c'è una discrepanza nel numero di elementi in ciascuno di essi che il programma non può elaborare finché non viene risolta.

Uno scenario comune in cui ciò può accadere è quando si uniscono frame di dati o si suddividono i dati, come illustrato di seguito.

Scenario 1 - Unire i frame di dati

Quando si ha df1[['a']] = df2, si assegnano i valori a sinistra del segno di uguale a quelli a destra.

Se guardiamo il lato destro, ci sono tre colonne, mentre il lato sinistro ne ha una.

Di conseguenza, appare l'errore "ValueError: Le colonne devono avere la stessa lunghezza della chiave", come indicato di seguito.

import pandas as pd

list1 = [1,2,3]
list2 = [[4,5,6],[7,8,9]]

df1 = pd.DataFrame(list1,columns=['column1'])
df2 = pd.DataFrame(list2,columns=['column2','column3','column4'])

df1[['a']] = df2

Il codice sopra riportato genera il seguente errore:

L'obiettivo è quello di avere tutte le colonne del lato destro accanto alle colonne del lato sinistro, come segue:

Abbiamo fatto in modo che entrambi i lati siano uguali per quanto riguarda il numero di colonne da mostrare da df2
In sostanza, prendiamo la colonna da DF1 e poi inseriamo le tre colonne da DF2.
Le columna, columnb, columnc qui sotto corrispondono alle tre colonne di DF2 e memorizzeranno i dati da esse provenienti.

La soluzione per questo problema è: df1['columna','columnb','columnc']] = df2

stampa (df1)

Scenario 2 - Suddivisione dei dati

Può capitare di avere un elenco in python e di dover dividere i valori dell'elenco in colonne separate.

new_list1 = ['1 2 3']
df1_newlist = pd.DataFrame(new_list1,columns=['column1'])

Nel caso precedente, abbiamo creato un elenco con tre valori che fanno parte di una stringa. Qui si vuole creare una nuova colonna con il codice seguente:

df1_newlist[["column1"]] = df1_newlist["column1"].str.split(" ", expand=True) #Splitting based on the space between the values.

print(df1_newlist)

Quando si esegue quanto sopra, viene generato il seguente errore di valore:

L'errore è dovuto al fatto che la logica prevede tre valori da suddividere in tre colonne, ma è stata definita solo una colonna in df1_newlist[["column1"]].

Per risolvere il problema, eseguire il codice seguente:

df1_newlist[["column1","column2","column3"]] = df1_newlist["column1"].str.split(" ", expand=True) #Splitting based on the space between the values.

print(df1_newlist)

Il risultato è il seguente: il problema è stato risolto!

Come controllare i caratteri indesiderati usando i loop con Python

Tempo di lettura stimato: 3 minuti

Su questo sito web abbiamo pubblicato Come rimuovere i caratteri indesiderati dai dati e Come rimuovere i caratteri da un file CSV importato, entrambi mostrano approcci diversi.

In questo post, affronteremo il processo utilizzando i loop all'interno di una funzione. In sostanza, passeremo un elenco e poi eseguiremo un ciclo attraverso le stringhe per verificare i dati rispetto ad esso.

Passo 1 - Importare i dati e creare una cornice di dati

La prima operazione da completare è il caricamento dei dati. Creiamo un dizionario con le rispettive coppie chiave-valore.

Per preparare i dati da elaborare tramite la funzione al punto 2, li carichiamo in un frame di dati.

import pandas as pd
#Create a dataset locally
data = {'Number':  ["00&00$000", '111$11111','2222€2222','3333333*33','444444444£','555/55555','666666@666666'],
        'Error' : ['0','0','0','0','0','0','0']}

#Create a dataframe and tell it where to get its values from
df = pd.DataFrame (data, columns = ['Number','Error'])

Passo 2 - Creare la funzione che controlla la presenza di dati non validi

Questo è il pezzo principale della logica che fornisce l'output. Come si può vedere, c'è un elenco "L" che viene dato in pasto alla funzione run.

Una cosa da notare è che *l viene passato alla funzione, poiché c'è più di un valore nell'elenco, altrimenti il programma non verrebbe eseguito correttamente.

Per iniziare creiamo un frame di dati, che estrae con un'espressione regolare i caratteri che non vogliamo avere.

Successivamente, occorre eliminare una colonna generata con valori NAN, poiché non sono necessari.

Poi abbiamo aggiornato la fama dei dati originali con i valori trovati.

Nel caso in cui vi siano valori NAN nella colonna "Errore" aggiornata, li rimuoviamo nella riga successiva.

La parte successiva è il ciclo che crea una nuova colonna chiamata "Fix". Questa contiene i valori che saranno popolati nel fix dopo che i dati non desiderati sono stati rimossi e i dati sono stati ripuliti.

I dati che non ci servono sono in str.replace.

#Function to loop through the dataset and see if any of the list values below are found and replace them
def run(*l):
    #This line extracts all the special characters into a new column
    #Using regular expressions it finds values that should not appear
    df2 = df['Number'].str.extract('(\D+|^(0)$)') # New dataframe to get extraction we need
    print(df2)
    df2 = df2.drop(1, axis=1) # Drops the column with NAN in it, not required

    df['Error'] = df2[0] # Updates original dataframe with values that need to be removed.
    #This line removes anything with a null value
    df.dropna(subset=['Error'], inplace=True)
    #This line reads in the list and assigns it a value i, to each element of the list.
    #Each i value assigned also assigns an index number to the list value.
    #The index value is then used to check whether the value associated with it is in the df['Number'] column 
    #and then replaces if found
    for i in l:
        df['Fix']= df['Number'].str.replace(i[0],"").str.replace(i[1],"").str.replace(i[2],"").str.replace(i[3],"") \
        .str.replace(i[4],"").str.replace(i[5],"").str.replace(i[6],"")
        print("Error list to check against")
        print(i[0])
        print(i[1])
        print(i[2])
        print(i[3])
        print(i[4])
        print(i[5])
        print(i[6])
    print(df)

#This is the list of errors you want to check for
l = ['$','*','€','&','£','/','@']

Fase 3 - Esecuzione del programma

Per eseguire questo programma, basta eseguire il codice seguente. Tutto ciò che fa è leggere l'elenco "L" alla funzione "run" e quindi produrre l'output al passo 4

run(l)

Fase 4 - Uscita

Error list to check against
$
*
€
&
£
/
@
          Number Error           Fix
0      00&00$000     &       0000000
1      111$11111     $      11111111
2      2222€2222     €      22222222
3     3333333*33     *     333333333
4     444444444£     £     444444444
5      555/55555     /      55555555
6  666666@666666     @  666666666666

Process finished with exit code 0

Come creare più file XML da Excel con Python

Avete un file Excel con centinaia o forse migliaia di record, ma volete convertirlo in un file XML e avere ogni riga come file separato?

Questo si può ottenere molto facilmente utilizzando Python, in tre semplici passi.

Prima di tutto, cos'è l'XML?

XML è l'acronimo di "extensible markup language" (linguaggio di marcatura estensibile) ed è ampiamente utilizzato nei siti Web, nei servizi Web e nei casi in cui le aziende desiderano trasferire dati tra loro in un formato predefinito che segue uno standard riconosciuto.

Per saperne di più su cos'è l'xml, seguite il link. Una cosa da notare è che può riferirsi al settore dei servizi finanziari, ma l'XML è ampiamente utilizzato anche in altri settori; poiché ora stiamo digitalizzando molti dei nostri processi, il trasferimento dei dati deve seguire uno standard con cui tutti possano lavorare senza problemi.

Fase 1 - Esaminiamo i nostri dati grezzi

Di seguito è riportato un file excel con tre colonne e otto righe. L'obiettivo è creare otto file XML separati per ogni riga.

dati grezzi per popolare più file excel

Fase 2 - Importare i dati e creare un file XML principale

Di seguito è riportata la logica che ho utilizzato in Come creare un file XML da Excel usando Python; ho allegato i commenti dove necessario per spiegare cosa fa ogni riga.

Lo scopo a questo punto è creare un file con tutti i dati di Excel, chiamato output.xml. Lo utilizzeremo poi per creare i file separati di cui abbiamo bisogno e quindi lo cancelleremo.

I prossimi passi vi illustreranno questo aspetto.

import pandas as pd
from lxml import etree as et
import os


# STEP 1 - This step creates a master XML file

raw_data = pd.read_excel(r'\Users\haugh\OneDrive\dataanalyticsireland\YOUTUBE\how_to_read_each_excel_row_into_a_separate_XML_file\excel_raw_data_city.xlsx')

root = et.Element('root')

for row in raw_data.iterrows(): #==> This is a loop that takes runs through each record and populates for each tag.
    root_tags = et.SubElement(root, 'ExportData') #=== > Root name
# These are the tag names for each row (SECTION 1)
    Column_heading_1 = et.SubElement(root_tags, 'City')
    Column_heading_2 = et.SubElement(root_tags, 'Area')
    Column_heading_3 = et.SubElement(root_tags, 'Population')


###These are the values that will be populated for each row above
# The values inside the [] are the raw file column headings.(SECTION 2)
    Column_heading_1.text = str(row[1]['City'])
    Column_heading_2.text = str(row[1]['Area'])
    Column_heading_3.text = str(row[1]['Population'])

# This Section outputs the data to an xml file
# Unless you tell it otherwise it saves it to the same folder as the script.
tree = et.ElementTree(root) #==> The variable tree is to hold all the values of "root"
et.indent(tree, space="\t", level=0) #===> This just formats in a way that the XML is readable
tree.write('output.xml', encoding="utf-8") #==> The data is saved to an XML file

Fase 3 - Eseguire il loop di ogni riga e creare i file separati

Nel codice seguente, viene aperto il file output.xml e, utilizzando il ciclo, vengono cercati tutti i dati tra i tag "ExportData".

Quindi li copia e crea un nuovo file.

Una volta terminato, passa alla serie successiva di tag e ripete il processo, fino a raggiungere la fine del file output.xml.

master_file = et.iterparse('output.xml', events=('end', ))
index = 0
for i, j in master_file:
    if j.tag == 'ExportData':
        index += 1
        filename = format(str(index) + ".xml")
        with open(filename, 'wb') as f:
            f.write(et.tostring(j))

Passo 4 - Cancellare il file output.xml - puramente facoltativo

L'obiettivo era quello di creare file XML separati, basati sull'input del file Excel originale.

Abbiamo anche creato un file aggiuntivo chiamato output.xml per raggiungere l'obiettivo finale.

Se non abbiamo bisogno di questo file, possiamo rimuoverlo con il codice seguente, assicurandoci che sia alla fine della logica.

La dichiarazione di importazione di os.unlink si trova al passo due.

os.unlink(r'\Users\haugh\OneDrive\dataanalyticsireland\YOUTUBE\how_to_read_each_excel_row_into_a_separate_XML_file\output.xml')

Come risolvere il TypeError: tipo 'slice' non modificabile

Tempo di lettura stimato: 2 minuti

Si dispone di un dizionario Python e si desidera recuperare i dati da esso e stamparli sullo schermo. Ci sono alcune caratteristiche di Python che vanno innanzitutto comprese:

  1. Sono mutevoli
  2. Inoltre, hanno la capacità di crescere e ridursi a seconda delle esigenze.
  3. L'accesso ai dati all'interno del dizionario avviene tramite le chiavi.

L'ultimo punto è molto importante, poiché i dizionari non hanno un valore di indice ed è per questo che si ottiene il TypeError che si sta cercando di risolvere.

Ricostruiamo il problema

Nel codice seguente abbiamo un dizionario chiamato "userdata", con le sue coppie chiave-valore.

Il ciclo cerca di recuperare il valore 1 dell 'indice per tutti i valori in dai_data.

Come si può vedere, dai_data sta cercando di recuperare gli ultimi tre valori dell'indice all'interno del dizionario.

Come già detto, l'unico modo per accedere ai valori del dizionario è attraverso i valori delle chiavi.

userdata = {
	  "name": "Data Analytics Ireland",
	  "Country": "Ireland",
	  "City": "Dublin",
	  "Age": "1000 years!",
}

dai_data = userdata[:3]

for i in dai_data:
	     print(i[1])

Output:
Traceback (most recent call last):
  File "", line 8, in <module>
    dai_data = userdata[:3]
TypeError: unhashable type: 'slice'

Come risolvere questo problema?

Prima di tutto, si accede ai valori attraverso la chiave all'interno del dizionario

Nel dizionario sottostante i valori chiave sono: Nome, Paese, Città, Età

userdata = {
	  "Name": "Data Analytics Ireland",
	  "Country": "Ireland",
	  "City": "Dublin",
	  "Age": "1000 years!",
}

print(userdata["Name"])
print(userdata["Country"])
print(userdata["City"])
print(userdata["Age"])

Output:
Data Analytics Ireland
Ireland
Dublin
1000 years!

Di conseguenza, ora siamo in grado di accedere ai valori associati a ciascuna chiave.

Sapevate che potete aggiungere un elenco a una delle vostre coppie chiave-valore?

Nell'esempio precedente, ci siamo concentrati su un singolo valore, ma potremmo anche rendere una chiave uguale a un elenco.

userdata = {
	  "Name": ["Joe","Jim"],
	  "Country": "Ireland",
	  "City": ["Dublin","Cork","Limerick"],
	  "Age": "1000 years!"
}

print(userdata["Name"])
print(userdata["Country"])
print(userdata["City"])
print(userdata["Age"])

Output:
['Joe', 'Jim']
Ireland
['Dublin', 'Cork', 'Limerick']
1000 years!

Come eseguire la validazione di Python da Javascript

Tempo di lettura stimato: 6 minuti

Sempre di più, gli sviluppatori di siti web stanno cercando di fondere diverse tecnologie di programmazione per consentire loro di utilizzare funzionalità che forse non sono disponibili nel linguaggio di programmazione corrente che utilizzano.

Nei post precedenti come passare variabili python a Javascript e come eseguire python direttamente da javascript, abbiamo toccato come usare Python e Javascript in modo intercambiabile per passare dati.

Qui, in questo post del blog, daremo un'occhiata alla convalida dei dati usando Python, con dati catturati da Javascript. Lo scopo qui è di permettere un altro modo di convalidare i dati oltre a fare affidamento su javascript.

Validazione Python eseguita da Javascript

Ci sono diverse ragioni per questo:

  1. È possibile utilizzare Python per elaborare i dati e fornire l'output.
  2. I dati potrebbero essere passati da Python in un database, è necessario eseguire alcuni controlli prima di procedere.
  3. Python è il linguaggio principale, si usa solo Javascript per catturare i dati e passarli da un sito web.

Ci sono quattro controlli di validazione

  1. Validazione se esiste un nome utente.
  2. Validazione se è stato inserito un numero in un campo nome utente.
  3. Convalida di una password inserita.
  4. Un controllo di convalida per assicurarsi che un indirizzo e-mail inserito sia nel formato corretto.

Abbiamo due file con il codice richiesto come segue:

  1. app.py ===> Poiché questa applicazione è costruita in Python Flask, questo file contiene la logica per aprire i file del sito web, e contiene i controlli di validazione Python .
  2. index.html ====> Questo file contiene l'HTML che crea le pagine, le etichette e le caselle di input che appaiono nel browser web. Include anche il Javascript che cattura i dati da passare a Python per la validazione.

Panoramica del codice - App.PY

Di seguito, cercherò di spiegare cosa sta succedendo come segue:

La variabile Regex è usata nella validazione dell'email per controllare se l'email inserita è corretta.

def inputcheck ===> Questo è solo il controllo del nome utente passato ed esegue alcune validazioni su di esso.

def inputvalidation ====> Anche questo controlla il nome utente ma guarda se sono stati inseriti solo numeri o se è vuoto.

def passvalidation ====> In questo pezzo di logica, controlla se la password è vuota, meno di cinque caratteri, è solo numeri.

def emailvalidation ====> Tutto ciò che sta facendo è controllare se i dati ricevuti dal Javascript sono nel formato email corretto. Fa riferimento alla variabile regex di cui sopra, che viene utilizzata per confermare se il formato è corretto o meno.

All'interno di ogni funzione, ci sono dichiarazioni if che sono i controlli di validazione fondamentali usati da Python.

Inoltre, tutti i menu popup usano ctypes, che vi permette di accedere alle librerie di finestre che contengono le caselle di messaggio, personalizzarle e chiamarle all'interno del vostro programma.

import json
import ctypes
import re
from flask import request,redirect,url_for

from flask import Flask, render_template

app = Flask(__name__)

regex = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'

@app.route('/')
def index():
    return render_template('index.html')


@app.route('/inputcheck', methods=['GET','POST'])
def inputcheck():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    username_list = ['joe','john']
    if result['username'] in username_list:
        MessageBox = ctypes.windll.user32.MessageBoxW(0, 'Username ' + result['username'] + ' ' + 'exists', "Username check", 0x00001000)
        return render_template('various.html')
    elif result['username'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'You cannot enter an empty value', 'Username check', 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Username ' + result['username'] + ' ' + 'does not exist', 'Username check', 0x00001000)

@app.route('/inputvalidation', methods=['GET','POST'])
def inputvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if result['username'].isdecimal():
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username cannot be numbers',"Number check", 0x00001000)
    elif result['username'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'The username cannot be empty', "Number check",0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username looks ok', "Number check", 0x00001000)
    return render_template('index.html')

@app.route('/passvalidation', methods=['GET','POST'])
def passvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if result['password'].isdecimal():
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your password cannot be numbers',"Password check", 0x00001000)
    elif result['password'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'The password cannot be empty', "Password empty check",0x00001000)
    elif len(result['password']) < 5:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username should be greater than five characters', "Password length check", 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your password looks ok', "Number check", 0x00001000)
    return render_template('index.html')

@app.route('/emailvalidation', methods=['GET','POST'])
def emailvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if re.search(regex, result['email']):
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your email is in the correct format', "Email check", 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your email is invalid, please correct', "Email check", 0x00001000)
    return render_template('index.html')



if __name__ == "__main__":
    app.run(debug=True)


Panoramica del codice - Index.html

Il codice riportato di seguito è il codice della pagina che consente di acquisire i dati attraverso una pagina HTML del browser web.

Between the <style></style> tags these are the CSS properties that format the labels and buttons on the page.

Within the <div></div> tags are where we create the labels and buttons to show on the screen. Also within these, are the references to the on click event function that should run once the buttons are clicked.

Within the <script></script> tags, this is where the javascript is written which captures the data entered into the input boxes within the <div> tags.

Inoltre, si noterà che all'interno di questo javascript ci sono sezioni chiamate $.ajax, che è il luogo in cui vengono memorizzati i dati catturati dal javascript e poi passati al file di script Python (app.py).

Notate che in ogni ajax si fa riferimento a url:"/APAGENAME". Queste sono le sezioni all'interno dell'app.py a cui vengono passati i dati, e poi la logica Python entra in gioco e convalida i dati.

<html lang="en">

<head>

    <title>Data Analytics Ireland</title></head>
<style>
.button1 {
    position: absolute;
    top: 50%;
    left: 55%;
    width: 900px;
    height: 300px;
    margin-left: -300px;
    margin-top: -80px;
}



.labels {
    position: absolute;
    top: 50%;
    left: 55%;
    width: 900px;
    height: 300px;
    margin-left: -300px;
    margin-top: -150px;
}

</style>

<body>



<div class="labels" id="mem1" >
<label  for="username">username:</label> <input type="text" id="username" name="username">
<label for="password">password:</label><input type="text" id="password" name="password">
    <label for="email">email:</label><input type="text" id="email" name="password">
</div>


<div class="button1" id="mem2" >
<button type="submit" onclick='myfunction();'>Click here to validate your username</button>
<button type="submit" onclick='myfunctionval();'>Click here to check if a number</button>
    <button type="submit" onclick='myfunctionpass();'>Click here to check password</button>
      <button type="submit" onclick='myfunctionemail();'>Click here to check your email</button>
</div>


<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.5/jquery.min.js"></script>

<script>
    function myfunction() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/inputcheck",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>
<script>
    function myfunctionval() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/inputvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>

<script>
    function myfunctionpass() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/passvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>

<script>
    function myfunctionemail() {

        const email = document.getElementById("email").value;


        const dict_values = {email} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/emailvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>




</body>
</html>

Come passare variabili Python a Javascript

Tempo di lettura stimato: 4 minuti

Nel nostro recente post sul blog Come passare una variabile Javascript a Python usando JSON, abbiamo dimostrato come usare facilmente AJAX per passare qualsiasi dato e poi manipolarlo con Python.

In questo post sul blog, mostreremo come fare il contrario. Lo scenario è quello di avere un'applicazione o un sito web che vuole usare i dati generati attraverso Python, ma lasciare che Javascript li usi all'interno dell'applicazione.

Poiché Python può essere collegato a numerosi database e file (txt, excel) ecc, questo pezzo di logica è molto utile per il programmatore che cerca di integrare entrambi i linguaggi di programmazione.

Cominciamo a guardare il codice, e vediamo come questo può essere ottenuto.

Passo 1 - Quali file vengono generati?

Questo programma usa Python Flask per creare una pagina web, che ha un menu a discesa. I due file utilizzati per generarlo sono i seguenti:

(A) app.py - Questo è il file python che crea un sito web e carica un file HTML modello come indicato di seguito.

(B) Index.html - Questo è il file template che viene caricato nel browser ed esegue tutto il javascript. Il javascript caricato qui carica anche i dati python passati da app.py

Passo 2 - Panoramica del codice APP.PY

La libreria Python che permette la creazione di pagine web si chiama Flask, e come si può vedere qui sotto deve essere importata.

Inoltre, dobbiamo anche importare render_template che dice al programma di andare nella cartella dei modelli e caricare "Index.HTML".

La variabile che è stata passata a JavaScript si chiama name, e questi sono i valori che vedrete nel browser web quando viene caricato.

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    name = ['Joe','John','Jim','Paul','Niall','Tom']
    return render_template('index.html', name=name)

if __name__ == "__main__":
    app.run(debug=True)

Passo 3 - Panoramica di Index.HTML

Ecco il file HTML del template che gira nel browser. Puoi aggiungere CSS ecc. a questo per renderlo più bello e più facile da usare.

Come potete vedere ha i soliti tag HTML che appaiono come parte di un sito web.

Beh, guardate ancora un po' di codice:

In this bit <select id =’select’> </select>, this is the dropdown menu that will appear when Index.html is opened. It will store all the values passed from python. Note that its id is “select”, this will be used later on.

The main parts to focus on next is between <script></script>. This is what reads in the python data and populates it to the dropdown menu.

Nel passo 2 abbiamo detto che c'era una variabile chiamata "nome", con valori da passare.

Questo si ottiene su questa linea:

var select = document.getElementById(“select”), test = {{ name | tojson }};

Notate che il nome appare qui, e questo fa riferimento allo stesso identico valore che è stato discusso nel passo 2.

Per il resto delle linee, ho spiegato con commenti cosa fa ciascuna.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Pass Python variable to Javascript</title>
</head>
<body>

<select id ='selectvalue'>
</select>
<script>
    //name = ['Joe','John','Jim','Paul','Niall','Tom']

    var selectvalue = document.getElementById("selectvalue"), test = {{ name | tojson }};
    //The increment operator (++) increments (adds one to) its operand and returns a value.
    for(var i = 0; i < test.length; i++) // This line checks for the length of the data you feeding in i.e the no of items
         {
var selection = document.createElement("OPTION"), // This line creates a variable to store the different values fed in from the JSON object "TEST"
txt = document.createTextNode(test[i]); // This just reads each value from the test JSON variable above
selection.appendChild(txt); // This line appends each value as it is read.
selection.setAttribute("value",test[i]); // This line sets each value read in as a value for the drop down
selectvalue.insertBefore(selection,selectvalue.lastChild); //This reads eah value into the dropdown based on the order in the "TEST" above.
 }
</script>
</body>
</html>

Passo 4 - Come appare l'output!

Dal passo 2, questi sono i valori che abbiamo chiesto di usare in Javascript per popolare un dropdown:

nome = ['Joe','John','Jim','Paul','Niall','Tom']

Variabile Python passata a Javascript

Come passare più liste a una funzione e confrontare

Tempo di lettura stimato: 3 minuti

Vi siete mai trovati di fronte a una situazione in cui avete più liste che volete confrontare e avete bisogno di una funzione che le legga e vi mostri cosa c'è di diverso tra tutte?

In questo scenario, questo può essere utile quando si hanno grandi insiemi di dati e si ha bisogno di un modo rapido per trovare queste differenze e correggerle dove necessario.

Confrontare due liste

Guardiamo e vediamo cosa sta succedendo qui sotto.

Prima di tutto, abbiamo definito due liste. L'unica differenza tra le due è che una ha un valore di sei, l'altra no.

Poi abbiamo la funzione "comparelists". Ciò che fa è prendere le due liste come parametri (a,b), e poi elaborarle.

Le liste sono passate come argomenti ai parametri in questa linea ===> comparelists(list1,list2)

I parametri a sono assegnati alla lista1, e b è assegnato alla lista2.

Il pezzo principale della funzione è la comprensione della lista, e sta facendo quanto segue:

  1. x for x è fondamentalmente la creazione di una variabile x, e l'avvio di un ciclo che passa attraverso tutti i valori di b.
  2. Ogni iterazione di x viene memorizzata e confrontata con a.
  3. "Se x non è in a" completa il confronto e se è vero restituisce il valore, altrimenti passa al valore successivo.

Come risultato di questa logica, si può vedere che sei è l'unico valore restituito, e questo è ciò che ci aspettiamo in base a un'ispezione visiva.

#Reading in two lists
list1 = [1,2,3,4,5] # parameter a below
list2 = [1,2,3,4,5,6] # parameter b below

def comparelists(a,b):
    z = [x for x in b if x not in a] #list comprehension
    print(z)

comparelists(list1,list2)

Output:

[6]

Confrontare più di due liste

Nella logica di cui sopra, abbiamo visto che due liste possono essere confrontate. Ma cosa succede se volete confrontare una lista con altre due liste?

Questo si fa facilmente, con qualche ritocco al codice.

Come prima le tre liste sono definite, create come argomenti in comparelists(list1,list2,list3), e poi passate ai parametri della funzione a,b,c.

L'unica differenza in questa logica è che la comprensione della lista è scritta un po' diversamente come segue:

  1. x for x è fondamentalmente la creazione di una variabile x, e l'avvio di un ciclo che passa attraverso tutti i valori di b. ====> Questo è lo stesso di sopra
  2. Ogni iterazione di x viene memorizzata e confrontata con a e c ===> Questa linea è diversa dal confronto con due liste ora.
  3. "se x non in a e x non in c" ====> Qui abbiamo due confronti
    • Controllo del valore x da b in a
    • Controllo del valore x da b in c
  4. Il valore di sei è corretto perché non si trova né in a né in c.
  5. Notate che l'istruzione if è specifica su cosa controllare con l'istruzione "e". Questo può essere cambiato in base alle vostre esigenze.
list1 = [1,2,3,4,5] # parameter a below
list2 = [1,2,3,4,5,6] # parameter b below
list3 = [1,2,3,7,8,9] # parameter c below

def comparelists(a,b,c):
    z = [x for x in b
         if x not in a and x not in c] #list comprehension
    print(z)

comparelists(list1,list2,list3)

Output:
[6]

Come usare i parametri in Python

Tempo di lettura stimato: 5 minuti

State usando una funzione e state cercando di passarle dei valori da elaborare? Bene, se questo è il caso, state cercando di passare argomenti ai parametri di quella funzione in modo che restituiscano un valore per voi.

I parametri non sono altro che valori associati alla funzione. Per ogni funzione, avrete uno o più parametri che si aspetta di elaborare.

Di conseguenza, ci sono diversi modi per crearli, esploriamo come questo può essere ottenuto.

Passare argomenti direttamente nei parametri di una funzione

In molti casi, i valori degli argomenti da elaborare saranno passati nei parametri della funzione, che poi esegue una logica e restituisce un valore.

Tipici modi in cui questo può accadere:

  1. Si inserisce una password (l'argomento inserito), la funzione conferma poi se è valida o no.
  2. Potrebbe essere necessario controllare se un valore inserito (l'argomento inserito) è superiore o inferiore a un certo valore. Viene passato come parametro di una funzione e poi la funzione fa i controlli necessari, e conferma il risultato nell'output.

Quelli sopra sono due esempi, ma vediamo questo in azione.

Qui sotto abbiamo una funzione. Lo scopo è quello di prendere due argomenti passati ad essa e condurre un calcolo su di essi.

Il calcolo avviene nella variabile numero 1 o numero 2.

La variabile numero 1 e la variabile numero 2 ottengono i loro valori dai parametri a e b rispettivamente.

La linea multiplenumber(1,2) non fa altro che chiamare la funzione e passare gli argomenti ai parametri a,b che poi li processa e l'output viene stampato.

def multiplenumber(a,b):
    number1 = a*2
    number2 = b*3
    print(number1,number2) #===> These values are different to the variables below as they happen as a result of the processing inside the function.

number1=1
number2=2
multiplenumber(number1,number2)
print(number1,number2) #===> These values are outside the function and do not have any relationship to the variables inside the function above, hence are different.

Result:
2 6
1 2

Il risultato della logica di cui sopra si chiama "passando per valore", il che significa essenzialmente che i dati vengono passati dalle variabili (numero 1 e numero 2) ai parametri della funzione, ma quando la funzione viene completata l'elaborazione, non ha impatto sulle variabili originali al di fuori della funzione.

Questo perché le variabili originali sono immutabili.

Passare argomenti direttamente in parametri di funzione da una lista

Nell'esempio precedente, come delineato, non ci sarà alcun impatto sulle variabili che passano gli argomenti nella funzione, rimangono le stesse.

D'altra parte, se la fonte originale degli argomenti è un oggetto mutabile, i suoi valori saranno cambiati.

Vediamo una situazione in cui questo può accadere.

def addnumber(a):
    number=['3']
    a.append(number)
    print(a) #===> This prints the original value of a with the addition of the value 3

number1=[1,2]
addnumber(number1)
print(number1) #===> As number1 is passed to the function, and number1 is allowed to be changed then this will print out the new list value once the function has completed processing.

Result:
[1, 2, ['3']]
[1, 2, ['3']]

Così in questo caso, dato che number1 è una lista, e questa è mutabile, il suo valore cambierà una volta che la funzione completa la sua elaborazione.

Questo può anche essere chiamato "passaggio per riferimento".

Passaggio di argomenti tra funzioni

In un altro video, abbiamo completato chiamato come passare i dati tra le funzioni questo discute come potete passare i dati tra due funzioni e stamparli.

Effettivamente nel seguito gli argomenti sono nome, paese, città, e questi valori sono passati alla funzioneb

def functiona():
    nome = "Giuseppe" 
    paese = "Marte 
    città = "atlantis" 
    #questo cattura le tre variabili di cui sopra
    restituisce nome, paese, città
funzionea()

def functionb():
    myname,mycountry,mycity = functiona()
    stampa(mionome)
    stampare(miopaese)
    stampare(mycity)

funzioneb()

Risultato:
Joseph
Marte
atlantis

Passare argomenti usando *args come parametro

Per capire questo, prima di guardare un po' di codice dobbiamo capire cosa sono gli *args?

*args permette essenzialmente di passare più argomenti posizionali a una funzione, e questo può variare nel tempo.

Di conseguenza, non è necessario assegnare gli argomenti posizionali a più di una variabile. Gli *args prendono tutti gli argomenti, non importa quanto siano lunghi o corti, e poi restituiscono un valore.

def addnumbers(*args):
    result = 2
    for x in args:
        result = result * x
    return result

print(addnumbers(1,2,3))

Result:
12

Passare argomenti usando **kwargs come parametro

Contrariamente a quanto detto sopra, questo elaborerà un insieme di valori che hanno un nome collegato ad essi.

Come si può vedere nell'esempio precedente, gli argomenti passati non hanno un nome.

Guardiamo da vicino un esempio. In questo scenario, agli argomenti viene assegnato un valore di a,b,c.

def addnumbers(**kwargs):
    result = 2
    for x in kwargs.values():
        result = result * x
    return result

print(addnumbers(a=1,b=2,c=3))

Result:
12

Qui è chiaro che la logica prende ogni valore di a,b,c lo elabora e poi restituisce il risultato richiesto.

In sostanza, sia *args che **kwargs vi danno la stessa risposta, dipende solo da altre parti del vostro codice e da come sta elaborando i vostri dati.

Per esempio, nei **kwargs potrebbe essere che i valori di a,b,c potrebbero essere popolati da altre variabili all'interno del programma.

Quindi, in questo scenario, la variabile che è stata passata può cambiare e non essere statica.

Quindi, in sintesi:

a. Gli argomenti possono essere passati in più modi alle funzioni, i parametri poi si limitano ad elaborarli.

b. Anche i parametri non devono essere assegnati a una variabile, possono essere letti attraverso *args.

c. D'altra parte potete far leggere più argomenti in una volta sola usando il **kwargs.