全部问题(coding)

我有列表（元素数量不均匀）：

my.list = list(col1 = c("CC", "CT", "TT"), 
     col2 = c("GG", "GT"), 
     col3 = c("CC", "CT"),
     col4 = c("CC", "CG", "GG"), 
     col5 = c("AC", "CC"),
     col6 = "GG")

$col1
[1] "CC" "CT" "TT"

$col2
[1] "GG" "GT"

$col3
[1] "CC" "CT"

$col4
[1] "CC" "CG" "GG"

$col5
[1] "AC" "CC"

$col6
[1] "GG"

可以将其转换为数据框：

mylist.df = plyr::ldply(my.list, rbind)
names(mylist.df) <- c("cols","g1", "g2", "g3")

我想使用mylistor对下面的数据框进行子集化mylist.df。基本上，我想保留每个值至少有一个元素的每一行mylist：

df.to.subset = structure(list(IDs = c("ID1", "ID2", "ID3", "ID4", "ID5", "ID6"), 
               gr = c("gr1", "gr1", "gr1", "gr1", "gr1", "gr1"), 
               var = c(-3.451, -3.469, -3.837, -3.344, -3.904, -3.943), 
               col1 = structure(c(1L, 2L, 3L, 1L, 2L, 2L), levels = c("CC", "CT", "TT"), class = "factor"), 
               col2 = structure(c(1L, 1L, 2L, 3L, 3L, 3L), levels = c("GG", "GT", "TT"), class = "factor"), 
               col3 = structure(c(1L, 2L, 1L, 1L, 1L, 1L), levels = c("CC", "CT"), class = "factor"), 
               col4 = structure(c(2L, 2L, 2L, 2L, 2L, 2L), levels = c("CC", "CG", "GG"), class = "factor"), 
               col5 = structure(c(1L, 2L, 2L, 2L, 2L, 2L), levels = c("AC", "CC"), class = "factor"), 
               col6 = structure(c(1L, 1L, 2L, 1L, 1L, 1L), levels = c("GG","AA"), class = "factor")), 
          row.names = c(NA, 
                        -6L), class = c("tbl_df", "tbl", "data.frame"))

  IDs   gr      var col1  col2  col3  col4  col5  col6 
  <chr> <chr> <dbl> <fct> <fct> <fct> <fct> <fct> <fct>
1 ID1   gr1   -3.45 CC    GG    CC    CG    AC    GG   
2 ID2   gr1   -3.47 CT    GG    CT    CG    CC    GG   
3 ID3   gr1   -3.84 TT    GT    CC    CG    CC    AA   
4 ID4   gr1   -3.34 CC    TT    CC    CG    CC    GG   
5 ID5   gr1   -3.90 CT    TT    CC    CG    CC    GG   
6 ID6   gr1   -3.94 CT    TT    CC    CG    CC    GG   

（最终结果将是）

  IDs   gr      var col1  col2  col3  col4  col5  col6 
  ID1   gr1   -3.45 CC    GG    CC    CG    AC    GG   
  ID2   gr1   -3.47 CT    GG    CT    CG    CC    GG   

另外，我想重新调整每一列的级别以df.to.subset匹配此数据框中的级别：

factor.levels.cols = structure(list(cols = c("col1", "col2", "col3", "col4", "col5", "col6"), 
               g1 = c("CC", "GG", "CC", "CC", "AA", "AA"), 
               g2 = c("CT", "GT", "CT", "CG", "AC", "AG"), 
               g3 = c("TT", "TT", "TT", "GG", "CC", "GG")), 
          row.names = c(NA, 6L), class = "data.frame")

  cols g1 g2 g3
1 col1 CC CT TT
2 col2 GG GT TT
3 col3 CC CT TT
4 col4 CC CG GG
5 col5 AA AC CC
6 col6 AA AG GG

这里是否强制使用 for 循环，或者有没有办法让它更快？我有超过 1,000,000 个条目需要修改。

为什么两个结果打印出来是一样的？

final list1 = [ "a", "b", "c" ];
final result1 = true ? list1 : list1..removeWhere((e) => e == "a");
print(result1); // prints ["b", "c"]

final list2 = [ "a", "b", "c" ];
final result2 = false ? list2 : list2..removeWhere((e) => e == "a");
print(result2); // prints ["b", "c"]

这种情况仅发生在三元条件下。当在正常的 if-else 中时，这工作得很好。

我在理解类型何时推导出std::ranges::dangling何时使用命名局部变量与纯右值作为std::ranges::sort算法的参数时遇到问题。例如，我有一个函数将 a 返回prvalue 到标准容器，例如 std::vector ，我直接将其用作 的参数，然后我期望在尝试取消引用迭代器时std::ranges::sort收到编译错误，这就是我得到的：std::ranges::dangling

#include <vector>
#include <algorithm>

auto get_data(){
    return std::vector<int>{1, 2, 99, 5, 9, 4};
}

auto get_sorted(){
    return std::ranges::sort(get_data());
}


