Visualizza post

Questa sezione ti permette di visualizzare tutti i post inviati da questo utente. N.B: puoi vedere solo i post relativi alle aree dove hai l'accesso.


Post - RicPol

Pagine: 1 ... 220 221 [222] 223 224 225
3316
Base / Re: stringa di rappresentazione locale della data
« il: Maggio 31, 2011, 10:10 »
Sì, hai sbagliato sezione. Per le wx c'è l'apposito forum nel reparto "interfacce grafiche"...
Detto questo, wx.DateTime purtroppo non è coerente con datetime, quindi devi fare un po' di acrobazie.
Per esempio puoi usare queste formule, o inventarti qualcosa di analogo, per convertire tra i due formati:
[codice]
# da datetime a wx.DateTime
py_now = datetime.datetime.now() 
tt = py_now.timetuple()
dmy = (tt[2], tt[1]-1, tt[0])
wx_now = wx.DateTimeFromDMY(*dmy)

# da wx.DateTime a datetime
wx_now = wx.DateTime().SetToCurrent() 
ymd = map(int, wx_day.FormatISODate().split('-'))
py_now = datetime.date(*ymd)
[/codice]

rp


3317
Base / Re: os.listdir e simili
« il: Maggio 27, 2011, 17:05 »
Beh, man mano che os.walk() raccatta directory e file, tu li testi con qualcosa come
[codice]
if mydir.startswith('img'):
    #etc
if myfile.startswith('file1'):
    #etc
[/codice]
rp

3318
Citazione
questi file erano in origine nella codifica "windows-1250"
Mi sembra abbastanza normale... se il testo era in polacco, probabilmente sarà stato scritto in polonia su un pc windows impostato con un locale polacco, da un signore non particolarmente competente sui problemi di encoding... che cosa potevi aspettarti?
http://en.wikipedia.org/wiki/Windows-1250
Citazione
come si fa ad evidenziare il codice python?
circondando il codice con i tag "codice" e "/codice" (tra parentesi quadre), che ottieni facendo clic sul pulsante col cancelletto.
rp

3319
Base / Re: Stupido problema
« il: Maggio 17, 2011, 11:18 »
Si chiama "programmazione a oggetti". Se vai a tentoni, sarà un po' lungo... Inizia da qui http://docs.python.org/tutorial/classes.html
Ecco un piccolo esempio per i tuoi quesiti:
[codice]
>>> class A(object):
   def __init__(self, foo):
      self.foo = foo
   def output(self):
      return self.foo

   
>>> a = A('hello')
>>> a.output()   # con le parentesi *chiamo* un metodo...
'hello'
>>> a.output     # ...senza parentesi, no!
<bound method A.output of <__main__.A object at 0x0124DB70>>
>>> class A(object):     # adesso proviamone un'altra
   def output(self):  # così invece non funzionera'...
      return self.foo

>>> a = A()
>>> a.output() #... perche', al momento di chiamare il metodo, "foo" non esiste!

Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    a.output()
  File "<pyshell#20>", line 3, in output
    print self.foo
AttributeError: 'A' object has no attribute 'foo'
[/codice]
ciao
rp

3320
E' tutto un po' ingarbugliato... oer esempio non sono sicuro di aver capito perché il tuo file ha dei caratteri "sbagliati" da sostituire... non credo che qualcuno all'origine si sia divertito a fare casino apposta... forse è solo in un encoding diverso da quello che tu credi?
In ogni caso, in linea di principio i passaggi dovrebbero essere i seguenti:
1) assicurati di aver capito qual è l'encode del file originario (se qualcosa va storto dopo, nove su dieci qui sta il problema)
2) se lavori da una shell interattiva, ok (credo!). Se invece vuoi scrivere uno script da eseguire dopo, assicurati di aver definito l'encoding dello script, e di dichiararlo all'inizio (con # -*- coding: utf-8 -*- per esempio).
3) assicurati che tutti i caratteri "strani" che compaiono nello script (o nella shell, se usi la shell) siano dichiarati come unicode: quindi, per esempio, scrivi caratteriAggiustati= [u'ą', u'ć', u'ę', u'ń', etc. etc])
4) leggi il file di origine riga per riga, e convertilo in unicode (con riga.decode("encoding-del-mio-file")).
5) fai la sostituzione
6) riconverti la riga in un encoding di tua scelta (con riga.encode('utf-8'), per esempio)
7) salva dove devi

