问题[dictionary](coding)

我有以下数据框

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，因此请让我知道我们可以使用什么来获取增量值。

我正在尝试编写一个函数来查找一手牌的价值。作为其中的一部分，我需要检查这手牌是否是同花。我这样做的代码是：

use itertools::Itertools;     // allows use of .all_equal()

fn find_hand_value(player_hand: Hand) {
    let is_flush: &bool = &player_hand.cards.map(|card| card.suit).iter().all_equal();
    // ... further checks
    println!("{:?}", player_hand)    // print takes ownership to represent further use of the hand
    // return hand value
}

但是，如果您尝试运行此代码，您将遇到一个错误，显示player_hand.cards由于方法调用而已部分移动map。考虑到地图是在不可变的借用上调用的，player_hands我不明白这是怎么可能的，因为它似乎与 Rust 的借用规则直接矛盾。

有人可以解释一下这里发生了什么以及如何/为什么可能吗？谢谢，

对于上下文：

#[derive(Debug)]
struct Hand {
    cards: [Card; 5],
}

#[derive(Debug)]
struct Card {
    suit: Suit,
    value: Value,
}

#[derive(Debug, PartialEq, Eq)]
enum Suit {
    Hearts,
    Diamonds,
    Spades,
    Clubs,
}

#[derive(Debug, Ord, PartialOrd, Eq, PartialEq)]
enum Value {
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
}