int main(){
    auto it = get_sorted();
    *(it-1); //Compiler Error because it is a std::ranges::dangling iterator
}

但是，如果我稍微更改get_sorted上面的函数以首先捕获命名变量中的向量并使用它来返回 的结果std::ranges::sort，那么我不会得到悬空迭代器，即使main命名变量中分配的向量应该是函数get_sorted返回后销毁：

auto get_sorted(){
    auto vec = get_data();
    return std::ranges::sort(vec);
}


int main(){
    auto it = get_sorted();
    *(it-1); //Okay result  = 99
}

即使我更改get_sorted为使用本地声明的基于命名变量的容器，我也会得到一种行为，编译器不会抱怨在其调用者（例如函数）中取消引用悬空迭代器main。

//doesn't return a std::ranges::dangling
auto get_sorted(){
    std::vector<int> vec{1, 2, 99, 5, 9, 4};
    return std::ranges::sort(vec);
}

当我将纯右值向量传递给std::ranges::sort算法时，我再次得到std::ranges::dangling预期的

//returns a std::ranges::dangling
auto get_sorted(){
    std::vector<int> vec{1, 2, 99, 5, 9, 4};
    return std::ranges::sort(std::vector<int>{1, 2, 99, 5, 9, 4});
}

对于编译器没有收到错误的情况，当我std::ragnes::dangling使用选项进行编译时，我确实观察到运行时错误，fSanitize=address这可能是因为在函数内的命名变量中分配的向量get_sorted一旦后一个函数就超出了范围回。

不过，我想了解为什么在函数中使用命名变量会更改get_sorted函数的返回类型，并可能提供有关如何正确使用临时变量和纯右值容器以std::ranges::dangling尽可能获取的指南。

我想在曲面内画一个半圆。所以我想使用， pygame.draw.arc() 但我不知道如何在表面内绘制圆弧，我已经看到了官方文档，并且正在使用math.radians()将度数转换为弧度，但我看不到圆弧。正在画一个圆...

import pygame
import math

pygame.init()
width, height = 800, 600
screen = pygame.display.set_mode((width, height))

surf = pygame.Surface((100, 100))
surf.fill("green")
rect = surf.get_rect(center=(100, 100))

run = 1
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = 0

    screen.fill((255, 202, 135))
    pygame.draw.circle(surf, (255, 255, 255), (30,30),25)
    pygame.draw.arc(surf, (255, 255, 255), rect, math.radians(270), math.radians(90))
    screen.blit(surf, rect)

    pygame.display.flip()
pygame.quit()

提前致谢

此代码在 XCode 和 Visual Studio 中提供不同的输出：

#include <iostream>

using namespace std;

int f() {
    cout << 'A';
    return 1;
}

int main() {
    cout << '.' << f();
    return 0;
}

在 Visual Studio 中它输出

A.1

在 XCode 中它输出

.A1

显然我希望两个编译器输出相同的东西..是否应该不这样做？这是已知的事情还是我可以对此做些什么？

我正在编写一个函数来将数据表转换为长格式。对于cols = 参数，第一列的名称将始终相同，但最后一列（和列数）将会更改。有没有办法在不命名列或不按索引的情况下获取列的“其余”部分？

假设我有这个样本数据：

data <- structure(list(Site = c("A", "B"), Group = c("1", "2"), grip = c("S", 
"H"), height = c("S", "T"), width = c("W", "N"), QA = c("Y", 
"N")), class = "data.frame", row.names = c(NA, -2L))

看起来像这样：

  Site Group grip height width QA
1    A     1    S      S     W  Y
2    B     2    H      T     N  N

有时数据集会有更多列。假设我想获取 columns grip:QA，而不命名 QA，或给出其索引号。我尝试了以下方法：

data %>%
  pivot_longer(cols = grip:everything(),
               names_to = "Name",
               values_to = "value")

但我收到了警告Warning message: In x:y : numerical expression has 6 elements: only the first used，它并没有按照我想要的方式旋转。我想要实现的目标可能吗？

大多数时候，powershell 中的错误报告非常有用。我看到了错误，看到了起源，但我注意到 ForEach-Object 管道中的任何错误都会丢失其起源行，并且错误堆栈仅指向带有ForEach-Object.

错误位置示例

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

[cultureinfo]::CurrentUICulture = 'en-US'

function Test-Something($val)
{
    # var is not defined here
    Write-Host($undefined_variable)
}

@("a","b") | ForEach-Object{
    $entry = $_

    Test-Something $entry
}

结果是

