All perguntas(coding)

Se eu tentar construir o seguinte código:

fn main () {
    let my_val: u32 = 42;
    
    match my_val % 2 {
        0 => println!("We're even now"),
        1 => println!("Well, that's odd"),
    }
}

Terei a seguinte mensagem de erro:

error[E0004]: non-exhaustive patterns: `2_u32..=u32::MAX` not covered
 --> src/main.rs:4:11
  |
4 |     match my_val % 2 {
  |           ^^^^^^^^^^ pattern `2_u32..=u32::MAX` not covered
  |
  = note: the matched value is of type `u32`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
6 ~         1 => println!("Well, that's odd"),
7 ~         2_u32..=u32::MAX => todo!(),
  |

Eu realmente não entendi. Qual é o caso representado por 2_u32..=u32::MAX?

Tenho um dataframe do Pandas que contém informações do usuário e também uma coluna para suas permissões:

UserName    Permissions
John Doe             02
John Doe             11
 Example             09
 Example             08
   User3             11

Estou tentando criar uma nova coluna chamada User Classque é baseada em suas Permissões (olhando para todas as permissões dos usuários). Se um usuário tiver todas as permissões <10, ele será considerado Admin. Se um usuário tiver todas as permissões >=10, ele será considerado User. No entanto, se ele tiver permissões que sejam <10 e >=10, ele será codificado como Admin/User. Então, minha saída resultante seria:

UserName    Permissions    User Class
John Doe             02    Admin/User
John Doe             11    Admin/User
 Example             09         Admin
 Example             08         Admin
   User3             11          User

Qual seria a melhor maneira de fazer isso? Minha ideia original era fazer:

for UserName, User_df in df.groupby(by='UserName'):
    LT10 = (User_df['Permissions'] < 10).any()
    GTE10 = (User_df['Permissions'] >= 10).any()
    if (LT10 & GTE10):
        UserClass = 'Admin/User'
    elif LT10:
        UserClass = 'Admin'
    elif GTE10:
        UserClass = 'User'
    df.at[User_df.index, 'User Class'] = UserClass

No entanto, isso parece muito ineficiente porque dftem cerca de 800 mil registros

Percebi que definir um estilo de fonte personalizado em um TextField no JavaFX também afetará seu menu de contexto padrão. O que posso fazer para alterar a fonte da entrada do usuário, mas manter os itens de menu no menu de contexto como eles apareceriam normalmente?

.custom-text-field {
  -fx-alignment: center;
  -fx-font-size: 2.5em;
  -fx-font-weight: bold;
  -fx-font-family: monospaced;
}

Estou procurando uma solução no estilo CSS , não quero alterar a fonte no código Java.

A documentação do componente TextField tem sido de pouca utilidade.

Infelizmente , verificar o estilo CSS padrão também não me ajudou caspian.cssmuito.

Tenho o seguinte código para construir o objeto de valor Boost::Json .

void tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AppointmentEnd const& obj)
{
    jv = { { "MridianPatientOid", obj.mridianPatientOid }, { "PdfOids", obj.pdfOids } };
}

Funciona perfeitamente com o Boost versão 1.79.

Estou tentando atualizar a versão 1.86 do Boost, mas está me dando o seguinte erro:

C:\Users\bobef\.conan2\p\b\boost8a406c6ccf4da\p\include\boost\json\impl\value_ref.hpp(36): error C2440: '<function-style-cast>': cannot convert from 'initializer list' to 'boost::json::value'

...

C:\projects\work\mercury\libs\ois-data\code\ois-data\models\states\AppointmentEnd.cpp(16): note: see reference to function template instantiation 'boost::json::value_ref::value_ref<std::vector<std::string,std::allocator<std::string>>>(const T &,void *) noexcept' being compiled
          with
          [
              T=std::vector<std::string,std::allocator<std::string>>
          ]

C:\Users\bobef\.conan2\p\b\boost8a406c6ccf4da\p\include\boost/json/value_ref.hpp(204): note: see reference to function template instantiation 'boost::json::value boost::json::value_ref::from_const<std::vector<std::string,std::allocator<std::string>>>(const void *,boost::json::storage_ptr)' being compiled
  ninja: build stopped: subcommand failed.

Posso usar a seguinte solução alternativa, mas ela é longa e feia.

void tag_invoke(boost::json::value_from_tag, boost::json::value& jv, AppointmentEnd const& obj)
{
  boost::json::object obj_;
  obj_["MridianPatientOid"] = obj.mridianPatientOid;
  obj_["PdfOids"] = array(obj.pdfOids.begin(), obj.pdfOids.end());
  jv = obj_;
}

A versão do compilador que estou usando é Microsoft Visual Studio Community 2022 (64-bit) Version 17.11.2.

Alguém poderia explicar a origem do erro e propor uma solução alternativa mais compacta?

Por que posso passar um array para um método que aceita IList, resultando em erro ao tentar usar esta interface (o array não suporta Add() obviamente)

using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        string[] thisIsArray = ["A", "B"];
        IsThisBug(thisIsArray);
    }
    
    public static void IsThisBug(IList<string> array) {
        array.Add("Hello");
    }
}

