Contenuti
Nel processo di apprendimento della programmazione, è spesso necessario creare programmi che non sono così facili da applicare nella vita reale. Dopotutto, di tanto in tanto devi seguire le istruzioni solo a determinate condizioni. Per poterlo implementare nel programma, tutte le lingue hanno istruzioni di controllo. Con il loro aiuto, puoi controllare il flusso di esecuzione del codice, creando loop o eseguendo determinate azioni solo quando una determinata condizione è vera.
Oggi parleremo dell'istruzione if, che controlla la situazione attuale per una determinata condizione e, sulla base di queste informazioni, prende decisioni su ulteriori azioni.
Tipi di dichiarazioni di controllo
In generale, if non è l'unica istruzione che controlla il flusso di un programma. Così come lui stesso può essere un componente di una più ampia catena di operatori.
Ci sono anche cicli e istruzioni che controllano il processo della sua esecuzione. Oggi parleremo solo dell'operatore condizionale e delle catene a cui può partecipare.
Nella programmazione c'è qualcosa come la ramificazione. È proprio questo che significa una sequenza di comandi che viene eseguita solo se una determinata condizione è vera. I criteri stessi possono essere diversi:
- Uguaglianza di una variabile ad un certo valore.
- Esecuzione di un'azione specifica.
- Stato dell'applicazione (compresso o meno).
Lo spettro può essere molto più ampio. Le dichiarazioni condizionali sono di diversi tipi:
- Con un ramo. Cioè, viene eseguito un unico controllo, a seguito del quale vengono eseguite determinate azioni.
- Con due o più rami. Se il criterio 1 è vero, verifica il criterio 2. Se è vero, verifica il 3. E quindi, esegui tutti i controlli necessari.
- Con diverse condizioni. Tutto è semplice qui. L'interprete verifica la presenza di più condizioni o di una di esse.
istruzione if
La struttura dell'istruzione if è simile in tutte le lingue. Tuttavia, in Python, la sua sintassi è leggermente diversa da tutte le altre:
se condizione:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
Per prima cosa viene dichiarato l'operatore stesso, dopodiché viene scritta la condizione in base alla quale inizia a funzionare. La condizione può essere vera o falsa.
Questo è seguito da un blocco con i comandi. Se segue immediatamente un criterio da soddisfare, la sequenza di comandi corrispondente viene chiamata blocco if. Puoi usare un numero qualsiasi di comandi al suo interno.
Attenzione! Il rientro all'interno di tutti i comandi if block deve essere della stessa dimensione. I limiti del blocco sono determinati dai rientri.
Secondo la documentazione della lingua, il rientro è di 4 spazi.
Come funziona questo operatore? Quando l'interprete vede la parola if, controlla immediatamente l'espressione rispetto ai criteri specificati dall'utente. Se questo è il caso, allora inizia a cercare le istruzioni e a seguirle. In caso contrario, tutti i comandi di questo blocco vengono ignorati.
Se un'istruzione dopo la condizione non è rientrata, non viene trattata come un blocco if. Nella nostra situazione, questa linea è
Ecco un frammento di codice per un esempio di come funziona questo operatore.
numero = int(input("Inserisci un numero: "))
se numero > 10:
print("Il numero è maggiore di 10")
Questo programma richiede all'utente un numero e controlla se è maggiore di 10. In tal caso, restituisce le informazioni appropriate. Ad esempio, se l'utente inserisce il numero 5, il programma terminerà semplicemente e il gioco è fatto.
Ma se specifichi il numero 100, l'interprete capirà che sono più di dieci e lo segnalerà.
Attenzione! Nel nostro caso, se la condizione è falsa, il programma si ferma, perché dopo l'istruzione non vengono dati comandi.
C'è un solo comando nel codice sopra. Ma ce ne sono molti di più. L'unico requisito è il rientro.
Analizziamo ora questa sequenza di comandi.
numero = int(input("Scrivi un numero: "))
se numero > 10:
print("prima riga")
print("seconda riga")
print("terza riga")
print(“La riga che viene eseguita, indipendentemente dal numero inserito”)
print("Termina domanda")
Prova a indovinare quale sarà l'output se inserisci i valori 2, 5, 10, 15, 50.
Come puoi vedere, se il numero inserito dall'utente è maggiore di dieci, vengono emesse tre righe + una con il testo "Esegui ogni volta ..." e una "Fine", e se inferiore a dieci, solo una, con un testo diverso. Solo le righe 3,4,5 verranno eseguite se true. Tuttavia, le ultime due righe verranno scritte indipendentemente dal numero specificato dall'utente.
Se utilizzi le istruzioni direttamente nella console, il risultato sarà diverso. L'interprete attiva immediatamente la modalità multiriga se, dopo aver specificato il criterio di verifica, preme Invio.
Supponiamo di aver scritto la seguente sequenza di comandi.
>>>
>>> n = 100
>>> se n > 10:
...
Successivamente, vedremo che >>> è stato sostituito dai puntini di sospensione. Ciò significa che la modalità di input multilinea è abilitata. In parole semplici, se premi Invio, verrai trasferito all'ingresso della seconda fase dell'istruzione.
E per uscire da questo blocco, devi aggiungere un'altra costruzione al blocco if.
>>>
>>> n = 100
>>> se n > 10:
… stampa(«nv 10»)
...
Se la condizione non è vera, il programma termina. Questo è un problema, poiché l'utente potrebbe percepire un programma del genere come chiuso a causa di un errore. Pertanto, è necessario fornire un feedback all'utente. Per questo, viene utilizzato un collegamento se altro.
operatore di espressione se altro
Questo operatore consente di implementare un collegamento: se l'espressione corrisponde a una determinata regola, eseguire queste azioni e, in caso contrario, altre. Cioè, ti consente di dividere il flusso del programma in due strade. La sintassi è intuitiva:
se condizione:
# se blocco
dichiarazione 1
dichiarazione 2
e così via
altro:
# altro blocco
dichiarazione 3
dichiarazione 4
Eccetera:
Spieghiamo come funziona questo operatore. Innanzitutto, l'istruzione standard viene eseguita nel thread tasso, controllando se corrisponde condizione "vero o falso". Ulteriori azioni dipendono dai risultati del controllo. Se true, l'istruzione che si trova nella sequenza di istruzioni che seguono la condizione viene eseguita direttamente. tasso, se è falso, allora altro.
In questo modo puoi gestire gli errori. Ad esempio, l'utente deve inserire un raggio. Ovviamente, può essere solo un numero con un segno più o è un valore nullo. Se è inferiore a 0, è necessario inviare un messaggio chiedendo di inserire un numero positivo.
Ecco il codice che implementa questa attività. Ma qui c'è un errore. Prova a indovinare quale.
raggio = int(input("Inserisci raggio: "))
se raggio >= 0:
print("Circonferenza = ", 2 * 3.14 * raggio)
print("Area = ", 3.14 * raggio ** 2)
altro:
print("Inserisci un numero positivo")
Errore di mancata corrispondenza del rientro. Se è Altro devono essere localizzati senza di essi o con lo stesso numero di essi (a seconda che siano nidificati o meno).
Diamo un altro caso d'uso (in cui tutto sarà corretto con l'allineamento dell'operatore): un elemento dell'applicazione che controlla una password.
password = input ("Inserisci password: ")
se password == «sshh»:
print("Benvenuto")
altro:
print(“Accesso negato”)
Questa istruzione salta ulteriormente la persona se la password è sshh. Se qualsiasi altra combinazione di lettere e numeri, viene visualizzato il messaggio "Accesso negato".
istruzione-espressione se-elif-else
Solo se diverse condizioni non sono vere, viene eseguita l'istruzione che si trova nel blocco. altro. Questa espressione funziona così.
se condizione_1:
# se blocco
dichiarazione
dichiarazione
più dichiarazione
condizione elif_2:
# primo blocco elif
dichiarazione
dichiarazione
più dichiarazione
condizione elif_3:
# secondo blocco elif
dichiarazione
dichiarazione
più dichiarazione
...
altro
dichiarazione
dichiarazione
più dichiarazione
È possibile specificare un numero qualsiasi di condizioni aggiuntive.
Dichiarazioni annidate
Un altro modo per implementare più condizioni consiste nell'inserire controlli di condizione aggiuntivi nel blocco if.
Operatore if all'interno di un altro blocco di condizioni
gre_score = int(input("Inserisci il tuo limite di credito attuale"))
per_grad = int(input("Inserisci il tuo rating creditizio: "))
se per_grad > 70:
# esterno se blocco
se gre_score > 150:
# interno se blocco
print(“Congratulazioni, hai ricevuto un prestito”)
altro:
print("Spiacenti, non hai diritto a un prestito")
Questo programma esegue un controllo del rating del credito. Se è inferiore a 70, il programma segnala che l'utente non ha diritto al credito. Se è maggiore, viene eseguito un secondo controllo per vedere se il limite di credito attuale è maggiore di 150. In caso affermativo, viene visualizzato un messaggio che indica che il prestito è stato erogato.
Se entrambi i valori sono falsi, viene visualizzato un messaggio che informa che l'utente non ha la possibilità di ottenere un prestito.
Ora rielaboriamo un po' quel programma.
gre_score = int(input("Inserisci limite di corrente: "))
per_grad = int(input("Inserisci punteggio di credito: "))
se per_grad > 70:
se gre_score > 150:
print(“Congratulazioni, hai ricevuto un prestito”)
altro:
print("Il tuo limite di credito è basso")
altro:
print("Spiacenti, non hai diritto al credito")
Il codice stesso è molto simile, ma annidato if fornisce anche un algoritmo nel caso in cui la condizione risulta essere falsa. Cioè, il limite sulla carta è insufficiente, ma la storia del credito è buona, viene visualizzato il messaggio "Hai un rating di credito basso".
istruzione if-else all'interno di una condizione altro
Creiamo un altro programma che determini il voto di uno studente in base ai punteggi dei test.
punteggio = int(input("Inserisci il tuo punteggio: "))
se punteggio >= 90:
print("Ottimo! Il tuo voto è A")
altro:
se punteggio >= 80:
print("Ottimo! Il tuo voto è B")
altro:
se punteggio >= 70:
print("Bene! Il tuo voto è C")
altro:
se punteggio >= 60:
print("Il tuo voto è D. Vale la pena ripetere il materiale.")
altro:
print("Non hai superato l'esame")
L'applicazione prima verifica se il punteggio è maggiore o uguale a 90. Se sì, restituisce un voto A. Se questa condizione è falsa, vengono eseguiti i controlli successivi. Vediamo che l'algoritmo è quasi lo stesso a prima vista. Quindi, invece di controllare dentro altro meglio usare una combinazione se-elif-altro.
Quindi l'operatore if svolge una funzione molto importante: si assicura che determinati pezzi di codice vengano eseguiti solo se necessario. È impossibile immaginare di programmare senza di essa, perché anche gli algoritmi più semplici richiedono fork come "se vai a sinistra, lo troverai, e se vai a destra, allora devi fare questo e quello".