Julia tem duas sintaxes para construir tuplas nomeadas.

A primeira sintaxe usa pares de chaves e valores dentro de parênteses, sem ponto e vírgula.

named_tuple = (a=1, b=2, c=3)

A segunda forma da sintaxe usa um ponto e vírgula inicial.

named_tuple = (; a=1, b=2, c=3)

Pelo que posso perceber pela documentação, ambos os formulários produzem o mesmo resultado. (Um NamedTupleobjeto.)

Não parece haver nenhuma diferença entre os dois formulários a seguir.

julia> tuple1 = (a=1, b=2, c=3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple1)
@NamedTuple{a::Int64, b::Int64, c::Int64}

julia> tuple2 = (; a=1, b=2, c=3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple2)
@NamedTuple{a::Int64, b::Int64, c::Int64}

Parece ser possível criar um NamedTuplea partir de uma série de pares, mas somente se o ponto e vírgula for incluído.

Em outras palavras, essa sintaxe é válida e produz o resultado esperado

julia> tuple3 = (; :a=>1, :b=>2, :c=>3)
(a = 1, b = 2, c = 3)

julia> typeof(tuple3)
@NamedTuple{a::Int64, b::Int64, c::Int64}

por outro lado, o seguinte não

julia> tuple4 = (:a=>1, :b=>2, :c=>3)
(:a => 1, :b => 2, :c => 3)

julia> typeof(tuple4)
Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}}

Isso produz um Tuplede Pairem vez de um NamedTuple.

Qual é a finalidade de cada formulário ou o motivo de ter dois formulários diferentes?

Estou tentando usar um sinalizador booleano para sinalizar que um thread deve sair. No entanto, atualmente meu código viola as regras do verificador de empréstimo. Eu entendo por que ele viola essas regras, no entanto, o que eu não sei é qual é o design mais apropriado e como isso pode corrigir o problema.

fn long_running(exit_flag: &bool) {

    loop {
        std::thread::sleep(std::time::Duration::from_secs(10));

        if *exit_flag {
            break;
        }
    }
}

fn main() {

    let mut exit_flag = false;
    std::thread::scope(
        |scope| {
            let handle = scope.spawn(
                || {
                    long_running(&exit_flag); # (1)
                }
            );

            exit_flag = true; # (2)

            // terminate the consumer poll loop
            handle.join().expect("failed to join thread");
        }
    );
}

O problema envolve as linhas marcadas com # (1)e # (2).

• # (1): A referência a exit_flagé emprestada
• # (2): Tentando mutar a variável subjacente enquanto a referência ainda está emprestada

Isso não é permitido devido às regras do verificador de empréstimos.

• Uma solução para o problema pode ser alocar o sinalizador em heap e usá-lo para compartilhar os dados entre os dois threads.
• Entretanto, a intenção de uso std::thread::scopeera permitir o lançamento de um thread que tenha acesso a uma variável local da pilha do thread pai (principal).

a propósito, tive a ideia de fazer isso neste tópico

• Como posso passar uma referência a uma variável de pilha para um thread?

A maioria dos exemplos que mostram a desserialização de JSON com Rust serde_jsonmostram a desserialização em um formato de estrutura conhecido, usando um struct.

É possível desserializar um documento JSON com uma estrutura desconhecida em um tipo de dado Rust genérico que pode lidar com essa variação estrutural?

Por exemplo, eu tentei algo assim

let filename = "example.json";
let maybe_ifile = std::fs::File::open(filename);

match maybe_ifile {
    Ok(ifile) => {
        let maybe_json_data = serde_json::from_reader::<_, BTreeMap<String, String>>(ifile);

        match maybe_json_data {
            Ok(json_data) => {
                println!("{json_data:?}");
            }

            Err(error) => {
                panic!("{error}")
            }
        }
    }

    Err(error) => {
        panic!("{error}");
    }
}

Isso funciona se o documento JSON for estruturado como pares de strings de chave-valor, mas não funciona para estruturas mais gerais, então claramente usar BTreeMap<String, String>não é a abordagem correta aqui.

O que estou tentando alcançar é flexibilidade usando tipos de tempo de execução/um tanto dinâmicos.

