Paniere domande esame Programmazione 2

B. INSERT, DELETE, UPDATE

(Questi sono i tre comandi DML standard per modificare i dati).

- Il comando INSERT permette di:

D. creare nuovi dati

(Il comando `INSERT` è utilizzato per aggiungere nuove righe a una tabella).

- Il comando DELETE permette di:

D. eliminare dati

(Il comando `DELETE` è usato per rimuovere righe da una tabella).

- Gli usi tipici di un trigger in un database sono:

B. 3

(I trigger possono essere utilizzati per validazioni, auditing, e per mantenere l'integrità dei dati).

- Nel caso di trigger che deve mantenere e aggiornare una tabella di log degli aggiornamenti di un

campo di un'altra tabella, nella creazione del trigger è necessario utilizzare la seguente

combinazione di keyword:

A. AFTER UPDATE

(Un trigger `AFTER UPDATE` esegue azioni dopo che un'operazione di aggiornamento è stata

completata).

Ecco le risposte corrette per il tuo quiz sulle stringhe in Python:

- Le stringhe sono sequenze di caratteri in codifica:

D. Unicode (16 bit)

(Le stringhe in Python 3 sono rappresentate in Unicode, che può usare più di 8 bit per

rappresentare caratteri).

- Il risultato dell'elaborazione del seguente codice:

```python

a = 1

s = 'ciao'

for i in s:

a -= 1

print(a)

```

A. -3

(Il ciclo `for` itera su 4 caratteri in `s`, quindi `a` viene decrementato 4 volte: 1 - 4 = -3).

- Stringa[4] equivale al:

C. quarto carattere

(In Python, l'indicizzazione delle stringhe parte da 0, quindi `Stringa[4]` restituisce il quinto

carattere).

- Il codice:

```python

s = 'ciao'

print(s[5])

```

D. Traceback IndexError

(La stringa `s` ha solo 4 caratteri, quindi l'indice 5 è fuori dal range).

- Il metodo `isalnum()` restituisce True se:

A. stringa contiene solo caratteri alfanumerici e ha lunghezza >=1

(Restituisce True solo se la stringa è non vuota e contiene solo caratteri alfanumerici).

- Il metodo `lstrip(a)` restituisce:

C. una stringa con tutti gli i caratteri a iniziali rimossi

(`lstrip(a)` rimuove i caratteri specificati dall'inizio della stringa).

- Il codice:

```python

s = 'va pensiero'

s1 = 'va'

s1 = s1 + 'pensiero'

print(s.replace(s, s1))

```

D. vapensiero

(Il codice sostituisce l'intera stringa `s` con `s1`, che diventa `'vapensiero'`).

- Il codice:

```python

s = '''Ei fu. Siccome immobile, Dato il mortal sospiro, Stette la spoglia immemore Orba di tanto

spiro, Così percossa, attonita La terra al nunzio sta'''

a = s.split(',')

print(len(a))

```

B. 4

(La stringa è divisa in base alla virgola, producendo 4 porzioni).

- L'istruzione `a = ''.join(cons + voc + ['x']*2)[0:3]` permette di:

C. calcolare la porzione del codice fiscale relativa al cognome

(La funzione `join` concatena i caratteri in una stringa, e `[0:3]` ne estrae i primi 3).

- Nell'istruzione `controllo[((a+b)%26)].upper()`, controllo è:

C. una stringa

(In questo contesto, `controllo` è comunemente una stringa utilizzata per l'indicizzazione).

Ecco le risposte corrette per il tuo quiz sul modulo `re` di Python:

- La funzione `findall()` del modulo re:

B. restituisce una lista di stringhe

(La funzione `findall()` restituisce tutte le occorrenze della corrispondenza come una lista di

stringhe).

- Il codice:

```python

import re

r = re.findall(r"[0-9a-z]+","1 2 3 a b c d")

print(len(r))

```

B. 6

(Ci sono 6 corrispondenze: '1', '2', '3', 'a', 'b', 'c', 'd').

- Il codice:

```python

import re

r = re.findall(r'".+"','"1 2 3" "a b c d"')

print(len(r))

```

C. una lista di 2 elementi

(Ci sono due stringhe che corrispondono: `"1 2 3"` e `"a b c d"`).

- Il codice:

```python

import re

r = re.sub(r'".*?"',"*",' "1 2 3" "a b c d"')

print(r)

```

C.

(Entrambe le stringhe racchiuse tra virgolette vengono sostituite da `*`, quindi l'output è `* *`).

- Il codice:

```python

import re

r = re.findall(r'\d (?=[a-z])','1 2 3 a b c d')

print(r)

```

D. ['3 ']

(La regex cerca una cifra seguita da uno spazio e poi da una lettera minuscola. Solo `3`

corrisponde).

- Il codice:

```python

import re

p = re.compile(r'\d (?=[a-z])')

r = p.findall('1 2 3 a b c d')

print(r)

```

D. ['3 ']

(Simile al punto 5, solo `3` soddisfa la condizione).

- Il codice: (Nota: sembra che tu abbia tralasciato parte della domanda, ma in base a ciò che hai

fornito finora, risponderò considerando un contesto simile a quello delle domande precedenti).

- Il codice:

```python

import re

p = re.compile(r'a(b(c)d)')

r = p.match('abcd')

print(r.group(1))

```

C. c

(Il gruppo 1 è `b(c)d`, quindi il gruppo interno è `c`).

- Il codice:

```python

import re

p = re.compile(r'a(?:b(c)d)')

r = p.match('abcd')

print(r.group(1))

```

C. c

(Il gruppo 1 cattura `c`, anche se la parte `b` è un gruppo non catturante).

- Per verificare le mail del tipo nome_utente@unimercatorum.it è necessario utilizzare la seguente

espressione regolare:

B. r'[a-zA-Z][\w-]*@unimercatorum.it'

(Questo assicura che il nome utente inizi con una lettera e possa contenere lettere, numeri,

underscore e trattini prima della parte `@unimercatorum.it`).

- Il globbing è:

B. un'operazione che consiste nel ricercare stringhe tramite espressioni regolari semplificate

- Nel globbing l'asterisco e il punto interrogativo rappresentano:

A. zero o più caratteri ed esattamente un carattere, rispettivamente

- La funzione `iglob()` è:

C. simile a `glob()`, ma non memorizza simultaneamente tutti i valori restituiti da `glob()`

- Per poter leggere e scrivere su file binario è necessario:

B. serializzare e deserializzare gli oggetti, rispettivamente

- Per poter leggere e scrivere su file binario si ricorre:

C. alla funzione `load` e `dump`, rispettivamente

- Nel codice:

```python

import pickle

ifile = open('a.dat','rb')

b = pickle.load(inputfile)

```

b è:

B. un oggetto

- La sentinella è:

D. uno o più valori di una variabile in una struttura iterativa

- Nell'istruzione `pickle.dump(a,b)` a e b sono:

B. oggetto e gestore del file

- L'istruzione `r = re.findall(r"\w+", line, re.I)` serve per:

C. trovare le parole in line senza considerare la differenza minuscolo/maiuscolo

- Nell'indicizzatore di file, l'istruzione `d[p.upper()] = d[p.upper()]+lista` permette di:

C. concatenare la lista dei valori di p

Ecco le risposte corrette per le domande:

- Data una lista v di 11 elementi, le operazioni di somma che vengono effettuate nella funzione

somma(v) sono:

B. 10

(Per sommare n elementi, si effettuano n-1 operazioni).

- Nell'inserimento ordinato in una lista, il nuovo elemento viene posto in coda alla lista in:

A. un caso

(In generale, si posiziona in coda se è maggiore di tutti gli altri).

- Nell'esercizio sliding window con larghezza della finestra uguale a 3, il codice che imposta la

struttura iterativa che permette lo scorrimento della finestra e che ha corpo del ciclo uguale a (av[i-

1]+v[i]+v[i+1])/ -0 è:

D. for i in range(1,len(v)-1):

(Questo consente di accedere a v[i-1] e v[i+1] senza uscire dai limiti della lista).

- Per applicare l'algoritmo della sliding window con una finestra di larghezza k=4, è possibile

usare la lista:

A. [1,2,3,4]

(Ha sufficienti elementi per applicare la finestra).

- Data una sliding window di larghezza k, il codice che permette di impostare la struttura iterativa

che permette lo scorrimento della finestra stessa sulla lista è:

C. for i in range(k//2,len(v)-k//2)

(Questo codice gestisce correttamente gli indici in base alla larghezza della finestra).

Se hai ulteriori domande o hai bisogno di chiarimenti su qualche punto specifico, fammi sapere!

- Data una lista v di 11 elementi, le operazioni di somma che vengono effettuate nella funzione

somma(v) sono:

B. 10

(Per sommare n elementi, si effettuano n-1 operazioni).

- Nell'inserimento ordinato in una lista, il nuovo elemento viene posto in coda alla lista in:

A. un caso

(In generale, si posiziona in coda se è maggiore di tutti gli altri).

- Nell'esercizio sliding window con larghezza della finestra uguale a 3, il codice che imposta la

struttura iterativa che permette lo scorrimento della finestra e che ha corpo del ciclo uguale a (av[i-

1]+v[i]+v[i+1])/ -0 è:

D. for i in range(1,len(v)-1):

(Questo consente di accedere a v[i-1] e v[i+1] senza uscire dai limiti della lista).

- Per applicare l'algoritmo della sliding window con una finestra di larghezza k=4, è possibile

usare la lista:

A. [1,2,3,4]

(Ha sufficienti elementi per applicare la finestra).

- Data una sliding window di larghezza k, il codice che permette di impostare la struttura iterativa

che permette lo scorrimento della finestra stessa sulla lista è:

C. for i in range(k//2,len(v)-k//2)

(Questo codice gestisce correttamente gli indici in base alla larghezza della finestra).

Ecco le risposte corrette per le domande sulla successione di Fibonacci, l'algoritmo selection sort e

altre nozioni di programmazione:

- Nella successione di Fibonacci:

A. Il valore di un elemento in una determinata posizione è uguale alla somma dei due elementi

che lo precedono ad eccezione dei primi due elementi

(La successione inizia con 0 e 1, e ogni elemento successivo è la somma dei due precedenti).

- La sezione aurea:

B. È il limite del rapporto dei valori consecutivi della successione di Fibonacci per n tendente ad

infinito

(Questo rapporto converge al valore della sezione aurea, che è circa -618).

- Nel selection sort:

C. dopo il primo turno di confronti tra elementi, in un ordinamento crescente, l'elemento

maggiore della sequenza viene posto in ultima posizione

(Selection sort seleziona il più piccolo elemento e lo sposta all'inizio, e ripete l'operazione per gli

elementi rimanenti).

- Per scambiare due elementi tra di loro il codice corretto per farlo è:

B. a = l[j] l[j+1] = l[j] l[j] = a

(Tuttavia, c'è un errore nella risposta B, il codice corretto per scambiare sarebbe: `a = l[j]; l[j] =

l[j+1]; l[j+1] = a`).

- Nel selection sort nell'i