Scarica Dispensa di linux/ gnu (sistemi e reti) e più Dispense in PDF di Sistemi di reti solo su Docsity!
INTRODUZIONE ALL'UTILIZZO DI GNU/LINUX
- 1.Premessa................................................................................................................................................. - Appunti delle lezioni di laboratorio -
- 2.Aprire una console Linux......................................................................................................................
- 3.I comandi in linea forniti dalla shell.....................................................................................................
- 3.1.Comandi per la gestione del filesystem........................................................................................
- 3.2.Comandi per la manipolazione dei files.......................................................................................
- 3.3.Comandi per la gestione degli utenti e dei processi....................................................................
- 3.4.Comandi per la gestione dei permessi sui files............................................................................
- 3.4.1.Digressione sui permessi sui file...............................................................................................
- 4.I comandi di ridirezione dell'output e i comandi di pipe......................................................................
- 4.1.Ridirezione dell’output..................................................................................................................
- 4.2.Comandi di pipe.............................................................................................................................
- 5.Editare testi dalla console......................................................................................................................
- 5.1.Breve guida ai comandi di VI
- 5.1.1.Normal mode...........................................................................................................................
- 5.1.2.Insert mode..............................................................................................................................
- 5.1.3.Command mode......................................................................................................................
- 6.L'interprete Python..............................................................................................................................
- 6.1.Introduzione.................................................................................................................................
- 6.2.Ciao mondo!..................................................................................................................................
- 6.3.Operatori.......................................................................................................................................
- 6.4.Commento.....................................................................................................................................
- 6.5.Variabili........................................................................................................................................
- 6.6.Strutture di controllo flusso........................................................................................................
- 6.6.1.Ciclo while..............................................................................................................................
- 6.6.2.Ciclo for..................................................................................................................................
- 6.6.3.Istruzione if.............................................................................................................................
- 6.6.4.Operatori di confronto e operatori logici................................................................................
- 6.7.Definizione di funzione................................................................................................................
- 6.8.Input da tastiera...........................................................................................................................
- 6.9.Importazione moduli....................................................................................................................
- 6.9.1.Introduzione............................................................................................................................
- 6.9.2.I moduli del Python.................................................................................................................
- 6.9.3.L'istruzione import
- 6.10.Librerie del Python....................................................................................................................
- 6.10.1.Modulo math.........................................................................................................................
- 6.10.2.Modulo Numeric...................................................................................................................
- 6.10.3.Modulo pil.............................................................................................................................
fa differenza digitare comandi con lettere maiuscole o minuscole. Segue un elenco di comandi con relativo esempio di utilizzo :
man: è l'help in linea
[d3ci01@thor d3ci01]$ man nomecomando
3.1.Comandi per la gestione del filesystem
cd: cambia la directory
[d3ci01@thor d3ci01]$ cd nomedirectory
pwd: indica il nome della directory corrente
[d3ci01@thor d3ci01]$ pwd
ls: crea la lista dei files presenti in una directory
[d3ci01@thor d3ci01]$ ls
rm: cancella un file o una directory
[d3ci01@thor d3ci01]$ rm nomefile
cp: copia uno o più files
[d3ci01@thor d3ci01]$ cp nomefile nomedir/.
mv: sposta uno o più files o directory
[d3ci01@thor d3ci01]$ mv nomefile1 nomefile
mkdir: crea una directory
[d3ci01@thor d3ci01]$ mkdir nomedir
3.2.Comandi per la manipolazione dei files
cat: visualizza il contenuto di un file
[d3ci01@thor d3ci01]$ cat nomefile
more: visualizza il contenuto di un file paginandolo
[d3ci01@thor d3ci01]$ more nomefile
less: consente di navigare all'interno di un file
[d3ci01@thor d3ci01]$ less nomefile
sort: ordina le righe di un file
[d3ci01@thor d3ci01]$ sort nomefile
3.3.Comandi per la gestione degli utenti e dei processi
who: stampa l'elenco di tutti gli utenti loggati in quel momento nel sistema
[d3ci01@thor d3ci01]$ who
whoami: Stampa a video il proprio nome utente
[d3ci01@thor d3ci01]$ whoami
id: stampa a video il proprio identificativo utente (UID) e l’identificativo di gruppo (GID)
[d3ci01@thor d3ci01]$ id
ps: visualizza i processi in esecuzione appartenenti all'utente
[d3ci01@thor d3ci01]$ ps
top: visualizza tutti i processi in corso
[d3ci01@thor d3ci01]$ top
kill: termina un processo in esecuzione dato l’identificativo di processo (PID)
[d3ci01@thor d3ci01]$ kill –p PID 9
3.4.Comandi per la gestione dei permessi sui files
chmod: consente di modificare i diritti di uso e apertura dei file
[d3ci01@thor d3ci01]$ chmod u+x nomefile
chown: cambia il proprietario del file
gruppi, p.e.: il gruppo degli amministratori di sistema, il gruppo degli sviluppatori o il gruppo degli studenti di una certa classe. Possiamo, allora, ipotizzare che l’utente 1 del gruppo A voglia condividere in lettura i suoi files con tutti gli utenti del gruppo e voglia impedire l’accesso a tutti gli altri. Per far questo i permessi vengono suddivisi in tre categorie: permessi riferiti all’utente, permessi riferiti al gruppo di appartenenza dell’utente e quelli riferiti a tutti gli altri. p.e. lavoro.txt rw-r---- oppure 640 indica che lavoro.txt può essere letto e modificato dall’utente, gli appartenenti al gruppo possono leggerlo e tutti gli altri non hanno alcuna autorizzazione. programma rwx--x--x indica che l’utente può leggere,modificare ed eseguire il file, gli appartenenti al gruppo e tutti gli altri possono solo eseguire il file. Esistono file speciali come le directory che vengono indicate con una d prima dei permessi. Esistono delle autorizzazioni speciali che non vengono in questa introduzione affrontati.
4.I comandi di ridirezione dell'output e i comandi di pipe
4.1.Ridirezione dell’output
Solitamente i comandi visualizzano il loro output a video, p.e.
[d3ci01@thor d3ci01]$ cat elenco.txt
visualizza le righe del file elenco.txt sulla finestra della console Linux. Lo standard output di ogni comando è il video. Ma se noi volessimo stampare l’output del comando sort su un file, in maniera tale da ottenere il file ordinato? Si esegue questa operazione utilizzando i comandi di ridirezione dell’output. Ne esistono due: > >> Vediamo subito un’esempio. Si abbiano due files primo.txt e secondo.txt il cui contenuto è:
primo.txt: secondo.txt: bravo paperino cattivo pluto bello pippo brutto
eseguiamo il seguente comando:
[d3ci01@thor d3ci01]$ sort primo.txt > secondo.txt
L’output del sort viene reindirizzato sul file secondo.txt, se questo non esiste
viene creato, altrimenti, viene sovrascritto. Se digitiamo:
[d3ci01@thor d3ci01]$ cat secondo.txt
otteniamo la stampa a video di:
secondo.txt: bello bravo brutto cattivo
cioè il contenuto del file primo.txt è stato ordinato e il contenuto del file secondo.txt è andato perduto.
Ora proviamo il seguente comando:
[d3ci01@thor d3ci01]$ sort primo.txt >> secondo.txt
Stampiamo a video, mediante il comando cat, il contenuto del file secondo.txt:
secondo.txt: bello bravo brutto cattivo bello bravo brutto cattivo
Notiamo che il contenuto ordinato di primo.txt è stato accodato al contenuto del file secondo.txt. Quindi il comando di ridirezione >> non è distruttivo come il comando >, se il file esiste la ridirezione dello standard output viene accodata al contenuto esistente. Se il file non esiste viene creato ex-novo.
4.2.Comandi di pipe
E’possibile connettere lo standard output di un programma con l'input di un altro, cioè l’uscita di un programma invece di comparire a video viene letta come ingresso dal secondo programma. Questo modo di lavorare si avvale dell’'uso dell'operatore pipe “|”. Una linea di comando contenente la pipe si chiama pipeline. Analizziamo un semplice esempio: vogliamo esaminare il contenuto di una directory che contiene un centinaio di files. Se lanciamo semplicemente il comando ls non riusciamo a vedere i primi files dell’elenco perché scorrono
dove nomefile è il nome del file che si vuol aprire o creare. In questo modo si apre l’editor in modalità full screen, cioè tutta la finestra della console ospita la schermata di vi.
VI permette di lavorare in tre modalità: 5.1.1 Normal mode 5.1.2 Insert mode 5.1.3 Command mode
5.1.1.Normal mode
Appena entrati in ambiente VI ci si trova in normal mode. Per spostarsi si usano i tasti cursore oppure i tasti:
- h freccia sinistra
- l freccia destra
- k freccia su
- j freccia giù
- x cancella un carattere (10x cancella 10 caratteri)
- dd cancella la riga
- u esegue undo dell’ultimo comando dato
- s cancella carattere e passa alla modalità di inserimento ( 10s cancella 10 caratteri e passa a modalità inserimento)
- yy copia riga in buffer di memoria
- p esegue il paste del contenuto del buffer di memoria
5.1.2.Insert mode
Digitando il carattere i si entra nella modalità di inserimento, sull’ultima riga apparirà un indicatore di tale modo. Si esce dalla modalità inserimento premendo il tasto ESC. In questa modalità si ha la possibilità di digitare il testo in full screen.
5.1.3.Command mode
Digitando il carattere : si entra nella modalità comandi (la precedente modalità deve essere quella normale). Dopo : si possono inserire i seguenti comandi:
- :q è il comando di quit, chiude la sessione di lavoro e chiede se si vuole salvare il testo
- :q! quit senza salvare le modifiche effettuate sul testo
- :w salva il testo
- :wq salva ed esci
- :sp nomefile divide in due (splitta) la finestra di editor per ospitare un nuovo file di nome nomefile
6.L'interprete Python
6.1.Introduzione
6.2.Ciao mondo!
Cominciamo subito con il primo programma. Lanciate dalla console di Linux il seguente comando:
$vi ciao.py
In questo modo aprite l’editor di testi per poter inserire il vostro codice sorgente python. Digitate la seguente riga:
print “ciao mondo!”
Salvate il file ed eseguitelo con il seguente comando :
$python ciao.py
Osservate cosa appare a video, dovreste ottenere un output simile a quello indicato di seguito:
ciao mondo!
Il vostro primo programma stampa a video la frase:”ciao mndo!”. Quindi abbiamo appreso che l’istruzione print permette di stampare sullo standard output e le virgolette delimitano una stringa.
6.3.Operatori
Continuiamo con il secondo programma. Seguendo la stessa procedura del precedente esempio scriviamo il seguente programma:
print “2 + 2 = “, 2+ print “3 * 4 = ”, 3* print “100-1,” = 100-1” print “(33+2)/5 + 11.5 = “, (33+2)/5+11.
Lanciamo il programma, l’output stampato a video è il seguente:
6.5.Variabili
Scriviamo il seguente programma:
a= 123. b23=’pippo’ b= c=a+b d= nome=’carlo’ print “a+b= “,c print “a+d= “,a+d print ‘il nome è ‘, nome print nome+b
Lanciamo il programma, l’output stampato a video è il seguente:
a+b= 555. a+d= 124. il nome è carlo carlopippo
Dall’analisi del codice e dell’output osserviamo che: Non è necessario dichiarare il tipo di variabili come altri linguaggi di programmazione. L’interprete python riconosce il tipo di variabile quando si effettua l’assegnazione. Questo non sempre è un vantaggio, non dichiarando le variabili si rischia di scrivere un sorgente poco leggibile. Per tali motivi si consiglia di usare abbondantemente il commento per descrivere il significato delle variabili in gioco e in generale la struttura del codice sorgente. I nomi delle variabili possono essere alfanumerici o alfabetici, nel primo caso il primo carattere deve essere numerico. Un’espressione viene valutata quando richiesto e gli operandi FLOW-CHART assumono i valori che hanno al momento della valutazione. I valori delle variabili stringhe possono essere delimitati da apici o doppi apici. ‘+’ è l’operatore che ci permette di concatenare tra loro due o più stringhe alfanumeriche
6.6.Strutture di controllo flusso
Il python ha diverse strutture per controllare il flusso delle informazioni in un algoritmo. Noi ne studieremo tre ed ogni volta confronteremo il programma sorgente con il flow-chart.
6.6.1.Ciclo while
Scriviamo il seguente programma:
a = 0 while a < 10 : a = a + 1 print a print “fine ciclo while”
Lanciamo il programma, l’output stampato a video è il seguente:
fine ciclo while
Il flow-chart dell’algoritmo è il seguente:
fine ciclo for
Il flow-chart dell’algoritmo è il seguente:
Dall’analisi del codice e dell’output osserviamo che: non esiste un carattere per indicare l'inizio e la fine del corpo del loop. L'interprete riconosce il corpo del loop dall'indentazione dello stesso rispetto all'istruzione while. Dopo la condizione di test vanno inseriti obbligatoriamente “:”. Questi introducono l'inizio del loop. La prima istruzione eseguita dopo il ciclo for e' la prima istruzione indentata allo stesso livello dell'istruzione for. “range” e' una funzione che restituisce una successione di numeri compresi tra il primo e l'ultimo escluso aventi passo unitario. La sintassi generale e' la
seguente:
range (inizio,fine,step)
dove inizio= numero di partenza della successione fine=numero finale della successione escluso step= passo della successione
p.e. range(1,4,2) fornira' la seguente successione: 1, Ovviamente possiamo costruire successioni decrescenti con inizio > fine e step <0 , p.e. range(4,1,-1) dara' origine alla seguente successione: 4,3,
Solitamente per implementare gli algoritmi di calcolo numerico ci sara' piu' utile lavorare con i cicli while perche' piu' versatili.
6.6.3.Istruzione if
Scriviamo il seguente programma:
n= if n < 0 : print “Il valore assoluto di “,n,” e’ “,-n else: print “Il valore assoluto di “,n,” e’ “,n
Lanciamo il programma, l’output stampato a video è il seguente:
Il valore assoluto di 10 e’ 10
Il flow-chart dell’algoritmo è il seguente:
Dall’analisi del codice e dell’output osserviamo che: L’istruzione “elif” ci permette di semplificare la scrittura del codice nel caso in cui abbiamo piu’ test in cascata. Possiamo avere piu’ livelli di indentazione, dipende dalla struttura e dalla complessita’ del nostro algoritmo.
6.6.4.Operatori di confronto e operatori logici
In questo paragrafo descriveremo gli operatori di confronto e gli operatori logici del python. Questi saranno gli operatori che solitamente utilizzeremo per le nostre condizioni di test del ciclo while e dell’if.
Operatori di confronto < minore <= mnore o uguale
maggiore = maggiore o uguale == uguale != oppure <> diverso
Gli operatori di confronto ci permettono di costruire una condizione di test mettendo a confronto due oggetti.
Operatori logici or oppure and e not negazione
Gli operatori logici ci permettono di costruire condizioni di test complesse mettendo in relazione espressioni logiche (p.e. le condizioni di test indicate sopra).
6.7.Definizione di funzione
Scriviamo il seguente programma:
a= b=- def my_abs(num): if num < 0 : num=-num return num if my_abs(a) >= my_abs(b) : print my_abs(a) else: print my_abs(b)
Lanciamo il programma, l’output stampato a video è il seguente:
Dall’analisi del codice e dell’output osserviamo che: L'istruzione def permette di definire una funzione, nel nostro caso la funzione si chiama:”my_abs” Non esistono i prototype per le funzioni python, si definisce la funzione e subito dopo il suo corpo. Dopo il def è necessario digitare “:”, il corpo della funzione si dovrà scrivere indentato. N.B. Il return fa parte del corpo della funzione e quindi va scritto anch'esso indentato. La funzione può essere definita in qualsiasi posto nel codice, l'importante è che sia definita prima che venga chiamata.