Isso é possível em outras linguagens, então presumo que haja uma solução bastante trivial em Rust, só não sei qual é.

Quero escrever uma função em Julia que mescle dois dicionários.

function merge(left::Dict, right::Dict)::Dict

A semântica é a seguinte:

• As entradas são lefteright
• Ambos lefte rightassumiram a propriedade de seus dados, o que significa que eles serão modificados após a chamada da função e nenhuma garantia sobre os dados que eles contêm deve ser feita
• O valor de retorno contém os dados de ambos os dicionários
• Se alguma chave estiver presente em ambos lefte righto valor de leftfor mantido

Aqui está uma ideia inicial sobre como abordar esse problema. (Este é um pseudocódigo com notas, não algo que realmente será compilado.)

function mergeDict(left::Dict, right::Dict)::Dict

    # create a new dictionary from `left`
    return_value = left

    # move data from `right` to `left`, "no-clobber"
    for k, v in pop_next!(right)
    # the function `pop_next!` does not exist, no iterator-like `pop!`

    for k in keys(right)
        v = pop!(right, k)
        # does this work as expected? destructive operation while reading keys?
        # `keys()` returns an *iterator*, not a collection! (?)

        if !haskey(left, k)
            push!(left, k, v) # no `push!` function
            left[k] = v # this works instead
        end
    end
    
    # `left` and `right` are not pointers, but "copy-by-value references"
    # just as in Python, so this doesn't work
    left = nothing
    right = nothing

    # we want to invalidate the data, how to do that?
    # this also won't work because `left` references the same data
    # structure as `return_value`
    clear(left)
    clear(right)
end

Você pode ver que eu tentei escrever uma implementação manual. Tenho quase certeza de que Julia terá algumas funções úteis como parte da biblioteca padrão para implementar isso, no entanto, sendo novo em Julia, não sei o que elas podem ser.

Encontrei as funções merge, mergewith, merge!e , mergewith!no entanto nenhuma delas parece ter a semântica descrita acima.

Quero realizar uma operação de comparação entre um arquivo que existe no disco e um arquivo que não existe mais porque eu o movi.

Aqui está a situação.

• Eu tinha um arquivo que existia em uma pasta. Vamos chamá-lo de ./src/A.txt.
• Mudei A.txtpara uma nova pasta. Agora ela se chama ./doc/A.txt.
• Eu editei ./doc/A.txt.

Agora quero comparar ./doc/A.txtcom o estado do ./src/A.txtque existe no branch origin/main. Claro, esse arquivo não existe realmente no diretório de trabalho atual.

Acredito que uma maneira possível de fazer isso seria fazer o seguinte:

• git checkout origin/main ./src/A.txt
• git diff ./src/A.txt ./doc/A.txt

(Edição: Não, isso não funciona. Use diff ./src/A.txt ./doc/A.txtem vez disso.)

Existe uma maneira de fazer isso "diretamente"?

Talvez algo como

git diff ./src/A.txt@origin/main ./doc/A.txt

Não entendo completamente qual é a diferença entre as expressões quote ... ende :( ... )em Julia.

Parece que a única diferença é que o primeiro ( quote) introduz linhas de comentários adicionais.

• A diferença é tão simples assim ou há mais do que isso?
• Qual é o propósito dessas linhas de comentários? O que elas fazem, ou, dito de outra forma, por que você usaria uma em vez da outra?

Aqui estão alguns exemplos

julia> :(2+2)
:(2 + 2)

julia> e1=:(2+2)
:(2 + 2)

julia> e1
:(2 + 2)

julia> eval(e1)
4

julia> quote
           2+2
       end
quote
    #= REPL[2]:2 =#
    2 + 2
end

julia> e2=quote
           2+2
       end
quote
    #= REPL[5]:2 =#
    2 + 2
end

julia> e2
quote
    #= REPL[5]:2 =#
    2 + 2
end

julia> eval(e2)
4

Eu encontrei este wikibook , mas ele só diz que

os números de linha úteis que foram adicionados a cada linha da expressão citada

(referindo-se a quotecomparado a :).

As páginas de documentação para expressões de palavras-chave também não diziam muito.

