[Python] Classi, oggetti e self

[kwb]

Sto facendo un programma per gestire un'ipotetica biblioteca.
Ho un dubbio sulla parola chiave self:
Uno sguardo a questo stralcio di codice:

class floor():
    
    __closet=[]
    __floorNumber=0

    def __init__(self, closetNumber, n):
        self.__floorNumber=n
        self.__closet.append(closetNumber)
        
    def addBook(self,bookObj,closetNumber,shelfNumber):
        for i in range(len(self.__closet)):
            if self.__closet[i].getClosetNumber()== closetNumber:
                self.__closet[closetNumber].addBook(bookObj,shelfNumber)

Possibile che io debba sempre usare self davanti ad ogni variabile della classe? È veramente scomodo, in Java non era così...

EDIT: Una domanda ulteriore sull'import: ho letto in giro che l'import non funziona bene su sistemi Mac OS e Windows nel caso in cui si importi un modulo che ha un'importazione al suo interno, nello specifico:

from modulo import *

importerebbe solo i metodi della classe 'modulo' ma non i metodi ereditati da 'modulo' tramite una import dentro di se.
È vero?

[ingframin]

Originariamente inviato da kwb

class floor():
    
    __closet=[]
    __floorNumber=0

    def __init__(self, closetNumber, n):
        self.__floorNumber=n
        self.__closet.append(closetNumber)
        
...

Possibile che io debba sempre usare self davanti ad ogni variabile della classe? È veramente scomodo, in Java non era così...

Attento perché così stai facendo un po'di confusione:
__closet=[] e __floorNumber=0 come l'hai create tu non sono variabili di istanza ma di classe (come se in Java tu ci avessi messo davanti static).
Per renderle variabili di istanza cancella la dichiarazione fuori dall'__init__.

self. va apposto a tutte le variabili di istanza e a tutti i metodi che richiami nella classe ed è il puntatore all'istanza specifica.

Non ho mai avuto problemi con from modulo import *, sia su linux che su windows, sei sicuro che non sia un bug di qualche versione precedente alla 2.7.3?

[kwb]

Originariamente inviato da coffe_killer

io sto programmando in python indifferentemente sia su ubuntu sia su windows senza problemi di compatibilità, è il vantaggio dei linguaggi interpretati...il problema arriva quando hai bisogno di una libreria comptibile solo con alcuni SO e nn altri....x esempio il modulo BeautifulSoup non è compatibile con windows...basta che fai però una rapida ricerca su google e scopri subito le comptibilità e ti tolgi tutti i dubbi

Originariamente inviato da ingframin

Non ho mai avuto problemi con from modulo import *, sia su linux che su windows, sei sicuro che non sia un bug di qualche versione precedente alla 2.7.3?

Bho era una cosa che avevo letto di sfuggita su internet cercando informazioni sull'import.
Una cosa che mi aspettavo di poter fare era la seguente: nel main importo il modulo floor ( from floor import * ) e se dentro floor ho già importato altri moduli, mi aspettavo di poterli usare anche dal main, ma non è così...

Originariamente inviato da ingframin

Attento perché così stai facendo un po'di confusione:
__closet=[] e __floorNumber=0 come l'hai create tu non sono variabili di istanza ma di classe (come se in Java tu ci avessi messo davanti static).
Per renderle variabili di istanza cancella la dichiarazione fuori dall'__init__.

Ma se voglio dichiarare una variabile privata ( non accessibili da moduli esterni ) non devo usare __ davanti alla variabile? Come faccio a dichiarare una variabile privata, così come si farebbe in java:

private int n;

E se poi non la voglio inizializzare ( e quindi non metterla nel costruttore )?

Da quel che mi hai detto, ho capito che le variabili le dichiaro private solo dentro il costruttore ( anche se, è vero, non esiste una vera e propria dichiarazione delle variabili in python )

Originariamente inviato da ingframin

self. va apposto a tutte le variabili di istanza e a tutti i metodi che richiami nella classe ed è il puntatore all'istanza specifica.

