Answer 1

您可以使用附加和条目方法来跟踪对实体模型的更改。要确定模型您需要所有键

var query = 
  from model in context
  where key == "someKey"
  select new myDTO
  {
    Id = model.Id,
    Item1 = model.column1,
    Item2 = model.column2
  };

var dto = query.First();

// Here I'm using Entity but you should use the right type
var entityyModified = new Entity();
entityModified.Id = dto.Id;
entityyModified.Item1 = dto.Item1;
entityyModified.Item2 = dto.Item2;

// ...
// Item1 or Item2 properties can be assigned to different values
// ...

// Save the changes
context.Attach(entityyModified);
var dbEntry = context.Entry(entityyModified);
dbEntry.Property(e => e.Item1).IsModified = true;
dbEntry.Property(e => e.Item2).IsModified = true;
context.SaveChanges();

Answer 2

价格过滤器是由saleschannelproductentity :: CheepeStprice生成的，因此请确保还要更改此问题，如文档中所示。

Answer 3

您可以使用scaletransform并为其scalex和scale> scaley属性进行动画：

<Storyboard x:Key="ExpandingAnimation">
    <Storyboard>
        <DoubleAnimation
            Storyboard.TargetName="MyScaleTransform"
            Storyboard.TargetProperty="(ScaleTransform.ScaleX)"
            From="0" To ="1" Duration="0:0:3"/>
        <DoubleAnimation
            Storyboard.TargetName="MyScaleTransform"
            Storyboard.TargetProperty="(ScaleTransform.ScaleY)"
            From="0" To ="1" Duration="0:0:3"/>
    </Storyboard>
</Storyboard>
...
<Grid x:Name="ExpandingGrid"
              RenderTransformOrigin="0.5,0.5"
              Height="222">
    <Grid.RenderTransform>
        <ScaleTransform x:Name="MyScaleTransform" ScaleX="0" ScaleY ="0" />
    </Grid.RenderTransform>
</Grid>

Answer 4

# Create DataFrame from data dictionary:
# - set_index(0) makes the keys (column 0) the index values
# - .T takes the transpose and makes the index the columns
# .reset_index(drop=True) resets index to 0 (1 row DataFrame) and drops old index
df = pd.DataFrame(data.items()).set_index(0).T.reset_index(drop=True)

# Select first 3 columns to keep as is
df = df[['calories', 'cautions', 'dietLabels']]

# For loop logic to create all other columns
# Since not all keys from totalNutrients are wanted, they must be selected in col_list
col_list = ['CA', 'CHOLE', 'FAT', 'FE', 'FIBTG', 'K', 'MG', 'NA', 'PROCNT', 'SUGAR', 'VITC']
value_list = []

# For each key and value (dictionary) in data['totalNutrients']
for key, value in data['totalNutrients'].items():
    # If key is in col_list
    if key in col_list:
        # Add value to value_list
        value_list.append(value['quantity'])
        
# Create dictionary of columns and values using zip()
clean_data_dict = dict(zip(col_list, value_list))

# Concatenate df with new DataFrame on the same index. axis=1 to concatenate on columns
df = pd.concat([df, pd.DataFrame(clean_data_dict, index=[0])], axis=1)

print(df)

可选的

# To run the API multiple times and store each run:
# - Try loading data.csv
# - Add new data row to main_df and overwrite
# - If the file is not found then save first run df
try:
    main_df = pd.read_csv('data.csv')
    main_df = pd.concat([main_df, df])
    main_df.reset_index(drop=True, inplace=True)
    print(main_df)
    main_df.to_csv('data.csv', index=False)
except FileNotFoundError:
    df.to_csv('data.csv', index=False)

可选

# To change the column names at the end you can repeat the zip process
new_col_list = ['calories', 'cautions', 'diet_labels', 'calcium', 'cholesterol', 'fat', 'iron', 'dietary_fiber', 'potasssium', 'magnesium', 'sodium', 'protein', 'sugar', 'vitamin_c']

col_dict = dict(zip(col_list, new_col_list))

# .rename() uses a dict to map old column names to new column names
df.rename(columns=col_dict)

print(df)

Answer 5

为什么每个线程运行时间都不同，并且每次运行代码时间都不同？线程的运行时间取决于什么？

您的系统上有很多流程。系统上任何内容的运行时间都受内核安排能力的影响，这取决于系统上其他所有内容的活动。获得一致运行时间的唯一方法是使用某种实时内核（或不运行多个进程的嵌入式设备）。

为什么顺序比多线程更快？

使用多个线程很少会为您提供CPU密集型任务的性能优势。由于Python的设计，实际上只有一个线程同时执行。当您尝试并行化IO-BOND操作（例如，通过网络获取数据）时，线程最有用。

