David Niklas wrote:
> Hello, I was following the doc, and in the beginning he gives an
> example where he creates a frame and accesses the main window by the
> name of Master.
>
> http://infohost.nmt.edu/tcc/help/pubs/tkinter/tkinter.pdf
I suppose you are asking about
"""
#!/usr/bin/env python
import Tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.grid()
self.createWidgets()
def createWidgets(self):
self.quitButton = tk.Button(self, text='Quit',
command=self.quit)
self.quitButton.grid()
app = Application()
app.master.title('Sample application')
app.mainloop()
"""
A link that is more accessible than the PDF is
http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/minimal-app.html
> I wanted to know, does the name have to be Master?
You can answer that question yourself. Rename to something unlikely to
produce a nameclash, e. g. david_niklas, and then run the script again. Does
it fail? If so, where? Come back here if you have trouble explaining your
findings.
> And why does he pass
> a second arg to tk.Frame.__init___ ?
Python has "bound" and "unbound" methods. Given a simple example class Foo
and an instance foo
>>> class Foo:
... def bar(self, x):
... return x * x
...
>>> foo = Foo()
you get an unbound method with
>>> Foo.bar
<unbound method Foo.bar>
and a bound method with
>>> foo.bar
<bound method Foo.bar of <__main__.Foo instance at 0x7fd8855834d0>>
A bound method stores the first argument (usually named self) so that you
can omit it when you invoke the method. You normally only use bound methods
as they are easier to invoke. Compare:
>>> foo.bar(2)
4
>>> Foo.bar(foo, 2)
4
Bound methods also make code more generic.
def add_bar_unbound(a, b, x):
return Foo.bar(a, x) + Foo.bar(b, x)
will always invoke Foo.bar, no matter what kind of object you provide as a
and b whereas
def add_bar_bound(a, b, x):
return a.bar(x) + b.bar(x)
will work with with any object that provides a suitable bar method.
But sometimes you have to explicit. How would you write a subclass of Foo
with a bar method that should do the same calculation as that of Foo.bar and
then add something?
def bar(self, x):
return self.bar(x) + 42
doesn't work because it will invoke the same bar() method over and over
again until it fails. One answer is to use an unbound method:
>>> class Baz(Foo):
... def bar(self, x):
... return Foo.bar(self, x) + 42
...
>>> baz = Baz()
>>> baz.bar(2)
46
Baz.bar invokes Foo.bar which calculates and returns the product of x, then
Baz.bar adds 42 and returns the result.
You might like to experiment a little and invoke add_bar_bound and
add_bar_unbound with Foo or Baz instances or any combination. Try to predict
the results.
(Just in case you want to investigate further: the alternative to unbound
methods in the context of inheritance is super())
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