Quindi, siccome io voglio dichiarare quelle variabili come private, i self che ho messo sono giusti no?
Non funziona come il this. di java?

[Eln]

Fai un pò di confusione, il this in Java veniva usato per richiamare un attributo/variabile (chiamala come vuoi) d'istanza, stessa cosa qui vale per il self. Servono esattamente alla stessa cosa.

La differenza è che in Java esistono i modificatori d'accesso, private ecc, cosa che in Python non c'è. Porre un _ d'avanti ad una variabile serve a far vedere agli altri, per convenzione, che quell'attributo è privato e quindi non dovrebbero accedervi direttamente (senza metodo get/set per capirci) e se lo fanno è a loro rischio e pericolo.

Come ti hanno scritto sotto quello che dovresti fare è mettere i tuoi attributi d'istanza nel Costruttore, ponendo un _ prima di quelli che vuoi indicare come privati. Fuori invece metti le variabili di classe, costanti, che infatti anche in Java si inizializzano fuori dal costruttore.

[cdimauro]

Esattamente, il _ davanti è per lo più una convenzione: "è roba mia, interna, per favore non toccarla". Ma nessuno t'impedisce di metterci le mani, perché non esiste nella maniera più assoluta il concetto di privato, protetto, pubblico.

Ma attenzione quando si importa tutto da un modulo con la sintassi from Modulo import *. In questo caso Python non importa tutti gli identificatori del modulo, ma soltanto quelli che NON iniziano con _. In pratica chi ha realizzato il modulo può decidere cosa far importare automaticamente e cosa no; un meccanismo più fine è rappresentato dall'uso della variabile __all__ .

Ovviamente non c'è alcun problema coi moduli rispetto al s.o. su cui gira Python.

Riguardo a self & this, anche qui ci sono differenze con gli altri linguaggi. All'interno di una funzione definita in una classe (che diventa un metodo a tutti gli effetti, se non viene "decorata" opportunamente per farla diventare metodo di classe o funzione statica; ma di questo non ne parliamo per ora), qualunque assegnazione produce una variabile locale alla funzione.

Se vogliamo creare, modificare, o semplicemente accedere a una variabile d'istanza, bisogna sempre utilizzare self.Variabile. Non è come negli altri linguaggi a oggetti, dove il self/this è implicitamente sempre presente; qui è obbligatorio, perché fa fede il motto di Python (explicit is better than implicit).

E' noioso scrivere sempre self.? Può darsi, ma il codice è più leggibile. Ciò detto, se il problema è il morbo dello scrivano, si può usare un qualunque altro identificatore al posto di self:

class c:
  def m(s):
    s.VariabileDIstanza = 'Hello!'

Meno caratteri da digitare, ma è una pratica che sconsiglio: il codice Python è bello anche perché è leggibile; non "sporchiamolo".

[kwb]

Originariamente inviato da Eln

Fai un pò di confusione, il this in Java veniva usato per richiamare un attributo/variabile (chiamala come vuoi) d'istanza, stessa cosa qui vale per il self. Servono esattamente alla stessa cosa.

La differenza è che in Java esistono i modificatori d'accesso, private ecc, cosa che in Python non c'è. Porre un _ d'avanti ad una variabile serve a far vedere agli altri, per convenzione, che quell'attributo è privato e quindi non dovrebbero accedervi direttamente (senza metodo get/set per capirci) e se lo fanno è a loro rischio e pericolo.

A me non interessa niente delle questioni etiche o morali che si possono celare dietro un _ . Semplicemente ho fatto così perchè quando ho iniziato la programmazione ad oggetti mi è stato spiegato di dichiarare ( salvo speciali eccezioni ) le variabili di una classe come private e fare il metodo per impostarle/stamparle. Ora da quello che ho letto rapidamente sul sito ufficiale, questo concetto pare non esistere ( o essere radicato ) come è per Java.
Quindi la domanda è: un programmatore che scrive in Python, come le deve gestire le variabili che dichiara di una classe?

Originariamente inviato da Eln