Ma non sono un grande esperto di queste cose, quindi magari mi sto perdendo qualcosa. La sostanza, comunque, dovrebbe essere: converti tutto in unicode -> "dentro" python lavora in unicode -> riconverti in uscita.
Il punto di partenza per approfondire è questo http://docs.python.org/howto/unicode.html
ciao
rp

3321
wxPython / Re: problema con un dialog
« il: Maggio 15, 2011, 11:31 »
Uhm, quando chiedi aiuto sul forum, cerca di postare codice funzionante e comprensibile, altrimenti tocca indovinare cosa stai cercando di fare.
Fortuna che nel caso specifico il problema salta all'occhio. Il guaio è che non hai capito come funziona Bind().
Guarda questo script: riproduce esattamente il tuo errore.
[codice]
import wx

class Prova(wx.Frame):
    def __init__(self, *a, **k):
        wx.Frame.__init__(self, *a, **k)
        b = wx.Button(self, -1, 'clic me')
        b.Bind(wx.EVT_BUTTON, self.output('spam', 'eggs'))

    def output(self, a, b):
        print a, b       

app = wx.App(False) 
test = Prova(None, -1, 'test', size=(200, 200)) 
test.Show()
app.MainLoop()
[/codice]
Quando il frame si inizializza, vedrai che il metodo "output" viene eseguito esattamente una volta, senza il tuo intervento.
Dopo di che, quando fai clic sul pulsante, non succede assolutamente nulla.
Riesci a indovinare perché:
1) "output" viene eseguito una volta all'inizio
2) poi non viene più eseguito quando fai clic sul pulsante?

Inoltre: alla riga 10, sostituisci "print a, b" con "return a, b". Adesso vedrai che lo script non funzionerà più, ma lo stacktrace dell'eccezione sollevata ti mette sulla giusta pista.
Oppure scrivi >>> help(wx.Window.Bind) e leggi che cosa dice alla parte "param handler".

Poi se proprio non ne esci fuori... zio ricpol è sempre pronto a dare una mano  :angel:

rp

3322
wxPython / Re: textdialog con più campi testo
« il: Maggio 14, 2011, 18:07 »
E bravo, il cuore del problema è risolto, direi: hai capito come generare una quantità variabile di TextCltr, e come recuperare il valore di ciascuno (basta raccogliere i TextCtrl in una lista...).  Questa è una delle tecniche-base per la costruzione di interfacce dinamiche. Probabilmente in futuro preferirai raccogliere i controlli generati dinamicamente in un dizionario, piuttosto che in una lista. Ma in questo caso una lista basta e avanza.

Il problema maggiore ovviamente è che il tuo Dialog è rigido come il cemento. Il posizionamento assoluto lo rende inutilizzabile: se una delle label è troppo lunga, sparirà sotto il TextCtrl. E se lo chiami con più di un tot di campi, grazie alle dimensioni fisse del Dialog, si vedranno solo i primi. E poi il posizionamento assoluto ti costringe a fare il calcolo esplicito delle posizioni di ciascun elemento, con alcune righe di codice veramente brutte.
Devi assolutamente imparare a usare i sizer: oltre a essere molto più eleganti, sono l'unica tecnica che non ti fa impazzire quando costruisci interfacce dinamiche.
Un secondo problema più marginale è la gestione dei valori di default... Adesso costringi l'utente a passare sempre un parametro default_values, anche quando non vuole inserire nessun default! E per giunta deve stare attento che le due liste campi e default_values abbiano la stessa lunghezza, altrimenti tutto crolla...
Un altro dettaglio: alla riga 18 enumerate non ti serve a nulla...

