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. Potresti voler usare 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 tuo linguaggio di base, usi 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 che segue è il codice della pagina, che permette la cattura dei 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, vedrai che all'interno di questo javascript, ci sono sezioni chiamate $.ajax, che è dove i dati catturati dal javascript vengono memorizzati, 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.

TypeError: gli indici delle liste devono essere interi o fette, non tuple

Tempo di lettura stimato: 3 minuti

Quando lavorate con le liste Python nei vostri progetti di analisi dei dati, quando cercate di leggere i dati, un problema comune si verifica se avete una lista di liste, e non è formattata correttamente.

In questo caso, Python non sarà in grado di leggere una o più liste e, di conseguenza, lancerà questo errore.

Per capire come si verifica questo problema, dobbiamo capire come creare una lista di liste.

Come creare una lista di liste

Guardiamo una semplice lista:

a = [1,2,3]
print(a)
print(type(a))

Result:
[1, 2, 3]
<class 'list'>

Creiamo una seconda lista chiamata b:

b = [4,5,6]
print(b)
print(type(b))

Result:
[4, 5, 6]
<class 'list'>

Quindi se vogliamo unire le liste in una lista (quindi una lista di liste) allora:

a = [1,2,3]
b = [4,5,6]

list_of_lists = []
list_of_lists.append(a)
list_of_lists.append(b)
print(list_of_lists)
print(type(list_of_lists))

Result:
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

Quindi, come si può vedere, le due liste sono contenute in una lista principale chiamata "lista_di_liste".

Allora perché gli indici della lista degli errori devono essere interi o fette, non tuple?

Motivo 1 (Mancano le virgole tra le liste)

Se li digitate manualmente e dimenticate la virgola tra le liste, questo causerà il vostro problema:

a=[[1,2,3][4,5,6]]
print(a)

Result (Error):
Traceback (most recent call last):
  line 10, in <module>
    a=[[1,2,3][4,5,6]]
TypeError: list indices must be integers or slices, not tuple

Ma se si mette una virgola tra le due liste, allora non restituisce alcun errore:

a=[[1,2,3],[4,5,6]]
stampa(a)

Risultato (nessun errore):
[[1, 2, 3], [4, 5, 6]]
Processo terminato con codice di uscita 0

Motivo 2 (virgola nel posto sbagliato)

A volte avete una lista e volete riportare solo alcuni elementi della lista, ma non altri:

Nel seguito, stiamo cercando di riportare i primi due elementi della lista.

a= [1,2,3,4,5]
print(a[0:,2])

Result:
Traceback (most recent call last):
   line 14, in <module>
    print(a[0:,2])
TypeError: list indices must be integers or slices, not tuple

Il motivo per cui si verifica lo stesso errore è la virgola aggiuntiva in a[0:,2], causa la comparsa dell'errore poiché Python non sa come processarla.

Questo è facilmente risolvibile rimuovendo la virgola aggiuntiva come segue:

a= [1,2,3,4,5]
stampa(a[0:2])

Risultato:
[1, 2]
Processo terminato con codice di uscita 0

Allora perché si parla di tuple nell'output di errore?

Il pezzo finale del puzzle deve capire perché c'è un riferimento a una tupla nell'output di errore?

Se torniamo a guardare una lista di liste e guardiamo i loro valori di indice:

a=[[1,2,3],[4,5,6]]
z = [index for index, value in enumerate(a)]
print(z)

Result:
[0, 1]
Process finished with exit code 0

Come si può vedere, i valori dell'indice sono 0,1, che è corretto.

Come prima la rimozione della virgola dà l'errore che stiamo cercando di risolvere:

a=[[1,2,3][4,5,6]]
z = [index for index, value in enumerate(a)]
print(z)

Result:
Traceback (most recent call last):
  line 16, in <module>
    a=[[1,2,3][4,5,6]]
TypeError: list indices must be integers or slices, not tuple

MA il riferimento alla tupla deriva dal fatto che quando si passano due argomenti (diciamo un valore di indice) viene creata una tupla , ma in questo caso, poiché manca la virgola la tupla non viene creata e viene chiamato l'errore.

Questo deriva dal __getitem__ per una classe integrata in una lista non può trattare con argomenti di tuple che non sono interi (cioè 0,1 come abbiamo restituito qui), quindi viene lanciato l'errore, sta cercando i due valori di indice da passare in una tupla.

Come confrontare le intestazioni di colonna in CSV con una lista in Python

Tempo di lettura stimato: 3 minuti

Quindi avete numerosi progetti di automazione diversi in Python. Per garantire un'elaborazione pulita e senza intoppi, è necessario fare dei controlli per assicurarsi che ciò che è stato ricevuto sia nel formato giusto.

