Fondamenti di informatica

Ricerca lineare

Una ricerca lineare ispeziona gli elementi di una sequenza fino a quando trova un match. Ad esempio, per trovare il primo valore che sia maggiore di 100, è necessario visitare tutti gli elementi fino a trovare una corrispondenza o fino alla fine dell'elenco.

values = [0, 24, 240]
limit = 100
pos = 0
found = False

while pos < len(values) and not found:
    if values[pos] > limit:
        found = True
    else:
        pos = pos + 1

if found:
    print("Found at position:", pos)
else:
    print("Not found")

Raccolta e conteggio delle corrispondenze

Raccolta in una nuova lista di tutti i match presenti in un'altra lista:

values = [0, 24, 244, 100, 101, 24444]
limit = 100
result = []

for element in values:
    if element > limit:
        result.append(element)

print(result)

Conteggio dei match trovati in una lista:

values = [0, 24, 244, 100, 101, 24444]
limit = 100
counter = 0

for element in values:
    if element > limit:
        counter = counter + 1

print(counter)

NB: Un elemento appartenente a una lista fa "match" se rispetta determinate condizioni.

la condizione imposta; nei due esempi preceden il match si verificava per tu quegli elemen superiori a “limit” (che era 100).

Rimozione delle corrispondenze

Come si fa a RIMUOVERE DA UNA LISTA TUTTI GLI ELEMENTI CHE CORRISPONDONO A UNAPARTICOLARE CONDIZIONE?

Esempio: rimuovere da una lista tu e le stringhe di lunghezza < 4

words = ["M", "Ma", "Mat", "Matt", "Matti", "Mattia"]

i = 0

while i < len(words):

word = words[i]

if len(word) < 4:

words.pop(i)

else:

i = i + 1

print(words)

Scambio delle posizioni tra gli elemen di una lista

# Step 1

temp = values[i]

# Step 2

values[i] = values[j]

# Step 3

values[j] = temp

NB: la variabile “temp” con ene values[i]

Ingresso di le ura

È molto comune LEGGERE GLI INPUT DI UN UTENTE E MEMORIZZARLI IN UNA LISTA per unasuccessiva elaborazione.

values = []

print("Please enter values, Q to quit:")

userInput = input("")

while userInput.upper() != "Q"

• il metodo pop() viene utilizzato per rimuovere un elemento da qualsiasi posizione di una lista.
• il metodo remove() viene utilizzato per rimuovere un elemento da una lista in base al suo valore.
• due liste possono essere concatenate utilizzando l'operatore più (+).
• la funzione list() viene utilizzata per copiare le liste.
• l'operatore slice (:) viene utilizzato per estrarre una sotto-lista o delle sotto-stringhe.
• l'operatore "in" verifica se un elemento è contenuto in una lista.

UTILIZZO DELLE LISTE CON LE FUNZIONI

Una funzione può accedere a una lista come argomento.

La funzione seguente, ad esempio, visita gli elementi della lista ma non li modifica:

def sum(values):
    total = 0
    for element in values:
        total = total + element
    return total

Questa funzione, invece, moltiplica tutti gli elementi di una lista per un determinato fattore:

def multiply(values, factor):
    for i in range(len(values)):
        values[i] = values[i] * factor

values[i] * factor

# Questo programma legge i 5 valori dall'utente, li moltiplica per 10 e li stampa in ordine inverso
def main():
    numbers = readFloats(5)
    multiply(numbers, 10)
    printReversed(numbers)

# La funzione readFloats legge una sequenza di numeri in virgola mobile e restituisce un elenco.
# @param numberOfInputs il numero di input da leggere
# @return una lista contenente i valori di ingresso
def readFloats(numberOfInputs):
    print("Enter", numberOfInputs, "numbers:")
    inputs = []
    for i in range(numberOfInputs):
        value = float(input(""))
        inputs.append(value)
    return inputs

# La funzione multiply modifica gli elementi della lista moltiplicandoli per un fattore 10.
# @param values è una lista di numeri
# @param factor è il valore per il quale ogni elemento della lista viene moltiplicato
def multiply(values, factor):
    for i in range(len(values)):
        values[i] = values[i] * factor

