问题[dictionary](coding)

[我之前发过这个问题，但有很多错误，所以我把它删掉了。如果我浪费了大家的时间，我深表歉意。]

我在配置文件中有一本字典：

foo:
  key1: value1
  key2: value2
  key3: value3
# …

当我启动剧本时，我在命令行添加了以下字符串变量：

--extra-vars "k1=key1 k2=key2"

如果我想在播放过程中访问特定的字典值（假设我已经将配置文件包含在我的“vars_files”中），我可以简单地这样做：

- debug:
    var="foo.{{ k1 }}"
#      => foo.key1: value1

假设字典名称是可更改的，所以我希望它也是一个变量。我可以添加一个额外的命令行变量：

--extra-vars "k1=key1 k2=key2 dict_name=foo"

我尝试再次访问value1，但这次，Ansible 似乎将语法解析为文字字符串，而不是对配置文件中变量的引用。例如：

- set_fact:
    dict_value: "{{ dictname ~ '.' ~ k1 }}"

或者

- set_fact:
    dict_value: "{{ dictname ~ k1 }}"

[对于第二种情况，我在命令行定义中添加了“。”，例如-e "dict_name=foo."]

我现在得到了一个文字结果：

- debug:
    var=dict_value
# => dict_value: foo.key1

=> foo.key1: value1与我将字典名称硬编码为字符串时相反。"foo.{{ k1 }}"如上所述，被识别为请求访问配置文件中的字典变量。当我尝试创建foo变量时，它变成了文字字符串。

总而言之，我想使用由字典名称和键的变量创建的复合词来访问字典值（并且以某种方式需要容纳“。” "{{ dict_name }}" appended to '.' appended to "{{ key_name }}" = "{{ composite_variable_to_lookup_value}}"：。

我有以下数据框

dataDictionary = [('value1', [{'key': 'Fruit', 'value': 'Apple'}, {'key': 'Colour', 'value': 'White'}]), 
                 ('value2', [{'key': 'Fruit', 'value': 'Mango'}, {'key': 'Bird', 'value': 'Eagle'}, {'key': 'Colour', 'value': 'Black'}])] 

df = spark.createDataFrame(data=dataDictionary)
df.printSchema()
df.show(truncate=False)

+------+------------------------------------------------------------------------------------------------+
|_1    |_2                                                                                              |
+------+------------------------------------------------------------------------------------------------+
|value1|[{value -> Apple, key -> Fruit}, {value -> White, key -> Colour}]                               |
|value2|[{value -> Mango, key -> Fruit}, {value -> Eagle, key -> Bird}, {value -> Black, key -> Colour}]|
+------+------------------------------------------------------------------------------------------------+

我只想提取key -> Colour的值。结果应该是，

White
Black

我尝试了使用regexp_extract_all以及使用instr的子字符串的多个选项，结果始终为空值。任何建议都将不胜感激。

result = spark.sql("""select
                    regexp_extract('_2', '''key': 'Colour' + '(\\w+)') as value
                    from table 
                    """)

给定一个如下所示的字典：

`a`b`c!((0;3); (1;4); enlist 2)

I'd like to find an elegant way to get the following list as a result: 

`a (index 0)
`b (index 1)
`c (index 2)
`a (index 3)
`b (index 4)

我可以用一个表达式来完成这个吗？

*map.entry(key).or_default() += 1;
let count = *map.get(&key).unwrap();

理想情况下，我希望这是一个原子操作，但如果需要，我可以锁定。

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=df6778cd1312c31eb230a545c6c2b6ce

我不确定我是否理解了 Postscript 字典的语义。如果在定义字典条目时使用“def”，而不是仅列出键值对，那么两者有什么区别？下面，我在字典 /d 中定义 /a 和 /b。/a 使用“def”定义；/b 使用键值对定义。当使用“===”运算符打印出 /d 时，我们只能看到 /b。如果我们将 /d 加载到字典堆栈上，我们可以访问和打印 /a 和 /b。如果我们在 /d /b 上执行 get，我们将返回 /b 的值。但如果我们在 /d /a 上执行 get，我们将收到未定义的错误。

