Mailman 3 November 2007 - Python-ideas

cmp and sorting non-symmetric types
by Adam Olsen Nov. 14, 2007

Nov. 14, 2007

(ugh, this was supposed to go to python-ideas, not python-list. No wonder I got no responses to this email!) (I've had trouble getting response for collaboration on a PEP. Perhaps I'm the only interested party?) Although py3k raises an exception for completely unsortable types, it continues to silently do the wrong thing for non-symmetric types that overload comparison operator with special meanings. >>> a = set([1]) >>> b = set([2, 5]) >>> c = set([1, 2]) >>> sorted([a, c, b]) [{1}, {1, 2}, {2, 5}] >>> sorted([a, b, c]) [{1}, {2, 5}, {1, 2}] To solve this I propose a revived cmp (as per the previous thread[1]), which is the preferred path for orderings. The rich comparison operators will be simple wrappers for cmp() (ensuring an exception is raised if they're not merely comparing for equality.) Thus, set would need 7 methods defined (6 rich comparisons plus __cmp__, although it could skip __eq__ and __ne__), whereas nearly all other types (int, list, etc) need only __cmp__. Code which uses <= to compare sets would be assumed to want subset operations. Generic containers should use cmp() exclusively. [1] http://mail.python.org/pipermail/python-3000/2007-October/011072.html -- Adam Olsen, aka Rhamphoryncus

4 8

python3: subtle change to new input()
by Mark Summerfield Nov. 14, 2007

Nov. 14, 2007

Hi, In Python 3, input() returns an empty string in two situations: blank lines and EOF. Here's a little program that uses it: print("enter numbers one per line; blank line to quit") count = 0 total = 0 while True: line = input() if not line: # EOF or blank line break n = int(line) total += n count += 1 print("count =", count, "total =", total) If input() returned None on EOF you could write this: print("enter numbers one per line; EOF (^D or ^Z) to quit") count = 0 total = 0 while True: line = input() if line is None: # EOF break elif not line: # Blank line continue n = int(line) total += n count += 1 print("count =", count, "total =", total) The advantage of this second approach is that you can accept blank lines, which is often more convenient if using < on the command line to read stdin. Furthermore, if you replaced input() with the None returning one in the first example, it will work just the same as before. So I think that returning None on EOF gives a subtle improvement without breaking much. -- Mark Summerfield, Qtrac Ltd., www.qtrac.eu

7 10

Raw strings return compiled regexps
by Neil Toronto Nov. 14, 2007

Nov. 14, 2007

It seems like every time somebody has issues with raw strings, the canonical answer is "don't use them for that, use the for regular expressions". What if they just returned regular expression objects? As in r'<some long exp>'.match('<my string>') That would guarantee they didn't get abused for anything else. It would break a lot of code, too. :) Quick question, if someone has the time: is there any way to test equivalence of regular expressions? If we had intersection and an emptiness test (both of which are easy in the theoretical construct, but harder to do in practice), it'd be easy. I may be able to fake intersection using lookahead and such, but there's no emptiness test that I know of. Thanks in advance, Neil

3 2

Make obj[] valid syntax?
by Thomas Heller Nov. 14, 2007

Nov. 14, 2007

I'm not sure if this is a good idea or not, but - hey - this is python.ideas ;-) The following statements currently raise a SyntaxError: obj[] = something x = obj[] I propose to make these statements valid syntax. 'obj[]' should behave like 'obj[()]' does: Call __getitem__ or __setitem__ with an empty tuple. My use case is in a COM library (comtypes). Some COM properties require one or more arguments; this is not a problem since one could write obj.prop[1, 2, 3] Sometimes, however, arguments are optional. Unfortunately one has to write obj.prop[()] to pass an empty tuple to __getitem__ or __setitem__, which looks strange imo. Comments? Thomas

4 10

Pause (sort of a 'deep yield'?)
by Adam Atlas Nov. 12, 2007

Nov. 12, 2007

Generator-based coroutines are great, but I've thought of some interesting cases where it would help to be able to sort of yield to an outer scope (beyond the parent scope) while being able to resume. I'm thinking this would make the most sense as a kind of exception, with an added "resume" method which would resume execution at the point at which the exception was raised. (They'd also have a throw() method for continuing execution but raising an exception, and a close() method, as with generators in Python >= 2.5.) Here's an example to demonstrate what I'm talking about: def a(): print 'blah' p = pause 7 # like using `yield` as an expression # but it raises "PauseException" (or whatever) print p return (p, 123) def b(): return a() try: print b() except PauseException, e: print e.value e.reusme(3) #prints: # blah # 7 # 3 # (3, 123) Normally you'd subclass PauseException so you can catch specific known instances of pausing in your application. If no outer scope can handle a pause, then the program should exit as with any other exception. For more practical use cases, I'm mainly thinking about asynchronous programming, things like Twisted; I see a lot of interesting possibilities there. But here's a simpler example... Suppose we have WSGI 2.0, and, as expected, it is rid of start_response() and the resulting write() callable. And suppose we want to write an adaptor to allow WSGI 1.0 applications to be used as WSGI 2.0 applications. We want to do this by creating a write() which pauses and sends the value to an outer wrapper which interleaves any write()en output with the WSGI 1.0 app's returned app_iter into a single generator. It would go something like this: class StartRespPause (PauseException): pass class WritePause (PauseException): pass class wsgi_adaptor (object): def __init__(self, app): self.app = app def _write(self, data): pause WritePause(data) # Interrupts this frame and returns control to the first outer frame # that catches WritePause. # If the `pause` statement/expression is given a PauseException # instance, it raises that; if it is given a PauseException subclass, # it raises that with None; if it gets another value `v`, it raises # PauseException(v). def _start_response(self, status, response_headers, exc_info=None): # [...irrelevant exc_info handling stuff here...] pause (status, response_headers) return self._write def _app_iter(self, environ): try: for v in self.app(environ, self._start_response): yield v except WritePause, e: yield e.value e.resume() # This part of the syntax is perhaps a little troublesome -- the # body of a `try` block might cause multiple pauses, so an `except` # block catching a PauseException subclass has the possibility of # running multiple times. This is the correct behaviour, but it is # somewhat counterintuitive given the huge precedent for at most # one `except` block to execute, once, for a given `try` block. # Perhaps there could be some syntax other than `except`, but of # course we'd rather keep the number of reserved words down. def __call__(self, environ): # [...whatever other bridging is needed...] try: app_iter = self.app_iter(environ) except StartRespPause, e: status, response_headers = e.value e.resume() return (status, response_headers, app_iter) Thinking about environments like Twisted, it seems to me that this could make Deferreds/callbacks [almost?] entirely unnecessary. PEP 342 (Coroutines via Enhanced Generators) speaks of using "a simple co- routine scheduler or 'trampoline function' [which] would let coroutines 'call' each other without blocking -- a tremendous boon for asynchronous applications", but I think pauses would simplify this even further; it would allow these matters to be mostly invisible outside the innermost potentially blocking functions. Basically, it "would let coroutines 'call' each other without blocking", but now without the quotes around the word 'call'. :) The PEP gives the simple example of "data = (yield nonblocking_read(my_socket, nbytes))", but with pauses, we could forget about yields -- we'd be able to program almost exactly as with traditional blocking operations. "data = read(my_socket, nbytes)". Only potentially blocking functions would have to be concerned with pausing; read() would pause to an outer scheduler/trampoline/Twisted- type reactor, which, when data was available, would resume the paused read() function (giving it the data similarly to generator.send()), which would then return the value to the calling function exactly as a synchronous function would.

2 1

Enable tab completion for interactive sessions
by Christian Heimes Nov. 12, 2007

Nov. 12, 2007

Hello fellow Pythonistas! Python has a very useful feature a lot of people don't know about. It's tab completion for the interactive shell. http://docs.python.org/lib/module-rlcompleter.html Tab completion is very useful for introspection and quick tests in an interactive shell. rlcompleter isn't enable by default - and it shouldn't. But I like to add a cmd line option and an env var to load and enable the rlcompleter in an interactive session. The right place to enable the feature is in Modules/main.c:460 if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) && isatty(fileno(stdin))) { code run when -i is given or neither command nor filename nor module is set and stdin is an interactive terminal. } At the moment the code block loads just the readline module. I also like to load the rlcompleter module and invoke readline.parse_and_bind("tab: complete") there. Options: (1) always enable tab completion for interactive shells w/o a command, module and filename. (2) only enable rlcompleter when the -i flag or PYTHONINTERACTIVE env var is set. (3) add a new command flag and env var to enable the completer when (1) or (2) is true Christian

2 1

Re: [Python-ideas] str(<int>, base=<int>) as complement to int(<str>, base=<int>)
by Ron Adam Nov. 1, 2007

Nov. 1, 2007

Christian Heimes wrote: >> Or should it be a function in the math or string module? > > Why do you want to hide the function somewhere instead of putting the > functionality in an obvious place. In Python 3000 the str() builtin has > two optional arguments: > > str(s, [encoding, [errors]]) > > Isn't base 2 or base 16 just another kind of encoding? IMHO the > intergers 2, 8 or 16 can be treated as a form of encoding just as > "ascii" or "latin-1". > > Christian See Guido's reply about it not being a str() constructor. Sense int types don't have non-special methods it can't be an int method. I don't think it's needed often enough to justify making it a global builtin function. That leaves putting it in either the string or math module. I don't think of it as hiding. I think of it a grouping which makes it easier to find rather than harder to find. Cheers, Ron

2 1

str(<int>, base=<int>) as complement to int(<str>, base=<int>)
by Christian Heimes Nov. 1, 2007

Nov. 1, 2007

Hello! Python's int type has an optional argument base which allows people to specify a base for the conversion of a string to an integer. >>> int('101', 2) 5 >>> int('a', 16) 10 I've sometimes missed a way to reverse the process. How would you like an optional second argument to str() that takes an int from 2 to 36? >>> str(5, 2) '101' >>> str(10, 16) 'a' I know it's not a killer feature but it feels right to have a complement. How do you like the idea? Christian

6 6