Answer 1

您只需要确保在创建/打开输出文件时指定相关编码。

import json

ls_dict = [
    { 'a': 'میلاد'},
    { 'b': 'علی'},
    { 'c': 'رضا'}
]

with open('j.json', 'w', encoding='utf-8') as j:
    j.write(json.dumps(ls_dict))

随后...

with open('j.json', encoding='utf-8') as j:
    j = json.load(j)
    print(j)

输出：

[{'a': 'میلاد'}, {'b': 'علی'}, {'c': 'رضا'}]

Answer 2

我发现。

这是因为Maxfdlimit。

谢谢

Answer 3

在以下方法中， UserId和rolename存储在角色表中

，我们检查表角色中给定角色的名称是否适用于所需人员，它将发送true：

private bool UserCheckInRole(int userId , string roleName)
{
   if(RoleTable.Where(role => role.roleName == roleName , role.UserId ==   
       userId).Any()) return true;
  return false;
}

[HttpGet]
public IActionResult DomSomething(string roleName = "")
{
    if(UserCheckInRole(userId , roleName){
        //true
    }
    // How can I know that user has a role here?
    return Ok();
}

Answer 4

事件驱动的功能可能由于功能代码本身丢弃的错误而无法成功完成。可能发生的一些原因如下：

• 该函数包含一个错误，并且运行时会引发异常。
• 该函数无法达到服务端点，或者在
  试图到达端点。
• 该功能有意抛出异常（例如，当
  参数失败验证）。
• 当用node.js编写功能时，返回拒绝的承诺或通过
  呼叫的非零值。

在上述任何情况下，默认情况下该函数停止执行，并且事件被丢弃。如果要在发生错误时重试函数，则可以通过属性。这会导致该事件重复进行多达多天，直到该功能成功完成为止。

在此问题中，服务端点'api-football-v1.p.rapidapi.com/v3'本身花了很多时间来加载（不可到达），这就是问题所在。将API端点更改为 v3.football.api-sports.io ，然后调用Firebase功能中的外部API为我们的用户解决了问题@TATE_XY

Answer 5

这看起来像剃须刀页面，在这种情况下，评论是错误的：简单地调用返回将将页面发送到浏览器。

相反，您应该返回 iActionResult ，如下：

public IActionResult OnGet()
{
    string id = Request.Query["id"];
    if (!int.TryParse(id, out int value) || value == 0)
    {
        return new RedirectResult("/Clients/Index");        
    }
    try                                         
    {
        using (SqlConnection connection = new(connectionString))
        {
            connection.Open();
            string sql = "SELECT * FROM clients WHERE id = @id";

            using (SqlCommand command = new(sql, connection))

     //etc........ 
    return Page();
}

现在您可以重定向并结束响应或返回页面。

Answer 6

您可以简单地使用：

 WHERE amount > 0 

Answer 7

正如@brujobenavides在评论中所建议的那样，您可以链接 。如果其中一个链接过程终止，则ERLANG VM将自动终止所有其他链接过程。参见参考手册和“从“学习一些erlang for for for Great Good” 以获取更多详细信息。

在您的示例中，更改 spawner/2 使用 spawn_link/3 而不是 spawn/3 ：

spawner(N, Nring) ->
    Pid = spawn_link(r, processes, [Nring]),
    spawner(N - 1, Pid).

此方式 loop/loop/1 不需要再传播 {停止，PID} ：

loop(Nring) ->
    receive
        { stop, From } ->
            io:format("~w received stop from ~w\n", [self(), From]),
            %% All linked processes will be terminated
            %% once we break out the loop/1
            ok;

请注意，在您的示例中，中央进程产卵其他过程也是戒指的一部分。这意味着a）每当另一个环中的一个过程中的一个和b）当中央进程死亡时，它也将被终止。

您可以通过不链接 self（）来避免这种情况：

spawner(N, Nring) ->
    if Nring == self() ->
        Pid = spawn(r, processes, [Nring]);
    true ->
        Pid = spawn_link(r, processes, [Nring])
    end,
    spawner(N - 1, Pid).

Answer 8

使用基础r

mydata["last_date"] <- apply(mydata[,-1],1,max, na.rm=T)

  ID      Date1 Date2      Date3      Date4  last_date
1  1       <NA>    NA 2022-02-08       <NA> 2022-02-08
2  2       <NA>    NA       <NA>       <NA>       <NA>
3  3 2022-06-10    NA       <NA> 2022-06-24 2022-06-24
4  4       <NA>    NA       <NA>       <NA>       <NA>
5  5       <NA>    NA       <NA> 2022-05-13 2022-05-13

Answer 9

如果这种格式可以适合您，则代码为PowerQuery。否则请说明为什么需要Code3，以及一行使用code3而不是示例中的Code2

let  Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content],
#"Changed Type" = Table.TransformColumnTypes(Source,{{"ID", Int64.Type}, {"Name", type text}, {"Proportion", Int64.Type}, {"%", type number}}),
#"Unpivoted Other Columns" = Table.UnpivotOtherColumns(#"Changed Type", {"ID", "Name"}, "Attribute", "Value"),
#"Grouped Rows" = Table.Group(#"Unpivoted Other Columns", {"ID"}, {{"data", each 
    Table.AddColumn(
        Table.TransformColumns(
            Table.AddIndexColumn(_, "Index", 2, 1, Int64.Type)
        ,{{"Index", each Number.IntegerDivide(_, 2), Int64.Type}})
    , "Header", each if [Attribute]="Proportion" then "Code " &Text.From([Index]) else "Code " &Text.From([Index]) & "%"
    ), type table}}),