Va bene, ecco il modo in cui io risolverei il problema.

[codice]
import wx

class MultiTextEntryDialog(wx.Dialog):
    """A sort of wx.TextEntryDialog with multiple entries.
    Usage:
         dlg = MultiTextEntryDialog(self,
                        input_labels=['first name', 'last name', 'address'],
                        defaults=['', 'Smith']) # set default for last name only
         if dlg.ShowModal() == wx.ID_OK:
             ret = dlg.GetValue()  # returns a list of inserted values
         dgl.Destroy()
     
    In addition to normal wx.Dialog behaviour, you should provide the following:
    @param input_labels: a list of labels, one for each entry to display
    @type  input_labels: list of strings
    @param defaults: a (facultative) list of default values
    @type  defaults: list of strings
    @param message: a (facultative) intro message
    @type  message: str
    """
    def __init__(self, parent, id=-1, title=wx.EmptyString,
                 pos=wx.DefaultPosition, size=wx.DefaultSize,
                 style=wx.DEFAULT_DIALOG_STYLE, name=wx.DialogNameStr,
                 input_labels=[''], defaults=[], message=''):
        wx.Dialog.__init__(self, parent=parent, id=id, title=title, pos=pos,
                           size=size, style=style, name=name)
        s = wx.BoxSizer(wx.VERTICAL)
        if message:
            s.Add(wx.StaticText(self, -1, message), 0, wx.ALL, 10)
            s.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)
        s1 = wx.FlexGridSizer(len(input_labels), 2)
        s1.AddGrowableCol(1, 1)
        self.text_ctrls = []
        for n, lab in enumerate(input_labels):
            t = wx.TextCtrl(self)
            self.text_ctrls.append(t)
            try:
                t.SetValue(defaults[n])
            except IndexError:
                pass
            s1.Add(wx.StaticText(self, -1, lab), 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
            s1.Add(t, 0, wx.EXPAND|wx.ALL, 5)
        s.Add(s1, 0, wx.EXPAND|wx.ALL, 5)
        s.Add(self.CreateButtonSizer(wx.OK|wx.CANCEL), 0, wx.ALL|wx.EXPAND, 5)
        self.SetSizer(s)
        if size == wx.DefaultSize:
            s.Fit(self)
        else:
            self.SetSize(size)

    def GetValue(self):
        """
        @returns: a list of values inserted in each entry
        @rtype: list of strings
        """
        return [i.GetValue() for i in self.text_ctrls]
[/codice]

Alcuni commenti:
1) visto che abbiamo detto che il codice dovrebbe servire ad altri, lo scrivo in inglese, con un nome significativo, e con una bella docstring.
2) scelgo di mettere a disposizione tutti i parametri possibili di un wx.Dialog, per offrire il massimo della flessibilità.
3) Nota i tre parametri personalizzati. Nota il default di input_labels=[''], che garantisce che si possa chiamare il dialog, al limite, anche senza specificare niente! Il parametro "message" lo metto per analogia con wx.TextEntryDialog.
4) riga 37-40: il modo in cui ho deciso di gestire gli eventuali valori di default, con la massima flessibilità: se non si vogliono default, si possono semplicemente ignorare e tutto funzionerà lo stesso
5) riga 46-49: il modo in cui ho deciso di gestire la questione delle dimensioni della finestra: se si chiama il dialog con un size specifico, questo viene applicato; altrimenti, la finestra avrà le dimensioni minime possibili.

Alcune scelte potrebbero essere diverse, ma più o meno l'impostazione mi sembra gradevole (nota che l'uso dei sizer risolve magicamente tutti i problemi).

rp

3323
Sì, forse wx.EVT_ENTER_WINDOW ha qualche problemuccio di compatibilità cross-platform... non so dirti con sicurezza perché non lo uso mai...
Di sicuro dovresti aggiungere un event.Skip() alla fine dei tuoi gestori, probabilmente basta questo. Se non basta... bisogna mettersi a pensare!
Leggiti questo http://wiki.wxpython.org/EventPropagation se non lo hai ancora fatto.
ciao
rp