<pre><code>float(userInput))</code></pre>
<pre><code>userInput = input("")</code></pre>
<pre><code>return values</code>
<h3>Removes the minimum value from a list.</h3>
<h4>@param values a list of size >= 1</h4>
<pre><code>def removeMinimum(values) :</code></pre>
<pre><code>    smallestPosition = 0</code></pre>
<pre><code>    for i in range(1, len(values)) :</code></pre>
<pre><code>        if values[i] < values[smallestPosition] :</code></pre>
<pre><code>            smallestPosition = i</code></pre>
<pre><code>    values.pop(smallestPosition)</code></pre>
<h3># Start the program.</h3>
<pre><code>main()</code></pre>
<p>La programmazione di questo algoritmo è stata svolta in questo modo:</p>
<h2>STEP 1</h2>
<p>Vogliamo iniziare con una scomposizione del problema ad alto livello:</p>
<ol>
    <li>Leggere i da in un elenco</li>
    <li>Elaborazione dei da</li>
    <li>Visualizzare i risulta</li>
</ol>
<p>Il passo successivo della raffinazione a tappe consiste nell'identificare il passaggio necessario per elaborare i da :</p>
<ol>
    <li>Leggi gli ingressi</li>
    <li>Rimuovere il minimo</li>
    <li>Rimuovere nuovamente il minimo</li>
    <li>Calcolare la somma</li>
</ol>
<h2>FASE 2</h2>
<p>Ora iniziamo a determinare gli algoritmi di cui abbiamo bisogno:</p>
<ul>
    <li>Abbiamo algoritmi funzionan per la le ura degli ingressi e il calcolo della somma.</li>
    <li>Per rimuovere il valore minimo possiamo trovare</li>
</ul>

Il minimo (abbiamo un algoritmo per questo) e rimuoverlo; è un po' più efficiente trovare la posizione del valore minimo e "fare un salto" in quella posizione.

STEP 3

Pianificare le funzioni di cui abbiamo bisogno:

• Possiamo calcolare la somma con la funzione somma esistente.
• Abbiamo bisogno di una funzione per leggere i numeri in virgola mobile: readFloats()
• Abbiamo bisogno di una funzione per rimuovere il minimo: removeMinimum() (la chiameremo due volte)

Dunque, la main function può essere strutturata in questo modo:

scores = readFloats()
removeMinimum(scores)
removeMinimum(scores)
total = sum(scores)
print("Final Score: ", total)

STEP 4

• Assemblare e testare il codice.
• Rivedere il codice e assicurarsi di gestire i casi "normali" ed "eccezionali":
• Come si gestisce un elenco vuoto?
• Un elenco con un solo elemento?
• E se non si trova il numero più piccolo?

In caso di errore si dovrebbe

Terminare il programma con un messaggio di errore prima di tentare di chiamare la funzione di rimozione dei minimi.

Sviluppare i casi di test e i risultati attesi:

TABELLE DI DATI

Le liste possono essere utilizzate per memorizzare dati in due dimensioni (2D) come un foglio di calcolo; in sostanza, possono fungere da matrici caratterizzate da righe e colonne.

Un esempio di codice per creare una tabella con 8 righe e 3 colonne, la quale è stata creata per contenere i dati del conteggio delle medaglie per ogni paese, è:

In questo modo si crea una lista in cui ogni elemento è a sua volta un'altra lista.

Tuttavia, a volte può essere necessario creare una tabella di dimensioni troppo grandi per essere inizializzata con valori letterali; in tal caso:

• Per prima cosa bisogna creare una lista che sarà usata per memorizzare le singole righe: table = []
• Successivamente, bisogna creare un nuovo elenco replicando il precedente (con il numero di colonne desiderato) per il numero di righe desiderato.

<table>
  <tbody>
    <!-- righe -->
    <tr>
      <!-- colonne -->
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <!-- colonne -->
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <!-- colonne -->
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <!-- colonne -->
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <!-- colonne -->
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
  </tbody>
</table>