#"Expanded data" = Table.ExpandTableColumn(#"Grouped Rows", "data", {"Name", "Value",  "Header"}, {"Name", "Value", "Header"}),
#"Pivoted Column" = Table.Pivot(#"Expanded data", List.Distinct(#"Expanded data"[Header]), "Header", "Value")
in  #"Pivoted Column"

Answer 10

您可以编写一个汇总查询来做到这一点。

1. 使用 $ group 带有 $ sum 来计算总和
2. 的ID密钥

db.collection.aggregate({
  $group: {
    _id: "",
    num: {
      $sum: "$num"
    },
    count: {
      $sum: "$count"
    }
  }
},
{
  $project: {
    _id: 0,
    num: "$num",
    count: "$count"
  }
})

投影的 $ project 操作员删除$ group oterator Playground链接

Answer 11

这是一个示例，说明如何使用Python标准库 difflib 模块，它提供了用于计算三角洲的帮助者。

给定以下玩具数据框和搜索句子：

import pandas as pd

df = pd.DataFrame(
    {
        "document": ["doc 1", "doc 2"],
        "sentences": [
            ["lore ipsum", "magna carta", "upside down"],
            ["tempus fugit", "memento mori", "lora ipsom"],
        ],
    }
)
search_sentence = "lor ipsum"

定义一个辅助功能以比较句子的相似性：

from difflib import SequenceMatcher

def ratio(a, b):
    return round(SequenceMatcher(None, a, b).ratio(), 2)

然后：

# Use Python instead of Pandas
df = df.to_dict(orient="list")

# Init empty dictionary
results = {"Matching sentence": [], "similarity score": [], "document name": []}

# Iterate to compare
for (doc, sentences) in zip(df["document"], df["sentences"]):
    for i, sentence in enumerate(sentences):
        results["Matching sentence"].append(f"Sentence {i+1}")
        results["similarity score"].append(ratio(search_sentence, sentence))
        results["document name"].append(doc)

最后：

new_df = (
    pd.DataFrame(results)
    .sort_values(by="similarity score", ascending=False)
    .reset_index(drop=True)
)

print(new_df)
# Ouptut
  Matching sentence  similarity score document name
0        Sentence 1              0.95         doc 1
1        Sentence 3              0.84         doc 2
2        Sentence 2              0.29         doc 2
3        Sentence 3              0.20         doc 1
4        Sentence 1              0.19         doc 2
5        Sentence 2              0.10         doc 1

Answer 12

替换第4行

＆lt;％包括partials/head.ejs％＆gt; with＆lt;％ - 包括（'partials/head.ejs'）; ％＆gt;

和83

＆lt;％包括partials/footer.ejs％＆gt; with＆lt;％ - 包括（'partials/footer.ejs'）; ％＆gt;

Answer 13

Luxon的工具是间隔，它具有重叠（）

const fromISOs = (start, end) => {
  const startDt = luxon.DateTime.fromISO(start);
  const endDt = luxon.DateTime.fromISO(end);
  return luxon.Interval.fromDateTimes(startDt, endDt);
};

const assignment = fromISOs('2022-06-26T12:00:00.000Z', '2022-06-26T12:30:00.000Z');

const ranges = [
 ['2022-06-26T10:00:00.000Z', '2022-06-26T10:30:00.000Z'],
 ['2022-06-26T10:35:00.000Z', '2022-06-26T11:00:00.000Z'],
 ['2022-06-26T11:45:00.000Z', '2022-06-26T12:15:00.000Z'],
 ['2022-06-26T12:10:00.000Z', '2022-06-26T12:25:00.000Z'],
 ['2022-06-26T12:20:00.000Z', '2022-06-26T12:45:00.000Z'],
 ['2022-06-26T12:40:00.000Z', '2022-06-26T13:00:00.000Z']
];

 ranges
   .map(([start, end]) => fromISOs(start, end)) // create intervals
   .filter(i => !i.overlaps(assignment)) // filter out the overlaps
   .forEach(i => console.log(i.toISO())) // print the interval ISO (you don't have to do this)

<script src="https://cdnjs.cloudflare.com/ajax/libs/luxon/2.4.0/luxon.min.js"></script>

Answer 14

let attributeService = widgetContext.$injector.get(widgetContext.servicesMap.get('attributeService'));

let attributes = [{
    "key": YOUR_ATTRIBUTE_KEY,
    "value": YOUR_ATTRIBUTE_VALUE
}];
attributeService.saveEntityAttributes(entityId, 'SERVER_SCOPE', attributes).
    subscribe(
        () => {
            console.log('Saved!');
        },
        error => {
            console.log('Error');
        }
    );

Answer 15

使用 dense_rank（） 用按列订购：

SELECT Column,
       DENSE_RANK() OVER (ORDER BY Column) AS 'Desire'
FROM mytable;

return

aaaaaaa	desires drees
1	aaaaaaa
1 aaaaaa	1
aaaaaa	1
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb bbbbbb	2
bbbbbbb	bbbbb
cccccc	2
3 cccccc	3
ccccc	3

使用 row_number（row_number（Row_number）（ ）用按列分区：

SELECT Column,
       ROW_NUMBER() OVER (PARTITION BY Column) AS 'Desire'
FROM mytable;

返回：

列	欲望
AAAAAA	1
AAAAAA	2
AAAAAA 2 AAAAAA	3
BBBBBBB	1
BBBBBBB	2
BBBBBB 2 BBBBBBB	3
BBBBBBB BBBBBB	4
CCCCCC	1
CCCCCC 2 CCCCCC	2