全部问题

任务是动态添加成对的小部件，例如，QLabel添加到QLineEdit界面。
我创建了一个QMixedWidget包含其他小部件的包装类。

class QMixedWidget(QWidget):
    def __init__(self, parent=None, *widgets):
        super().__init__(parent)
        self._widgets = widgets

    def paintEvent(self, event: PySide6.QtGui.QPaintEvent) -> None:
        for w in self._widgets:
            w.paintEvent(event)
        super().paintEvent(event)

    def update(self) -> None:
        for w in self._widgets:
            w.update()
        super().update()

但是，当我尝试将创建的小部件添加到Layout没有任何反应时，也许应该覆盖其他一些方法？

def _add_n_action(self):
   label = QLabel("Источник шума L")
   value = QLineEdit("0")
   w = QMixedWidget(self.add_group_box, label, value)
   self.add_layout.addWidget(w)

有两个数组

var_dump($postsIdNewsArr);
array(2) { [0]=> int(243) [1]=> int(219) }

var_dump($postsIdArticlesArr);
array(2) { [0]=> int(242) [1]=> int(202) }

你需要得到一个像这样的数组

[243,242,219,202]

这是在 WordPress 中显示两种类型的帖子所必需的。如何做到这一点？

关于模板类的信息有很多，但是我仍然没有找到任何关于非模板类中的模板方法的信息。

当我尝试这样做时，编译器会抱怨很多：

class c
{
public:
    template<class T>
    void method(const T& arg)
    {

    }

    template<>
    void method<int>(const int& arg)
    {

    }
};

如何正确地做到这一点？

我需要将 TextView 之一附加到布局的末尾，这与屏幕截图完全相同。 我还想知道如何在元素之间制作线条。 （layout_gravity，重力不起作用）代码如下：

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginHorizontal="50dp"
    android:layout_marginTop="10dp"
    android:background="#E1EBF0"
    android:orientation="horizontal"
    app:layout_constraintEnd_toEndOf="parent"

    app:layout_constraintHorizontal_bias="0.0"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toBottomOf="@+id/frameLayout">

    <TextView
        android:id="@+id/day"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:fontFamily="@font/inter_medium"
        android:text="10"
        android:textSize="34sp"
        android:textColor="@color/black"
        />
    <TextView
        android:id="@+id/month"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:fontFamily="@font/inter_medium"
        android:layout_marginHorizontal="8dp"
        android:text="10"
        android:textSize="34sp"
        android:textColor="@color/black"/>
    <TextView
        android:id="@+id/year"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:fontFamily="@font/inter_medium"
        android:text="10"
        android:textSize="34sp"
        android:textColor="@color/black"/>
</LinearLayout>

例子取自《100 Go Mistakes》一书

我不明白为什么使用通道比简单地添加数组更有利可图？他们不仅要承担创作成本，还要承担经营活动的成本，因为它们的背后是结构。

小澄清：

Count并Count3使用类似的结构Result

Count2使用类型结构Result2

type Input struct {
    a int64
    b int64
}

type Result struct {
    sumA int64
    sumB int64
}

//[56]byte используется для расположение sumA и SumB в разных сегментах кеша
type Result2 struct {
    sumA int64
    _    [56]byte
    sumB int64
}

// 1048576 - 2^20 для наглядности
func CreateInput() []Input {
    input := make([]Input, 0, 1048576)

    for i := int64(0); i < 1048576; i++ {
        input = append(input, Input{
            a: i,
            b: i,
        })
    }

    return input
}

func Count(inputs []Input) Result {
    wg := sync.WaitGroup{}
    wg.Add(2)

    result := Result{}

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumA += inputs[i].a
        }

        wg.Done()
    }()

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumB += inputs[i].b
        }

        wg.Done()
    }()

    wg.Wait()

    return result
}

func Count2(inputs []Input) Result2 {
    wg := sync.WaitGroup{}
    wg.Add(2)

    result := Result2{}

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumA += inputs[i].a
        }

        wg.Done()
    }()

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumB += inputs[i].b
        }

        wg.Done()
    }()

    wg.Wait()

    return result
}

func Count3(inputs []Input) Result {
    var result Result
    sumAChan := make(chan int64)
    sumBChan := make(chan int64)

    go func() {
        var sumA int64
        for i := 0; i < len(inputs); i++ {
            sumA += inputs[i].a
        }
        sumAChan <- sumA
    }()

    go func() {
        var sumB int64
        for i := 0; i < len(inputs); i++ {
            sumB += inputs[i].b
        }
        sumBChan <- sumB
    }()

    result.sumA = <-sumAChan
    result.sumB = <-sumBChan

    return result
}

更新：结果在很大程度上取决于参数-coverprofile

Count2和Count3非常接近，但为什么-coverprofile它只在 上产生如此大的差异Count2？如果没有它，平均结果是：

          │  stats.txt   │
          │    sec/op    │
Count-12    18.24m ±  2%
Count2-12   677.0µ ±  7%
Count3-12   689.8µ ± 12%
geomean     2.042m

          │  stats.txt  │
          │    B/op     │
Count-12    162.5 ± 19%
Count2-12   192.0 ±  6%
Count3-12   288.0 ±  0%
geomean     207.9

          │ stats.txt  │
          │ allocs/op  │
Count-12    4.000 ± 0%
Count2-12   4.000 ± 0%
Count3-12   4.000 ± 0%
geomean     4.000

以下是包含 1,048,576 个元素的基准测试结果c -coverprofile

cpu: AMD Ryzen 5 5600G with Radeon Graphics         
BenchmarkCount-12             49      25359128 ns/op         237 B/op          4 allocs/op
BenchmarkCount2-12           295       3661261 ns/op         300 B/op          4 allocs/op
BenchmarkCount3-12          1946        644967 ns/op         288 B/op          4 allocs/op

以下是基准测试结果：без -coverprofile

BenchmarkCount-12             67          18467245 ns/op             209 B/op          4 allocs/op
BenchmarkCount2-12          1833            597416 ns/op             211 B/op          4 allocs/op
BenchmarkCount3-12          1938            734245 ns/op             288 B/op          4 allocs/op

基准代码

var res test.Result
var res2 test.Result2
var res3 test.Result

// BenchmarkResult placeholder.
func BenchmarkCount(b *testing.B) {
    var sum test.Result
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count(input)
    }

    res = sum
}

func BenchmarkCount2(b *testing.B) {
    var sum test.Result2
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count2(input)
    }

    res2 = sum
}

func BenchmarkCount3(b *testing.B) {
    var sum test.Result
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count3(input)
    }

    res3 = sum
}

运行基准测试的命令，通过 vscode 中的图形界面启动

go test -benchmem -run=^$ -coverprofile=/tmp/vscode-govayH6A/go-code-cover -bench . alice/effective/internal/test