Come ti hanno scritto sotto quello che dovresti fare è mettere i tuoi attributi d'istanza nel Costruttore, ponendo un _ prima di quelli che vuoi indicare come privati. Fuori invece metti le variabili di classe, costanti, che infatti anche in Java si inizializzano fuori dal costruttore.

Ma quindi invece di inizializzarle a 0 fuori dal costruttore e poi impostarle al valore scelto col costruttore, le sparo dirette dentro il costruttore con un underscore davanti? Oppure 2 (underscore)?

Originariamente inviato da cdimauro

Ma attenzione quando si importa tutto da un modulo con la sintassi from Modulo import *. In questo caso Python non importa tutti gli identificatori del modulo, ma soltanto quelli che NON iniziano con _. In pratica chi ha realizzato il modulo può decidere cosa far importare automaticamente e cosa no; un meccanismo più fine è rappresentato dall'uso della variabile __all__ .

Quindi mi pare di capire che le mie variabili che ho dichiarato tutte con un __ non saranno affatto visibili dentro altri moduli, no? Non è un po' il comportamento che si ottiene tramite il private di Java?

Originariamente inviato da cdimauro

E' noioso scrivere sempre self.? Può darsi, ma il codice è più leggibile. Ciò detto, se il problema è il morbo dello scrivano, si può usare un qualunque altro identificatore al posto di self:

class c:
  def m(s):
    s.VariabileDIstanza = 'Hello!'

Meno caratteri da digitare, ma è una pratica che sconsiglio: il codice Python è bello anche perché è leggibile; non "sporchiamolo".

Fammi capire, quindi mi basta impostare come primo parametro un qualuque carattere per renderlo equivalente al self.?
Se così fosse andremmo moooolto meglio

[banryu79]

Originariamente inviato da kwb

Fammi capire, quindi mi basta impostare come primo parametro un qualuque carattere per renderlo equivalente al self.?
Se così fosse andremmo moooolto meglio

Un consiglio spassionato (basato sulla mia esperienza). Quando studi per imparare un nuovo linguaggio, tenta sempre di:
1) dimenticare le idiosincrasie di altri linguaggi che già conosci;
2) rispettare le convenzioni e gli idiomi del nuovo linguaggio;
3) cercarne di capire le ragioni (col tempo & esperienza).

Ho trovato questo atteggiamento molto utile.

[cdimauro]

Originariamente inviato da kwb

A me non interessa niente delle questioni etiche o morali che si possono celare dietro un _ . Semplicemente ho fatto così perchè quando ho iniziato la programmazione ad oggetti mi è stato spiegato di dichiarare ( salvo speciali eccezioni ) le variabili di una classe come private e fare il metodo per impostarle/stamparle. Ora da quello che ho letto rapidamente sul sito ufficiale, questo concetto pare non esistere ( o essere radicato ) come è per Java.

Infatti (e per fortuna ) NON è Java.

Quindi la domanda è: un programmatore che scrive in Python, come le deve gestire le variabili che dichiara di una classe?

Come ritieni più opportuno. Il che significa che spesso un programmatore Python le dichiara:
- nell'__init__ se serve che siano sempre inizializzate, magari con valori di default;
- all'interno di altri metodi.

Non siamo forzati a impostare le variabili d'istanza per forza nel costruttore, insomma. Lo facciamo quando lo riteniamo più opportuno.

In altri casi è possibile definire delle property, Delphi/C# like per intenderci, e quindi controllare l'accesso di una variabile d'istanza tramite getter e/o setter e/o deleter.

Ma quindi invece di inizializzarle a 0 fuori dal costruttore e poi impostarle al valore scelto col costruttore, le sparo dirette dentro il costruttore con un underscore davanti? Oppure 2 (underscore)?

Io raramente uso l'underscore come prefisso di una variabile d'istanza. La dichiaro direttamente col nome che deve avere.

Quindi mi pare di capire che le mie variabili che ho dichiarato tutte con un __ non saranno affatto visibili dentro altri moduli, no? Non è un po' il comportamento che si ottiene tramite il private di Java?

No, non è così. Se c'è un _ davanti, le variabili non saranno importabili direttamente tramite from Modulo import *, ma rimangono sempre accessibili:

