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 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.

Come automatizzare i test con Python | unittest

Tempo di lettura stimato: 5 minuti

Quindi state lavorando con grandi quantità di dati, e i dati stanno avendo trasformazioni applicate ad essi o semplicemente avete bisogno di vedere, mentre spostate i dati, se sono cambiati in qualche modo.

La domanda che sorge è: se ho molte convalide da completare, come posso vedere rapidamente se passano o falliscono?

Qui vi porteremo attraverso unittest, un framework di test Python che vi permetterà un modo rapido per validare i dati con cui state lavorando.

Passo 1 - Definire gli scenari di test

Come in ogni test, il primo passo è definire cosa si vuole testare e qual è il risultato atteso. Qui stiamo testando dei dati che sono stati trasformati in un valore diverso.

Il test poi guarda i nuovi valori e li confronta con una lista di valori che sono attesi nell'output.

Come si può vedere, le due righe di cui sopra saranno ciò che useremo per creare i nostri casi di test, che saranno delineati di seguito.

Anche se i seguenti possono sembrare molto rigidi, sottolineano esattamente ciò che stiamo testando. O tutti i dati passano il test o non lo passano.

In realtà, queste regole possono essere modificate/allentate a seconda di ciò che dovete testare, questo è puramente a scopo illustrativo:

Passo 2 - Creare il nostro file python che passerà i dati trasformati

Questo è il primo file di cui abbiamo bisogno, sarà il file sorgente che verrà utilizzato per trasformare i dati e poi passare al modulo di test in seguito.

In questo caso, si chiama "automate_testing_python.py".

Ho creato un dizionario qui, ma potete leggere un file CSV o qualsiasi file che desiderate. Basta assicurarsi che venga passato al frame di dati.

import pandas as pd

data = {'Name_before':['Joe','Liz','Pat'],'Name_after':['Joseph','Elizabeth','Patrick']} #===> Creating a dictionary

df = pd.DataFrame(data) #===> Creating a dataframe


def main():

    transfromations_applied = data['Name_after'] #===> Defines the column you want to test against
    return transfromations_applied #===> Returns the values that will be used in the automation script

La funzione "main" sopra definisce chiaramente quale colonna contiene i dati da passare al test automatico, in questo caso " transfromations_applied "

Fase 3 - Creare un file di script di test

Nel seguito ci sono diversi passi da seguire:

  1. Installate il pacchetto HTMLTestrunner in qualsiasi soluzione stiate usando.
  2. Installate la libreria Unittest nello stesso programma. Questo eseguirà i test richiesti e fornirà gli output dei risultati.
  3. Poi stiamo importando ciò che è stato restituito dalla funzione "main" nel file "automate_testing_python.py".
  4. Il passo successivo è la creazione della classe, questo serve ai seguenti scopi:
    1. Definisce i test esatti che vogliamo eseguire.
    2. Nel primo metodo, si definisce chiaramente quali valori sono attesi e contro quali devono essere testati.
    3. Il secondo metodo è puramente il controllo che tutti i valori siano alfabetici.
  5. L'ultima linea è l'esecuzione di un file che eseguirà i test e poi restituirà i valori al file html di output.
from HTMLTestRunner import HTMLTestRunner
import unittest

from automate_testing_python import main #===> Importa i dati restituiti


#Questo è il codice che esegue i test
#Ogni metodo è un test specifico
class test_values(unittest.TestCase):


def test_ValueEquals(self):

ExpectedValues = ['Joseph','Elizabeth','Patrick']
values_received = main()
self.assertListEqual(ExpectedValues,values_received)

def test_Valueisalphabetic(self):

values_received = main()
for c in values_received:
self.assertTrue(c.isalpha())



if __name__ == "__main__":
HTMLTestRunner.main()

Passo 4 - Creare il file che genererà il file HTML di output con i risultati.

Come risultato dei passi precedenti abbiamo creato i dati, li abbiamo portati a testare contro scenari di test predefiniti.

Ora, tutto quello che dobbiamo fare è presentare i risultati in un file HTML.

