############################################################################# # INTRODUZIONE ALL'USO DI R # ############################################################################# # # # impostare la directory di lavoro # #---------------------------------------------------------------------------# # dal menu File-->Cambia Directory --> selezionare C:/R-lab # oppure... setwd("C:/R-lab") getwd() dir() #----------------------------------------------------------------- # * chiedere aiuto ad R #----------------------------------------------------------------- help() # help generale help(q) # help del comando "q", oppure... ?q help.start() # lancia l'help in un browser help.search("normal") # cerca comandi contenenti la parola chiave #----------------------------------------------------------------- # * definire oggetti R #----------------------------------------------------------------- # R come calcolatrice 2 + 2 # Assegnamo ad una variabile chiamata "a" il valore di uno scalare numerico a = 3 # ...o anche... b <- 2 1 -> cc # per vedere cosa contiene "a", digitare a sul prompt della Console e dare Invio: a b cc # oppure evidenziare l'oggetto da stampare nell finestra dello script e clickare sul tasto Run del Menu in basso # # # Tipi di alcuni oggetti che è possibile definire in R (e a cui assegnare un nome): # # 1. numerici: interi, reali o complessi # a=10 b=15.53 c=3.51+1.2i # # 2. stringhe di caratteri (CON "virgolette"!) d="CIAO" e="ciao" # # 3. logici (SENZA virgolette!) f=TRUE g=FALSE h=F i=T f i # # per avere l'elenco di tutti gli oggetti creati: ls() # # CONSIGLIO: Evitare di dare, agli oggetti che vengono via via creati, i nomi di funzioni già definite in R (per es. pi) #----------------------------------------------------------------- # * terminare la sessione R e salvare... #----------------------------------------------------------------- # q() # # se si intende mantenere memoria degli oggetti creati, rispondere SI # alla richiesta di salvataggio dell'area di lavoro (workspace) # # Per recuperare il workspace dalla directory di lavoro, # clickare su Session nel menu in cima alla pagina, poi Load Workspace e poi selezionare # directory e il file .RData # In alternativa, per ricreare tutti gli oggetti creati in una sessione # precedente, si può aprire il file .Rhistory ed eseguire nuovamente tutti i comandi precedenti memorizzati # E' possibile salvare il workspace o la history in qualunque momento # dal menu File --> Salva Area di lavoro # oppure salvare solo alcuni elementi... save(a,file = "solo-a.RData") # # # se chiudiamo R e vogliamo ricaricare il workspace precedente # basta cliccare 2 volte sul file .RData oppure richiamarlo da dentro l'ambiente R con il load # # Per rimuovere uno (o piu') oggetti, per esempio c: rm(c) ls() # se vogliamo rimuovere tutto... rm(list=ls()) #----------------------------------------------------------------- # * Verifica della natura di un oggetto R #----------------------------------------------------------------- help(mode) mode(a) mode(d) mode(g) # # Possiamo anche fare delle ''domande dirette'': is.character(a) is.character(d) # # Volendo, possiamo anche cambiare la "natura" di un oggetto (quando consentito) mode(a) a as.character(a) # ma che succede se l'operazione non è consentita? as.logical(d) # # NA vuol dire "Not Available" (non disponibile, dato mancante) # 0/4 # ok 4/0 # ..ok.. 0/0 # NaN vuol dire "Not a Number" (forme indeterminate) y1<-c(2, 3, NA,10, 21) length(y1) sum(y1) sum(y1, na.rm=T) y2<-c(2, 3, NULL,10, 21) length(y2) sum(y2) # #----------------------------------------------------------------- # Operazioni di Base #----------------------------------------------------------------- # Le operazioni aritmetiche elementari sono: +, -, * e / 3+2 3*a 3*d # ops! # # Inoltre R e' dotato di FUNZIONI (sono sostanzilmente dei comandi) # che consentono di effettuare le operazioni piu' comuni sqrt(9) log(1) abs(-1) # # E molte altre... help(Arithmetic) help(Trig) help(Special) # # Operatori logici help(Logic) # # NOT: ovvero Negazione [punto esclamativo] !TRUE # # AND: ovvero Congiunzione o Intersezione TRUE & FALSE TRUE & TRUE # # OR: ovvero Alternativa o Unione TRUE | FALSE # #----------------------------------------------------------------- # Creazione di Vettori #----------------------------------------------------------------- # # Oltre a scalari, si possono definire vettori, ossia sequenze di elementi dello stesso # tipo, utilizzando comandi come: c(), seq() e rep() # # Funzione c() # # creazione di un vettore di numeri: numeri<-c(10,20,4,13,5) vett1 = c(1.3, 4.2, 3.0) # creazione di un oggetto (vettore) alfanumerico: colore<-c('giallo','blu', 'rosso','verde', 'bianco') vett.char = c("qui", "quo", "qua") vett.char # # Funzione seq() help(seq) vett2 = seq(1, 10, 1) vett2 vett3 = seq(0, 9.9, 0.1) vett3 # # ...alternativamente... vett4 = 1:10 vett4 # # Funzione rep() help(rep) vett5 = rep(10, 100) vett5 vett6 = rep(c(1,2), 10) vett6 rep(d, 3) rep(vett.char, 4) # # Lunghezza di un vettore ed altre operazioni length(vett3) sum(vett3) prod(vett3) min(vett3) max(vett3) mean(vett2) sd(vett2) var(vett2) cumsum(vett3) cumprod(vett3) diff(cumprod(vett3)) vett3*vett3 vett3*5 vett3*c(5) vett3*c(1,2) # che è successo?? sort(numeri, decreasing = T) # estrazione di un sotto-vettore: sub_num<-numeri[c(1,3,4)] # # # Operazioni su stringhe ?paste paste("Ciao","Ciao") paste("Ro","ma",sep="") paste("Roma","Milano","Torino",sep="-") paste(c("Roma","Milano","Torino"),collapse="-") paste(c("Roma","Milano","Torino"),"Palermo",sep="-") # # Esempio: operazioni (elemento per elemento) su vettori numerici altezza = c(1.75, 1.80, 1.65, 1.90, 1.74, 1.91) peso = c(60, 72, 57, 90, 95, 72) # bmi = peso/altezza^2 # Body Mass Index # # Operazioni con vettori logici c(T,T,F,F) & c(T,F,T,F) c(T,T,F,F) | c(T,F,T,F) # vett.logico = c(T,T,F,F,T) vett.logico # # uso delle funzioni any, all, which: any(colore=='nero') all(numeri>10) which(numeri==4) # # Comando utile per individuare dove sono i dati mancanti: is.na(c(1,2,3,NA,4)) !is.na(c(1,2,3,NA,4)) # ricordare che ! implica la negazione # # Identificazione di un particolare elemento di un vettore # (quello che occupa il 4° posto): colore[4] # # Ordinamenti: # funzione sort() Restituisce il vettore ordinato dal valore (o lettera, nel caso di oggetto character) piu' piccolo al piu' grande sort(numeri) sort (colore) # funzione che inverte l'ordine degli elementi, dall'ultimo al primo: numeri; rev(numeri) #Attenzione non ordina! Inverte l'ordine del vettore originale. colore; rev(colore) # #----------------------------------------------------------------- # Creazione di matrici, data.frame e liste #----------------------------------------------------------------- # help(cbind) # rbind() #creazione di una matrice con due righe (colore e numeri) # e 5 colonne (pari al numero di elementi di ciascuno dei due vettori) righe<-rbind(colore, numeri) # #creazione di una matrice con due colonne (colore e numeri) # e 5 righe (pari al numero di elementi di ciascuno dei due vettori) colonne<-cbind(colore, numeri) # # funzione dim: dim(righe) # per i vettori si può usare solo length, infatti: dim(colore) # # creazione di una matrice e assegnazione nomi alle colonne z<-seq(-9,9,length=9) matz<-matrix(z,3,3) colnames(matz)=c('First-Column', 'Second-Column', 'Third-Colum') # oppure colnames(matz)=paste(c('First', 'Second', 'Third'),'Colum',sep='-') rownames(matz)=paste(c('First', 'Second', 'Third'),'Row',sep='-') # # Identificazione di un particolare elemento di una matrice # - quello che si trova all'incrocio tra seconda riga e terza colonna): matz[2,3] # - tutti quelli che si trovano nella seconda riga: matz[2,] # - tutti quelli che si trovano nella terza colonna: matz[,3] # # Uso della funzione APPLY per il calcolo della somma # somma totale: sum(matz) # totale prima riga: sum(matz[1,]) # totale seconda riga: sum(matz[2,]) # stessi risultati con apply: apply(matz,MARGIN=1, FUN=sum) apply(matz,1, sum) # cambiando l'opzione MARGIN si hanno i totali di colonna: apply(matz,2, sum) # sono possibili altre sintesi, per es. la media: apply(matz,1, mean) # # ## Creazione di un dataframe ## # Il dataframe e' l'oggetto principe dell'analisi statistica. Formato classico: unita' (righe) x variabili (colonne) # Creiamo un data-frame: df=data.frame(altezza,peso) # Ogni riga di questo oggetto rappresenta una unità statistica su cui vengono rilevati i dati di altezza e peso # se vogliamo inserire un identificativo per ogni unità: id=seq(1,6,1) df2=data.frame(id,altezza,peso) dim(df2) str(df2) # ci fornisce la 'struttura' di un oggetto; e' utile per vedere cosa c'e' dentro un data.frame mode(df2) # ...e' una lista! class(df2) # mat2 e' un oggetto di classe "data.frame" e modo "list" # # ### Liste ### # Nella lista, a differenza di vettori e matrici, si possono # mettere insieme oggetti, anche complicati, di tipo diverso prova1 = c("ciao", 15, TRUE) prova1 prova2 = list("ciao", 15, TRUE) prova2 # # Altro esempio... sex = c("M", "F", "M", "M", "F", "F") laurea = c(TRUE, FALSE, FALSE, T, T, F) # mat3 = cbind(altezza, peso, sex, laurea) mode(mat3) # come per righe, sono diventati tutti "character"! mat3 # mat4 = data.frame(altezza, peso, sex, laurea) str(mat4) mat4 # mat5 = list(altezza, peso, sex, laurea) mat5 # ... meglio mat4!!! # list1<-list(c('a','b','c'), c(1,.8,2,.6), c(T,F,T,T)) # presenta tre livelli list1[[1]] list1[[2]] list1[[2]][3] # list2<-list(c(2,3,4), seq(1,10,2),1:5) # uso di apply con le liste: lapply(list2, sum) #----------------------------------------------------------------- # Operazioni tra scalari, vettori e matrici # x = 3*vett3 y = vett3*vett2 # elemento per elemento, gia' visto v3<-c(1.5, 2, 0.6) # Prodotto matriciale matz*v3: [3,3] x [3,1] = [3,1] m4=matz%*%v3 dim(m4) # ora funziona dim! # # determinante di una matrice x = matrix(0:3, ncol = 2) det(x) # Inversione di una matrice quadrata non singolare x = matrix(0:3, ncol = 2) solve(x) # verifichiamo che premoltiplicando (o postmoltiplicando) x per la sua inversa, otteniamo la matrice identita': solve(x)%*%x; x%*%solve(x) # diagonale principale di una matrice: diag(x) # traccia di una matrice: sum(diag(x)) # somma per righe di una matrice: rowSums(x) # somma per colonne di una matrice: colSums(x) # trasposta di una matrice: t(x) # selezione degli elementi di un vettore o matrice per negazione v1<-c(19, 2, 4, 7, 1) v1[-c(2,4)] # lettura di datasets esistenti in R data() # otteniamo l'elenco dei datasets disponibili data("UCBAdmissions") # upload del dataset UCBAdmission # E' un 'array' a 3 dimensioni, di classe table: UCBAdmissions UCBAdmissions[,,1] # fornisce la prima distribuzione doppia, condizionata a Dept=A dati_adm<-as.data.frame(UCBAdmissions) # consente di trasformare il dataset in un'unica matrice (dataframe) di dati # names(dati_adm) # ci fornisce i nomi delle variabili contenute nel dataset; attenzione però: names(UCBAdmissions) # se vogliamo lavorare con una particolare variabile (colonna) di un dataframe, per esempio Freq, abbiamo due possibilità: summary(dati_adm$Freq) # il summary fornisce alcune informazioni di sintesi della distribuzione osservata summary(dati_adm[,4]) # calcoliamo il numero totale di 'Freq' separatamente per gli 'Admitted' e i 'Rejected': sum(dati_adm[dati_adm$Admit=='Admitted',4]) sum(dati_adm[dati_adm$Admit=='Rejected',4]) # # uso della funzione tapply: tapply(dati_adm$Freq, dati_adm$Gender, summary) tapply(dati_adm$Freq, dati_adm$Dept, sum) # # richiamare gli elementi di un dataframe in base ad etichetta (se gli elementi la posseggono) # proviamo a caricare un dataset disponibile in R data("ChickWeight") dati<-ChickWeight names(dati) summary(dati) hist(dati$weight) # oppure: summary(dati["weight"]) # però: mean(dati["weight"]) # selezione casi in base a una condizione "logica" peso<-dati$weight prova<-peso>=180 # e' un oggetto di tipo logico, invece: prova2<-peso[peso >= 180] # e' un sottinsieme di peso, come pure: peso[peso > 175 & peso < 190] peso[peso >= 175 & peso < 190] # questo contiene in più gli elementi esattamente =175 # # altro tipo di condizione: matrice1<-dati[1:3,2:3] matrice1>1 maggiore1=matrice1[matrice1 >1] # restituisce un vettore con le frequenze di T e F, ma e' alfanumerico!!! # # Salvataggio di un oggetto in un file esterno: write(colore, file='colore.txt', ncolumns = 1 ) # il file viene salvato nella directory di lavoro # per un dataset e' meglio utilizzare i comandi write.table o write.csv: write.table(dati_adm, file='dati_adm1.txt', quote=T, col.names = T) # con l'opzione quote=T i dati delle variabili character sono scritti tra virgolette, mentre col.names=T fa inserire i nomi delle colonne write.csv(dati_adm, file='dati_adm2.txt', quote=T) # con l'opzione quote=T i dati delle variabili character sono scritti tra virgolette, mentre col.names=T fa inserire i nomi delle colonne write.table(dati_adm, file='dati_adm3.txt', quote=T, col.names = T, sep=';') # qui e' stata inserita anche l'opzione sep=';', per separare le osservazioni con il simbolo ; # ## Lettura di un file esterno: prova1<-read.csv(file='dati_adm1.txt', header = T, sep='') prova2<- read.csv(file='dati_adm3.txt', header = T, sep=';') # nessuna differenza tra prova1 e prova2 # creazione di un loop: for (i in inizio:fine) { # 'inizio' e 'fine' sono valori numerici da specificare # qui occorre inserire i comandi da far eseguire nel loop }