Modulo._NonSonoInvisibile = True

Oppure:

from Modulo import _NonSonoInvisibile

_NonSonoInvisibile = True

Fammi capire, quindi mi basta impostare come primo parametro un qualuque carattere per renderlo equivalente al self.?
Se così fosse andremmo moooolto meglio

Sì, esatto, ma non troverai un solo programmatore Python che lo faccia.

Siamo una setta di integralisti votati alla leggibilità del sorgente.

Originariamente inviato da banryu79

Un consiglio spassionato (basato sulla mia esperienza). Quando studi per imparare un nuovo linguaggio, tenta sempre di:
1) dimenticare le idiosincrasie di altri linguaggi che già conosci;
2) rispettare le convenzioni e gli idiomi del nuovo linguaggio;
3) cercarne di capire le ragioni (col tempo & esperienza).

Ho trovato questo atteggiamento molto utile.

Sante parole.

[kwb]

Ho provato un po' a giocare con queste cose. Ma non ho ben afferrato come sono riuscito ( e se ci sono riuscito ) a fare una lista di oggetti ( 2 ) che contenesse un'altra lista di oggetti.
Ad esempio, il main:

from floor import *
from book import *
#Initialize the array
piano=[]

for i in range(2): #Use 2 floors
    tempFloor=floor(0,i)
    piano.append(tempFloor)

libroProva = book("Isaac Asimov","Cronache della Galassia")
#piano[0].addBook(book,1,1)

C'è questa classe floor che dovrebbe rappresentare il piano della biblioteca.
Su ogni piano della biblioteca ci devono essere un tot di armadi ( il cui numero è ancora da definire ), e poi per ogni armadio ci dovranno essere scaffali ecc... ( ma ancora non ci sono arrivato ).
Quello che ho fatto è stato creare una lista piano. Tramite il for creo degli oggetti piano temporanei ( tempFloor ) che inserisco dentro la lista piano.
Ora la classe floor:

class floor():

    def __init__(self, closetNumber, n):
        self._closet=[]
        self._closet.append(closetNumber)
        self._floorNumber=n
        
    def addBook(self,bookObj,closetNumber,shelfNumber):
        for i in range(len(self._closet)):
            if self._closet[i].getClosetNumber()== closetNumber:
                return self._closet[closetNumber].addBook(bookObj,shelfNumber)
        return False

Siccome ho una classe che si chiama closet, ho preferito chiamare la variabile con un underscore davanti.
Tuttavia, mi aspettavo che scrivendo:

def __init__(self, closetNumber, n):
        self._closet.append(closetNumber)
        self._floorNumber=n

Funzionasse, in realtà non va. Credo perchè non ho mai specificato cos è _closet. Inoltre utilizzare self. o meno non da errori sintattici, però credo di doverlo mettere, anche se non capisco veramente il perchè..

Premesso che _closet è una lista di numeri ( poi lo trasformerò in oggetto, tramite la sua classe ), sono riuscito a creare la seguente struttura ( che dura fino alla fine dell'esecuzione del programma )?

piano[0]:
	closet[0]
piano[1]:
	closet[0]

EDIT: Dal debugger mi pare di si, ma vorrei avere conferma da voi anche.

[ingframin]

Se ci scrivi il testo dell'esercizio per come lo hai concepito proviamo a farlo e poi ci scambiamo i sorgenti completi.
ti va?

[kwb]

La biblioteca è composta da:
- 2 piani
- Per ogni piano vi sono, diciamo, 5 armadi
- Per ogni armadio vi sono 5 scaffali
- Per ogni ripiano ci sono 10 libri

Dal main si chiama il metodo addBook che aggiunge l'oggetto book alla libreria, nella posizione indicata dai parametri ( specificando il piano ):

piano[0].addBook(oggetto_Book,NumeroArmadio,NumeroMensola)

addBook è un metodo presente nelle classi:
floor, closet e shelf.
Vi è una classe aggiuntiva, book che contiene, oltre al titlo e l'autore ( inizializzati tramite costruttore alla creazione dell'oggetto libro ) anche i metodi set/get per impostare il piano/armadio/scaffale a cui si trova e l'anno di pubblicazione del libro.