Diferentemente de outros meios de citação, :( ... ), esta forma introduz elementos QuoteNode na árvore de expressão, o que deve ser considerado ao manipular diretamente a árvore.

O que isto significa?

Estou tentando selecionar linhas de um DataFrame do Pandas, usando valores de índice inteiro.

Isso não funciona e obtenho erros de índice.

• Isso me sugere que realizar uma seleção de linhas por índice faz com que reset_index()seja chamado implicitamente, embora eu possa estar enganado
• O exemplo a seguir explica por que o comportamento que observo sugere que esse seja o caso

import pandas

data = {
    'number': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'fruit': 3 * ['apple'] + 3 * ['pear'] + 2 * ['banana'] + ['pear'] + ['apple'],
    'color': 3 * ['red', 'green', 'blue'] + ['red'],
    'letter': 5 * ['A', 'B'],
}
df = pandas.DataFrame(data)
df

df_selected = df[df['fruit'] == 'pear']
df_selected

df_selected.index
Index([3, 4, 5, 8], dtype='int64')

Isto certamente sugere que tenho um DataFrame com um índice contendo os valores 3, 4, 5 e 8.

Agora quero selecionar todas as linhas no DataFrame desde a primeira ocorrência de 'pear' até a última ocorrência, usando o índice inteiro :

Achei que isso deveria ser possível com a seguinte sintaxe:

FIRST = 3
LAST = 8
df_selected[FIRST:LAST+1]

Mas estou enganado:

• Ao imprimir (exibindo o DataFrame stdoutou uma célula do Jupyter Notebook), o índice mostra valores 3, 4, 5, 8.
• Ao selecionar por índice usando a sintaxe df_selected[A:B]ou df_selected.iloc[A:B]os argumentos inteiros Ae Bsão interpretados como se df_selected.reset_index()tivessem sido chamados
• Digo isso porque a chamada reset_index()produz a seguinte saída

O que implica que o intervalo correto a ser usado ao selecionar por índice édf_selected.iloc[0:3+1]

Estou ciente de que esta é uma pergunta incrivelmente básica, mas espero que alguém possa me indicar a direção certa para entender por que o comportamento é assim, se houver uma razão específica para isso.

Muitas linguagens fornecem uma biblioteca padrão que fornece um tipo de dicionário ou mapa de árvore binária. Muitas dessas implementações de estruturas de dados fornecem uma função para dividir a estrutura de dados em um par de estruturas de dados com base em alguma condição.

Isso é conhecido como operação de partição. Rust chama isso de "separação". Os tipos C++ maptêm operação de "limite inferior" e "limite superior" para comparação com chaves. A biblioteca padrão também fornece uma operação de "partição" que existe no std::algorithm.

Não consigo ver uma maneira ideomática de fazer isso em Python. Consegui criar uma maneira manual de fazer isso, mas não gosto muito desse código, porque ele não divide um dictem duas partes, mas divide uma parte e depois divide outra parte, resultando em código frágil (e duplicado).

map = {
   ...
}

map_part_1 = {
    key: value for key, value in map.items() if <condition>
}

map_part_2 = {
    key: value for key, value in map.items() if not <condition>
}

Não é ótimo, certo? Existe uma maneira melhor?

Estou vendo um problema um pouco irritante ao plotar alguns dados com o matplotlib.

Conforme mostrado no exemplo de saída abaixo, o eixo x tem um formato ligeiramente inesperado.

Os rótulos são (por exemplo) 04 12:30. Sendo 04o dia do mês.

O código e os dados são fornecidos para reproduzir esta figura, anexados ao final desta questão.

Por que o eixo x está sendo formatado assim e o que posso fazer para "consertar" isso? (Não quero que o dia do mês seja mostrado e, especialmente, não quero que seja formatado como "04".)

Código

Para executar o código:python3 example.py

# example.py

import matplotlib.pyplot as plt
import pandas

df = pandas.read_json('data.json')

print(df.head())

fig, ax1 = plt.subplots(figsize=(12, 8))
ax1.plot(df['column_name'], label='My data')
ax1.set_xlabel('Timestamp')
ax1.set_ylabel('Value')
ax1.grid(True)
ax1.legend()

