主页 / coding / 问题

全部问题(coding)

Martin Hope
Yoan Ivanov
Asked: 2024-09-17 17:57:42 +0800 CST
  • 9

尝试将我的应用分发到 TestFlight 时出现以下错误：

在此处输入图片描述

我到目前为止尝试过的：

  • 我检查了 XCode 中的 ENABLE_BITCODE 选项，它在调试和发布时都设置为“NO”。
  • 我检查了 DEBUG_INFORMATION_FORMAT，它在调试和发布时均设置为“带有 dSYM 文件的 DWARF”
  • 我尝试使用这个命令，我发现它是一个解决方案，但它不起作用：

installer.pods_project.targets.each do |target|
      target.build_configurations.each do |config|
        config.build_settings['ENABLE_BITCODE'] = 'NO'
      end
    end

MacOS: Sequoia 15.0

Martin Hope
Abhay Sharma
Asked: 2024-09-17 16:16:19 +0800 CST
  • 9

我很困惑该用什么，是使用更新还是复制来更改/更新 Jetpack Compose 中的 UI 状态。

有人说使用

_uiState.update {
    it.copy()
}

有人说使用

_uiState.value = _uiState.value.copy()

哪一个更好用以及为什么？

我已经使用了copy()很多次，但仍然不确定我是否有效或正确地更新了 uiState。

Martin Hope
OmniZ
Asked: 2024-09-17 09:08:05 +0800 CST
  • 9

我正在尝试编写一个logging.Logger基本可以正常工作的自定义子类，但是在尝试使用logging.Formatter包含自定义格式的插值值的子类时遇到问题%(filename)，它会打印我的自定义子类所在的文件名，而不是调用日志记录函数的代码的文件名。

我找到了很多关于 Logger 子类化的教程，但是没有一个能解决它对文件名插值的影响。有没有一种无需重写大量代码的直接解决方案logging.Logger？

定义我的自定义记录器的示例代码：

#-------------------------------------
# custom_logger.py
#-------------------------------------
import logging
import io
class CustomLogger(logging.Logger):
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setLevel(logging.DEBUG)
        
        # create the record format
        formatter = logging.Formatter(fmt = "%(filename)s - %(message)s")
        
        # create the handler
        self.stream = io.StringIO()
        handler = logging.StreamHandler(self.stream)
        handler.setFormatter(formatter)
        self.addHandler(handler)
    
    def debug(self, msg, *args, **kwargs):
        super().debug(msg, *args, **kwargs)
        
        # do some other stuff
        ...        

#-------------------------------------
# test.py
#-------------------------------------
from custom_logger import CustomLogger
import logging

logging.setLoggerClass(CustomLogger)
myLog = logging.getLogger("myLog")
myLog.debug("hello world")
print(myLog.stream.getvalue())

预期输出： >>> test.py - hello world

实际产量： >>> custom_logger.py - hello world

python
Martin Hope
fabricioLima
Asked: 2024-09-15 05:05:46 +0800 CST
  • 9

请考虑以下三个示例列表：

List<string> localPatientsIDs = new List<string> { "1550615", "1688", "1760654", "1940629", "34277", "48083" };

List<string> remotePatientsIDs = new List<string> { "000-007", "002443", "002446", "214", "34277", "48083" };

List<string> archivedFiles = new List<string>{
    @"G:\Archive\000-007_20230526175817297.zip",
    @"G:\Archive\002443_20230526183639562.zip",
    @"G:\Archive\002446_20230526183334407.zip",
    @"G:\Archive\14967_20240703150011899.zip",
    @"G:\Archive\214_20231213150003676.zip",
    @"G:\Archive\34277_20230526200048891.zip",
    @"G:\Archive\48083_20240214150011919.zip" };

请注意，中的每个元素archivedFiles都是 ZIP 文件的完整路径，其名称以 开头，patientID位于localPatientsIDs或中remotePatientsIDs。

例如：@"G:\Archive\000-007_20230526175817297.zip"：文件名000-007_20230526175817297.zip以 开头000-007，它是列表中的一个元素remotePatientsIDs。

患者 ID 不能同时位于 和localPatientsIDs，archivedFiles因此这两个列表之间不允许有重复项。但是archivedFiles可以包含也位于 中的患者 ID remotePatientsIDs。