In questo caso, l'output sarà più facile da capire e più veloce da digerire.

Nel codice qui sotto, segue i seguenti passi:

(A) La prima e la seconda riga importano le librerie di cui avremo bisogno per eseguire questo pezzo di codice.

(B) La terza linea sta ricevendo i valori che sono stati generati dalla classe nel passo 3.

(C) Tutte le prossime quattro linee fanno, è tirare dentro i dati, allegarli al file myreport.html

(D) Le ultime due linee fanno quanto segue:

  1. Dite al programma di prendere i dati ricevuti e poi usare il pacchetto HTMLTestRunner per elaborarli e creare l'output del modello.
from HTMLTestRunner import HTMLTestRunner
import unittest
from test_automate_testing_python import test_values

if __name__=='__main__':
    suite=unittest.makeSuite(test_values)
    filename='C:\\Users\haugh\OneDrive\dataanalyticsireland\YOUTUBE\how_to_automate_testing_with_python\myreport.html'
    fp=open(filename,'w')
    runner=HTMLTestRunner.HTMLTestRunner(fp,title=u'Data Analytics Ireland Test Output',description=u'This shows the testing output result')
    runner.run(suite)

Passo 5 - Eseguire il file html_report.py

L'esecuzione di questo file aprirà ed eseguirà anche il codice negli altri file a cui si fa riferimento in questo post.

Come risultato, quando il programma è finito l'output sarà simile a questo:

All'inizio del programma abbiamo creato un dizionario (STEP 1) come questo:

data = {‘Name_before’:[‘Joe’,’Liz’,’Pat’],’Name_after’:[‘Joseph’,’Elizabeth’,’Patrick’]} #===> Creating a dictionary

e poi nel Passo2 nella nostra classe "test_values" abbiamo definito gli output attesi.

def test_ValueEquals(self): ExpectedValues = ['Joseph','Elizabeth','Patrick']

In questo caso, i valori sono gli stessi, l'output di cui sopra segnerà i due test come Pass.

Ma se i valori passati sono:

data = {‘Name_before’:[‘Joe’,’Liz’,’Pat’],’Name_after’:[‘Joseph’,’Elizabeth’,‘Patrick1’]} #===> Creating a dictionary

e sono confrontati con

def test_ValueEquals(self): ExpectedValues = ['Joseph','Elizabeth','Patrick']

Apparirà il seguente output, poiché i due test falliranno:

Così abbiamo creato due casi di test qui, ma potremmo aggiungerne molti altri e poi avere l'automazione che ci restituisce rapidamente i risultati dei test.

Come aggiungere formule a Excel usando Python

Tempo di lettura stimato: 3 minuti

Potresti lavorare sull'automazione di alcune esportazioni in Excel usando Python per confrontare i file o semplicemente aggiungendo formule a un file Excel prima di aprirlo.

Qui spieghiamo l'aggiunta di formule all'output di Excel usando Numpy o aggiungendo i calcoli a celle specifiche nell'output.

Aggiungere formule a celle specifiche

Prima di tutto, guardiamo il normale foglio di calcolo con alcuni calcoli, questi hanno le formule digitate. L'obiettivo finale è che il codice Python faccia questo per noi, un passo in meno.

Come si può vedere, le celle hanno le formule al loro interno, ma questo sarebbe un processo molto dispendioso in termini di tempo se si dovesse fare più volte, in più fogli di calcolo.

Per aggirare questo problema possiamo scrivere la logica Python come segue:

  1. Crea tre liste e tre dataframes come segue.
datasetA_list = np.array([1,2,3,4,5,6,7,8,9,10])

datasetB_list = np.array([9,8,65,43,3,21,3,2,1,7])

dataset_list = ('sum','average','median','standard deviation','count','correlation')


datasetA = pd.DataFrame(datasetA_list,columns=['ValueA'])
datasetB = pd.DataFrame(datasetB_list,columns=['ValueB'])
dataset_list_calcs = pd.DataFrame(dataset_list, columns=['Calcs'])

2. Quindi create un percorso dove memorizzerete i dati come segue:

