I'm sorry that I didn't send a copy of the discussions here.
---------- Forwarded message ----------
From: Thautwarm Zhao <yaoxiansa...@gmail.com>
Date: 2018-04-09 1:24 GMT+08:00
Subject: Re: [Python-ideas] Is there any idea about dictionary destructing?
To: "Eric V. Smith" <e...@trueblade.com>
Thank you, Eric. Your links really help me and I've investigated it
carefully.
After reading them, I found the discussion almost focused on a non-nested
data structure.
The flatten key-value pairs might be easily replaced by something like
x, y, z = [some_dict[k] for k in ('a', 'b', 'c')]
I couldn't agree more but, when it comes to nested,
some_dict = {
'a': {
'b': {
'c': V1},
'e': V2
},
'f': V3
}
I agree that there could be other ways as intuitive as the dict destructing
to
get `V1, V2, V3` instead, however dict destructing refers to the
consistency of Python language behaviours.
When I'm writing these codes:
[a, *b] = [1, 2, 3]
The LHS is actually equals to RHS, and if we implement a way to apply this
on dictionary
{'a': a, 'b': b, '@': c, **other} = {'a': 1, 'b': 2, '@': 3, '*': 4}
It also presents that LHS equals to RHS. Dict destructing/constructing is
totally compatible to Python unpack/pack,
just as what iterable destructing/constructing does. It's neat when we talk
about Python's data structures we can talk about
the consistency, readability and the expression of intuition.
In the real world, the following one could really help when it comes to the
field of data storage.
some_dict = {'a': [1, 2, 3, {"d": 4, "f": 5}]}
{'a': [b, *c, {"d": e, **_}]} = some_dict
The LHS doesn't only show the structure of some variable intuitively(this
makes review easier, too), but also supplies a way to access data in fewer
codes.
In the previous talk people have shown multiple usages of dict destructing
in real world:
- Django Rest Framework validate
- Load config files and use them, specifically Yaml/JSON data
access.
In fact, any other operation on dictionary than simply getting a value from
a key might needs dict destructing, just when the task is complicated
enough.
I do think the usages are general enough now to make us allow similar
syntax to do above tasks.
P.S:
Some other advices in the previous talk like the following:
'a' as x, 'b' as y, 'c' as z = some_dict
'a': x, 'b': y, 'c': z = some_dict
mode, height, width = **prefs
Either of them conflicts against the current syntax, or does mismatch the
consistency of Python language(LHS != RHS).
thautwarm
2018-04-08 5:39 GMT+08:00 Eric V. Smith <e...@trueblade.com>:
> There was a long thread last year on a subject, titled "Dictionary
> destructing and unpacking.":
> https://mail.python.org/pipermail/python-ideas/2017-June/045963.html
>
> You might want to read through it and see what ideas and problems were
> raised then.
>
> In that discussion, there's also a link to an older pattern matching
> thread:
> https://mail.python.org/pipermail/python-ideas/2015-April/032907.html
>
> Eric
>
> On 4/7/2018 1:26 PM, thautwarm wrote:
>
>> We know that Python support the destructing of iterable objects.
>>
>> m_iter= (_for _in range(10))
>> a,*b, c= m_iter
>>
>> That's pretty cool! It's really convenient when there're many corner
>> cases to handle with iterable collections.
>> However destructing in Python could be more convenient if we support
>> dictionary destructing.
>>
>> In my opinion, dictionary destructing is not difficult to implement and
>> makes the syntax more expressive. A typical example is data access on
>> nested data structures(just like JSON), destructing a dictionary makes the
>> logic quite clear:
>>
>> data= {
>> "direct": "some data",
>> "nested": {
>> "lst_data": [1,2,3],
>> "int_data": 1
>> }
>> }
>> {
>> "direct": direct,
>> "nested": {
>> "lst_data": [a, b, c],
>> }
>> }= data
>>
>>
>> Dictionary destructing might not be very well-known but it really helps.
>> The operations on nested key-value collections are very frequent, and the
>> codes for business logic are not readable enough until now. Moreover Python
>> is now popular in data processing which must be enhanced by the entire
>> support of data destructing.
>>
>> Here are some implementations of other languages:
>> Elixir, which is also a popular dynamic language nowadays.
>>
>> |iex> %{} = %{:a => 1, 2 => :b} %{2 => :b, :a => 1} iex> %{:a => a} =
>> %{:a => 1, 2 => :b} %{2 => :b, :a => 1} iex> a 1 iex> %{:c => c} = %{:a =>
>> 1, 2 => :b} ** (MatchError) no match of right hand side value: %{2 => :b,
>> :a => 1}|
>>
>> And in F#, there is something similar to dictionary destructing(actually,
>> this destructs `struct` instead)
>> type MyRecord = { Name: string; ID: int } letIsMatchByName record1 (name:
>> string) = matchrecord1 with| { MyRecord.Name = nameFound; MyRecord.ID = _;
>> } whennameFound = name -> true| _ -> falseletrecordX = { Name = "Parker";
>> ID = 10} letisMatched1 = IsMatchByName recordX "Parker"letisMatched2 =
>> IsMatchByName recordX "Hartono"
>>
>> All of them partially destructs(or matches) a dictionary.
>>
>> thautwarm
>>
>>
>>
>> _______________________________________________
>> Python-ideas mailing list
>> Python-ideas@python.org
>> https://mail.python.org/mailman/listinfo/python-ideas
>> Code of Conduct: http://python.org/psf/codeofconduct/
>>
>>
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