plt.title('Example')
plt.tight_layout()
plt.savefig('example.png')

Dados

Salve este arquivo comodata.json

{"column_name":{"1649073600000":174.79,"1649073660000":174.8,"1649073720000":174.79,"1649073780000":174.76,"1649073840000":174.69,"1649073900000":174.7,"1649073960000":174.69,"1649074020000":174.65,"1649074140000":174.67,"1649074200000":174.7,"1649074260000":174.74,"1649074320000":174.65,"1649074380000":174.69,"1649074440000":174.65,"1649074500000":174.7,"1649074560000":174.74,"1649074680000":174.72,"1649074740000":174.7,"1649074860000":174.7,"1649074920000":174.71,"1649074980000":174.75,"1649075040000":174.76,"1649075100000":174.73,"1649075160000":174.76,"1649075220000":174.7,"1649075280000":174.66,"1649075340000":174.61,"1649075400000":174.63,"1649075460000":174.65,"1649075520000":174.7,"1649075580000":174.69,"1649075640000":174.63,"1649075760000":174.66,"1649075820000":174.63,"1649075880000":174.58,"1649075940000":174.5,"1649076000000":174.52,"1649076060000":174.55,"1649076120000":174.55,"1649076180000":174.54,"1649076240000":174.48,"1649076300000":174.45,"1649076360000":174.38,"1649076420000":174.22,"1649076480000":174.21,"1649076540000":174.15,"1649076660000":174.25,"1649076720000":174.3,"1649076780000":174.28,"1649076840000":174.26,"1649076900000":174.25,"1649076960000":174.23,"1649077020000":174.21,"1649077080000":174.25,"1649077140000":174.26,"1649077200000":174.27}}

Eu tenho uma instrução SQL como esta:

insert into table1 (col1, col2, col3, col4)
select
    value1,
    value2,
    now(),
    now()
from
    othertable inner join anotherothertable on somecolumn = someothercolumn;

O selectcomponente desta consulta retornará centenas de milhares de linhas.

Como a chamada se now()comportará?

• Ele retornará o mesmo valor para todas as inserções de linhas?
• Ele retornará o mesmo valor na mesma inserção, visto que parece ser chamado duas vezes por inserção de linha única?

Quero realizar esta inserção de forma que now()seja chamada uma vez, e esse valor seja fixo e usado ao inserir todas as linhas e dados. Não tenho certeza se esta consulta se comportará dessa maneira ou não.

Como não há como fazer algo como current_timestamp = now()no SQL e usar current_timestampcomo argumento no lugar das duas chamadas para now(), não sei como fazer isso.

Eu tenho um código Python contendo as seguintes linhas:

# Poisson model

lambda_param = 3.0

x_model = numpy.linspace(0, 10, num=11, dtype=int)
y_model = numpy.zeros(10)

index = 0
for x in x_model:
    y_model[index] = numpy.power(lambda_param, x) / math.factorial(x) * numpy.exp(-lambda_param)
    index += 1

Quero escrever isso de uma forma mais pitônica - sem usar um loop for.

Eu tentei isso:

y_model = numpy.power(lambda_param, x_model) / math.factorial(x_model) * numpy.exp(-lambda_param)

Mas isso não pareceu funcionar, eu acho, porque math.factorialnão sabe como operar em um objeto semelhante a um array.

Existe uma maneira de fazer isso?

Eu escrevi a seguinte função Rust, que contém um encerramento.

    fn has_a_none_element(&self) -> bool {

        let elements_is_none =
            self.elements.iter().flatten().map(Option::is_none);

        let optional_any_is_none =
            elements_is_none.reduce(
                |lhs, rhs| {
                    lhs || rhs
                }
            );

        match optional_any_is_none {
            
            None => false,
            Some(any_is_none) => any_is_none,
        }
    }

self.elementsé do tipo Vec<Vec<Option<f64>>>, embora isso não seja particularmente importante.

O que importa é o fechamento:

|lhs, rhs| {
    lhs || rhs
}

Esta é uma função "Ou". É o tipo de coisa que se poderia esperar que já existisse uma função embutida para a qual poderia ser usada como parte de um encerramento.

Será que tal coisa existe?