有人能帮助我理解为什么 /a 没有在字典 /d 上使用“get”定义/可见，为什么在打印 /d 时它没有显示，以及为什么当我们将 /d 加载到字典堆栈上时它是可访问/定义的？

“def”运算符的定义非常简单：

def - 将当前字典（位于字典堆栈顶部的字典）中的键与值关联（请参见第 3.4 节“堆栈”）。如果当前字典中已经存在键，def 只会替换其值；否则，def 会为键创建一个新条目，并将值存储在其中。- p.568 Postscript 语言参考第三版

在这种情况下，我看到定义 /a 时的 currentdict 是 /d。但“get”看不到它。但是，它在字典中，因为当您将字典加载到字典堆栈上时，它就被定义了。

/d <<
        /a 22 def
        /b 33 
    >> def % Define dictionary 'd'

d ===      % Print out contents of d; Prints /b 33 but no /a

d begin    % Push d onto the dictionary stack
a =        % Prints value of d/a '22'
b =        % Prints value of d/b '33'
end        % Pop d off of the dictionary stack

d /b get =  % Prints value of d/b '33'
d /a get =  % Error /undefine. Cannot find /a in d

输出（使用 ghostscript）：

$ gs -q -dALLOWPSTRANSPARENCY -dBATCH -dNOPAUSE -dQUIET -dNOSAFER     -sDEVICE=pdfwrite  -o tmp_test.pdf tmp_test.ps
<< /b 33 >>
22
33
33
Error: /undefined in --get--
Operand stack:
   --dict:1/1(L)--   a
Execution stack:
   %interp_exit   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--   --nostringval--   --nostringval--   false   1   %stopped_push   1990   1   3   %oparray_pop   1989   1   3   %oparray_pop   1977   1   3   %oparray_pop   1833   1   3   %oparray_pop   --nostringval--   %errorexec_pop   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--
Dictionary stack:
   --dict:795/1123(ro)(G)--   --dict:0/20(G)--   --dict:77/200(L)--
Current allocation mode is local
Current file position is 317
GPL Ghostscript 10.01.2: Unrecoverable error, exit code 1
$

在代码中它运行良好，如下所示

divide :: Int -> Int -> Either String Int
divide a 0 = Left "Error with 0"
divide a b = Right (a `div` b)

要更改的代码

Map.adjust (divide 3) "A" $ Map.fromList [("A",3),("B",0)]

预期结果应该是：

Map.adjust (divide 3) "A" $ Map.fromList [("A",3),("B",0)] 
=>  Right $ Map.fromList [("A",1),("B",0)]   

Map.adjust (divide 3) "B" $ Map.fromList [("A",3),("B",0)]
=>  Left "Error with 0"

或者一般来说如何构建如下函数：

Map.adjust:: (a -> m a) -> k -> (Map k a) -> m (Map k a)

非常感谢 ！

我想在 Julia 中编写一个合并两个字典的函数。

function merge(left::Dict, right::Dict)::Dict

语义如下：

• 输入left为right
• left和都right拥有其数据的所有权，这意味着它们将在函数调用后被修改，并且不应对它们包含的数据做出任何保证
• 返回值包含两个字典的数据
• 如果任何键同时存在于两者中left，并且right值left保持不变

以下是关于如何解决此问题的一些初步想法。（这是带有注释的伪代码，而不是可以实际编译的代码。）