3324
Boh... probabilmente perché, essendo un controllo composito, non regge il posizionamento e dimensionamento assoluto, come hai fatto tu.
In generale, è sempre meglio usare i sizer. In questo caso particolare, si vede che è proprio necessario.
[codice]
# <cut>
wx.Frame.__init__(self, None, wx.ID_ANY, 'wxButton', pos=(300, 150), size=(400, 250)) 
p = wx.Panel(self) # ovviamente ci vuole un panel se usiamo i sizer...
scegli = wx.FilePickerCtrl(p, -1, 'c:\\', 'File da convertire', '*.*')
button1 = wx.Button(p, -1, 'converti')
s = wx.BoxSizer(wx.VERTICAL)
s.Add(scegli, 0, wx.EXPAND|wx.ALL, 5)
s.Add(button1, 0, wx.EXPAND|wx.ALL, 5)
p.SetSizer(s)
[/codice]

ciao
rp

3325
Database / Re: Esportazione e tab
« il: Maggio 13, 2011, 13:16 »
Citazione
Devi scrivere semplicemente un parser.
Beh, in linea generale certamente.
Ma se il suo caso è "abbastanza" semplice, può bastare anche molto meno.

[codice]
>>> spaziature = (5, 7, 3, 10)
>>> dataset = (('aaa', 'bbbbbb', 'c', 'ddddddd'), ('bb', 'fffff', 'vv', 'dd'))
>>> for record in dataset:
   for n, item in enumerate(record):
      print item.ljust(spaziature[n]),
   print

   
aaa   bbbbbb  c   ddddddd  
bb    fffff   vv  dd        
>>>
[/codice]
Certo, se hai paura che un valore possa essere più lungo della corrispondente spaziatura, devi introdurre qualche forma di controllo, etc..

rp

EDIT
vebbè, un dettaglio implementativo: la virgola inserisce uno spazio in più del voluto...
Facciamo così allora, che è anche più usabile:

[codice]
>>> spaziature = (5, 7, 3, 10)
>>> dataset = (('aaa', 'bbbbbb', 'c', 'ddddddd'), ('bb', 'fffff', 'vv', 'dd'))
>>> for record in dataset:
   print ''.join([i.ljust(spaziature[n]) for n, i in enumerate(record)])

   
aaa  bbbbbb c  ddddddd   
bb   fffff  vv dd       
>>>
[/codice]

rp

3326
Base / Re: problema con caratteri unicode
« il: Maggio 11, 2011, 12:11 »
Citazione
Faccio presente che l'idea buona sarebbe *non* mettere caratteri non ascii nelle stringhe dentro i sorgenti.

Assolutamente.

La cosa buffa è che tutti questi avanti e indietro con l'encoding non sarebbero neppure necessari nel codice così com'è... basta specificare l'encoding in cima, e poi premettere la "u" davanti alle stringhe da intendere come unicode:
[codice]
# -*- coding: utf-8 -*-
def Char_finder(string):   
    for idx, char in enumerate(string): 
        if char in u"àèéìòù":
            print "Found %s at index %s" % (char, idx) 
        elif char == "\n": 
            print "Found newline at index %s" % idx 

Mystring = u'undue tre un due\n tre quattro un due à \n cin sei sette otto' 
Char_finder(Mystring)
[/codice]
certo se le stringhe derivano (come dovrebbe essere) da una sorgente esterna non-unicode, allora bisogna encodarle...

Ah, dimenticavo: eviterei di usare "string" come nome di un parametro. Qui non importa, ma le brutte abitudini prima o poi si pagano...
rp

3327
wxPython / Re: Copiare Frame negli appunti
« il: Maggio 10, 2011, 23:36 »
Eh eh, eccomi di ritorno...

