yes, this can already be done, and yes, mapping unpacking is little used (I
never think to use it). But in this case, it's a no-op, not sure the point.
I get the same thing with just the ternary expression:
In [11]: def create(val1):
...: data = {"val1": "me here"} if val1 else {}
...: return data
...:
In [12]: create(True)
Out[12]: {'val1': 'me here'}
In [13]: create(False)
Out[13]: {}
-CHB
On Sat, Apr 27, 2019 at 8:25 AM Joao S. O. Bueno <jsbu...@python.org.br>
wrote:
> Calling upon ol' Guidos Time Machinne:
>
>
> In [31]: def create(val1):
> ...: data = {
> ...: **({"val1": "me here"} if val1 else {})
> ...: }
> ...: return data
> ...:
>
>
> In [32]: create(False)
>
> Out[32]: {}
>
> In [33]: create(True)
>
> Out[33]: {'val1': 'me here'}
>
> Now, please, just move to the next request to the language.
>
> I think the in-place star exapanding, along with the inline if like above
> can make out
> for all of your use-cases. If it can't, then expect xpression assignment-s
> (the `a:=1` from PEP 572,
> comming in Python 3.8) to cover for the rest - as you can define variables
> inside the `if` expressions
> like the above which could be re-used in other `if`s (or even in
> key-names), further down the dictionary)
>
>
>
> So, seriously - On one hand, Python's syntaxalready allow what you are
> requesting.
> On the other hand, it makes use of a syntax that is already little used
> (in place star-expansion for mappings),
> to a point that in this thread, up to here, no one made use of it.
> Threfore, IMHO, it demonstrates that adding arbitrary syntaxes and
> language features ultimatelly fills the language
> with clutter very few people ends up knowing how to use - - we should now
> work on what
> is already possible instead of making the language still more difficult to
> learn .
>
> (respasting the code so you can further experiment):
>
> def create(val1):
> data = {
> **({"val1": "me here"} if val1 else {})
> }
> return data
>
>
>
>
>
> On Fri, 26 Apr 2019 at 21:22, Christopher Barker <python...@gmail.com>
> wrote:
>
>> Others have responded, but a note:
>>
>> > What I want to do is:
>>
>> ```
>> def my_func(val_1, val_2):
>> return {
>> "field_1": val_1 if val_1,
>> "next_depth": {
>> "field_2": val_2 if val_2
>> }
>> }
>> ```
>>
>> I am finding this very confusing as to how to generalize this:
>>
>> How do we know that val_1 belongs to the "top-level" field_1, and val_2
>> is in the nested dict with field_2?
>>
>> Or:
>> ```
>> def my_func(val_1, val_2):
>> return {
>> if val_1 : "field_1": val_1,
>> "next_depth": {
>> if val_2: "field_2": val_2
>> }
>> }
>>
>> but this makes it seem like that distinction is hard-coded -- so is the
>> nested dict is relevant?
>>
>> > The more core syntax, which should be valid throughout the language,
>> would be to have statements like `x = y if cond`
>>
>> we have the
>>
>> x = y if cond else
>>
>> expression already -- and an assignment HAS to be assigned to something,
>> so it seems what you want is:
>>
>> x = y if cond else None
>>
>> Maybe the "else None" feels like too much typing, but I prefer the
>> explicitness myself. (and look in the history of this thread for "null
>> coalescing" discussion, that _may_ be relevant.
>>
>> The first of these intuitively reorganizes to `if cond: x = y`
>>
>> then what do we get for x `if not cond`? it ends up undefined? or set to
>> whatever value it used to have?
>>
>> Frankly, I think that's a mistake -- you're going to end up with having
>> to trap a NameError or do a a hasattr() check later on anyway. It's
>> generally considered good practice to set a name to None if it isn't
>> defined, rather than not defining it.
>>
>> > and `x[y if cond]` ... But the second is not as clear, with a likely
>> equivalent of `if cond: x[y] else raise Exception`.
>>
>> assuming x is a dict, then you could do:
>>
>> d[y if cond else []] = value
>>
>> It's a hack, but as lists aren't hashable, you get an TypeError, so maybe
>> that would work for you?
>>
>> example:
>>
>> In [16]: key = "Fred"
>> In [17]: value = "Barnes"
>> In [18]: d = {}
>>
>> In [19]: # If the key is Truthy:
>> In [20]: d[key if key else []] = value
>>
>> In [21]: d
>> Out[21]: {'Fred': 'Barnes'}
>>
>> In [22]: # if the key is Falsey:
>> In [23]: key = None
>>
>> In [24]: d[key if key else []] = value
>>
>> ---------------------------------------------------------------------------
>> TypeError Traceback (most recent call
>> last)
>> <ipython-input-24-170a67b9505a> in <module>()
>> ----> 1 d[key if key else []] = value
>>
>> TypeError: unhashable type: 'list'
>>
>> -CHB
>>
>>
>>
>>
>> --
>> Christopher Barker, PhD
>>
>> Python Language Consulting
>> - Teaching
>> - Scientific Software Development
>> - Desktop GUI and Web Development
>> - wxPython, numpy, scipy, Cython
>> _______________________________________________
>> Python-ideas mailing list
>> Python-ideas@python.org
>> https://mail.python.org/mailman/listinfo/python-ideas
>> Code of Conduct: http://python.org/psf/codeofconduct/
>>
>
--
Christopher Barker, PhD
Python Language Consulting
- Teaching
- Scientific Software Development
- Desktop GUI and Web Development
- wxPython, numpy, scipy, Cython
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