La maggior parte dei file utilizzati in un processo automatizzato, ma non tutti, saranno in formato CSV . È importante che le intestazioni di colonna in questi file siano corrette in modo da poter elaborare correttamente il file.

Questo assicura un processo rigoroso che limita gli errori.

Come confrontare le intestazioni

Il primo passo sarebbe quello di caricare i dati in unframe di dati Pandas :

import pandas as pd

df = pd.read_csv("csv_import.csv") #===> Include the headers
print(df)

Il file originale attuale è il seguente:

Poi dobbiamo assicurarci di avere una lista con la quale possiamo confrontarci:

header_list = ['Nome','Indirizzo_1','Indirizzo_2','Indirizzo_3','Indirizzo_4','Città','Paese']

Il prossimo passo ci permetterà di salvare le intestazioni importate nel file in una variabile:

import_headers = df.axes[1] #==> 1 è per identificare le colonne
print(import_headers)

Notate che l'asse scelto era 1, e questo è quello che Python riconosce come asse delle colonne.

Infine applicheremo un ciclo come segue:

a = [i per i in import_headers if i non in header_list]
print(a)

In questo ciclo, la variabile "a" prende il valore "i" che rappresenta ogni valore nella variabile import_headers e attraverso un ciclo controlla ognuno di essi con la lista header_list per vedere se è presente.

Poi stampa i valori non trovati.

Il fatto di mettere insieme tutto questo dà:

importa pandas come pd

df = pd.read_csv("csv_import.csv") #===> Includere le intestazioni
stampa(df)

#Valori attesi da ricevere nel file CSV
header_list = ['Nome','Indirizzo_1','Indirizzo_2','Indirizzo_3','Indirizzo_4','Città','Paese']

import_headers = df.axes[1] #==> 1 è per identificare le colonne
print(import_headers)


a = [i per i in import_headers if i non in header_list]
print(a)

Il risultato è il seguente output:

Come si può vedere gli indirizzi qui sotto non sono stati trovati validi, poiché non erano contenuti nella nostra lista di controllo "header_list".

TypeError: l'oggetto 'list' non è un iteratore

Abbiamo coperto molti TypeErrors su questo sito web, qui andremo attraverso che usando una lista con e non è un iteratore ti dà errori.

Per capire meglio questo errore, dobbiamo prima capire cos'è un iteratore in Python?

Un iteratore è un oggetto Python che ha le seguenti caratteristiche:

  • Si può contare il numero di valori che sono contenuti in esso.
  • Può anche essere iterato, quindi è necessario applicare un metodo di iterazione ad esso.

Come si verifica questo errore?

Normalmente questo errore si verifica quando si cerca di iterare su una lista, ma non si è resa la lista iterabile.

Ci sono due cose necessarie perché questo accada:

(A) La funzione iter() restituisce un oggetto iteratore

(B) Il metodo next() passa al valore successivo.

Senza entrambi il codice fallirà e si verificherà l'errore di cui state parlando!

Nel codice seguente abbiamo una lista:

a = ['q', 'w', 'e', 'r', 't', 'y']

with the following:

b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)

Come si può vedere nel codice sopra abbiamo un solo componente per l'iterazione, ci aspettiamo due come per il precedente.

Come risultato otteniamo l'errore:

Traceback (most recent call last):
  File "list_object_is_not_an_iterator.py", line 13, in <module>
    b = next(a)
TypeError: 'list' object is not an iterator

Per risolvere questo, tutto quello che dobbiamo fare è applicare l'iteratore alla lista come segue:

a = iter(['q', 'w', 'e', 'r', 't', 'y']) ====> We added in the iter() here, enclosing the list within it

b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)
#b = next(a)


print(b)

Giving output:
y

Come risultato di ciò, ora abbiamo i due metodi richiesti che non daranno questo errore.

Cosa sta succedendo all'interno dell'iteratore?

Nel codice precedente abbiamo chiesto di stampare b. Ciò che l'iteratore sta facendo è andare al primo valore di b, in questo caso q e stampare.

Ma poiché abbiamo una variabile b su più linee, con il metodo "next()" in essa, la logica si muove attraverso ogni valore della lista fino ad arrivare alla fine.

Quello che si può fare però è ridurre la lunghezza delle variabili b restituite da stampare come segue:

a = iter(['q', 'w', 'e', 'r', 't', 'y'])
b = next(a)
print(b)
returns:
q

BUT
a = iter(['q', 'w', 'e', 'r', 't', 'y'])
b = next(a)
b = next(a)
print(b)
returns:
w