function mergeDict(left::Dict, right::Dict)::Dict

    # create a new dictionary from `left`
    return_value = left

    # move data from `right` to `left`, "no-clobber"
    for k, v in pop_next!(right)
    # the function `pop_next!` does not exist, no iterator-like `pop!`

    for k in keys(right)
        v = pop!(right, k)
        # does this work as expected? destructive operation while reading keys?
        # `keys()` returns an *iterator*, not a collection! (?)

        if !haskey(left, k)
            push!(left, k, v) # no `push!` function
            left[k] = v # this works instead
        end
    end
    
    # `left` and `right` are not pointers, but "copy-by-value references"
    # just as in Python, so this doesn't work
    left = nothing
    right = nothing

    # we want to invalidate the data, how to do that?
    # this also won't work because `left` references the same data
    # structure as `return_value`
    clear(left)
    clear(right)
end

您可以看到，我尝试编写手动实现。我确信 Julia 会有一些有用的函数作为标准库的一部分来实现这一点，但是由于我是 Julia 新手，我不知道这些函数是什么。

我找到了函数merge、和mergewith，然而这些函数似乎都不具备上面描述的语义。merge!mergewith!

我有一个解析输入字符串的函数：

fn parse_input(s: &str) -> ((usize, usize), BTreeMap<(usize, usize), Tile>){
 let mut start: (usize, usize) = (0,0);
 let grid = s.split("\n").enumerate().flat_map(|(r,l)| {
     l.chars().enumerate().map(move |(col, c)| {
         let t = classify_tile(c);
         match t {
             Tile::Start => {
                  *start = (r, col);
                  ((r,col), t)
                 },
             _ => ((r,col), t) 
         }
     })
 }).collect::<BTreeMap<(usize, usize), Tile>>();
 (start, grid)
}

我基本上想捕获起始图块的 r 和 col 值（这是唯一的，仅出现一次）。但目前，如果我尝试修改迭代器内的元组，我假设由于借用和范围原因，该值不会在迭代器外部修改。不过，迭代器完成很重要。

另一种解决方案是随后在 btreemap 中搜索起始图块，但我希望有一个更有效的解决方案。

我应该将其作为嵌套 for 循环吗？这里的迭代实际上是否更有效？

编辑：classify_tile 函数返回枚举类型。开始，土壤或管道。*start = (r,col) 部分不起作用。这是我试图解决这个问题的尝试。其他一切都可以。

我想在映射例程中使用数组的索引。例如，这个 Raku 代码：

raku -e 'my @a = "First", "Second", "Third", "First"; say @a.map({ "Index of $_ is: ;" })'

印刷：

(Index of First is: ; Index of Second is: ; Index of Third is: ; Index of First is: ;)

是否可以获取数组的索引，例如：

(Index of First is: 0; Index of Second is: 1; Index of Third is: 2; Index of First is: 3;)

谢谢！

我们有多级数组，因此我们使用多个映射函数的转换。在这种情况下如何为字段 ID 分配增量值。

输入：

[
  {
    "productNo": "00011111",
    "items": [
      {
        "color": "000000000006000060",
      },
      {
        "color": "000000000006000061",
      }
    ]
  },      
  {
    "productNo": "00022222",
    "items": [
      {
        "color": "000000000006000060"
      },
      {
        "color": "000000000006000061"
      }
    ]
  }
]

我为此尝试过的 Dataweave 代码：

%dw 2.0
output application/json
---
flatten(payload map (item, index) -> item.items map (subItem, subIndex) -> {
    "ID": subIndex,
    "PNR": item.productNo,
    "Color": subItem.color
})

预期输出：

[
  {
    "ID": 1,
    "PNR": 00011111,
    "Color": "000000000006000060"
  },
  {
    "ID": 2,
    "PNR": 00011111,
    "Color": "000000000006000061"
  },
  {
    "ID": 3,
    "PNR": 00022222,
    "Color": "000000000006000060"
  },
  { 
    "ID": 4,
    "PNR": 00022222,
    "Color": "000000000006000061"
  }
]

根据 dataweave，上面的 subIndex 将在下一次迭代中重置为 0，因此请让我知道我们可以使用什么来获取增量值。