No livro C#12 In a Nutshell (p. 259 Capítulo Sobrecarga de verdadeiro e falso), eles nos fornecem este exemplo para ilustrar como sobrecarregar os operadores verdadeiro e falso.

SqlBoolean a = SqlBoolean.Null;
if (a)
    Console.WriteLine ("True");
else if (!a)
    Console.WriteLine ("False");
else
    Console.WriteLine ("Null");

public struct SqlBoolean
{
    public static bool operator true (SqlBoolean x)
    {
        return  x.m_value == True.m_value;
    }

    public static bool operator false(SqlBoolean x)
    {
        return x.m_value == False.m_value;
    }

    public static SqlBoolean operator ! (SqlBoolean x)
    {
        if (x.m_value == Null.m_value) return Null;
        if (x.m_value == False.m_value) return True;
        return False;
    }

    public static readonly SqlBoolean Null = new SqlBoolean (0);
    public static readonly SqlBoolean False = new SqlBoolean (1);
    public static readonly SqlBoolean True = new SqlBoolean (2);

    SqlBoolean (byte value) { m_value = value; }
    byte m_value;
}

Estou tentando entender quando a falsesobrecarga é chamada, e pelo meu entendimento (e confirmando brincando com o depurador), parece que ela nunca é chamada. Por que a falsesobrecarga seria útil então? Já que só usamos while (a)or , etc ... Sobrecarregar and while (!a)não seria o suficiente?true!

Python faz fatiamento por cópia em strings: O Python faz fatiamento por referência em strings?

Isso é algo que todas as implementações do Python precisam respeitar ou é apenas um detalhe da implementação do CPython?

Tenho um arquivo tsv que contém inteiros com separadores de milhar. Estou tentando lê-lo usando polars==1.6.0, a codificação éutf-16

from io import BytesIO
import polars as pl

data = BytesIO(
"""
Id\tA\tB
1\t537\t2,288
2\t325\t1,047
3\t98\t194
""".encode("utf-16")
)

df = pl.read_csv(data, encoding="utf-16", separator="\t")
print(df)

Não consigo descobrir como fazer com que os polares tratem a coluna "B" como um inteiro em vez de uma string, e também não consigo encontrar uma maneira limpa de convertê-la em um inteiro.

shape: (3, 3)
┌────────┬─────┬───────┐
│ Id     ┆ A   ┆ B     │
│ ---    ┆ --- ┆ ---   │
│ i64    ┆ i64 ┆ str   │
╞════════╪═════╪═══════╡
│ 1      ┆ 537 ┆ 2,288 │
│ 2      ┆ 325 ┆ 1,047 │
│ 3      ┆ 98  ┆ 194   │
└────────┴─────┴───────┘

cast falha, assim como passar o esquema explicitamente. Eu também tentei usar str.strip_charse para remover a vírgula, minha solução alternativa é usar str.replace_allem vez disso.

df = df.with_columns(
    pl.col("B").str.strip_chars(",").alias("B_strip_chars"),
    pl.col("B").str.replace_all("[^0-9]", "").alias("B_replace"),
)
print(df)

shape: (3, 5)
┌────────┬─────┬───────┬───────────────┬───────────┐
│ Id     ┆ A   ┆ B     ┆ B_strip_chars ┆ B_replace │
│ ---    ┆ --- ┆ ---   ┆ ---           ┆ ---       │
│ i64    ┆ i64 ┆ str   ┆ str           ┆ str       │
╞════════╪═════╪═══════╪═══════════════╪═══════════╡
│ 1      ┆ 537 ┆ 2,288 ┆ 2,288         ┆ 2288      │
│ 2      ┆ 325 ┆ 1,047 ┆ 1,047         ┆ 1047      │
│ 3      ┆ 98  ┆ 194   ┆ 194           ┆ 194       │
└────────┴─────┴───────┴───────────────┴───────────┘

Além disso, para que isso funcione em geral, preciso garantir que read_csvele não tente inferir tipos para nenhuma coluna, para que eu possa convertê-los manualmente (qualquer coluna numérica com um valor > 999 conterá uma vírgula)

Tenho um dataframe que tem um campo chamado fieldsque é uma lista de dicts (todas as linhas têm o mesmo formato). Aqui está como o dataframe é estruturado:

formId    fields
   123    [{'number': 1, 'label': 'Last Name', 'value': 'Doe'}, {'number': 2, 'label': 'First Name', 'value': 'John'}]

Estou tentando descompactar a fieldscoluna para que fique assim:

formId    Last Name    First Name
   123          Doe          John

O código que tenho atualmente é:

for i,r in df.iterrows():
    for field in r['fields']:
        df.at[i, field['label']] = field['value']

No entanto, isso não parece ser a maneira mais eficiente. Existe uma maneira melhor de fazer isso?

O meu filter_listtem um grande número de elementos. A filtragem abaixo funciona, mas como alguém tornaria a dplyr::filtermais concisa?

Não consegui all_oftrabalhar.

filter_list <- list(
  hair_color = c("blond", "brown"),
  skin_color = "light"
)

dplyr::starwars |> 
  dplyr::filter(
    hair_color %in% filter_list[["hair_color"]],
    skin_color %in% filter_list[["skin_color"]]
  )