Início / coding / 问题

All perguntas(coding)

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

Estou recebendo os seguintes erros ao tentar distribuir meu aplicativo para o TestFlight:

insira a descrição da imagem aqui

O que tentei até agora:

  • Verifiquei a opção ENABLE_BITCODE no XCode e ela está definida como "NÃO" para depuração e lançamento.
  • Verifiquei o DEBUG_INFORMATION_FORMAT e ele está definido como "DWARF com arquivo dSYM" para depuração e lançamento
  • Tentei com esse comando que achei como solução mas não funcionou:

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

Estou confuso sobre o que usar, se devo usar atualização ou cópia para alterar/atualizar o estado da interface do usuário no Jetpack Compose.

Alguns dizem para usar

_uiState.update {
    it.copy()
}

Alguns dizem para usar

_uiState.value = _uiState.value.copy()

Qual seria melhor usar e por quê?

Já usei copy()muitas vezes, mas ainda não tenho certeza se estou atualizando o uiState de forma eficiente ou adequada.

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

Estou tentando escrever uma logging.Loggersubclasse personalizada que está funcionando, mas tenho problemas ao tentar usar uma logging.Formatterque inclui o valor interpolado %(filename)no formato personalizado. Ela imprime o nome do arquivo onde está minha subclasse personalizada, em vez do nome do arquivo do código que chamou a função de registro.

Encontrei vários tutoriais para subclassificar Logger, mas nenhum deles aborda os efeitos que isso tem na interpolação de nome de arquivo. Existe uma solução direta para isso sem ter que sobrescrever grandes seções de logging.Logger?

Código de exemplo definindo meu registrador personalizado:

#-------------------------------------
# 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())

Saída esperada: >>> test.py - hello world

Produção real: >>> custom_logger.py - hello world

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

Considere as três listas de exemplos a seguir:

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" };

Observe que cada elemento em archivedFilesé o caminho completo de um arquivo ZIP, cujo nome começa com o patientIDque está em localPatientsIDsou remotePatientsIDs.

Por exemplo: @"G:\Archive\000-007_20230526175817297.zip": o nome do arquivo 000-007_20230526175817297.zipinicia com 000-007, que é um elemento na lista remotePatientsIDs.

Um patientID não pode estar em localPatientsIDse archivedFilessimultaneamente, portanto, nenhuma duplicata é permitida entre essas duas listas. No entanto, o archivedFilespode conter patientIDs que também estão localizados em remotePatientsIDs.

Preciso obter os elementos em archivedFilescujos nomes de arquivo começam com os elementos presentes em remotePatientsIDsmas não presentes em localPatientsIDs. O ponto final é descompactar esses arquivos para o diretório que contém localPatientsIDso banco de dados.

Para o exemplo dado, eu esperaria ter o seguinte resultado:

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

Então, como posso usar o LINQ para fazer isso?

Na minha falta de conhecimento, eu esperaria que fosse tão simples quanto:

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

Não consigo nem compilar isso, pois Containsprovavelmente não consigo iterar sobre os membros da lista e recebo a mensagem:

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

Então meu melhor teste até agora é a seguinte frase (confesso que parece um pouco confusa para mim). Ela sempre retorna uma lista vazia.

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

Encontrei estas postagens úteis que me ajudaram a entender melhor as diferenças entre Wheree Select:

Além disso, estou procurando instruções sobre como usar LINQ em:

e outros links também, mas ainda não consigo encontrar uma solução que funcione.

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

Tenho 2 conjuntos de dados:

O primeiro descreve o que espero:

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

e o segundo descreve o que observo:

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

Quero combinar todas as minhas observações com descrições baseadas na ordem que espero. Mas, uma vez que vejo uma inconsistência, nada mais deve combinar.

