[Python-3000] Droping find/rfind?
exarkun at divmod.com
Fri Aug 25 20:49:02 CEST 2006
On Fri, 25 Aug 2006 10:53:15 -0700, Guido van Rossum <guido at python.org> wrote:
>On 8/25/06, Jean-Paul Calderone <exarkun at divmod.com> wrote:
>> >For the record, I think this is a major case of YAGNI. You appear way
>> >to obsessed with performance of some microscopic aspect of the
>> >language. Please stop firing random proposals until you actually have
>> >working code and proof that it matters. Speeding up microbenchmarks is
>>Twisted's core loop uses string views to avoid unnecessary copying. This
>>has proven to be a real-world speedup. This isn't a synthetic benchmark
>>or a micro-optimization.
>OK, that's the kind of data I was hoping for; if this was mentioned
>before I apologize. Did they implement this in C or in Python? Can you
>point us to the docs for their API?
One instance of this is an implementation detail which doesn't impact any application-level APIs:
Another instance of this is implemented in C++:
but doesn't interact a lot with Python code. The C++ API uses char* with a length (a natural way to implement string views in C/C++). The Python API just uses strings, because Twisted has always used str here, and passing in a buffer would break everything expecting something with str methods.
>>I don't understand the resistance. Is it really so earth-shatteringly
>>surprising that not copying memory unnecessarily is faster than copying
>It depends on how much bookkeeping is needed to properly free the
>underlying buffer when it is no longer referenced, and whether the
>application repeatedly takes short long-lived slices of long otherwise
>short-lived buffers. Unless you have a heuristic for deciding to copy
>at some point, you may waste a lot of space.
Certainly. The first link above includes an example of such a heuristic.
>>If the goal is to avoid speeding up Python programs because views are too
>>complex or unpythonic or whatever, fine. But there isn't really any
>>question as to whether or not this is a real optimization.
>There are many ways to implement views. It has often been proposed to
>make views an automatic feature of the basic string object. There the
>optimization in one case has to be weighed against the pessimization
>in another case (like the bookkeeping overhead everywhere and the
>worst-case scenario I mentioned above).
I'm happy to see things progress one step at a time. Having them _at
all_ (buffer) was a good place to start. A view which has string methods
is a nice incremental improvement. Maybe somewhere down the line there
can be a single type which magically knows how to behave optimally for all
programs, but I'm not asking for that yet. ;)
>If views have to be explicitly
>requested that may not be a problem because the app author will
>(hopefully) understand the issues. But even if it was just a standard
>library module, I would worry that many inexperienced programmers
>would complicate their code by using the string views module without
>real benefits. Sort of the way some folks have knee-jerk habits to
> def foo(x, None=None):
>if they use None anywhere in the body of the function. This should be
>done only as a last resort when real-life measurements have shown that
>foo() is a performance show-stopper.
I don't think we see people overusing buffer() in ways which damage
readability now, and buffer is even a builtin. Tossing something off
into a module somewhere shouldn't really be a problem. To most people
who don't actually know what they're doing, the idea to optimize code
by reducing memory copying usually just doesn't come up.
More information about the Python-3000