[banryu79]

Altro consiglio (non richiesto, lo so) spassionato:
Scrivi il sorgente (i nomi delle variabili e dei tipi custom) in una sola lingua, o inglese o italiano o altro (la regola sarebbe usare la ingua franca dell'informatica: l'inglese).
Altrimenti vien fuori un pasticcio (dal punto di vista della leggibilità del codice e della facilità di comprensione)

[kwb]

Originariamente inviato da banryu79

Altro consiglio (non richiesto, lo so) spassionato:
Scrivi il sorgente (i nomi delle variabili e dei tipi custom) in una sola lingua, o inglese o italiano o altro (la regola sarebbe usare la ingua franca dell'informatica: l'inglese).
Altrimenti vien fuori un pasticcio (dal punto di vista della leggibilità del codice e della facilità di comprensione)

Lo faccio bilingue perchè ho paura poi di finire in qualche scambio di metodi/variabili/classi inatteso, soprattutto ora che non sto capendo assolutamente niente ( no dai beh, poco ) di come si gestiscono le variabili..

[banryu79]

Originariamente inviato da kwb

Lo faccio bilingue perchè ho paura poi di finire in qualche scambio di metodi/variabili/classi inatteso

Questa non l'ho capita..

[kwb]

Originariamente inviato da banryu79

Questa non l'ho capita

Nel senso che poi magari mi confondo e invece di scrivere il nome della variabili, scrivo il nome della classe ( che magari si chiamano simili ).

[banryu79]

Originariamente inviato da kwb

Nel senso che poi magari mi confondo e invece di scrivere il nome della variabili, scrivo il nome della classe ( che magari si chiamano simili ).

Ma scusa, adotta una convenzione.
Tipo: i nomi delle classi iniziano in maiuscolo, i campi delle istanze in minuscolo.
Floor è la classe, floor il campo.
Closet è la classe, closet il campo, ecc...
Comunque nessuno ti vieta di fare qual cavolo che vuoi eh, il mio era solo un consiglio

[kwb]

Ho seguito il tuo suggerimento e ho fatto così.
Ora però, alle prese con la creazione della biblioteca vuota ( senza libri ), mi da un errore, dentro il file Closet.py

self._shelf[i].append(dummyS)
IndexError: list index out of range

I moduli
Main.py:

from Floor import *
from Book import *
#Initialize the array
floor=[]

for i in range(2): #Use 2 floors
    tempFloor=Floor(i)
    floor.append(tempFloor)

Floor.py:

from Closet import *

class Floor():
    floorNumber =0
    def __init__(self, n):
        self._closet=[]
        for i in range(5): #Create 5 closets
            dummyC=Closet(i)
            self._closet[i].append(dummyC)
        self.floorNumber=n

Closet.py:

from Shelf import *
class Closet():
    
    closetNumber=0
    def __init__(self, closetNumber):
        self.closetNumber=closetNumber
        self._shelf=[]
        for i in range(5): #Create 5 shelves
            dummyS=Shelf(i)
            self._shelf[i].append(dummyS)

Shelf.py:

class Shelf():
    
    shelfNumber=0
    book=[]
    def __init__(self, shelfNumber):
        self.shelfNumber=shelfNumber

Non capisco perchè gli indici i nei for, non aumentano...
Inoltre, è giusto come ho gestito le variabili?

[cdimauro]

Ci sono diversi errori. Il primo è che hai dichiarato floorNumber, closetNumber, shelfNumber, e (soprattutto!) book come variabili di classe, quando è chiaro che dovrebbero essere d'istanza, per l'uso che ne fai. Quindi ti basta eliminare l'assegnazione a zero (e lista vuota per l'ultimo) che nei fai all'interno della definizione della classe.

Quello che ti crea problemi, comunque, è il fatto che accedi a un elemento della lista quando ancora non gliel'hai inserito con append. Infatti per popolare la lista al posto di questo:

self._closet[i].append(dummyC)

devi scrivere:

