Mailman 3 March 2003 - Edu-sig

Re: [Edu-sig] Some design patterns with iterators
by Kirby Urner 06 Apr '03

06 Apr '03

At 07:44 PM 3/30/2003 -0500, Guido van Rossum wrote: .... Your comments highly welcomed and greatly appreciated! >-- > >That's a contorted example. Why not change this a bit so that instead >of __call__ it has a next method that raises StopIteration when >exhausted, and an __iter__ method returning self? Agreed. Students should realize that objects don't need to be wrapped by iter() in order to perform as iterators. It's sufficient to define a next() method internally, and then assign the object itself as the return of __iter__ -- as you point out. It's also possible to equate __call__ to next, so if the programmer *does* happen to wrap the object inside iter(), even with a sentinel, it won't break -- although the sentinel is irrelevant in this pattern, because now the test raises an exception instead. class Fib2(object): def __init__(self,start=0,next=1,test=lambda x: False): # note revised default for test -- previous default of # 'False' was not callable self.start = start self.next = next self.test = test def next(self): self.start,self.next = self.next, self.start + self.next if self.test(self.start): raise StopIteration return self.start __call__ = next # makes object callable def __iter__(self): return self def testfunc(max): """a factory for test functions""" def t(x): return x > max t.__doc__ = "stop when x > %s" % max return t t1 = testfunc(1000) t2 = testfunc(5000) def looper(iterable): for i in iterable: print i, print # newline when done def tests(): print t1.__doc__ looper(Fib2(test=t1)) # note: no iter() wrapper -- Fib2 is already iterable print t2.__doc__ looper(iter(Fib2(test=t2),-1)) # but we can wrap it without problems print t2.__doc__ looper(iter(Fib2(test=t2))) # with or without a sentinel Having a sentinel where it's not needed is of course a sign of programmer confusion. But one might argue the object itself is "more robust" this way. > > >>> def fibfunc(test): > > data = [1,1] > > while not test(data[0]): > > yield data[0] > > data[0],data[1] = data[1],data[0]+data[1] > > return > >Comment here: instead of using a two-element list (which could just as >well be a tuple!), use two variables. Faster and clearer IMO: > > def f(test): > last, next = 1, 1 > while not test(last): > yield last > last, next = next, last+next Yes, clearer. The list-based approach was left over from a version which makes the initial two-value seed a parameter as in: def iterseq(seed=[0,1],test=lambda x: False): # but even so, it's easier to read with two variables: last,next = seed while not test(last): yield last last, next = next, last+next With this new freedom we can generate the Lucas Numbers, with seed [2,1] instead of [1,1]: http://www.mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/lucasNbs.html def tests(): #... print "Lucas Numbers" looper(iterseq([2,1],t1)) >>> iters.tests() ... Lucas Numbers 2 1 3 4 7 11 18 29 47 76 123 199 322 521 843 A modification lets us iterate until a last/next ratio is reached through convergence -- need to be careful here, as infinite loops often result from equating floating point numbers. def iterseq2(seed=[1,1],test=lambda x,y: False): # variation, where test looks at both last and next last,next = seed while not test(last,next): yield "%s/%s" % (last,next) last, next = next, last+next # probaby overkill to wrap a function here, but I'm wanting to *not* rely on a # global value for phi, nor do I want to keep re-evaluating a square root with # every test -- so I pass it in explicitly and build a function around it. def testratio(terminus): def t(inta,intb): return (intb/inta) == terminus # uses new division # it'd be safer to test for abs(difference) < tolerance return t t3 = testratio(0.5*(1+pow(5,.5))) # phi = (1 + sqrt(5))/2 def tests(): # ... print "Converging..." looper(iterseq2([1,1],t3)) # Fibonacci seed, convergence test Converging... 1/1 1/2 2/3 3/5 5/8 8/13 13/21 21/34 34/55 55/89 89/144 144/233 233/377 377/610 610/987 987/1597 1597/2584 2584/4181 4181/6765 6765/10946 10946/17711 17711/28657 28657/46368 46368/75025 75025/121393 121393/196418 196418/317811 317811/514229 514229/832040 832040/1346269 1346269/2178309 2178309/3524578 3524578/5702887 5702887/9227465 9227465/14930352 14930352/24157817 24157817/39088169 39088169/63245986 63245986/102334155 The Lucas Number next/last ratios likewise converge to phi. >Are your students familiar with functions as first-order objects at >this point? It would be simpler if you could simply pass the limit as >the argument to Fib() rather than having to construct a test function >first. Sure, a test function allows more freedom, but the API design >here doesn't actually make it much easier to do something different in >the test function -- e.g. another useful termination test would be to >produce the first N numbers, but that would require the test function >to be stateful, and the API doesn't promise that test() is only called >once per iteration. Yes, I'm sort of demonstrating two concepts -- iterators, and the fact that functions may be passed as parameters. There's more convolution as a result. Plus the above example points up a weakness in this design: the passed-in function is relying on a hard-wired set of arguments, is in test(last), whereas we might want access to both last and next for our test. Our only access to the local scope, within the generator function, is based on the arguments to test() -- a limit on our freedom. I do find it interesting that objects don't suffer as much from this limitation, as one has access to all the object's instance variables through 'self' -- so it's possible to write a top-level test function knowing that 'self' is the only argument needed -- yet internal to the test function, you may access self's scope at will: class Fib3(object): def __init__(self,start=0,next=1,test=lambda x: False): self.start = start self.next = next self.test = test def next(self): self.start,self.next = self.next, self.start + self.next if self.test(self): # single parameter sufficient to access __dict__ raise StopIteration return self.start __call__ = next def __iter__(self): return self def testratio2(terminus): def t(obj): # obj will be the self of the enclosing object return obj.next/obj.start == terminus # uses new division return t But we're just getting more and more convoluted here (useful learning on my end though) ... Kirby

