在Python中解析类似字典的URL参数 [英] Parsing dictionary-like URL parameters in Python

问题描述

我正在使用服务器端过滤服务KendoUI的Grid组件，使用Python。

我面对的问题是AJAX调用它默认生成似乎与Flask的内置URL解析器和Python的 urlparse 模块不兼容。我有麻烦了： a = b& c = d& foo [bar] = baz& foo [baz] = qis& foo [qis] = bar

以下是我要做的结果：

 'a'：'b'，
'c'：'d'，
'foo'：{
'bar'：'baz'， 
'baz'：'qis'，
'qis'：bar'
} 
} 
  

不幸的是，如果传递给一个Flask端点，可以从这里得到 request.args ：

  {
'a'：'b'，
'c'：'d'，
'f oo [bar]'：'baz'
'foo [baz]'：'qis'
'foo [qis]'：'bar'
} 
  

更糟糕的是，实际上，结构可能会有几层深。将 foo 列过滤为值等于'bar'的行的基本调用将会产生以下内容：

$ $ $ $ b $ {
'filter [logic]'：'and'，
'filter [filters] [0] [value]'：'bar'，
'filter [filters] [0] [field]'：'foo'，
'filter [filters] [0] [operator ]'：'eq'
}

我检查了RFC，查询字符串只包含非分层数据。虽然我相信它指的是URI所代表的对象，但在规范中并没有规定这种类型的数据结构。

我开始写一个这个函数需要一个参数字典并返回它们代表的嵌套结构，但是我很快就意识到这是一个细微的问题，而且肯定有人在这之前就遇到了这个麻烦。

是否有人知道要么会解析这些参数的模块，我想要的方式，或者一个优雅的方式来解析他们，我可能忽略了？

  from collections import defaultdict  
 import re 
 params = {
'a'：'b'，
'c'：'d'，
'foo [bar]'：'element1 '，
'foo [baz]'：'element2'，
'foo [qis]'：'element3'，
'foo [borfarglan] [bofgl]'：'element4 ，
'foo [borfarglan] [bafgl]'：'element5'，
} 
 $ b def split（string，brackets_on_first_result = False）：
 matches = re。 split（[\ [\]] +，string）
 matches.remove（''）
返回匹配
 
 def mr_parse（params）：
结果= {} 
输入参数中的键值：
 if'['in key：
 key_list = split（key）
d = results 
 key_list中的partial_key [ ：-1]：
如果partial_key不在d：
d [partial_key] = dict（）
d = d [partial_key] 
d [key_list [-1]] = params [key ] 
 else：
 results [key] = params [key] 
返回结果
 print mr_parse（params）
  

这应该适用于任何嵌套级别。

I'm working on implementing server-side filtering to serve KendoUI's Grid component, using Python.

The problem I'm facing is that the AJAX call that it generates by default seems to be incompatible with both Flask's built-in URL parser and Python's urlparse module.

Here's a contrived sample of the type of query string I'm having trouble with: a=b&c=d&foo[bar]=baz&foo[baz]=qis&foo[qis]=bar

Here's the result I'm going for:

{
    'a': 'b',
    'c': 'd',
    'foo': {
        'bar': 'baz',
        'baz': 'qis',
        'qis': bar'
    }
}

Unfortunately, here's the request.args you get from this, if passed to a Flask endpoint:

{
    'a': 'b',
    'c': 'd',
    'foo[bar]': 'baz'
    'foo[baz]': 'qis'
    'foo[qis]': 'bar'
}

Worse yet, in practice, the structure can be several layers deep. A basic call where you're filtering the column foo to only rows where the value is equal to 'bar' will produce the following:

{
    'filter[logic]': 'and',
    'filter[filters][0][value]': 'bar',
    'filter[filters][0][field]': 'foo',
    'filter[filters][0][operator]': 'eq'
}

I checked the RFC, and it requires that the query string contain only "non-hierarchical" data. While I believe it's referring to the object the URI represents, there is no provision for this type of data structure in the specification that I can find.

I begin to write a function that would take a dictionary of params and return the nested construct they represented, but I soon realized that it was nuanced problem, and that surely someone out there has had this trouble before.

Is anyone aware of either a module that will parse these parameters in the way I'm wanting, or an elegant way to parse them that I've perhaps overlooked?

解决方案

I just wrote a little function to do this:

from collections import defaultdict
import re
params = {
    'a': 'b',
    'c': 'd',
    'foo[bar]': 'element1',
    'foo[baz]': 'element2',
    'foo[qis]': 'element3',
    'foo[borfarglan][bofgl]': 'element4',
    'foo[borfarglan][bafgl]': 'element5',
}

def split(string, brackets_on_first_result = False):
    matches = re.split("[\[\]]+", string)
    matches.remove('')
    return matches

def mr_parse(params):
    results = {}
    for key in params:
        if '[' in key:
            key_list = split(key)
            d = results
            for partial_key in key_list[:-1]:
                if partial_key not in d:
                    d[partial_key] = dict()
                d = d[partial_key]
            d[key_list[-1]] = params[key]
        else:
            results[key] = params[key]
    return results
print mr_parse(params)

This should work to any nest level.

这篇关于在Python中解析类似字典的URL参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！