Repository navigation
Expand file tree
/
Copy path16-conditionals.Rmd
More file actions
297 lines (201 loc) · 8.7 KB
/
Copy path16-conditionals.Rmd
File metadata and controls
297 lines (201 loc) · 8.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
# Programmazione Condizionale {#conditionals}
```{r settings, echo = FALSE}
knitr::opts_chunk$set(
echo = TRUE,
collapse=TRUE,
fig.align="center"
)
```
Uno dei principali costrutti della programmazione sono proprio le espressioni condizionali. L'idea semplice alla base è quella di eseguire alcune operazioni o eseguire le operazioni in un certo modo in funzione di alcune *condizioni*. Le condizioni non sono altro che espressioni che resituiscono sempre un valore *booelan* ovvero `TRUE` oppure `FALSE`.
L'esempio classico è quello dell'ombrello, immaginate di scrivere il codice per un videogioco e avete scritto una funzione per far prendere prendere e aprire l'ombrello al vostro personaggio. Chiaramente per rendere tutto credibile, dovete far eseguire questa operazione solo quando è richiesto ovvero quando piove. In termini di programmazione, dovete prima verificare una certa condizione (la pioggia) e poi eseguire (o non eseguire) una serie di operazioni di conseguenza.
## Strutture condizionali
Ci sono diverse possibilità in R, tuttavia la logica di eseguire operazioni solo quando alcune condizioni sono rispettate è sempre la stessa. La Figura \@ref(fig:plot-if-chart) rappresenta la struttura generica di un flusso di controllo condizionale.
### if
```{r, plot-if-chart, fig.cap="Rappresentazione if", out.width="65%"}
knitr::include_graphics("images/if_chart.png")
```
#### Struttura if {-}
Per scrivere la struttura condizionale della Figura \@ref(fig:plot-if-chart) si usa la seguente sintassi in R:
```{r, echo = TRUE, eval = FALSE}
...
if (<test>) {
<codice-da-eseguire>
}
...
```
#### Esempio {-}
- Singolo if
```{r, echo = TRUE}
my_function <- function(value){
if(value > 0){
cat("Il valore è maggiore di 0\n")
}
cat("Fine funzione\n")
}
my_function(5)
my_function(-5)
```
- Multipli if
```{r, echo = TRUE}
my_function <- function(value){
if(value > 0){
cat("Il valore è maggiore di 0\n")
}
if(value > 10){
cat("Il valore è maggiore di 10\n")
}
cat("Fine funzione\n")
}
my_function(5)
my_function(15)
my_function(-5)
```
### if...else
Il semplice utilizzo di un singolo `if` potrebbe non essere sufficiente in alcune situazioni. Sopratutto perchè possiamo vedere l'`if` come una deviazione temporanea dallo script principale (molto chiaro nella figura \@ref(fig:plot-if-chart)) che viene imboccata solo se è vera una condizione, altrimenti lo script continua. Se vogliamo una struttura più "simmetrica" possiamo eseguire delle operazioni se la condizone è vera `if` e altre per tutti gli altri scenari (`else`). La Figura \@ref(fig:plot-ifelse-chart) mostra chiaramente questa struttura diversa nel flusso.
```{r, plot-ifelse-chart, fig.cap="Rappresentazione if...else", out.width="65%"}
knitr::include_graphics("images/ifelse_chart.png")
```
#### Struttura if {-}
In R questo viene implementato nel seguente modo:
```{r, echo = TRUE, eval = FALSE}
...
if (<test>) {
<codice-da-eseguire>
} else {
<codice-da-eseguire>
}
...
```
#### Esempio {-}
- Singolo if...else
```{r, echo = TRUE}
my_function <- function(value){
if(value >= 0){
cat("Il valore è maggiore di 0\n")
} else {
cat("Il valore non è maggiore di 0\n")
}
cat("Fine funzione\n")
}
my_function(5)
my_function(-5)
```
- Multipli if
```{r, echo = TRUE}
my_function <- function(value){
if(value > 0){
cat("Il valore è maggiore di 0\n")
} else if (value > 10){
cat("Il valore è maggiore di 10\n")
} else {
cat("Il valore non è maggiore di 0\n")
}
cat("Fine funzione\n")
}
my_function(5)
my_function(15)
my_function(-5)
```
E' importante capire la differenza tra usare multipli `if` e `else if` rispetto a utilizzare un semplice `else`. Se noi vogliamo specificare un set **finito** di alternative, la scelta migliore e quella più chiara consiste di usere `else if` perchè al contrario di `else` richiede di specificare la condizione. Se invece siamo interessanti ad alcune condizioni mentre per tutto il resto applichiamo la stessa operazione, possiamo concludere il nostro flusso con un `else`.
### Nested
Oltre a concatenare una serie di `if` e `else if` è possibile inserire uno o più `if` all'interno di un'altro. Questo permette di controllare delle condizioni che sono dipendenti dal controllo precedente e quindi non possono essere eseguite in serie.
```{r, plot-ifnested, fig.cap="Rappresentazione if nested", out.width="65%"}
knitr::include_graphics("images/ifnested.png")
```
#### Struttura if {-}
```{r, echo = TRUE, eval = FALSE}
...
if (<test>) {
if(<test>) {
<codice-da-eseguire>
} else {
<codice-da-eseguire>
}
}
...
```
#### Esempio {-}
```{r, echo = TRUE}
my_function <- function(value){
if(value > 0){
if(value > 10) {
cat("Il valore è maggiore di 10\n")
} else {
cat("Il valore è maggiore di 0\n")
}
} else {
cat("Il valore non è maggiore di 0\n")
}
cat("Fine funzione\n")
}
my_function(5)
my_function(15)
my_function(-5)
```
### Esercizi {-}
Esegui i seguenti esercizi:
1. Definisci una funzione per assegnare un voto in base alla percentuale di rispote corrette (*score*) segui le seguenti indicazioni:
- score < .55 insufficiente
- .55 <= score < .65 - sufficiente
- .65 <= score < .75 - buono
- .75 <= score < .85 - distinto
- .85 <= score - ottimo
2. Definisci una funzione che determini se un numero è pari o dispari.
3. Definisci una funzione che determini se un numero è un multiplo di 3, 4, o 5.
4. Definisci una funzione che calcoli lo stipendio mensile considerando gli straordinari che sono retribuiti 1.5 della paga oraria normale. Utilizza come parametrile ore svolte nel mese, la paga oraria ed il tetto ore lavorative, oltre cui si contano gli straordinari.
## Altri Operatori Condizionali
### switch
L'operatore `switch` è un utile alternativa quando vogliamo eseguire una porzione di codice in modo condizionale all'input senza tuttavia usare una serie di `if`.
#### Struttura switch {-}
```{r, echo = TRUE, eval = FALSE}
switch(my_value,
case1 = action1,
case2 = action2,
... )
```
In questo caso, se il valore input (`my_value`) ha una corrispondenza tra i casi considerati (ad esempio `case1`), il codice corrispondente (`action1`) viene eseguito.
Ci sono alcune regole da considerare quando si utilizza uno `switch` statement:
- se il valore inserito è una stringa, R cercherà una corrispondenza come `input == argomento`
- se è presente più di una corrispondenza, viene utilizzata la prima
- non c'è la possibilità di inserire un valore di default
- se non viene trovata una corrispondenza viene restituito un valore `NULL`. Inserendo però un `case` senza un valore corrispondente, questo verra utilizzato al posto di `NULL`.
#### Esempio {-}
```{r, echo = TRUE}
my_colors <- function(color){
new_color <- switch(color,
"rosso" = "red",
"blu" = "blue",
"verde" = ,
"verde acqua" = "green",
"Not Found") # valore non trovato
return(new_color)
}
my_colors("blu")
my_colors("verde")
my_colors("arancione")
```
### ifelse
Gli `if`, `else` e `else if` statements funzionano solo per un singolo valore. In altri termini non è possibile testare una stessa condizione su una serie di elementi. Nel prossimo capitolo affronteremo la programmazione iterativa che permette di ripetere una serie di operazioni. Tuttavia utilizzando la funzione `ifelse()` è possibile implementare una versione vettorizzata delle operazioni condizionali.
La struttura è la seguente:
```{r, echo = TRUE, eval = FALSE}
ifelse(test = , yes = , no = )
```
Dove:
- `test` è la condizione da valutare e corrisponde a quello che di solito era tra parentesi negli `if` precedenti `if(test){...}`
- `yes` è il codice che viene eseguito se la condizione è `TRUE`
- `no` è il codice che viene eseguito se la condizione è `FALSE`
#### Esempio {-}
Immaginiamo di avere un vettore di numeri che corrispondono a delle età e vogliamo eseguire qualcosa se il l'età è maggiore o minore di 18 anni, ad esempio mostrare semplicemente la scritta "maggiorenne" oppure "minorenne". Utilizzando un semplice `if` vediamo che:
```{r}
age <- c(18, 19, 11, 10, 23, 55, 33, 26, 10)
if(age < 18){
print("Minorenne")
}else{
print("Maggiorenne")
}
```
Veniamo avvertiti che `age` non è un singolo valore e che quindi solo il primo valore è utilizzato. Questo dimostra che `if` non funziona su una lista di elementi. Utilizzando `ifelse` invece:
```{r}
ifelse(age < 18, yes = print("Minorenne"), no = print("Maggiorenne"))
```
In questo caso l'idea è di eseguire il codice precedente per ogni valore del nostro vettore in input. Questo è possibile perchè l'operazione `<` è vettorizzata.