对于CPU密集型操作，多处理模块通常是一个更好的选择（因为这会产生Python解释器的多个独立实例，并且可以利用多个CPU），但是在设置和撕裂中涉及的间接费用根据您的工作负载，这些过程使得解决方案没有比单个过程版本更好（甚至更糟）。

Answer 6

是的，您不能将儿童和儿童财产分配给专栏。专栏将孩子带到[]（正方形支架）内部的儿童街区。

Answer 7

好吧，有不同的方法可以解决问题。一种方法是使用zipwith订阅可观察到的源的管道操作员，并将其与任何数量的可观察结果输入的值结合使用。 zipwith操作员是RXJS 8的替代zip运算符。您可以做类似的事情：

import { zipWith } from 'rxjs';

private createResult() {
   this.userObservable.getFullName().pipe(
      zipWith(
        this.userObservable.getPhoneNumber(),
        this.userObservable.getEmailAddress()
      ),
      map(([fullName, phoneNumber, emailAddress]) => this.httpService.createSomething(fullName, phoneNumber, emailAddress))
    ).subscribe((result) => console.log(result))
  }

该方法的好处是，您没有将多个订阅彼此嵌套，这可能会导致意想不到的副作用。

Answer 8

您在正确的轨道上！几件事会有所帮助...

首先，您忽略了输出中的键信息，因为求解器说您的配方是不可行的！

Status: Infeasible

因此，变量中出现的任何内容都是胡言乱语，您必须首先弄清楚该部分。

那么，为什么不可行？看看您的约束。您正在尝试 force 如果您的距离值为零，则不可能无法正确：

prob += int(distances[w][b]) * J[w]  >= 1

因此，您需要重新格式化！您在这里缺少一个概念。实际上，对于此问题，您需要2个约束。

1. 如果路由太长，
2. 您需要强制涵盖每个目的地，则需要约束源用途的选择。

您还需要一个双重指数的决策变量。为什么？好吧，可以说，来源'a'涵盖了目标1、2； “ B”覆盖2、3、4、5 ....您将能够知道所有目的地都被一个变量“覆盖”，但是您不知道使用了哪些源，因此您需要保持跟踪两者都得到完整的图片。

这是一个开始，还有几个编辑。我建议变量名称source和目标，因为这是标准的。在此特定问题中，您没有特定的需求，只是需要连接。您可能还希望使用词典多于嵌套列表，我认为这更清楚。以下是一个示例以第一个约束开始。在限制覆盖变量时，请注意这里的技巧。如果距离小于限制，则s，则可以满足此约束。例如，如果距离为3：

3 * 1 <= s

无论如何，这是建议的开始。另一个约束未实施。您将需要在所有来源上总结，以确保目的地被“覆盖”。如果您被卡住，请回信。

prob = LpProblem('source minimzer', LpMinimize)
dist_limit = 5
sources = ['A', 'B']            # the source locations
# note this is zero-indexed to work with the list indexes in dist dictionary...
destinations = list(range(5))   # the demand locations 0, 1, 2, 3, 4   
dist = {    'A': [2, 23, 30, 54, 1],
            'B': [3, 1, 2, 2, 3]}

covered = LpVariable.dicts('covered', [(s, d) for s in sources for d in destinations], cat='Binary')
# set up constraint to limit covered if the destination is "reachable"
for s in sources:
    for d in destinations:
        prob += covered[s, d] * dist[s][d] <= dist_limit

# add one more constraint to make sure that every destination is "covered"...

Answer 9

由于您需要根据您的条件删除和添加频道，因此我提到了一种方法来达到您的要求，它适用于您。

let Channels = {
    "channel-1": "2022-06-29T11:20:14.000Z",
    "channel-2": "2022-06-29T05:58:18.000Z",
    "channel-3": "2022-06-29T05:18:49.000Z",
    "channel-4": "2022-06-29T04:08:35.000Z",
    "channel-5": "2022-06-29T01:52:31.000Z",
    "channel-6": "2022-06-29T01:00:40.000Z",
    "channel-7": "2022-06-29T00:59:47.000Z",
    "channel-8": "2022-06-29T00:07:28.000Z",
    "channel-9": "2022-06-28T23:55:27.000Z",
}

if(!channel.live) {
  delete Channels[name];
  Channels[name] = date.toJSON();
}

if(channel.live)
  Channels = { [name]: time.toJSON(), ...Channels };
}

const updatedChannels = {};
Object.keys(Channels).sort().forEach(item => (updatedChannels[item] = Channels[item]));

Channels = updatedChannels;

Answer 10

检查您的身份验证设置 - ＆GT;未经验证的请求，如果不是“ HTTP 302”，则Azure将不会返回授权_uri和其他数据。

Answer 11

const data=[{_id:"D01",name:"Lunetts",profession:"shop"},{_id:"D02",name:"Glasses",profession:"keeper"},{_id:"D03",name:"Auros",profession:"UiiSii"}];

const out = {};