Come si può vedere, restituisce il prossimo valore della lista. Potete continuare ad aggiungere le variabili b.

Cosa succede quando si arriva alla fine della lista?

Così ora abbiamo il seguente, e stiamo restituendo l'ultimo valore:

a = iter(['q', 'w', 'e', 'r', 't', 'y'])
b = successivo(a)
b = successivo(a)
b = successivo(a)
b = successivo(a)
b = successivo(a)
b = successivo(a)

Restituisce:
y

La ragione di questo è che abbiamo il numero richiesto di variabili con il metodo successivo, che è uguale alla lunghezza della lista.

Se aggiungiamo un'altra variabile b:

a = iter(['q', 'w', 'e', 'r', 't', 'y'])
b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a)
b = next(a) ===> Additional b variable

Returns: 
Traceback (most recent call last):
  File "list_object_is_not_an_iterator.py", line 19, in <module>
    b = next(a)
StopIteration

Lo scopo di StopIteration è di non permettere un ciclo continuo e riconoscere che la fine della lista è stata raggiunta.

Implementare gli iteratori

Gli iteratori potrebbero essere utilizzati nelle seguenti circostanze:

(A) Avete una lista definita di valori di oggetti con cui lavorare.

(B) Se la sequenza è importante, un iteratore aiuterà ad elaborare i valori nell'ordine in cui appaiono in una lista.

come si dichiara un valore nullo in python?

Nello scrivere su questa questione, è importante capire alcune cose, prima di entrare nel codice.

I valori nulli appaiono in quasi tutti i linguaggi di programmazione, ma possono avere un significato diverso.

Un valore n ullo significa fondamentalmente che è vuoto. Quindi, quando si restituisce un valore nullo, non c'è niente dentro.

A volte può essere confuso con il valore zero, ma siccome zero è un intero reale, non è un valore vuoto in un campo.

Python usa None per definire la parola chiave null, che restituisce un valore vuoto.

Come possiamo mostrare null in un output?

Guardiamo l'output qui sotto. Dall'osservazione si può vedere che a,b,d restituisce un valore int, ma questo è abbastanza semplice.

Concentriamoci su c. Quando viene stampato, il valore sullo schermo non mostra nulla, e il suo tipo di dati è str. Ma perché è così, sicuramente è None o vuoto come ci aspettavamo?

Python restituirà una stringa, a meno che non sia esplicitamente dichiarata vuota. La prossima sezione vi guiderà in questo.

a = 1
b = 1
c = ""
d = a-b
print(a)
print(b)
print(c)
print(d)
print(type(a))
print(type(b))
print(type(c))
print(type(d))

Returns:
1
1

0
<class 'int'>
<class 'int'>
<class 'str'>
<class 'int'>

Quindi, sulla base di quanto sopra, come faccio a dichiarare un valore nullo in python?

Abbiamo modificato il codice sopra, e dichiarato c come None, e in questo caso il codice ora riconosce l'output come vuoto.

a = 1
b = 1
c = None
d = a-b
print(a)
print(b)
print(c)
print(d)
print(type(a))
print(type(b))
print(type(c))
print(type(d))

Result:
1
1
None
0
<class 'int'>
<class 'int'>
<class 'NoneType'>
<class 'int'>

Quali sono gli altri scenari in cui Nessuno sarà restituito?

Python restituisce anche valori su None, anche se non sono stati dichiarati esplicitamente.

Di seguito, se provate a stampare niente, per default restituirà un valore vuoto.

D'altra parte, usando un'istruzione if si può controllare se un valore è None.

L'ultimo esempio è quello in cui si usa una funzione per controllare se un valore è in una lista. Se il valore non appare nella lista non restituisce nulla.

Questo è particolarmente utile, se volete essere completamente sicuri che i valori restituiti non siano nulla.

Vi dà un livello di comfort che il codice non passerà nulla ad altre parti del programma.

a = print()
stampa(a)

variabile = Nessuno

se la variabile è Nessuno
    stampa("Corretto")
altrimenti:
    stampa("Non corretto")

variabile1 = "oggi"
se variabile1 è Nessuno
    stampa("Corretto")
altrimenti:
    stampa("Non corretto")


def returnnone():
    lista = [1,2,3,4,5]
    per i nella lista
        se i == 6:
            print("Sei trovato")
        else:
            stampa(Nessuno)
            
returnnone()

Risultato:
Nessuno
Corretto
Non corretto
Nessuno
Nessuno
Nessuno
Nessuno
Nessuno

Clicca qui per avere maggiori informazioni su altri post rilevanti di analisi dei dati.

come confrontare due liste in Python