ForEach-Object : The variable '$undefined_variable' cannot be retrieved because it has not been set.
In D:\dummy.ps1:12 Line:14
+ @("a","b") | ForEach-Object{
+              ~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (undefined_variable:String) [ForEach-Object], RuntimeException
    + FullyQualifiedErrorId : VariableIsUndefined,Microsoft.PowerShell.Commands.ForEachObjectCommand

该线12指向@("a","b") | ForEach-Object{，这显然不是错误位置。

foreach 的更有用的示例

现在我使用的是foreach（只有最后4行代码发生了变化）

Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

[cultureinfo]::CurrentUICulture = 'en-US'

function Test-Something($val)
{
    # var is not defined here
    Write-Host($undefined_variable)
}

$data = @("a","b")

foreach($entry in $data)
{
    Test-Something $entry
}

现在的错误更加有用，它实际上指向错误9行Write-Host($undefined_variable)

The variable '$undefined_variable' cannot be retrieved because it has not been set.
In D:\dummy.ps1:9 Line:16
+     Write-Host($undefined_variable)
+                ~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (undefined_variable:String) [], ParentContainsErrorRecordException
    + FullyQualifiedErrorId : VariableIsUndefined

这是否与管道运营商的管道性质有关，或者我理解有误。当中间有更多函数时，第一种情况使得错误跟踪变得非常困难。在大多数情况下，我可以切换到foreach，但我很想了解实际发生的情况。

所以我基本上是从文件中读取第一行，并且我希望修剪第一个和最后一个字符，但前提是它们等于某个字符。我希望从字符串中删除“{”和“}”，但前提是它们分别是第一个和最后一个字符。

输入：

{Some_random_data_here, {more data here}, test}  

输出：

Some_random_data, {more data here}, test

这是我正在使用的完整命令，它能够删除第一个命令，但不能删除最后一个命令。

$(head -n 1 "$filePath" | sed s/^{//;s/}$//)

考虑这个 XML 文档：

<foo>
    <bar id="aaa"/>
    <jam>
        <bar id="bbb"/>
    </jam>
</foo>

我试图找到<bar>文档中的第一个元素。

这是我发现的：

我不明白的是为什么 Test #2 返回aaa，bbb而不是仅仅aaa. 就好像[1]操作员不工作一样。

我的理解是，在测试 #2 中，//bar表达式将找到两个节点，然后[1]运算符将选择第一个节点。显然，我错过了一些东西。

测试 #3 似乎证实了这一点，这显然是如何表达我真正想要的。

另外，如果将 XML 文档更改为：

<foo>
    <bar id="aaa"/>
    <bar id="bbb"/>
</foo>

然后你就得到了我期望看到的：

[1]关于应该如何工作，我在这里错过了什么微妙之处？

我有这些（杂乱的）数据，其中包含每个患者的药物治疗阶段（ip 或 cp）、药物名称（编码为数字）以及多种药物的剂量信息：

df_have

#   id ip_drug1 ip_dose1 ip_drug2 ip_dose2 cp_drug1 cp_dose1 cp_drug2 cp_dose2
# 1 A1        1      300        3      100        6      500        7      100
# 2 A2        1      300        2      200       11      300       NA       NA
# 3 A3        1      500       NA       NA        9      100        5     1500

我想让这些数据整洁并采用长格式：

df_want

#    id phase drug dose
# 1  A1    ip    1  300
# 2  A1    ip    3  100
# 3  A1    cp    6  500
# 4  A1    cp    7  100
# 5  A2    ip    1  300
# 6  A2    ip    2  200
# 7  A2    cp   11  300
# 8  A2    cp   NA   NA
# 9  A3    ip    1  500
# 10 A3    ip   NA   NA
# 11 A3    cp    9  100
# 12 A3    cp    5 1500

我能够通过 、 和 (和 ) 的组合获得所需tidyr::pivot_longer的dplyr::mutate数据tidyr::pivot_wider框dplyr::select：

library(tidyr)
library(dplyr)

df_have %>% 
  pivot_longer(cols = -id, 
               names_to = c("phase", "type"),
               names_pattern = "(cp|ip)_(drug|dose)") %>%
  mutate(temp = row_number(), 
         .by = c(id, phase, type)) %>%
  pivot_wider(names_from = type, 
              values_from = value) %>%
  select(-temp)

然而，上面的多步代码在我非常大的实际数据上非常慢。我希望在tidyr/内更快地完成此转换dplyr，最好是一步完成pivot_wider。这可能吗？

可重复的df_have数据df_want框：

# have
df_have <- data.frame(id = paste0("A", 1:3), 
                 ip_drug1 = 1,
                 ip_dose1 = c(300, 300, 500),
                 ip_drug2 = c(3, 2, NA),
                 ip_dose2 = c(100, 200, NA),
                 cp_drug1 = c(6, 11, 9),
                 cp_dose1 = c(500, 300, 100),
                 cp_drug2 = c(7, NA, 5),
                 cp_dose2 = c(100, NA, 1500))

# want
df_want <- data.frame(id = rep(paste0("A", 1:3), each = 4),
                      phase = rep(rep(c("ip", "cp"), each = 2), times = 3),
                      drug = c(1, 3, 6, 7, 1, 2, 11, NA, 1, NA, 9, 5),
                      dose = c(300, 100, 500, 100, 300, 200, 300, NA, 500, NA, 100, 1500))