Answer 1

从服务器流式文件数据不允许寻求，因为它是服务器上下文的一次性操作。

要允许寻求服务器需要允许

当您使用 res.sendfile（） 发送文件数据。

如果要渲染一个带有音频播放器的网页，则需要添加（至少）两个处理程序：一个用于HTML文件，一个用于音频文件。如果您只是使用常规的plain html文件，则可以使用中间件，您指出包含HTML文件的目录。

Answer 2

您可以使用 tf.stack 。

import tensorflow as tf

@tf.function
def join_tns_num(tensor, num):
    return tf.stack([tensor, tf.constant(num)], axis=0)

检查功能：

>>> join_tns_num(tf.constant(3), 2)
<tf.Tensor: shape=(2,), dtype=int32, numpy=array([3, 2], dtype=int32)>

Answer 3

您可以以这种方式清除选择：

private void DataGrid_SelectionChanged(Object sender, EventArgs e)
{
    DataGrid.ClearSelection(); 
}

Answer 4

确保您也更改模式： chmod -r u+rwx db

Answer 5

您应该尝试使用对象而不是数组，然后按这样的用户ID存储用户详细信息：

{1: User, 2: User, 3: User}

然后，您可以通过其ID获取其ID，而无需每次循环浏览数组

Answer 6

如果我正确理解的话，您要设置一个多项目workspace 。
您基本上将拥有一个定义工作区或根项目的单个 angular.json 文件，然后您将拥有子项目。

接下来，您可以定义一个带有模块的儿童项目，作为图书馆。您不必发布它即可使用它。您可以在您的应用程序中使用该库 。

最后，另一个解决方案是使您的项目完全分开。在这种情况下，您可以使用 ng-paackagr 将角模块作为单独的库提取。在这种情况下，请参见本教程关于如何做。

Answer 7

方法 MoveFocus（FocusDirection） 不能这样访问。

obain实例： val focusmanager = localfocusmanager.current and
然后使用该实例： focusmanager.movefocus（focusDirection.down）。

这在 @composable
的范围内工作，目标需求 modifier.focusable（）。

Answer 8

从我的有限反应经验中，当发生这种有趣的事情时，我有一些尝试尝试的方法。其中之一是在将功能传递为道具时调用空功能。 IE而不是：

<MealComponentForMagicDiary
            diary={diary}
            setDiary={setDiary}
            index={index}
          />

尝试：

<MealComponentForMagicDiary
            diary={diary}
            setDiary={() => setDiary}
            index={index}
          />

我很想知道为什么有时会起作用，如果有人（有人吗？）理解正确的反应。

我的手指交叉，它适合您！

Answer 9

您生成的假图像的数量取决于您采样的噪声向量的大小。理想情况下，在训练的单个步骤中，您将采样dimension batch_size x Noings_dim 的噪声向量，然后使用生成器生成 batch_size face>伪造图像。同样，您的歧视者会看到 batch_size 真实图像的数量。

这样，在每个步骤中，您的歧视者都会看到相等数量的假和真实图像，而歧视者看到的假图像总数将等于训练集中的图像总数本身。

Answer 10

联合全部

select trial, start_date, end_date, start_date as date, 'start' marker_start_end from table1
union all
select trial, start_date, end_date, end_date as date, 'end' marker_start_end from table1

unnest case

select trial, start_date, end_date, 
case when a.num = 1 then start_date else end_date end date, 
case when a.num = 1 then 'start' else 'end' end marker_start_end from
(
select trial, start_date, end_date, 
unnest(array[1,2]) num from table1
) a

隐藏<代码> JOIN （但仍在加入）

select 
  trial, 
  start_date, 
  end_date, 
  case when a.num = 1 then start_date else end_date end date, 
  marker_start_end 
from table1, (values(1,'start'),(2, 'end')) a(num,marker_start_end)

Answer 11

其小的语法误差应为n*m数组。因此，您需要将其转换为数组。这是代码。