path = 'output.xlsx'

3. In questo passo successivo create la cartella di lavoro e la posizione in cui verranno memorizzati i dati. Questo caricherà le intestazioni create nel passo 1 in una particolare posizione del foglio di lavoro.

workbook = pd.ExcelWriter(path, engine='openpyxl')
workbook.book = load_workbook(path)
workbook.sheets = dict((ws.title,ws) for ws in workbook.book.worksheets)

datasetA.to_excel(workbook,sheet_name="Sheet1", startrow=1,index=False, header=True,)
datasetB.to_excel(workbook,sheet_name="Sheet1", startrow=1, startcol=2,index=False, header=True)
dataset_list_calcs.to_excel(workbook,sheet_name="Sheet1", startrow=1, startcol=4,index=False, header=True)

4. Caricate le formule nelle celle accanto alle relative intestazioni. Questo dovrebbe allineare queste formule accanto all'intestazione pertinente creata nel passo 1.

###Creazione di calcoli per datasetA

sheet = workbook.sheets['Sheet1']
sheet['E2'] = 'CalcsA'
sheet['F3'] = '=SUM(A3:A12)'
sheet['F4'] = '=AVERAGE(A3:A12)'
sheet['F5'] = '=MEDIAN(A3:A12)'
sheet['F6'] = '=STDEV(A3:A12)'
sheet['F7'] = '=COUNT(A3:A12)'
sheet['F8'] = '=CORREL(A3:A12,C3:C12)'

###Creazione di calcoli per datasetB

sheet = workbook.sheets['Sheet1']
sheet['H2'] = 'CalcsB'
sheet['H3'] = '=SUM(C3:C12)'
sheet['H4'] = '=AVERAGE(C3:C12)'
sheet['H5'] = '=MEDIAN(C3:C12)'
sheet['H6'] = '=STDEV(C3:C12)'
sheet['H7'] = '=COUNT(C3:C12)'
sheet['H8'] = '=CORREL(A3:A12,C3:C12)'

Usa Numpy per creare i calcoli

a. Create i calcoli che popolerete nel foglio di calcolo, usando Numpy

a = np.sum(datasetA_list)
b = np.average(datasetA_list)
c = np.median(datasetA_list)
d = np.std(datasetA_list,ddof=1) ## Setting DDOF = 0 will give a differnt figure, this corrects to match the output.
f = np.count_nonzero(datasetA_list)
g = np.corrcoef(datasetA_list,datasetB_list)

b. Creare le intestazioni e assegnarle a particolari celle

sheet['E14'] = 'Numpy Calculations'
sheet['E15'] = 'Sum'
sheet['E16'] = 'Average'
sheet['E17'] = 'Median'
sheet['E18'] = 'Standard Deviation'
sheet['E19'] = 'Count'
sheet['E20'] = 'Correlation'

c. Assegnare le variabili del passo a a un insieme di celle

sheet['F15'] = a
sheet['F16'] = b
sheet['F17'] = c
sheet['F18'] = d
sheet['F19'] = f
sheet['F20'] = str(g)

d. Salvare la cartella di lavoro e chiuderla - Questo passo è importante, e va sempre incluso.

workbook.save()
workbook.close()

E l'output finale appare come...

TypeError: il primo argomento deve essere richiamabile

Tempo di lettura stimato: 3 minuti

Quindi potreste usare le classi Python e aver riscontrato il problema TypeError: First Argument Must be Callable. Quindi cosa significa il problema e come potete risolverlo?

In questo articolo, stiamo cercando di spiegare come può verificarsi e la facile soluzione che si può applicare per fermare il problema in futuro.

Prima cerchiamo di capire come chiamare le funzioni/metodi

Normalmente in un programma python per computer, avrete bisogno di usare una funzione/metodo perché ha la funzionalità che vi farà risparmiare tempo, e può essere continuamente riutilizzata.

Un esempio classico è print("Hello") che gestisce tutta la logica necessaria per mostrarlo su uno schermo. Il suo output è rapidamente visualizzabile, e non c'è bisogno di capire cosa sta succedendo in background.

