Newsgroup: it.comp.lang
Titolo: [python] Pubblico e privato ed ereditarietà fra classi

Di solito nella prog a oggetti sono abbituato a trovare
il concetto di pubblico, protetto, e privato.
Un dato pubblico è accessibile anche esternamente con - classe.dato
Un dato protetto è accessibile solo dalla classe e dalle classi figlie
Un dato privato non è accessibile a nessun altra classe.
Ho fatto un prog di test, ma sul manuale (
python.org
) non ho trovato nulla
che avesse il significato di protected: Private, come è evidente dal 
programma di test che riporto sotto, non è riconosciuto nella classe 
derivata. Anzi, mi fa uno strano effetto, non cambia nulla anche
se nella classe derivata lo dichiaro esplicitamente, non capisco
quale sia il valore ritoranto da test.GetProtectedVar() 
Come faccio un protected ? Se non esiste, mi adatto, faccio tutto public e 
al diavolo gli errori che si possono generare saltando il costruttore, ma 
magari è solo una mia svista.
Domanda di riserva, come implemento una variabile static ad una funzione o 
ad una classe?
 
Mi serve aiuto per chiarire/trovare meglio i concetti della 
programmazione ad oggetti in python. Public, private, 
inerited, virtual, overload, override e static come si realizzano?
L'ideale sarebbe qualche link ad un manuale che tratti dettagliatamente 
questi argomenti. Oviamente, anche se non ho seguito tutti i link, 
Python.org l'ho già visitato. Utilissimo, ma su alcune cose mi sembra 
troppo succinto e non sono riuscito a chiarirmi le idee sui concetti di 
ereditarietà.
-----------------------------------------------------------
import string
class BaseTestClass:
        __PrivateVar=""
        PublicVar=""
        def SetVar(self,v1,v2):
                self.__PrivateVar=v1
                self.PublicVar=v2
        def GetProtectedVar(self):
                return self.__PrivateVar
        def GetPublicVar(self):
                return self.PublicVar
        def __init__ (self,v1,v2):
                self.SetVar(v1,v2)
 
class DerivedTestClass(BaseTestClass):          
        #perchè togliere la rem a __PrivateVar non produce differenza?
        #__PrivateVar="pippo" 
        def SetVar(self,v1,v2):
                self.__PrivateVar=string.upper(v1)
                self.PublicVar=v2=string.upper(v2)
 
test=DerivedTestClass("Protetto","Pubblico")
print "test.GetProtectedVar < "+test.GetProtectedVar() +" >"
print "test.GetPublicVar < " +test.GetPublicVar()+" >"
print "Se uso var pubbliche è possibile fare test.PublicVar=qualcosa e io"
test.PublicVar="preferirei non fosse possibile fare l'assegnazione diretta"
print "GetPublicVar < " +test.GetPublicVar()+" >"
test1=BaseTestClass("private Funziona solo per la classe base?","Pubblico")
print "test1.GetProtectedVar < "+test1.GetProtectedVar() +" >"

                 self.__PrivateVar=string.upper(v1)
riassegni il valore a self._DerivedTestClass__PrivateVar
Se commenti la dichiarazione, di fatto questo assegnamento
diventa anche la dichiarazione della variabile self.__PrivateVar
Aggiungo che le variabili private sono solo simulate, in Python,
ma vengono gestite trasformando il nome da
__nome
a
_classe_nome
per cui, usando questa seconda sintassi, se conosci sia il nome
della variabile che quello della classe, puoi sempre accedere
direttamente alla variabile "privata"
--
Gerolamo

....cut....
Grazie.
Speravo di aver capito male, le variabili protected, aiutano ad evitare 
errori di incoerenza  (esempio date 30 febbraio) all'interno dei dati di 
una classe.
Se qualcuno potesse aiutarmi anche per il concetto di 'static'
gli sarei grato.
Ad esempio come faccio ad implementare una classe
che contenga un dato che fa da contatore di quante volte viene istanziata?

 istanziata?
mmm... la sparo:
Crei una classe counter implementata come singlethon e la
richiami nel costruttore della tua classe.
Che ne dici?
--
Gerolamo

 Che ne dici?
Per ora non so cosa sia un "singlethon" e non capisco cosa vuoi dire.
Attualmente pensavo di salvare il contatore in un dizionario di contatori

 gli sarei grato.
Per le variabili basta usare una variabile di classe e non di istanza:
class C:
    contatore = 0 # di classe
    def __init__(self):
        C.contatore += 1
        self.a = 42 # variabile di istanza
-- 
Marco Barisione  (ICQ 84277092)
Vota per la creazione di it.comp.software.editor seguendo le istruzioni
contenute nel messaggio news://
MK.it.comp.soft...@news.nic.it

         self.a = 42 # variabile di istanza
o bella...
non lo sapevo, grazie!
A questo punto mi rimangio la frase sui singlethon che diventa
ovviamente inutile
--
Gerolamo

         C.contatore += 1
GRAZIE!!!
sono un newbye e questa possibilità non la avevo ancora incontrata.
Molto più pulito delle soluzioni che avevo pensato.

 richiami nel costruttore della tua classe.
Scusa, cosa vuol dire "implementata come singleton" ?
Ciao e grazie
     :ce
-- 
Per rispondermi in privato, togliere "_pre" e "sso_" dall'indirizzo
Remove "_pre" and "sso_" from my email address to reply directly to me

 Scusa, cosa vuol dire "implementata come singleton" ?
Il singleton č dei pattern piů conosciuti nella programmazione, consiste 
nell'avere una solo istanza di un determinato oggetto, per quanto riguarda 
Python ci sono diversi modi per ottenere questo effetto, Thinking in Python 
di Eckel tratta anche di questo (
http://www.mindview.net/Books/TIPython
). 
Comunque spesso quando serve un singleton ci sono soluzioni piů semplici ed 
eleganti.


 Per le variabili basta usare una variabile di classe e non di istanza:
Attenzione comunque ad usare codice che possa accedere alla stessa 
variabile in thread diversi!


 dichiarare una variabile static.
Avevo letto non molto tempo fa un post di Alex Martelli sulla ML di Python
(
http://www.python.it
) che parlava delle metaclassi e di come creare dei
metodi "statici". Prova a cercare negli archivi. Ciao.
-- 
Andrea Bergia - studente              Linux Registred User #281550
"The one thing we're all waiting for, is peace on Earth and an end to war,
it's a miracle we need, the miracle, the miracle, 
Peace on earth and end to war today,
That time will come one day you'll see when we can all be friends"

 ovviamente inutile
ehm... si scrive singleton, senza 'h' ;-)
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra