Mailman 3 March 2014 - Edu-sig

a short essay about programming
by kirby urner Dec. 8, 2022

Dec. 8, 2022

A common "error" (not too serious) that I see in beginning Python (and no doubt other languages, but Python is the one I'm teaching), is having a while condition that appears to put a lid on things, but then the flow all leaks away through break statements, such that the "front door" condition is never revisited. while guess != secret: guess = int(input("Guess?: ") if guess == secret: print("You guessed it!") break else: print("Nope, try again...") What's messed up about the above code is you never really go back to the top in the case where you'd get to leave. Rather, you exit by the back door, through break. So in that case, wouldn't have been simpler and more elegant, even more "correct" (dare I say it) to have gone: while True: # no ifs ands or buts guess = int(input("Guess?: ") if guess == secret: print("You guessed it!") break else: print("Nope, try again...") I see lots of heads nodding, and that could be the end of the matter, but then a next question arises: wouldn't this also be a more correct solution?: while guess != secret: guess = int(input("Guess?: ") if guess == secret: print("You guessed it!") continue # instead of break else: print("Nope, try again...") We're back to having a variable while condition, not a boolean constant, but this time we actually exit by means of it, thanks to continue or... while guess != secret: guess = int(input("Guess?: ") if guess == secret: print("You guessed it!") else: print("Nope, try again...") ... thanks to no continue. This last one is getting a thumbs up, but then I'd pause here and say "continue" can be easier on the eyes. It's unambiguous where it takes you, in contrast to having to scan on down the gauntlet, looking for possibly other open doors. "What happens next" should not require scanning ahead too far. Help us not to get lost. Be a civic-minded coder. I'm thinking of a programming style that advises two things: (a) if you use a while condition that's variable, that's expected to change, then your goal should be to always exit because of that, i.e. that should be your only exit point. Even if some other criterion suggests exiting, you have the option to flip that "lid" at the top, to crack that front door, and bounce the ball out. (b) which is why 'continue' is your friend. You are showing the user where your 'break' statements are, except you don't use "break" statements, as you've given a non-constant condition, and your aim is to make that your ONLY exit point. In short: never use break to exit a while loop unless your condition is while True. Instead, always flip the condition and exit through the font door. However, as soon as I make that rule I can think of good reasons to break it. The other programmers in the room are shaking their heads. Won't we lose information, needed elsewhere in the program, if we "artificially" force a True condition to False. Aren't we, in effect, lying? That concern could be addressed. Keep all the info true, just treat the "lid condition" (it "keeps a lid on it") as a flag. Go ahead and remember the user's guess. allowed = 5 tries = 1 exit = False while not exit: # no other way out guess = int(input("Guess?: ") if guess == secret: print("You guessed it!") exit = True # instead of break continue print("Nope, try again...") tries += 1 if tries == allowed: print("You've maxed out") exit = True continue I think we all understand the main issue: writing reader-friendly code, and rules for doing so. There's something comforting about approaching a while loop and knowing its not a leaky sieve, riddled with back doors, maybe even an exit( ) time bomb. But in the recursion world we want a minimum of two exits usually: when another round is called for versus when we've "hit bottom". Can we have it both ways? Conclusions: Lets not be too hasty with rules of thumb and: Lets keep the reader in mind when writing code. Just because the interpreter knows to compute the flow unambiguously, doesn't mean all ways of writing it are equally reader-friendly. What may seem a gratuitous gesture, an unnecessary flourish, may actually promote reader comprehension of your code, and that should be a goal as much as satisfying the interpreter. Kirby

8 17

Re: [Edu-sig] RurPLE-NG is nice
by Jurgis Pralgauskis April 5, 2014

April 5, 2014

Some updates: - separated Variables Watch and Output panes, to be seen simultaneusly - implemented Breakpoints :) - beta style Todo: - let enter arbitrary watch expressions http://ftp.akl.lt/users/jurgis/python/rurple-NG053.png http://ftp.akl.lt/users/jurgis/python/rurple-ng-dz0-SplitLogVars_and_Breakp… for windows one doesn't need to install python separately, just unzip and run :) http://ftp.akl.lt/users/jurgis/python/RURPLE-NG-0.53%20%5bindependent%20exe… ps.: RurPLE-NG uses py3 unicode_literals, with_statement, division, print_function so code is generally py3 compliant. when wxpy will work well with py3 it shouldn't be too hard to port fully... >> >> just wanted to mention, >> that http://dev.lshift.net/paul/rurple/ >> is a very nice and lightweit PLE. >> >> what I like most (compared to RurPLE) are: >> 1) variables watch list (if it had breakpoints, it would rock :)

2 3

Easy Web Environment to post pupils Python Creations
by Philip Bagge April 1, 2014

April 1, 2014

Dear Colleagues, My Y6 pupils (10-11 year olds) have been creating some simple text based linear adventures using Python. Does anyone know of a way we can play their adventures online? They are not very complicated. You can see the planning here. https://sites.google.com/site/pythoncodecouk/python-adventure Also as a new person to your forum does anyone know of an easy way to search you archives just in case someone has already answered this question. Thanks in advance for any help Phil Bagge -- Primary ICT Advanced Skills Teacher HCC Teacher & IT Manager http://code-it.co.uk

4 5

Parallel computing
by roberto March 31, 2014

March 31, 2014

Hi, I recently finished setting up a Beowulf Cluster using some Linux machines at schools. Some students eagerly helped out. We'd like to start studying some parallel computing on this system. I already studied it on C but never on Python. My students regularly study Python, so I'd like to ask you if you taught some Python Parallel Computing to High School students and where to start from. Thank you very much -- Roberto

3 3

Re: [Edu-sig] reviewing the context manager construct
by Vernon D. Cole March 28, 2014

March 28, 2014

You are working too hard in creating your string literal. The *Python Language Reference Manual* says: > 2.4.2. String literal concatenation Multiple adjacent string literals > (delimited by whitespace), possibly using different quoting conventions, > are allowed, and their meaning is the same as their concatenation. Thus, > "hello" 'world' is equivalent to "helloworld". This feature can be used > to reduce the number of backslashes needed, to split long strings > conveniently across long lines, [...] > Also, the output is hard to really comprehend. So, may I humbly submit... from __future__ import print_function > > digits = > "1.61803398874989484820458683436563811772030917980576286213544862270526046281890" > \ > "244970720720418939113748475408807538689175212663386222353693179318006076672635" > \ > "443338908659593958290563832266131992829026788067520876689250171169620703222104" > \ > "321626954862629631361443814975870122034080588795445474924618569536486444924104" > \ > "432077134494704956584678850987433944221254487706647809158846074998871240076521" > \ > "705751797883416625624940758906970400028121042762177111777805315317141011704666" > \ > "599146697987317613560067087480710131795236894275219484353056783002287856997829" > \ > > "778347845878228911097625003026961561700250464338243776486102838312683303724292" > > import decimal > > def compress_print(d): > s = str(d) > reps = 0 > digit = s[2] > i = 3 > while s[i] == digit: > i += 1 > reps += 1 > return '{} and {} more "{}"s then {}'.format(s[:3], reps, digit, s[i:]) > > with decimal.localcontext() as context: > context.prec = len(digits)-1 > phi = decimal.Decimal(digits) > id1 = phi**2 + phi**-2 # Identity 1 (== 3) > id2 = 8 * phi**2 - phi**6 # Identity 2 (== 3) > print('Phi is {} digits long, {}...{}'.format(len(digits) - 1, > digits[:5], digits[-5:])) > print('The 1st identity is', compress_print(id1)) > print('The 2nd identity is', compress_print(id2)) > print('Equal?', id1 == id2) > print('The difference is=', id2 - id1) > > Phi is 624 digits long, 1.618...24292 The 1st identity is 2.9 and 621 more "9"s then 8 The 2nd identity is 3.0 and 620 more "0"s then 2 Equal? False The difference is= 2.2E-622

2 1

reviewing the context manager construct
by Kirby Urner March 27, 2014

March 27, 2014

""" Just for Fun A quick sketch of a Context Manager construct. A context manager is a type instance with an __enter__ and __exit__ protocol, and designed to work with a suite indented under a "with statement" (cc) Kirby Urner, MIT License O'Reilly School of Technology Sebastopol, CA With thanks to: http://www.greatplay.net/uselessia/articles/e2-1000.html """ import decimal class Haunted_Castle: """ Shows the workflow of a context manager """ def __enter__(self): print("Welcome to my world...") return self def __exit__(self, *stuff): print("Sorry to see you leave. Come back again soon.") return True # handled exception def __repr__(self): return "Context manager object at: {}".format(id(self)) print("Before the context scope...") with Haunted_Castle() as ctx: print("This is the suite within the scope of the context") print("Available from inside:", repr(ctx)) raise Exception # raise a fuss print("After context...") # and now that we have introduced the concept, here is one way # to use it in practice: temporarily boost the precision of # Decimal type objects beyond a default of 28 decimal digits # of precision print("Do a big decimal computation...") print("Default precision is:", decimal.getcontext().prec) with decimal.localcontext() as ctx: ctx.prec = 500 print("Precision in suite:", decimal.getcontext().prec) n = decimal.Decimal("1"+"0"*300) # 100000....0 (300 zeros) result = str((1 + 1/n) ** n) # converges to Euler's e print("Default precision is:", decimal.getcontext().prec) # as in math.e but to more digits (1000) euler = """\ 2. 7182818284 5904523536 0287471352 6624977572 4709369995 9574966967 6277240766 3035354759 4571382178 5251664274 2746639193 2003059921 8174135966 2904357290 0334295260 5956307381 3232862794 3490763233 8298807531 9525101901 1573834187 9307021540 8914993488 4167509244 7614606680 8226480016 8477411853 7423454424 3710753907 7744992069 5517027618 3860626133 1384583000 7520449338 2656029760 6737113200 7093287091 2744374704 7230696977 2093101416 9283681902 5515108657 4637721112 5238978442 5056953696 7707854499 6996794686 4454905987 9316368892 3009879312 7736178215 4249992295 7635148220 8269895193 6680331825 2886939849 6465105820 9392398294 8879332036 2509443117 3012381970 6841614039 7019837679 3206832823 7646480429 5311802328 7825098194 5581530175 6717361332 0698112509 9618188159 3041690351 5988885193 4580727386 6738589422 8792284998 9208680582 5749279610 4841984443 6346324496 8487560233 6248270419 7862320900 2160990235 3043699418 4914631409 3431738143 6405462531 5209618369 0888707016 7683964243 7814059271 4563549061 3031072085 1038375051 0115747704 1718986106 8739696552 1267154688 9570350354\ """ #remove spaces and newlines euler = euler.replace(" ", "") euler = euler.replace("\n", "") # the result of the computation matches the published value to how many digits? c=0 while True: if euler[c] != result[c]: print("Same to {} places".format(c)) break c += 1 #show significant digits #print(euler[:c]) #print(result[:c])

2 1

What's a Callable?
by kirby urner March 27, 2014

March 27, 2014

What's a callable? In making the transition from Algebra to a computer science friendly math class, such as many states have legislatively enabled (Oregon one such state), the distinction between "what's a callable" and "what's not" may feel familiar. Traditional math notation has to disambiguate between b * x, bx, b(x) and (b)(x), i.e. no operator at all between operands is taken to mean "multiplication". Few computer languages try to take it that far, but in reading (b)(x) it still helps to know if b is a "callable" or not, as if it is, then b(x) may be the evaluation strategy to employ. >>> def F(x): return x >>> (F)(3) 3 What I like about "callable" is one can identify a callable as having "a mouth" i.e. the parens form an emoticon-style sideways mouth, and that's the hallmark of any callable, whether they "eat arguments" or just "suck air". call_me(). Students know about emoticons, little sideways faces, so to associate "callable" with "emoticon" is anchoring and reinforcing. Then when you see the typically amateur use of parens: def F(x): return(2 + x) you can say: remember, return-the-keyword is not a callable; it has no mouth. return(2 + x) is not illegal but that's not a picture of return eating, that's a picture of (2 + x) putting on a belt or fencing itself in. 'return' does not eat, nor 'if', nor 'while'. Kirby

1 0

Reeborg news
by Andre Roberge March 21, 2014

March 21, 2014

The long-time subscribers to this list may remember RUR-PLE ( https://code.google.com/p/rur-ple/), a Karel-the-robot clone using Python that I wrote. The robot's name in my version is Reeborg, hence the title of this post. Since the last version was produced in 2009, RUR-PLE had been downloaded more than 11,000 times. Since people that download it do not need to contact me to do so, it is only through serependity that I find out where it is used. I know that it has been used by elementary school children in Austria, by high school children in New Jersey and by university students in the U.S. and Latin America as a tool to introduce Python. Recently, Samsung contacted me and got my permission to produce a book based on RUR-PLE. They distributed free copies of this book yesterday to something like 1000 Korean students. (I will likely post pictures of the book on my blog when I get a copy.) So what you say?.... I am happy to announce that a test-version of "Reeborg's world" is now available online as a tool to learn Python. It is free to use and does not require registration. The first version of Reeborg's world was produced to teach Javascript; it is the default version available from http://reeborg.ca. It includes some 98 lessons and can be found directly at http://reeborg.ca/learn_js.html I'm working on an "improved" version which can be found at http://reeborg.ca/learn_js_dev.html#welcome Following some comments by early adopters, the UI of this version is improved slightly and more changes are planned, including a graphical world builder, new images for the robot, the option to import from file and save to file programs and worlds, etc. The proof-of-concept Python version can be found at http://reeborg.ca/learn_py_test.html It is based on the "improved" version. I do not plan to do more work on it (including adapting the lessons to teach Python instead of Javascript) until I have nailed down the "improved" Javascript version. If you want to quickly try the Python version to see what it can do, I suggest you select (from the drop down menu showing "Alone" by default) the world "Tokens 1" and run the following program: move() take() move() put() move() I welcome any comments & suggestions about Reeborg's world; please feel free to email me directly. This time, I will probably include a page on the site where I will ask teachers that use it to communicate with me to let me know in what context they use it, and keep track of it on a "wall of fame".

2 2

round trip with unicode (the Latin-1 neighborhood)
by kirby urner March 16, 2014

March 16, 2014

Round Trip in UTF-8: Two Byte Encodings Explanation: Latin-1 includes all of 127 7-bit ASCII and begins the 2-byte encodings in UTF-8. Below, Latin-1 character at code point 200 is represented as bytes then broken down into bits. When utf-8 needs two bytes (it might use up to six), the leading byte begins 110 to signify that, and the followup byte begins 10. So the significant payload bits are just 11001000 which Python shows is 200, where we started. http://youtu.be/vLBtrd9Ar28 (see chart @ 10:30) Leading byte begins 0xxxxxxx - this is the only byte 110xxxxx - another byte after this 1110xxxx - two more bytes 11110xxx - three more bytes 111110xx - four more bytes 1111110x - a total of six bytes x means 'room for payload' Console session: Python 3.2.3 (v3.2.3:3d0686d90f55, Apr 10 2012, 11:09:56) [GCC 4.0.1 (Apple Inc. build 5493)] on darwin sys.path.extend(['/Users/kurner/Documents']) >>> import sys >>> sys.getdefaultencoding() 'utf-8' >>> chr(200) 'È' >>> bytes(chr(200), encoding='utf-8') b'\xc3\x88' >>> bin(0xc3) # left byte in bits '0b11000011' >>> bin(0x88) # right byte in bits '0b10001000' >>> 0b11001000 # the encoded number 200

1 0

A Descriptor (demonstrating the concept)
by Kirby Urner March 5, 2014

March 5, 2014

""" Just for Fun A quick sketch of a Descriptor construct. A descriptor is a type instance with a __get __ and __set__ protocol, also __delete__, and designed to satisfy a common need to manage setting and getting with mediating methods. http://docs.python.org/3.4/howto/descriptor.html (cc) Kirby Urner, MIT License O'Reilly School of Technology """ class Guardian: """ Takes a field name and a function for screening out banned values for said field name """ def __init__(self, fn, banned): self.field = fn self.banned = banned def __set__(self, obj, val): # print("Setting {} on {}".format(self.field, obj)) if self.banned(val): raise AttributeError("Can't be {}".format(val)) obj.__dict__[self.field] = val def __get__(self, obj, objtype): objtype.ringding() # calls class method return obj.__dict__[self.field] class Guest: # data descriptors age = Guardian("age", banned = lambda a: a in range(1,21)) # 21 or older fave_color = Guardian("fave_color", banned = lambda c: c in ["Orange", "Black"]) def __init__(self, n, age=0, fc=None): self.name = n # data descriptors always override instance dictionaries. self.age = age self.fave_color = fc @classmethod def ringding(cls): # called by __get__ in data descriptors print("Ring Ding!") def __repr__(self): return "Guest of name {}".format(self.name) t1 = Guest('Helga', 40) t2 = Guest('Vlad', 30) print("Age of t2:", t2.age) try: t1.age = 11 # comes up against banned() except AttributeError: print("No can do: 11") try: t1.fave_color = "Orange" # ditto banned() except AttributeError: print("No can do: Orange") t1.age = 22 t1.fave_color = "Green" # attributes stick to their respective instances if legal print(t1.age) print(t1.fave_color) print(t2.age)

1 0