1 4

constructive criticism sought (Rob Andrews)
by ahimsa 30 Mar '03

30 Mar '03

Hello Rob First, as an erstwhile 'consumer' of Useless Python, thanks for the work you and now your volunteer team have done on that site. It's good fun to surf. Second, by way of offering (hopefully) constructive criticism, kindly accept the following points: 1. PLEASE remove it from yahoo! groups. I would be quite happy to volunteer but was unhappy with going via yahoo to do so. 2. Rather than toss truly useless code (I think my few contributions have probably landed in that bin!!), would it be possible to catalogue it and remove duplicates. I suspect that many snippets of code are those done by newbies (such as myself) who are working through tuts or text books, etc, so is likely to be replicated. 3. With the foregoing in mind however, if it is to be "Useless" Python, then perhaps it could be graded because there is some pretty complex material on the site last time I looked and then there is some pretty basic stuff too. It would be a shame, I think, if the really basic stuff was elided by the complex, not for any other reason than the sense of accomplishment a newbie might get surfing through and reading code that s/he can actually understand and even contribute to without feeling daunted/intimidated by really elaborate/complex code. Let's face it, a certain % of that code is never going to be worth anything, which surely is as good a definition of useless as anything I've ever come across. Third, look forward to seeing the new site once it is done and dusted. Well done Rob - it was a good idea, and I for one am happy that you continued with it. Thanks. Andrew

3 2

Re: An outline I'm using
by Arthur 19 Mar '03

19 Mar '03

Kirby writes - >In the actual presentation, I'll have more focus on some specific uses of >Python (e.g. Python + Povray). Of course I'll have some screen shots >(e.g. from PyGeo) to show what kinds of stuff goes on out there. I must have good political instincts. Hadn't known you were undertaking this project. But am adding a polyhedra exploration tool to PyGeo, mostly with you in mind. Essentially creating the 120 polyhedron vertexes and edge and face mapping based on: http://www.rwgrayprojects.com/Lynn/Coordinates/coord01.html as a PyGeo "library". Had to work on the lighting and the Povray output to make it fully functional. But seem to be mostly there. Having some fun with it. Art

1 0

re: An outline I'm using
by Arthur 19 Mar '03

19 Mar '03

Dethe writes - >Have you seen PythonPoint[1]? It's a pythonic alternative to >PowerPoint, and there's a reStructuredText[2] project to create[3] >PythonPoint slides from a (lightly marked-up) text document. Good suggestion. I'm finding reStructuredText a very practical tool for doing documentation. The light mark-up goes a long way, and the list of output possibilities continues to grow. Kirby might find that preparing his presentation in reStructuredText will allow him, for example, to use it in PythonPoint, and publish it on the web as html, or "do sutff" with it as xml output, all from the same marked up document. Art

1 0

ANN: Stifte und Maeuse f. Python!
by Ingo Linkweiler 18 Mar '03

18 Mar '03

SuM - Von Stiften und Mäusen DESCRIPTION: ------------ German only: About pens and mice, a conversion of the well-known didactical learning software to Python. BESCHREIBUNG: ------------- Eine Umsetzung der bekannten didaktischen Lernsoftware nach Python. Einführung in die Grundlagen der objektorientierten Programmierung. Anhand fertiger Klassen "Stift", "Maus", "Bildschirm" u.a. kann in dieser Lernumgebung der Einstieg in die objektorientierte Softwareentwicklung mit einfacher Computergrafik vermittelt werden. VERSION: -------- 1.0 erste öffentliche Version 1.1 zahlreiche Verbesserungen wurden vorgenommen. Es erfolgten Anpassungen an die aktuelle Klassenbibliothek. Zahlreiche Beispiele und eine komplett erneuerte Dokumentation demonstrieren die Anwendung. URL: ---- http://www.ingo-linkweiler.de/diplom/

4 5

constructive criticism
by reavey 14 Mar '03

14 Mar '03

Replt to Rob Andrews Perhaps an approach which provides commented code would help make this more usefull. There are many examples and I hate to finger point. However , helpdesk.py is pretty typical, it has virtually no comments. The last several weeks of mail on the tutor seem to have a lot of questions related to class and defining variables. Re-v