import pandas as pd
import numpy as np
import scipy

#obs = df[['tablename1', 'tablename2']].to_numpy()
      #OR
obs = np.array(df[['tablename1', 'tablename2']])
test= scipy.stats.contingency.association(obs,method='tschuprow')
print(test)

希望，这将解决错误。

Answer 12

它帮助我添加到Run（）方法：

environment.admin()
            .addServlet("metrics", new MetricsServlet(environment.metrics()))
            .addMapping("/metrics");

Answer 13

我有点惊讶前两个示例起作用。 strcpy 将第二个参数指向的字符阵列将其复制到第一个参数指向的字符数组。

在您的第一个示例中，指针名称和 AltName 没有指向任何内容。它们是非直接的指针。现在，当执行 main 函数或只是编译器决定初始化它们时，它们具有基于内存中的任何内容的值。这就是为什么我惊讶于您的代码没有崩溃的原因。

无论如何，您的第三个示例是segfaulting的原因是，您将两个指针都设置为字符串文字（即，“ hi” 和“ andandstring” ）。字符串文字（很可能）存储在仅读取的内存部分中。因此，当您运行 strcpy 将目标指针设置为 altname 时，您正在尝试写入仅阅读内存。这是对内存的无效使用，因此崩溃了。您的第四个例子也是如此。

在最后一个示例中，您的问题是 n 未终止。 strcpy 继续复制字符，直到达到终结器（即，'\ 0''）。您已将'C'和a 'b'放在数组中，但没有终结器。因此， strcpy 即使达到 n 的末尾，也将继续复制。当 sizeof（s）大于8时，它起作用的事实可能涉及堆栈中存在的空字节。也就是说，如果您使 s 太小，您将在其末端编写并损坏堆栈上的内存。您可能会覆盖返回指针，从而在执行功能后返回到一些无效的内存地址。

您需要做的是使用指针，而是使用数组。这将为您提供可写入的记忆部分所需的存储空间。您还需要确保阵列为无效。可以通过使用字符串文字初始化阵列来自动完成。

char name[] = "HI";
char altname[] = "randomstring";
strcpy(altname, name);

char s[3]; // Enough space to hold "cb" plus a null-terminator.
char n[] = "cb";
char *name = n;
char *altname = s;
strcpy(altname, name);

Answer 14

将此存储库克隆到新位置，发现更多的文件更改了。
原来我有.gitattributes文件。删除它之后 - 更改的文件消失了

Answer 15

基本上，您遇到此错误的原因是因为多处理使用 pickle 通常，通常仅序列化模块级函数。功能 addi 不是顶级模块级功能。实际上，线全局addi 没有做任何事情，因为 addi 从未在外部模块中声明。因此，您有三种解决此问题的方法。

方法1

您可以在执行 calc 函数之前在全局范围中定义 addi ：

import multiprocessing as mp
import os


def addi(num1, num2):
    print(num1 + num2)

def calc(num1, num2):

    m = mp.Process(target=addi, args=(num1, num2))
    m.start()

    print("here is main", os.getpid())
    m.join()


if __name__ == "__main__":
    # creating processes
    calc(5, 6)

output

here is main 9924
11

方法2

您可以切换到多进程，它使用而不是泡菜，可以序列化此类功能。

import multiprocess as mp  # Note that we are importing "multiprocess", no "ing"!
import os

def calc(num1, num2):

    def addi(num1, num2):
        print(num1 + num2)

    m = mp.Process(target=addi, args=(num1, num2))
    m.start()

    print("here is main", os.getpid())
    m.join()


if __name__ == "__main__":
    # creating processes
    calc(5, 6)

输出

here is main 67632
11

方法2b

当它是一个有用的库时，您可能不想使用 Multiprocess 有一些有效的理由。一个很大的事实是，标准库的多处理，并且该叉子彼此不兼容（尤其是如果您在Subpackage Multiprocessing.managers.managers 中使用任何内容）。这意味着，如果您在自己的项目中使用此叉子，同时也使用第三方库，这些库本人使用标准库的多次浏览，则可能会看到意外的行为。