Consegui encontrar a primeira inconsistência como:

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  │
└─────────────┴──────┘
"""

Como posso propagar isso nullapós a primeira inconsistência?

Além disso, meus dados reais têm uma idcoluna adicional, onde cada um idé um caso como descrito acima, e independente de outros ids. É possível de alguma forma "agrupar por id" e aplicar essa lógica de uma só vez em vez de trabalhar com cada um idseparadamente:

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

Aqui está um código que cria elipses de 1400 m de comprimento no eixo principal e 1000 m no eixo lateral. Cada elipse é atribuída com um 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")

Aqui está o gráfico resultante: insira a descrição da imagem aqui

É óbvio que há elipses sobrepostas. Sobreposições são ok, desde que o centro de uma elipse não seja sobreposto. Espero que essas figuras ajudem a deixar isso mais claro: insira a descrição da imagem aqui

No primeiro caso, a elipse superior não está sobrepondo o centro da inferior, o que é bom. Neste caso, ambas as elipses devem ser mantidas. No segundo caso, a elipse superior está sobrepondo a inferior, incluindo seu centro, o que não é bom. Nestes casos, a elipse com o ID mais alto deve ser removida, de modo que somente a elipse com o ID mais baixo permaneça . Elipses individuais que não se tocam em nada devem, é claro, também ser mantidas.

Alguém tem alguma ideia de como conseguir isso?

Caso tenha alguma dúvida ou incerteza, não hesite em escrever um comentário.

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

Estou geralmente familiarizado com rvest. Sei a diferença entre html_elements()e html_element(). Mas não consigo entender esse problema:

Suponha que temos dados como os que estão nesta página da web . Os dados estão em um formato hierárquico e cada cabeçalho tem um número diferente de subtítulos.

Quando tento raspar, obtenho 177 cabeçalhos. Mas, os subtítulos são, na verdade, 270. Quero extrair os dados em um formato organizado. Mas com tamanhos de vetores diferentes, não consigo combiná-los facilmente em um tibble.

Aqui está meu código com alguns comentários sobre os resultados:

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

Recentemente, tentei ler assemblies do binário do meu código e descobri que muitas operações de ponto flutuante são feitas usando registradores XMM e instruções SSE. Por exemplo, o código a seguir:

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

será compilado em

        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

e o resultado é semelhante para outros compiladores. https://godbolt.org/z/G988PGo6j

E com -O3bandeira

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

Isso significa que as operações que usam registradores e instruções SIMD são geralmente mais rápidas do que usar registradores normais e a FPU?

Também estou curioso sobre casos específicos em que a decisão do compilador de usar SSE pode falhar.

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

Gostaria de preencher um valor em uma coluna com base no nome de outra coluna, na biblioteca Polars do python (obtive o seguinte DF explodindo os nomes das colunas das minhas variáveis):

Entrada:

Nome Média Mediana Q1 Variável
Maçã 2 3 4 Média
Maçã 2 3 4 Mediana
Maçã 2 3 4 Q1
Banana 1 5 10 Média
Banana 1 5 10 Mediana
Banana 1 5 10 Q1

Saída esperada:

Nome Média Mediana Q1 Variável Valor
Maçã 2 3 4 Média 2
Maçã 2 3 4 Mediana 3
Maçã 2 3 4 Q1 4
Banana 1 5 10 Média 1
Banana 1 5 10 Mediana 5
Banana 1 5 10 Q1 10

Você pode gerar a tabela de entrada aqui:

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"]
    }
)

Eu tentei:

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

Mas isso não funciona porque polars percebem o argumento como uma função (?). Alguém sabe como fazer isso?

Nota: Eu também tentei transpor o dataframe, o que, além de ser computacionalmente caro, também não funcionou! Porque ele transporia o DF para um DF de 5 linhas. O que eu preciso é de um DF de (Nome * Número de Variáveis) linhas.

Ou seja, por exemplo, se eu tiver 3 nomes diferentes (por exemplo, Maçã, Banana e Fruta do Dragão) e 3 variáveis ​​(Média, Mediana, Q1), meu DF deverá ter 9 linhas de comprimento!

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

No C# 12, há o analisador "A inicialização da coleção pode ser simplificada" IDE0028 .

Estou me perguntando como o fixador decide quando corrigir ou não inicializadores como new(), new List<string>(), new Collection<int>(), Array.Empty<double>(), new string[] { }, etc. A correção é substituir um inicializador qualificado por [].

Por exemplo:

// 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>();

Geralmente escolho um tipo de coleção que se adapta a um propósito específico. Então, não quero aceitar cegamente a recomendação do analisador sem entender qual tipo de coleção o compilador realmente usará quando vir [].

Então:

  • Como o analisador/fixador decide quando sugerir uma correção e o que exatamente significa "pode ​​alterar a semântica"
  • Que tipo de coleção o compilador/tempo de execução realmente usa quando encontra[]
c#
Prev
Próximo