Talin wrote:
> Ian Bicking <ianb <at> colorstudy.com> writes:
>>>I want to go back for a moment to the original question. Whenever someone
>>>asks
>>>me "how should we solve this problem?" the first thing I always ask is "do we
>>>really need to?" Once we've answered that, we can then go on to the issue of
>>>coming up with a solution.
>>
>>Without this all dictionaries must be copied. I think maybe Guido
>>suggested something involving a shortcut that would not covert the
>>dictionary, but that shortcut isn't available to Python so the behavior
>>could be different for custom formatters implemented in Python. Also,
>>only dictionaries are allowed after **; that could be changed (maybe
>>that's part of the signature changes?), but that doesn't change the fact
>>that only a dictionary can be passed into a function with **.
>
>
> I think you are missing some alternatives. You see, the question I was asking
> wasn't "How important is it that we be able to efficiently pass whole
> dictionaries to the format function?" The question was "How important is it to
> be able to pass whole dictionaries at all?" Remember, that anything that you
> can do with **args you can also do by explicitly passing the individual args
> you want.
If you allow for {0.name}, yes. Otherwise, no, not at all.
> Another alternative is just to fix the efficiency problems with **args. The
> reason that **args is so expensive is because of the need to funnel all calls
> through the existing C API, which requires that all function calls have the
> signature of ( PyTuple *args, PyDict *kwargs ). If you were somehow able to
> bypass or extend the C API, you could take the **args from the function call,
> and directly hook it up to the **args in the formal parameter list, without
> any flattening.
That seems like a tricky optimization that disappear in ways that are
hard for people to understand. So:
def x(**kw):
return kw
You can pass through the dictionary directly, right? What about:
def x(**kw):
v = kw.pop('template')
return v.format(**kw)
Well, you need a copy there, unless you want the caller to have their
dictionary modified. Or what about:
def x(template, **kw):
return template.format(**kw)
Now, if you call it as x('...', **d) then it can be optimized. But if
you call it as x('...', var1='foo', **d) it can't? What about x(**d)?
To me any optimization just feels like a corner case.
> Assumming that neither of those options are available, I would probably then
> do one of the following:
>
> 1) Create a different method name for the dict case:
>
> "{name}".vformat( mydict )
That would be fine.
> 2) Have some sort of reserved, keyword-only argument for dicts:
>
> "{name}".format( indirect_args=mydict )
That seems not as nice, but maybe okay.
> 3) Bring back field expressions:
>
> "{0.name}".format( mydict )
That would be fine sometimes.
> (Perhaps the '.' operator can mean both '.' and '[]' depending on the type of
> the object.)
As an option that could be nice regardless; I'd be a little nervous
about enabling that everywhere. It's a lot less powerful (and less of a
security issue) than full evaluation, but still leans a bit in that
direction. But without auto-calling it's not actually that bad.
--
Ian Bicking / [EMAIL PROTECTED] / http://blog.ianbicking.org
_______________________________________________
Python-3000 mailing list
Python-3000@python.org
http://mail.python.org/mailman/listinfo/python-3000
Unsubscribe:
http://mail.python.org/mailman/options/python-3000/archive%40mail-archive.com