无论如何，如果您想坚持使用标准库的多处理而不使用叉子，则可以使用 dill 自己来序列化python闭合，例如函数 addi 通过划分 Process 类并添加我们自己的一些逻辑。下面给出了一个示例：

import dill
from multiprocessing import Process  # Use the standard library only
import os

class DillProcess(Process):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._target = dill.dumps(self._target)  # Save the target function as bytes, using dill

    def run(self):
        if self._target:
            self._target = dill.loads(self._target)    # Unpickle the target function before executing
            self._target(*self._args, **self._kwargs)  # Execute the target function


def calc(num1, num2):

    def addi(num1, num2):
        print(num1 + num2)

    m = DillProcess(target=addi, args=(num1, num2))  # Note how we use DillProcess, and not multiprocessing.Process
    m.start()

    print("here is main", os.getpid())
    m.join()


if __name__ == "__main__":
    # creating processes
    calc(5, 6)

输出

here is main 23360
11

方法3

此方法适用于那些不能使用代码中任何第三方库的人。我建议您在诉诸于该方法之前确保上述方法不起作用，因为它有点骇客，您确实需要重组一些代码。

无论如何，此方法通过在顶部模块范围中引用您的本地功能来起作用，以便它们可以通过泡菜访问。为了动态执行此操作，我们创建一个占位符类，并将所有本地函数添加为其类属性。我们还需要确保函数' __ Qualname __ 属性已更改为指向其新位置，并且所有这些都在之外完成（如果__ -name __ ... block（否则新启动的过程不会看到属性）。在此处考虑您的代码的稍微修改的版本：

import multiprocessing as mp
import os

def calc(num1, num2):

    def addi(num1, num2):
        print(num1 + num2)

    # Another local function you might have
    def addi2():
        print('hahahaha')

    m = mp.Process(target=addi, args=(num1, num2))
    m.start()

    print("here is main", os.getpid())
    m.join()


if __name__ == "__main__":
    # creating processes
    calc(5, 6)

以下是您可以使用上述详细方法使其正常工作的方法：

import multiprocessing as mp
import os


# This is our placeholder class, all local functions will be added as it's attributes
class _LocalFunctions:
    @classmethod
    def add_functions(cls, *args):
        for function in args:
            setattr(cls, function.__name__, function)
            function.__qualname__ = cls.__qualname__ + '.' + function.__name__


def calc(num1, num2, _init=False):
    # The _init parameter is to initialize all local functions outside __main__ block without actually running the 
    # whole function. Basically, you shift all local function definitions to the top and add them to our 
    # _LocalFunctions class. Now, if the _init parameter is True, then this means that the function call was just to 
    # initialize the local functions and you SHOULD NOT do anything else. This means that after they are initialized,
    # you simply return (check below)

    def addi(num1, num2):
        print(num1 + num2)

    # Another local function you might have
    def addi2():
        print('hahahaha')

    # Add all functions to _LocalFunctions class, separating each with a comma:
    _LocalFunctions.add_functions(addi, addi2)

    # IMPORTANT: return and don't actually execute the logic of the function if _init is True!
    if _init is True:
        return

    # Beyond here is where you put the function's actual logic including any assertions, etc.
    m = mp.Process(target=addi, args=(num1, num2))
    m.start()

    print("here is main", os.getpid())
    m.join()


# All factory functions must be initialized BEFORE the "if __name__ ..." clause. If they require any parameters,
# substitute with bogus ones and make sure to put the _init parameter value as True!
calc(0, 0, _init=True)

if __name__ == '__main__':
    a = calc(5, 6)

因此，您需要更改代码中的一些内容如果__ -name__ ... 子句，需要初始化顶部和所有工厂功能（他们需要接受 _Init 参数）。但这可能是如果您不能使用莳萝，可以做到最好。