我需要获取文件名以 中存在但不存在于 中archivedFiles的元素开头的元素。终点是将这些文件解压缩到包含数据库的目录中。remotePatientsIDslocalPatientsIDslocalPatientsIDs

对于给定的示例，我期望得到以下结果：

archivedFilesToUnzip == {
    @"G:\Archive\000-007_20230526175817297.zip",
    @"G:\Archive\002443_20230526183639562.zip",
    @"G:\Archive\002446_20230526183334407.zip",
    @"G:\Archive\214_20231213150003676.zip" }

那么，如何使用 LINQ 来做到这一点？

由于我缺乏知识，我期望它会简单到如下程度：

List<string> archivedFilesToUnzip = archivedFiles.Where(name => name.Contains(remotePatients.Except(localPatients)))

我甚至无法编译它，因为Contains可能无法遍历列表成员，并且我收到消息：

CS1503: Argument 1: cannot convert from 'System.Collections.Generic.IEnumerable<string>' to 'string'

那么，到目前为止，我最好的尝试是以下句子（我承认它对我来说似乎有点混乱）。它总是返回一个空列表。

List<string> archivedFilesToUnzip = archivedFiles.Where(name => archivedFiles.Any(x => x.ToString().Contains(remotePatients.Except(localPatients).ToString()))).ToList();

我发现这些有用的帖子帮助我更好地理解Where和之间的区别Select：

另外，我一直在寻找使用 LINQ 的任何方向：

以及其他链接，但我仍然找不到可行的解决方案。

c#
Martin Hope
DJDuque
Asked: 2024-09-13 21:50:20 +0800 CST
  • 9

我有两组数据集：

第一个描述了我的期望：

expected = {
    "name": ["start", "stop", "start", "stop", "start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d", "e", "f", "g", "h"],
}

第二段描述了我的观察：

observed = {
    "name": ["start", "stop", "start", "stop", "stop", "stop", "start"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7],
}

我想根据我期望的顺序将我的所有观察结果与描述进行匹配。但是一旦发现不一致，就什么都不能匹配了。

我设法找到了第一个不一致之处，例如：

observed_df = pl.DataFrame(observed).with_row_index()
expected_df = pl.DataFrame(expected).with_row_index()

result = observed_df.join(expected_df, on=["index", "name"], how="left").select(
    "description", "time"
)
"""
┌─────────────┬──────┐
│ description ┆ time │
│ ---         ┆ ---  │
│ str         ┆ f64  │
╞═════════════╪══════╡
│ a           ┆ 0.1  │
│ b           ┆ 0.2  │
│ c           ┆ 0.3  │
│ d           ┆ 0.4  │
│ null        ┆ 0.5  │   -> First inconsistency gets a "null" description
│ f           ┆ 0.6  │
│ g           ┆ 0.7  │
└─────────────┴──────┘
"""

我怎样才能传播这个null通过第一个不一致的情况？

此外，我的真实数据还有一个附加id列，其中每个列id都是如上所述的情况，并且独立于其他id列。是否可以以某种方式“按 ID 分组”并一次性应用此逻辑，而不是id分别处理每个逻辑：