Ripensandoci a stomaco pieno, mi è venuto in mente che tu non vuoi prendere semplicemente prendere un DC subito dopo che ci hai disegnato sopra, e copiarlo nella clipboard...
In realtà cerchi il modo di "fotografare" il disegno contenuto in una finestra, indipendentemente da quando è stato fatto, e anche più volte di seguito...
Ma allora devi per forza passare da un MemoryDC collegato a una bitmap.
Questa sarebbe la soluzione "facile".

Però, mentre stavo buttando giù un codice di esempio, mi è venuta in mente anche una soluzione un po' più raffinata.
In pratica si tratta di creare una bitmap all'inizio, e tenerci dentro il disegno attuale, man mano che si crea, collegandola di volta in volta a dei BufferedDC creati alla bisogna.
Naturalmente i BufferedDC vanno subito svuotati, altrimenti il disegno non si vede sullo schermo; ma la cosa bella è che la bitmap contiene sempre la versione più aggiornata del disegno.
In questo modo, ogni volta che vuoi copiare il disegno nella clipboard, basta prendere la bitmap e copiarla!
Molto pratico.

Ho messo insieme il codice in una classe DrawPanel separata, per praticità.
Ci sono due metodi di prova, disegna_cerchio e disegna_rettangolo, così puoi provare a copiare nella clipboard in momenti diversi, e vedere che in effetti la bitmap è aggiornata correttamente.

Il metodo "clipboard_copy" contiene un ramo "if False" che ormai non serve più, ma che presenta l'idea da cui sono partito, ossia fare uso di un MemoryDC per "fotografare" lo stato attuale del disegno.

Attenzione: noterai che le dimensioni del DrawPanel sono fisse (300x300): questa è una scorciatoia per evitare di dover gestire l'eventuale resizing...

[codice]
import wx 

class DrawPanel(wx.Panel):
    def __init__(self, *args, **kw):
        kw['size'] = (300, 300)
        wx.Panel.__init__(self, *args, **kw)
        # una bitmap che conterra' il disegno del panel, man mano che si forma
        self.bitmap = wx.EmptyBitmap(300, 300, -1)
       
        # stato iniziale
        dc = wx.BufferedDC(None, self.bitmap)
        dc.SetBackground(wx.Brush(wx.WHITE))
        dc.Clear()
       
        self.Bind(wx.EVT_PAINT, self.OnPaint)

    def OnPaint(self, evt):
        # creo un BufferedPaintDC collegato all'immagine attuale...
        dc = wx.BufferedPaintDC(self, self.bitmap)
        # ... e tanto basta!
        # Appena si esce da OnPaint, il BufferedPaintDC viene distrutto, e
        # automaticamente il contenuto viene disegnato nel panel... comodo!
   
    def disegna_rettangolo(self):
        "Disegna un rettangolo di prova..."
        self.dc = wx.BufferedDC(wx.ClientDC(self), self.bitmap)
        self.dc.SetPen(wx.BLACK_PEN)
        self.dc.SetBrush(wx.TRANSPARENT_BRUSH)
        self.dc.DrawRectangle(10, 10, 280, 280)
        self.Refresh() # questo innesca OnPaint
       
    def disegna_cerchio(self):
        "Disegna un cerchio di prova..."
        self.dc = wx.BufferedDC(None, self.bitmap)
        self.dc.SetPen(wx.BLACK_PEN)
        self.dc.SetBrush(wx.TRANSPARENT_BRUSH)
        self.dc.DrawCircle(150, 150, 100)
        self.Refresh() # questo innesca OnPaint
       
    def clipboard_copy(self):
        "Copia se stesso nella clipboard."
        if False:
            # questo sarebbe un metodo normale per copiare
            # lo stato attuale del panel in una bitmap, che poi
            # puo' essere salvata o copiata nella clipboard:
           
            # il dc del panel stesso
            dc = wx.ClientDC(self) 
            # una bitmap delle stesse dimensioni del panel
            x, y = self.GetClientSizeTuple()
            self.bitmap = wx.EmptyBitmap(x, y, -1)
            # un MemoryDC collegato alla bitmap
            mem = wx.MemoryDC(self.bitmap)
            # copio il dc nel MemoryDC (quindi nella bitmap)
            mem.Blit(0, 0, x, y, dc, 0, 0)
            # eventualmente svuoto il MemoryDC (per non sprecare memoria)
            mem.SelectObject(wx.NullBitmap)
            # e ora self.bitmap contiene l'immagine attuale del panel
       
        # ma siccome noi abbiamo fin dall'inizio una self.bitmap che
        # contiene l'immagine del panel sempre aggiornata, ci basta
        # usare quella, e procedere senza troppo disturbo!
        wx.TheClipboard.Open()
        b = wx.BitmapDataObject(self.bitmap)
        wx.TheClipboard.SetData(b)
        wx.TheClipboard.Close()
       
        # oppure naturalmente potrei salvare la bitmap in un file...
        # self.bitmap.SaveFile('prova.bmp', wx.BITMAP_TYPE_BMP)