for (const obj of data) {
  out[obj._id] = obj.name;
}

console.log(out);

Answer 12

也许有两个传说，一个使用自定义字形？

draw_key_arrow_left <- function(data, params, size, dir) {
  if (is.null(data$linetype)) {
    data$linetype <- 0
  } else {
    data$linetype[is.na(data$linetype)] <- 0
  }
  
  segmentsGrob(0.9, 0.5, 0.1, 0.5,
               gp = gpar(
                 col = alpha(data$colour %||% data$fill %||% "black", data$alpha),
                 # the following line was added relative to the ggplot2 code
                 fill = alpha(data$colour %||% data$fill %||% "black", data$alpha),
                 lwd = (data$size %||% 0.5) * .pt,
                 lty = data$linetype %||% 1,
                 lineend = "butt"
               ),
               arrow = params$arrow
  )
}


arrows2 <- arrows %>%
  mutate(x_orig = x, xend_orig = xend,
         x = if_else(direction == "forward", x_orig, xend_orig),
         xend = if_else(direction == "forward", xend_orig, x_orig))

ggplot() +
  geom_segment(data = arrows2 %>% filter(direction == "forward"),
               aes(x, y, xend = xend, yend = yend, col = direction),
               arrow = arrow(length = unit(0.3, "cm"), type = "closed")) +
  scale_color_manual(values = "#F8766D") +
  
  ggnewscale::new_scale_color() +
  geom_segment(data = arrows2 %>% filter(direction == "backward"),
               aes(x, y, xend = xend, yend = yend, col = direction),
               arrow = arrow(length = unit(0.3, "cm"), type = "closed"),
               key_glyph = "arrow_left") +
  scale_color_manual(values = "#619CFF", name = "") +
  theme(legend.key.width=unit(0.7,"cm"))

Answer 13

如@Teemu所示，您必须使用命名函数，因为如果要从侦听器中删除该功能，则需要对该函数进行引用。

因此，您没有在addeventListener（）中编写匿名函数，而是向其提供您在其他地方定义的函数的名称 - 最重要的是，不在循环中。

例如：

parent[i].addEventListener('mouseover', e => {
    this.addChildrenActive(i)
});

变为

parent[i].addEventListener('mouseover', mouseOverHandler);

命名函数，

function mouseOverHandler(e)
{
  console.log("mouse over", e.currentTarget);
}

您可能已经注意到该函数内部的e参数。这将填充与事件有关的数据，例如事件的名称或元素引起的。

然后可以使用以下方式删除此听众：

parent[i].removeEventListener('mouseover', mouseOverHandler);

让我给您一个更完整的示例：

class Navigation {
  constructor() {
    this.isMobile = false;
    this.parent = document.querySelectorAll("div");
    this.navbarInteraction();
  }

  navbarInteraction() {
    for (let i = 0; i < this.parent.length; i++) {
      this.parent[i].removeEventListener('mouseover', this.addChildrenActive);
      this.parent[i].removeEventListener('click', this.addChildrenActive);
      if (this.isMobile) {
        this.parent[i].addEventListener('click', this.addChildrenActive);
      } else {
        this.parent[i].addEventListener('mouseover', this.addChildrenActive);
      }
    }
  }

  addChildrenActive(e) {
    console.log("addChildrenActive()", e.currentTarget, e.type);
  }
}

let navigation = new Navigation();

<div id="divA">DIV1</div>
<div id="divB">DIV2</div>
<input type="checkbox" onchange="navigation.isMobile=this.checked;navigation.navbarInteraction();">
<span>isMobile</span>

Answer 14

前提您将调用sql_script规则：

myTree = parser.sql_script();

Answer 15

您可以将combine_images传递到预期列的功能号码，space像素中的图像和> > images> images的列表：

from PIL import Image


def combine_images(columns, space, images):
    rows = len(images) // columns
    if len(images) % columns:
        rows += 1
    width_max = max([Image.open(image).width for image in images])
    height_max = max([Image.open(image).height for image in images])
    background_width = width_max*columns + (space*columns)-space
    background_height = height_max*rows + (space*rows)-space
    background = Image.new('RGBA', (background_width, background_height), (255, 255, 255, 255))
    x = 0
    y = 0
    for i, image in enumerate(images):
        img = Image.open(image)
        x_offset = int((width_max-img.width)/2)
        y_offset = int((height_max-img.height)/2)
        background.paste(img, (x+x_offset, y+y_offset))
        x += width_max + space
        if (i+1) % columns == 0:
            y += height_max + space
            x = 0
    background.save('image.png')


combine_images(columns=3, space=20, images=['apple_PNG12507.png', 'banana_PNG838.png', 'blackberry_PNG45.png', 'cherry_PNG635.png', 'pear_PNG3466.png', 'plum_PNG8670.png', 'strawberry_PNG2595.png'])

7张图像和3列的结果：

​

​