observed = {
    "id": [1, 2, 1, 2, 2],
    "name": ["start", "start", "stop", "stop", "stop"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}

expected = {
    "id": [1, 1, 2, 2],
    "name": ["start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d"],
}

result = {
    "id": [1, 2, 1, 2, 2],
    "description": ["a", "c", "b", "d", None],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}
python
Martin Hope
climsaver
Asked: 2024-09-12 23:45:08 +0800 CST
  • 9

以下代码创建了主轴长 1400 米、侧轴长 1000 米的椭圆。每个椭圆都分配有一个 ID。

library(sf)
library(ggplot2)
library(dplyr)

# coordinate data
x <- c(611547.6411, 589547.6411, 611447.6411, 609847.6411, 606347.6411, 611447.6411, 613547.6411,642747.6411, 589647.6411, 606447.6411, 613547.6411, 640347.6411, 642847.6411, 612147.6411, 613847.6411, 640247.6411, 642947.6411, 584347.6411, 587747.6411, 606447.6411, 614247.6411, 640447.6411, 642747.6411, 584447.6411, 608647.6411, 612047.6411, 612747.6411,
       613847.6411, 643147.6411, 583147.6411, 608747.6411, 611847.6411, 609647.6411, 610047.6411, 613747.6411, 586247.6411, 588647.6411, 643147.6411, 584347.6411, 606447.6411, 610147.6411, 613347.6411, 614647.6411, 586047.6411, 587247.6411, 611547.6411, 640347.6411, 643147.6411, 587147.6411, 583047.6411, 608747.6411, 612047.6411, 613947.6411, 587647.6411, 588547.6411, 586847.6411, 611247.6411, 643247.6411, 587247.6411, 590347.6411, 582947.6411, 608947.6411, 611847.6411, 613447.6411, 614647.6411, 585147.6411, 587647.6411, 588547.6411, 586947.6411, 611247.6411, 643047.6411, 587147.6411, 583947.6411, 587747.6411, 608547.6411, 611747.6411, 614047.6411, 585247.6411, 586247.6411, 588447.6411, 589147.6411, 611347.6411, 642447.6411, 586947.6411, 585847.6411, 587747.6411, 581447.6411, 612447.6411, 611947.6411, 600547.6411,
       612047.6411, 610347.6411, 614147.6411, 582847.6411, 588547.6411, 589247.6411, 611247.6411, 638147.6411, 640547.6411, 642947.6411, 587047.6411, 585947.6411, 587647.6411, 600447.6411, 611347.6411, 612347.6411, 610347.6411, 587747.6411, 579747.6411, 583847.6411, 586847.6411, 588447.6411, 589347.6411, 643347.6411, 589347.6411, 586947.6411, 588247.6411, 588847.6411, 585847.6411, 590847.6411, 589447.6411, 590947.6411, 581347.6411, 611847.6411, 600647.6411, 610347.6411, 615947.6411, 613947.6411, 586347.6411, 579647.6411, 584047.6411, 586347.6411, 587747.6411, 587947.6411, 586547.6411, 587647.6411, 614047.6411, 643047.6411, 587947.6411, 585747.6411, 584947.6411, 600547.6411, 611947.6411, 606847.6411, 600847.6411, 612847.6411, 615747.6411, 620747.6411, 614047.6411, 632947.6411, 588147.6411, 579747.6411, 582747.6411)

y <- c(5272140.5728, 5271740.5728, 5271640.5728, 5267440.5728, 5271540.5728, 5272040.5728, 5272340.5728, 5268540.5728, 5271240.5728, 5271640.5728, 5272140.5728, 5272240.5728, 5272240.5728, 5277940.5728, 5278040.5728, 5278040.5728, 5266940.5728, 5267040.5728, 5267440.5728, 5268140.5728, 5268640.5728, 5271140.5728, 5271740.5728, 5271740.5728, 5271940.5728, 5272140.5728, 5272240.5728, 5272040.5728, 5272140.5728, 5272140.5728, 5272140.5728, 5272240.5728, 5272340.5728, 5277240.5728, 5278040.5728, 5268540.5728, 5271240.5728, 5271340.5728, 5272240.5728, 5271940.5728, 5271940.5728, 5272040.5728, 5272040.5728, 5272040.5728, 5272040.5728, 5272040.5728, 5272140.5728, 5272140.5728,
       5272140.5728, 5272240.5728, 5272240.5728, 5277240.5728, 5278040.5728, 5278140.5728, 5278140.5728, 5265540.5728, 5266840.5728, 5266940.5728, 5267040.5728, 5268540.5728, 5272240.5728, 5272340.5728, 5272040.5728, 5272040.5728, 5277340.5728, 5278140.5728, 5278140.5728, 5265640.5728, 5266840.5728, 5267240.5728, 5268440.5728, 5271540.5728, 5272140.5728, 5271840.5728, 5271940.5728, 5271940.5728, 5271940.5728, 5272040.5728, 5272040.5728, 5272140.5728, 5272140.5728, 5272140.5728, 5272340.5728, 5277140.5728, 5277240.5728, 5277340.5728, 5277740.5728, 5277740.5728, 5278040.5728, 5278140.5728, 5278140.5728, 5278240.5728, 5278240.5728, 5264940.5728, 5265040.5728, 5265140.5728, 5266740.5728, 5266840.5728, 5266940.5728, 5267040.5728, 5267140.5728, 5267340.5728, 5267440.5728, 5268340.5728,
       5271240.5728, 5271840.5728, 5271940.5728, 5272040.5728, 5272040.5728, 5272340.5728, 5271840.5728, 5271840.5728, 5272140.5728, 5272140.5728, 5272240.5728, 5272240.5728, 5272340.5728, 5274340.5728, 5274440.5728, 5274640.5728, 5285140.5728, 5285240.5728, 5277340.5728, 5277540.5728, 5277840.5728, 5278040.5728, 5278040.5728, 5278140.5728, 5278140.5728, 5265540.5728, 5265640.5728, 5266740.5728, 5266740.5728, 5266940.5728, 5268340.5728, 5268440.5728, 5271440.5728, 5271540.5728, 5271540.5728, 5271740.5728, 5272040.5728, 5272340.5728, 5271740.5728, 5272240.5728, 5272240.5728, 5274540.5728, 5275040.5728, 5275340.5728, 5284840.5728, 5284940.5728, 5284940.5728, 5285040.5728, 5285040.5728)

# create data frame
coordinates.df <- data.frame(x = x, y = y)

# add ID column
coordinates.df$ID <- 1:nrow(coordinates.df)
coordinates.df <- coordinates.df[c(3,1:2)]

# convert data frame to sf object
coordinates.sf <- st_as_sf(coordinates.df, coords = c("x", "y"), crs = 25832)

# function for creating ellipses
create_ellipse <- function(center, a = 1400, b = 1000, angle = 225, n = 100) {
  angle_rad <- angle * pi / 180
  angles <- seq(0, 2 * pi, length.out = n)
  ellipse_coords <- cbind(a * cos(angles), b * sin(angles))
  rotation_matrix <- matrix(c(cos(angle_rad), -sin(angle_rad), 
                              sin(angle_rad),  cos(angle_rad)), 
                            nrow = 2)
  rotated_ellipse <- as.matrix(ellipse_coords) %*% rotation_matrix
  x_center <- center[1]
  y_center <- center[2]
  rotated_ellipse <- rotated_ellipse + matrix(c(x_center, y_center), nrow = n, ncol = 2, byrow = TRUE)
  rotated_ellipse <- rbind(rotated_ellipse, rotated_ellipse[1, ])
  st_polygon(list(rotated_ellipse))
}

# create ellipses
ellipses <- st_coordinates(coordinates.sf) %>%
  apply(1, function(p) create_ellipse(p)) %>%
  st_sfc(crs = st_crs(coordinates.sf))

# convert ellipses into sf objects
ellipses.sf <- st_sf(geometry = ellipses)

# plot
ggplot() +
  geom_sf(data = coordinates.sf, color = "black", size = 2) +
  geom_sf(data = ellipses.sf, fill = "blue", alpha = 0.2) +
  theme_minimal() +
  labs(x = "Easting", y = "Northing")

最终结果如下： 在此处输入图片描述

很明显，椭圆是重叠的。只要椭圆的中心不重叠，重叠是可以的。我希望这些图有助于更清楚地说明： 在此处输入图片描述

在第一种情况下，上椭圆不与下椭圆的中心重叠，这是可以的。在这种情况下，两个椭圆都应该保留。在第二种情况下，上椭圆与下椭圆（包括其中心）重叠，这是不行的。在这些情况下，应该删除 ID 较高的椭圆，只留下 ID 较低的椭圆。完全不接触的单个椭圆当然也应该保留。

有人知道如何实现这个吗？

如果有任何问题或不确定性，请随时发表评论。

Martin Hope
Alireza Sadeghi
Asked: 2024-09-11 21:03:40 +0800 CST
  • 9

我通常熟悉。我知道和rvest之间的区别。但我无法解决这个问题：html_elements()html_element()

假设我们有类似此网页上的数据。数据采用分层格式，每个标题都有不同数量的子标题。

当我尝试抓取时，我得到了 177 个标题。但是，副标题实际上有 270 个。我想将数据提取成整齐的格式。但由于向量大小不同，我无法轻松地将它们组合成 tibble。

这是我的代码以及一些关于结果的评论：

page <- read_html("https://postdocs.stanford.edu/about/department-postdoc-admins")

person_departments <- page %>% 
    html_elements(".item-list") %>% 
    html_element("h3") %>% 
    html_text2()
# The above code returns 

person_names <- page %>% 
  html_elements(".item-list li") %>% 
  html_element("h4") %>% 
  html_text2()
# This one returns 270 names (some departments have more than 1 admin)

# Using the above codes, I can't get a nice table with two columns, one for the name and one for the person's department.
Martin Hope
HiroIshida
Asked: 2024-09-11 19:52:08 +0800 CST
  • 9

我最近尝试阅读我的代码的二进制汇编，发现很多浮点运算都是使用 XMM 寄存器和 SSE 指令完成的。例如，以下代码：

float square(float a) {
    float b = a + (a * a);
    return b;
}

将被编译成

        push    rbp
        mov     rbp, rsp
        movss   DWORD PTR [rbp-20], xmm0
        movss   xmm0, DWORD PTR [rbp-20]
        mulss   xmm0, xmm0
        movss   xmm1, DWORD PTR [rbp-20]
        addss   xmm0, xmm1
        movss   DWORD PTR [rbp-4], xmm0
        movss   xmm0, DWORD PTR [rbp-4]
        pop     rbp
        ret

其他编译器的结果也类似。https ://godbolt.org/z/G988PGo6j

并带有-O3旗帜

        movaps  xmm1, xmm0
        mulss   xmm0, xmm0
        addss   xmm0, xmm1
        ret

这是否意味着使用 SIMD 寄存器和指令的操作通常比使用普通寄存器和 FPU 更快？

另外，我很好奇编译器决定使用 SSE 可能会失败的具体情况。

c
Martin Hope
user24758287
Asked: 2024-09-11 12:30:00 +0800 CST
  • 9

我想在 python 的 Polars 库中根据另一列的名称在一列中填充一个值（我通过扩展变量的列名获得了以下 DF）：

输入：

姓名 平均的 中位数 问题 1 多变的
苹果 2 3 4 平均的
苹果 2 3 4 中位数
苹果 2 3 4 问题 1
香蕉 1 5 10 平均的
香蕉 1 5 10 中位数
香蕉 1 5 10 问题 1

预期输出：

姓名 平均的 中位数 问题 1 多变的 价值
苹果 2 3 4 平均的 2
苹果 2 3 4 中位数 3
苹果 2 3 4 问题 1 4
香蕉 1 5 10 平均的 1
香蕉 1 5 10 中位数 5
香蕉 1 5 10 问题 1 10

您可以在此处生成输入表：

test = pl.DataFrame(
    {
        "Name": ["Apple","Apple","Apple","Banana","Banana","Banana"],
        "Average": [2,2,2,1,1,1],
        "Median": [3,3,3,5,5,5],
        "Q1": [4,4,4,10,10,10],
        "Variable":["Average","Median","Q1","Average","Median","Q1"]
    }
)

我尝试过：

df = df.with_columns(value = pl.col(f"{pl.col.variable}"))

但这并不奏效，因为极坐标将参数视为函数 (?)。有人知道怎么做吗？

注意：我还尝试过转置数据框，但这不仅计算成本高昂，而且也不起作用！因为它会将 DF 转置为 5 行长的 DF。我需要的是 (名称 * 变量数) 行长的 DF。

也就是说，例如，我有 3 个不同的名称（比如，苹果、香蕉和火龙果），并且有 3 个变量（平均值、中位数、Q1），那么我的 DF 应该有 9 行长！

python
Martin Hope
lonix
Asked: 2024-09-10 13:13:56 +0800 CST
  • 9

在 C# 12 中有“集合初始化可以简化”分析器IDE0028。

我一直想知道修复程序如何决定何时修复或不修复初始化程序，例如，，，，，等new()。它的修复方法是用 替换合格的初始化程序。new List<string>()new Collection<int>()Array.Empty<double>()new string[] { }[]

例如：

// Collection initialization can be simplified
public List<string> Foo1 { get; } = new List<string>();
public HashSet<string> Foo2 { get; } = new HashSet<string>();
public ICollection<string> Foo3 { get; } = new List<string>();
public Dictionary<int, string> Foo4 = new Dictionary<int, string>();

// Collection initialization can be simplified (may change semantics)
public IEnumerable<string> Bar1 { get; } = new List<string>();
public ICollection<string> Bar2 { get; } = new Collection<string>();

// no code fix offered
public IDictionary<int, string> Baz1 = new Dictionary<int, string>();

我通常会选择适合特定用途的集合类型。因此，我不想盲目接受分析器的建议，而不了解编译器在看到时实际上会使用哪种集合类型[]。

所以：

  • 分析器/修复器如何决定何时建议修复，以及“可能改变语义”到底是什么意思
  • 当编译器/运行时遇到[]
c#
上一页
下一页