class Test(wx.Frame):
    def __init__(self, *args, **kw):
        wx.Frame.__init__(self, *args, **kw)
        p = wx.Panel(self) # area per i bottoni
        self.draw_panel = DrawPanel(self)  # area per il disegno
       
        copia = wx.Button(p, -1, 'copia')
        cerchio = wx.Button(p, -1, 'cerchio')
        rettangolo = wx.Button(p, -1, 'rett.')
        self.Bind(wx.EVT_BUTTON, self.su_copia, copia)
        self.Bind(wx.EVT_BUTTON, self.su_cerchio, cerchio)
        self.Bind(wx.EVT_BUTTON, self.su_rettangolo, rettangolo)
       
        s = wx.BoxSizer(wx.VERTICAL)
        for b in (cerchio, rettangolo, copia):
            s.Add(b, 0, wx.EXPAND|wx.ALL, 5)
        p.SetSizer(s)
        s = wx.BoxSizer()
        s.Add(p, 0, wx.EXPAND)
        s.Add(self.draw_panel, 1, wx.EXPAND)
        self.SetSizer(s)
        self.Fit()
   
    def su_cerchio(self, evt):
        self.draw_panel.disegna_cerchio()
       
    def su_rettangolo(self, evt):
        self.draw_panel.disegna_rettangolo()
       
    def su_copia(self, evt):
        self.draw_panel.clipboard_copy()


app = wx.App(False) 
test = Test(None, -1, 'test') 
test.Show()
app.MainLoop() 
[/codice]

Studia con attenzione questo codice... purtroppo sono cose un po' tecniche, e se ti perdi tra un BufferedDC, un BufferedPaintDC, un MemoryDC... hai tutta la mia comprensione!

Per approfondire, ti consiglio di studiare bene il codice contenuto in
.../wxPython2.8 Docs and Demos/samples/doodle  e .../pySketch, e poi anche quello di
.../wxPython2.8 Docs and Demos/wxPython/samples/wxPIA_book/Chapter-06

ciao
rp

3328
wxPython / Re: Copiare Frame negli appunti
« il: Maggio 10, 2011, 19:06 »
Uhm... ma guarda... pensavo fosse banale, invece non lo è...

Allora, prima la parte banale.
La clipboard funziona in modo semplicissimo, per esempio:
[codice]
# questo per il testo
data = wx.TextDataObject()
data.SetText('ciao ciao')
wx.TheClipboard.Open()
wx.TheClipboard.SetData(data)
wx.TheClipboard.Close()

# e questo per una bitmap
data = wx.BitmapDataObject()
data.SetImage(wx.Bitmap('mia_bitmap.bmp'))
wx.TheClipboard.Open()
wx.TheClipboard.SetData(data)
wx.TheClipboard.Close()
[/codice]

Se provi questo codice, funziona, nel senso che (una volta che lo hai fatto girare), nella clipboard resta il testo o l'immagine che hai copiato, e la puoi incollare altrove.