Qui in questo esempio abbiamo eseguito la funzione da sola, di conseguenza non ha bisogno di puntare da qualche altra parte per eseguire la logica che contiene.

Per l'errore che stiamo cercando di risolvere, questo è parte del problema. Una funzione/metodo può essere eseguita da sola o dall'interno di una classe.

La differenza determinante è che da solo ha bisogno della parentesi, cioè (), ma se lo si chiama dall'interno di una classe, allora deve essere gestito in modo diverso.

Vedere l'errore di tipo First Argument deve essere richiamabile e correggerlo

Di seguito abbiamo un blocco di codice che produce l'errore che stiamo cercando di risolvere.

In seguito a quanto discusso sopra, la linea incriminata viene evidenziata.

In particolare il problema sta con printprogress(). Questo è stato chiamato, ma in realtà il problema è che quando si ha la logica scritta in questo modo, dà l'errore per cui questo post è stato impostato.

In sostanza sta cercando di eseguire il programma da quel punto esatto, cosa che python non permette.

La rimozione della parentesi permette quindi al programma di andare a cercare il modulo a cui fa riferimento e di eseguire la logica contenuta in esso.

import schedule
import time

class scheduleprint():

    def printprogress(self):
        print("Start of Processing")
        print("Processing Complete")

    def schedule_a_print_job(self, type="Secs", interval=5):

        if type == "Secs": # Fed from the function paramaters
            schedule.every(interval).seconds.do(self.printprogress())===> The problem is here, remove the () after printprogress.
            # Including the parentheses  after printprogess will throw an error as you cant run that method directly from there you can only call it.

        if type == "Mins": # Fed from the function paramaters
            schedule.every(interval).minutes.do(self.printprogress)
            # Including the parentheses  after printprogess will throw an error as you cant run that method directly from there you can only call it.

        while True:
            schedule.run_pending()
            time.sleep(1) # The number of seconds the Python program should pause execution.

run = scheduleprint() # initiating an instance of the class "scheduleprint"
run.schedule_a_print_job() # running the function contained within the class.

In sintesi, per aiutare a risolvere questo problema:

(A) Controlla il tuo codice per vedere dove sta chiamando un modulo all'interno di una classe.

(B) Poi assicuratevi che in quella chiamata non ci siano parentesi, altrimenti non sarà in grado di trovare il modulo.

TypeError: l'oggetto 'str' non è richiamabile

Tempo di lettura stimato: 2 minuti

Questo è un comune TypeError che si incontra in Python, in realtà è facile diagnosticare come si è verificato.

Per iniziare dobbiamo capire che "str" è una funzione in python, e converte qualsiasi valore in una stringa.

Di conseguenza, poiché è una funzione, la vostra capacità di chiamarla ha delle limitazioni.

Quindi, in sostanza, ha delle parentesi () accanto, e permette di passargli dei parametri.

Vediamo prima come funziona la funzione stringa:

x = str("10")
y = 10

print(type(x))
print(type(y))
print(x)
print(y)

With output:
<class 'str'>
<class 'int'>
10
10

Come vedrete sopra il valore 10, da solo è un intero, ma quando chiamate la funzione stringa, ora diventa una stringa.

Per questo motivo questo, chiamando una funzione stringa, completa una conversione in stringa di dieci, ma cosa succede se la variabile si chiama str?

Prendiamo un esempio qui sotto da un input:

str = input("what year where you born?")
print(str(str))

Output:

what year where you born?2021
Traceback (most recent call last):
  File "str obj is not callable.py", line 2, in <module>
    print(str(str))
TypeError: 'str' object is not callable

Process finished with exit code 1

La ragione di questo errore sopra, è che abbiamo chiamato la variabile "str".

Come si può vedere il programma sta cercando di usare la prima str nella dichiarazione di stampa come una funzione.

Come sappiamo ormai le variabili stringa non sono richiamabili.

Di conseguenza la funzione str() che il programma sta cercando di eseguire, fallisce con il TypeError identificato.

Per questo motivo per risolvere questo problema cambieremmo la variabile chiamata str in "anno", l'errore poi scompare.