self._closet.append(dummyC)

Ciò vale anche per Closet.py.

Infatti tu hai creato una lista vuota con self._closet = [] , ma... devi ancora popolarla. E lo fai col metodo append, ma devi applicarlo a self._closet, perché è questa lista, mentre self._closet[i] non è una lista (potrebbe anche esserlo, eh!) ma un suo elementi, che nello specifico è un'istanza di Closet.

Un'ottimizzazione che potresti fare è quella di eliminare l'uso delle variabili temporanee. Un esempio:

for i in range(2): #Use 2 floors
    floor.append(Floor(i))

Se sistemi tutto il codice in modo che sia in questa forma, puoi sfruttare un bellissimo strumento di Python che sono le list comprehension, che ti permettono di creare (e popolare) una lista in maniera compatta ed elegante:

floor = [Floor(i) for i in range(2)] #Use 2 floors

Se hai un background matematico, ti dovrebbe essere facile leggerla e comprenderne il significato.

[kwb]

Allora, non riesco ancora ad afferrare la differenza tra variabile di classe e d'istanza.
A livello di allocazione di memoria ed accesso alla variabile ( perchè credo che la differenza sia in quello ), cosa cambia?
Non sono riuscito a trovare qualcosa che lo spiegasse chiaramente, nemmeno il tutorial sul sito di python lo spiega...
Da quello che ho capito io la variabile di istanza esiste ( e lo spazio in memoria per essa viene allocato ) quando creo l'oggetto ( ovvero con un Floor(i) ad esempio ) e dura fino alla deallocazione in memoria dell'oggetto.
Ma la variabile di classe?

Originariamente inviato da cdimauro

Ci sono diversi errori. Il primo è che hai dichiarato floorNumber, closetNumber, shelfNumber, e (soprattutto!) book come variabili di classe, quando è chiaro che dovrebbero essere d'istanza, per l'uso che ne fai. Quindi ti basta eliminare l'assegnazione a zero (e lista vuota per l'ultimo) che nei fai all'interno della definizione della classe.

Per book=[] devo ancora vedere come gestirlo, ma penso tu abbia ragione, perchè deve essere creato dentro l'oggetto shelf.

Originariamente inviato da cdimauro

Quello che ti crea problemi, comunque, è il fatto che accedi a un elemento della lista quando ancora non gliel'hai inserito con append. Infatti per popolare la lista al posto di questo:

self._closet[i].append(dummyC)

devi scrivere:

self._closet.append(dummyC)

Ciò vale anche per Closet.py.

Infatti tu hai creato una lista vuota con self._closet = [] , ma... devi ancora popolarla. E lo fai col metodo append, ma devi applicarlo a self._closet, perché è questa lista, mentre self._closet[i] non è una lista (potrebbe anche esserlo, eh!) ma un suo elementi, che nello specifico è un'istanza di Closet.

Si è vero, è una svista. Mi confondono un casino ste liste...

Originariamente inviato da cdimauro

Un'ottimizzazione che potresti fare è quella di eliminare l'uso delle variabili temporanee. Un esempio:

for i in range(2): #Use 2 floors
    floor.append(Floor(i))

Se sistemi tutto il codice in modo che sia in questa forma, puoi sfruttare un bellissimo strumento di Python che sono le list comprehension, che ti permettono di creare (e popolare) una lista in maniera compatta ed elegante:

floor = [Floor(i) for i in range(2)] #Use 2 floors

Se hai un background matematico, ti dovrebbe essere facile leggerla e comprenderne il significato.

Mi sono guardato le list comprehension sul sito di python.
Mi pare di capire che essenzialmente ciò che vuoi far fare in seguito ad un condizione lo metti prima e dopo metti la/e condizione/i.
Poi la teoria è sempre diversa dalla pratica

[kwb]

Ho aggiustato un po' e ora almeno stampa qualcosa.
Tuttavia, come faccio a creare lo spazio di memoria per l'oggetto book ( creare una lista lunga 10 book, dentro shelf ) senza però dover assegnare i valori ( perchè lo farò tramite il metodo addBook )?