Di conseguenza mi immaginavo che, nel tuo caso, bastasse fare:
[codice]
# aggiungi queste righe alla fine del tuo "OnPaint"
b = wx.BitmapDataObject()
b.SetImage(dc.GetAsBitmap())
wx.TheClipboard.Open()
wx.TheClipboard.SetData(b)
wx.TheClipboard.Close()
[/codice]

Solo che non funziona (almeno su win xp...), nel senso che se fai girare il codice e poi provi a incollare gli appunti dentro un programma di grafica (fai ctrl-C dentro Paint, per esempio) ti dà un bell'errore.
Probabilmente perché wx.PaintDC.GetAsBitmap() è un po' bucato, o non restituisce il tipo di bitmap giusto...

Dovrei fare delle prove... forse si deve trattare in qualche modo la bitmap generata da wx.PaintDC.GetAsBitmap(), prima di inserirla nel wx.BitmapDataObject()... scommetto che c'entrano le trasparenze...
Un'altra strada è usare un wx.MemoryDC per disegnare direttamente su una bitmap... quando si ha finito, si può inserire nella clipboard normalmente e/o salvarla, e allo stesso tempo disegnarla sullo schermo usando wx.DC.Blit()... ma certo non sarebbe il massimo...
Non ho tempo adesso di fare esperimenti, ma se riesci ad andare avanti facci sapere, è interessante...

rp

3329
wxPython / Re: textdialog con più campi testo
« il: Maggio 10, 2011, 17:25 »
Eh beh, per forza... lui si aspetta un "self" come primo argomento, poverino...
[codice]
wx.Dialog.__init__(SELF, parent, -1, title='Informazioni personali', eccetera)
[/codice]

Lascia perdere "inizializza", te l'ho detto... ti conviene dare un default al parametro default_values (scusa il bisticcio), piuttosto...
[codice]
class infodialog(wx.Dialog): 
    def __init__(self,parent, default_values=['', '', '']): 
[/codice]
Così, se non passi default_values, va bene comunque; se invece vuoi che, per dire, il secondo campo abbia un default, passi default_values=["", "ciao come va?", ""], ed eviti completamente tutta la brutta operazione "inizializza"

Comunque resta da risolvere il punto fondamentale... fare in modo che il numero dei campi di testo sia parametrizzabile, così da creare all'occorrenza un dialogo con 1, 2, 3 o enne campi.
ciao
rp

3330
No, siamo perfettamente d'accordo, anche io spingo per i **kwargs a ogni costo...
Dico solo che tra questa ipotesi:
[codice]
class MyFrame(wx.Frame):
    def __init__(self, *args, **kwargs):
    foo = **kwargs.pop('foo')
    wx.Frame.__init__(self, *args, **kwargs)
[/codice]
e questa ipotesi:
[codice]
class MyFrame(wx.Frame):
    def __init__(self, parent, id, size, position, e_tutti_gli_altri, foo): # ora non ricordo l'ordine consueto...
    wx.Frame.__init__(self, id=id, parent=parent, size=size, position=position, etc. etc.)
    foo = foo
[/codice]
la seconda, per quanto più verbosa, mi sembra un po' più esplicita perché non nasconde il parametro "anomalo" foo nella signature.

Poi è chiaro che se uno è molto temerario e vuole chiamare la classe ricordandosi la posizione di tutti i parametri senza usare keywords,
[codice]
fr = MyFrame(self, -1, (300, 300), (10, 10), etc_etc, "foo")
[/codice]
questa mi sembra una pessima idea, ma peggio per lui.

Citazione
questo e' generalmente un sintomo di una classe che fa troppe cose (..).
Sfortunatamente il caso delle GUI (...)
Sante parole. Gui con centinaia di classi con ereditarietà multipla usata in modo massivo, mixin... Sono problemi noti e ineliminabili (soprattutto nelle wx, ahimé). Ovviamente uno cerca di trovare una soluzione abbastanza elegante, tenendo conto del contesto.

rp

Pagine: 1 ... 220 221 [222] 223 224 225