[SOLUCIONADO] Consultas sobre wxPython

[negrolito]

¡Holas!

Estoy siguiento un tuto para aprender wxPython y me dejan es ascuas en varios asuntos, sobre todo a uno que manya inglés. Voy copiando cada ejercicio, luego leo las lecciones y luego comento cada línea de código. Por ejemplo, la expresión:

Código:

super(Example, self).__init__(parent, title=title, size=(390, 350))

no la explica en ningún lado. Otra que me intriga es "vbox.Add((-1, 10))" en el siguiente código.

Código:

# se crea otro contenedor horizontal
hbox2 = wx.BoxSizer(wx.HORIZONTAL)
# se crea otra statictext
st2 = wx.StaticText(panel, label='Juego de clases')
# se configura la misma font para este nuevo statictext
st2.SetFont(font)
# se anexa el estatictext al nuevo contenedor horizontal
hbox2.Add(st2)
# se anexa el nuevo contenedor horizontal al contenedor vetical
vbox.Add(hbox2, flag=wx.LEFT | wx.TOP, border=10)
# ----- ¿? ------
vbox.Add((-1, 10))

En ningún lado explica cuál es su función.

Desde ya muy agredecido si me dan una mano.

Suerte.

[razpeitia]

Supongo que estas siguiendo este tutorial. http://zetcode.com/wxpython/layout/

Donde claramente explica que es para darle espacio.

We already know that we can control the distance among widgets by combining the flag parameter with the border parameter. But there is one real constraint. In the Add() method we can specify only one border for all given sides. In our example, we give 10px to the right and to the left. But we cannot give 25 px to the bottom. What we can do is to give 10px to the bottom, or 0px. If we omit wx.BOTTOM. So if we need different values, we can add some extra space. With the Add() method, we can insert widgets and space as well.

[Carlangueitor]

Lo de super no es de wxPython es de python: http://www.niwi.be/2011/06/09/herenc...per-en-python/

Saludos

[negrolito]

Gracias gente por contestar.

Razpeitia: afirmativo, estoy usando ese tutorial, pero es un pdf que al parecer lo ha traducido algún traductor como google traslatión, que pone los puntos y las comas donde se le antoja. He cometido un error de tipeo en la consulta "no manyo nada de inglés". Ahora voy a probar quitando esas líneas para ver cuál es el efecto.

Carlangueitor: gracias por el enlace. He estado aprendiendo Python de tutoriales en Youtube pero no recuerdo que hayan tocado el tema de Super(). Pensé que era de wxPython.

¡Muchas gracias por la ayuda!
Suerte.

[razpeitia]

Como ya dije:

Código Python:

vbox.Add((-1, 10))
 

Lo que hace es agregar un widget arbitrario, de ancho default (-1) y alto 10.

[negrolito]

Gracias nuevamente. Ese -1 lo veo en varios métodos, ahora asumo que es un valor de default. Me tengo que detener a ver un poco más el tema de los constructores que me pierden un poco.

Suerte.

[AlvaroG]

Para agregar algo que quizás no sea necesario, pero me parece que queda pendiente.

Nota que add() recibe 1 solo argumento, no dos. El argumento de add() es una tupla de dos valores, de ahí que sea necesario usar doble paréntesis:

add(-1, 10) # dos argumentos, -1 y 10
add((-1, 10)) # 1 argumento, la tupla (-1, 10)


Y para resumir la respuesta a la primera pregunta:

Código Python:

super(Ejemplo, obj).__init__(parent, title=title, size=(390, 350))
 

Quiere decir algo como:
Entre todos los ancestros de la clase Ejemplo (clases de las que herede, y todo el árbol hasta "object"), busca la primera que implemente un método __init__ (salteando a la propia Ejemplo), y llama a ese método con los parámetros dados. Además, llama a ese método __init__ encontrado como si fuese un método de obj.

Basicamente es llamar a un método de una clase padre, solo que un poco más complicado porque Python permite herencia múltiple, y tiene la flexibilidad añadida de que, si quiero, puedo hacerlo desde fuera de la clase Ejemplo, porque super() es una función global.

[negrolito]

Gracias AlbaroG.

En este ejemplo (del libro antes citado).

Código:

class Example(wx.Frame):
     def __init__(self, parent, title):
           super(Example, self).__init__(parent, title=title, size=(320, 130))
           self.InitUI()
           self.Centre()
           self.Show()

Entre todos los ancestros de Example va a buscar el primer __init__() y lo implementa con los parámetros dados. Presumo que el super() se incluye dentro del propio __init__() porque lo que allí se coloca (según lo tutoriales que he visto) se ejecuta automáticamente. Al ver dos __init__() la cosa se vuelve un poco confusa.
Por lo que he visto de herencia no hace falta invocar un __init__() para que éste se incluya en nuestra clase, basta con omitirlo; entonces el __init__() del padre será heredado. Pero me imagino que el problema se presenta con los parámetros; que los que el padre tiene no sean precisamente los que nuestra clase necesita.
Si voy mal rumbeado avisame.

Gracias y suerte.

[AlvaroG]

No vas mal rumbeado, pero no es por un tema de parámetros que se incluye u omite la llamada a super().
Si tenés una clase A y una B(A), no es raro que necesites inicializar tu clase B con alguna cosa extra que A no hace, y por eso necesites definir __init__, pero a su vez necesites que A haga lo que debe hacer, y por eso además incluyas la llamada a super().

Si cada clase define su __init__, entonces al crear un objeto de clase B, el __init__ de A no es invocado. Solamente es invocado si B no define su __init__ propio.

Te agrego un par de ejemplos simples para que quede claro:

Código Python:

# clase base para el ejemplo
>>> class A(object):
...   def __init__(self):
...     print 'init A'
... 
>>> class B(A):
...   def __init__(self):
...     print 'init B'
... 
>>> B()
init B # B no llama al __init__ de A mediante super()
 
>>> class C(A):
...   pass
... 
>>> C()
init A # C no define __init__, corre el de A
 
>>> class D(A):
...   def __init__(self):
...     super(D, self).__init__()
...     print 'init D'
... 
>>> D()
init A
init D # D y A definen __init__, y D llama al de A
 
>>> class E(D):
...   def __init__(self):
...     super(E, self).__init__()
...     print 'init E'
... 
>>> E()
init A
init D
init E #gracias a las sucesivas llamadas a super() en cada clase, corren todos los __init__
 
>>> class F(E):
...   def __init__(self):
...     super(E, self).__init__()
...     print 'init F'
... 
>>> F()
init A
init D
init F # al llamar a super(E) en vez de super(F), salteamos el __init__ de E
 

[negrolito]

¡Perfecto! Para redundar en palabras ensayo una definición: sería como anexar atributos y métodos a la clase padre, pero definidas en la clase hija.
¡Es muy útil! Sobre todo cuando se trabaja con estas librerías, que uno las usa sin tratar de comprender cómo están hechas. Vendría a ser unas suerte de conjunción «y» que desactiva o sobrescribe una disyunción «o».

Gracias y suerte.