Il codice aggiornato funzionerà perché quando si chiama str(), non è in conflitto con un nome di variabile.

anno = input("in che anno sei nato?")
stampa(str(anno))

Output:
"str obj non è richiamabile.py"
in che anno sei nato? 2021
2021

Processo finito con codice di uscita 0

Quindi, per riassumere:

  • Le stringhe non sono richiamabili
  • Non nominate una variabile come str, o qualsiasi nome di funzione, queste sono parole riservate dal sistema.
  • Le funzioni sono richiamabili, le stringhe no.

Tkinter GUI tutorial python - come pulire i dati excel

Tempo di lettura stimato: 2 minuti

Tkinter è un'applicazione all'interno di Python che permette agli utenti di creare GUI o interfacce utente grafiche per gestire i dati in modo più user-friendly.

Stiamo costruendo la nostra capacità di analisi dei dati qui, e cercando di fornire all'utente le funzionalità che usano nel loro lavoro o nei loro progetti universitari.

Abbiamo testato questo codice su 100.000 record seduti sulla rete Microsoft OneDrive, quindi in un certo senso, per questo motivo, le sue velocità erano abbastanza buone.

Come risultato su cinque prove, sono stati tutti sotto i 100 dall'inizio alla fine.

pulizia dei dati pulizia dati fissa

In questo tutorial Tkinter GUI python, vi verrà mostrato come trovare gli errori dei dati, pulirli e poi esportare il risultato finale in excel.

Vi guideremo attraverso quanto segue:

  • Creazione dell'interfaccia Tkinter.
  • Metodi/funzioni per trovare gli errori.
  • Metodi/funzioni per pulire i dati.
  • Esportazione dei dati puliti in un file excel.

 

Per riassumere:

Il video passa attraverso la creazione di una finestra di Tkinter utilizzando una tela e un fotogramma per memorizzare il fotogramma dei dati.

Poi si cerca di importare i dati attraverso pd.read_excel, per caricare i dati in un frame di dati panda.

Successivamente, c'è una funzione e/o un metodo che estrarrà gli errori attraverso str.extract , che viene caricato in colonne separate

Infine, ho esportato il dataset pulito usando rawdata.to_excel , e ho salvato il file come un nuovo foglio di calcolo separato.

come passare i dati tra le funzioni

Tempo di lettura stimato: 2 minuti

In questo programma python, stiamo imparando come passare i dati tra le funzioni. 

Alla luce di ciò, userete e vedrete le funzioni in molti linguaggi di programmazione e progetti di analisi dei dati.

Di conseguenza, la capacità di capirli è diventata importante.

Lefunzioni servono una serie di vantaggi:

  • È possibile passare loro una serie di argomenti da elaborare.
  • Riduce la ripetizione perché la funzione può essere chiamata da molti posti in un programma.
  • Sono facilmente identificabili utilizzando la parola chiave def nel vostro codice.
  • Una dichiarazione di ritorno può darvi l'output della funzione da mostrare sullo schermo o da passare ad un'altra funzione.

Si complimenta con r-tutorial-how-to-pass-data-between-functions/ come risultato questo è un pezzo pratico di funzionalità usato ampiamente in molti linguaggi di programmazione diversi.

Qui sotto c'è un video che aiuterà a dare una comprensione di come passare i dati tra le funzioni quando si cerca di imparare python:

 

In molti dei video del canale YouTube di Data Analytics Ireland, c'è un'enfasi sulla creazione di contenuti che eliminano la duplicazione del codice all'interno del codice.

Abbiamo anche iniziato ad incorporare le classi e potete vedere qui Come creare una classe in Python, un tutorial su come crearne una.

Leclassi per loro natura hanno metodi, che sono chiamati sugli oggetti che le hanno create (la classe), e possono alterare il loro stato, mentre una funzione viene eseguita e restituisce solo un valore.

È importante capire la distinzione, perché mentre i due otterranno molto probabilmente lo stesso risultato, è la capacità di cambiare lo stato della classe che li differenzierà.