Tempo di lettura stimato: 2 minuti

Spesso vi verrà chiesto di confrontare le liste, e avete bisogno di un modo rapido per completarle.

Qui prenderemo tre modi per completare il tutto, se avete altri commenti qui sotto.

Looping per trovare valori comuni tra le liste

Un semplice loop può aiutare a trovare i dati comuni a due liste:

# confrontare per valori simili
lista1 = ["1", "2", "3", "4"].
lista2 = ["1", "2", "3", "3", "4", "5"]

per i nella lista1:
    per j nella lista2:
        se i in j:
            stampa(i)

il che rende:

1
2
3
4

Confrontare per una voce in un elenco e non nell'altro

Ci sono forse delle volte in cui si desidera trovare solo i valori che sono in una lista e non nell'altra.

Qui di seguito utilizziamo un codice a una riga che utilizza la comprensione della lista, che fa la stessa cosa di un loop:

lista1 = ["1", "2", "3", "4"].
lista2 = ["1", "2", "3", "3", "4", "5"]
per l'articolo in [x per x nella lista2 se x non nella lista1]:
    stampa(voce)

che dà il risultato di:

5

confronto delle liste con il metodo impostato

Il terzo modo utilizza set di pitoni, che essenzialmente trova l'intersezione tra due liste, come un diagramma di Venn.

Qui usiamo set per trovare quali valori non sono comuni ad ogni lista usando la sottrazione:

lista1 = ["1", "2", "3", "4"].
lista2 = ["1", "2", "3", "3", "4", "5"]
a = set(lista1)
b = set(lista2)
c = b-a
stampa(c)

che ti da'..:

{'5'}

In alternativa si può trovare ciò che è comune ad entrambi:

lista1 = ["1", "2", "3", "4"].
lista2 = ["1", "2", "3", "3", "4", "5"]
a = set(lista1)
b = set(lista2)
c = a.intersezione(b)
stampa(c)

e il vostro risultato sarà:

{'1', '3', '4', '2'}

Ricordate che l'utilizzo dei set li restituirà non ordinati, se volete che siano ordinati applicate quanto segue al codice di cui sopra:

a = set(lista1)
b = set(lista2)
c = a.intersezione(b)
d=sortato(c)
stampa(tipo(d))
stampa(d)

e l'uscita sarà:

<class 'list'>
['1', '2', '3', '4']

Una cosa da notare è che il metodo ordinato sopra riportato restituisce l'insieme come una lista e non come un insieme.

Ci sono un sacco di risorse online dove si può imparare a conoscere i set.

Tutorial del Pitone: Come ordinare le liste

Tempo di lettura stimato: 2 minuti

Seguendo il nostro post su come usare le liste Python vi siete mai chiesti come ordinare le liste per il vostro progetto Python?

Il nostro ultimo video sulle liste passerà in rassegna alcune delle tecniche disponibili in modo che possiate farvi un'idea di come strutturare e ordinare i vostri dati.

Arrivare a capire come implementare

In quest'ultimo video vedremo:

  • metodo di ordinamento()
  • funzione ordinata()
  • ordinamento di una lista attraverso una funzione

 

Aggiunta di questi bit extra per aiutare a rendere il processo più fluido

Avete pensato di smistare l'ascendente e il discendente?

  • Anche su questo argomento si discute e, sebbene sia disponibile un indice per l'elenco, che a vostro avviso non merita di essere classificato, potrebbero esserci altre ragioni logiche per implementare lo smistamento.
  • Lasciando fuori l'inverso = Vero / falso nel metodo ordinato può avere un impatto, anche se se lo si richiede lasciato fuori dalla lista che si è creata, l'ascesa automatica sarà quella predefinita.

Su questo canale abbiamo discusso diversi modi per gestire i vostri dati. Pensando di ordinare una lista, perché vorreste farlo?

Alcuni motivi comuni sono:

  • Per vedere visivamente se ci sono duplicati, sia sullo schermo che stampati.
  • Se altri oggetti dipendono dalla lista, diciamo una combo box, allora avere dei duplicati visibili può aiutare a ridurre la dimensione del loro contenuto.
  • Iterazione - Se si cerca di iterare su una lista, sarà più veloce se viene ordinata.

Se volete saperne di più sulle liste, sul loro utilizzo e su come possono essere iterate, perché non visitate il canale YouTube di Data Analytics Ireland, ci sono molti video che vi aiuteranno a spiegare i concetti qui discussi.

Per ottenere qualche altro link su questo argomento clicca qui metodo di ordinamento pitone, è un blog postato dal nostro sito web che ha alcuni link utili e spiegazioni per voi.