1 0

constructive criticism sought
by Rob Andrews 13 Mar '03

13 Mar '03

Useless Python has been working on "getting its act together" to become a more beneficial resource for learning Python, and the team of volunteers is at a point in the process where I feel it would be good to solicit some constructive criticism. After it became obvious that the site had far outgrown the ability of one person to maintain the site more-or-less manually, a team of volunteers was recruited, and some development work has begun to bolster the integrity of the site. It's all underway currently, and is at a stage where there is still room to take suggestions to heart. A development version of the site is at http://uselesspython.com/newsite/ (much nicer navigation in store, and faster-loading) and the "old" version of the site is still carrying on at http://uselesspython.com (quite functional, but with plenty of room for improvement). In the new version of the site, it should be much easier to find source code by means of navigating through categories, and some reasonably advanced search capabilities are being developed. We have also noted a need to add some "quality control" and basic means for peer-review. So far, peer review has meant referring contributors to the Python Tutor email list, but we want to start making sure that each contribution is reviewed by a volunteer, and we may add a database-powered discussion board. The verdict is still out on which directions to take with this. So, aside from the fact that the development site has more dead links than actual pages (because it's a development site), how can we make the site a genuinely useful resource for novice/student programmers and educators? -Rob Andrews

1 0

Pferdemarkt.ws informiert! Newsletter 03/2003 http://www.pferdemarkt.ws
by webmaster＠pferdemarkt.ws 06 Mar '03

06 Mar '03

http://www.pferdemarkt.ws Wir sind in 2003 erfolgreich in des neue \"Pferdejahr 2003 gestartet. Für den schnellen Erfolg unseres Marktes möchten wir uns bei Ihnen bedanken. Heute am 06.03.2003 sind wir gut 2 Monate Online! Täglich wächst unsere Datenbank um 30 Neue Angebote. Stellen auch Sie als Privatperson Ihre zu verkaufenden Pferde direkt und vollkommen Kostenlos ins Internet. Zur besseren Sichtbarmachung Ihrer Angebote können SIe bis zu ein Bild zu Ihrer Pferdeanzeige kostenlos einstellen! Wollen Sie direkt auf die erste Seite, dann können wir Ihnen unser Bonussystem empfehlen. klicken Sie hier: http://www.pferdemarkt.ws/bestellung.html Ihr http://Pferdemarkt.ws Team Klicken Sie hier um sich direkt einzuloggen http://www.Pferdemarkt.ws Kostenlos Anbieten, Kostenlos Suchen! Direkt von Privat zu Privat! Haben Sie noch Fragen mailto: webmaster(a)pferdemarkt.ws

1 0

Fw: [Visualpython-users] Towers of Hanoi
by Arthur 04 Mar '03

04 Mar '03

Forward of my post to the VPython list. As I get more familiar with the capabilities of distutils, supplemented as necessary by a full featured Installer like Inno Setup, the idea of a Python "runtime" - at least for a specific "app" like VPython scripts becomes, I think intriguing. The small size of the distribution is particularly impressive considering the fact of the dependencies on Numeric and VPython as well as on the standard Python files and moudles. A simple way to share one's Python based efforts with a very broad base of folks, is - potentially - a Very Good Thing. FWIW, the acutal VPython script that created what I think is a very impressive Tower of Hanoi implementation, is less than 75 lines of code. (Again, not my work) The script is included in the "executable" distribution. But of course it is built on top of VPython and Numeric and Python and C, etc - like Plone, but different. I have a small worry of running afoul of licensing issues by going down this road - only because I don't understand much about the subject, and it seems to be a quagmire even for people who do. I guess I will continue, and if anyone is offended by what I am trying to do, I will hear about it. Art > [Bruce] > > > Cool! And only a megabyte. > > Of the megabyte, probably about 80% is essentially a runtime environment - > which theoretically is a one time download. If one could educate a Setup > script sufficiently to look for the environment, the distribution of even > the most complex VPython constructions could be done as an executable of < > 250k. An eye blink at decent bandwidth. Setup could only go back for the > "runtime" if it doesn't find it on the machine. > > Not terribly different from what is normal for Flash or Java applets. > Probably the best available alternative to a Java based VPython - in some > ways better, I think. > > Of course, the Windows only aspect is a big downside. I won't even try to > approach what would be necessary to make this a true crossplatfrom > capability. > > Art >

1 0

Towers of Hanoi
by Arthur 03 Mar '03

03 Mar '03

Proof of concept: Ruth Chabay's Tower of Hanoi VPython demo as a Windows executable. http://www.dstoys.org/Members/ajsiegel/TowerSetup/file_view The executable created using Python distutils together with py2exe. Uses Inno Setup to create an easy install, unistall of the executable and dependencies. (Wanted to get hands-on with it) Even used the VPython export to Povray facility to create a cute desktop icon for it. Button 1 pressed to pick and move the rings. Art

2 2