All perguntas(coding)

import requests
import json
url = "https://betkarma.com/api/propsComparison?startDate=2023-10-17&endDate=2023-10-23&league=nfl"
response = requests.get(url)
data = response.json()
print(response)

for player_name in data["games"][0]["offers"][0]["player"]:
    if offers[0] == "player":
        value = player["value"] 
break
print(player_name)

O código acima parece estar correto; no entanto, certamente algo está faltando no código abaixo. Estou esperando o nome e o sobrenome de cada participante, mas estou apenas recebendo a primeira letra do nome da primeira pessoa retornada por algum motivo. Qualquer ajuda é muito apreciada. Não tenho certeza se não estou exibindo a coisa correta, se algum código está faltando ou o que preciso fazer para obter uma lista de nomes. Eu sou um novato em python!

Estou usando lambdas em vez de uma classe comparadora para meu conjunto, mas estou tendo problemas.

Eu tenho algo assim:

class Processor {
    
private:
    const function<bool(std::string, std::string)> _lenComp = [](string a, string b) { return a != b && a.size() >= b.size(); };
    set<string, decltype(_lenComp)> _inputSet;

// ...
    
public:
    Processor() : _inputSet() {
    }

    void addLine(string line) {
        _inputSet.insert(line);
    }
    

Quando crio uma Processorinstância e chamo addLine2 vezes, recebo uma exceção de chamada de função incorreta. Como inicializo corretamente esta classe?

Eu tenho uma função que faz referência a a T*: void f(T *&t);. Quando eu o chamo com uma expressão condicional com throw, f(t == nullptr ? throw "nullptr" : t)o programa falha ao compilar:

error: cannot bind non-const lvalue reference of type 'T*&' to an rvalue of type 'T*'
note:   initializing argument 1 of 'f(T*&)'

No entanto, substituir a chamada acima por f(t)compila perfeitamente.

Por que é que? A expressão inteira deve ter o mesmo tipo que o operando não lançado: https://en.cppreference.com/w/cpp/language/operator_other . Do link,Either E2 or E3 (but not both) is a (possibly parenthesized) throw-expression. The result of the conditional operator has the type and the value category of the other expression.

Exemplo reproduzível: https://godbolt.org/z/9MW1Kevxz

#include <iostream>
using namespace std;

struct T {
  int i;  
};

void f(T*& t) { 
    t->i = 2; 
}

int main()
{
    T *t = new T{5};
    f(t == nullptr ? throw "hi" : t);
    return 0;
}

Falha com gcc 9.4 em x86-64.

Estou tentando usar o novo S7 OOP que está sendo apresentado ao R ( https://github.com/RConsortium/S7 ). Eu gostaria de usar o S7 para agrupar um método S3 para o operador unário |.

Tenho um objeto class "ggsurvfit"e gostaria de definir três novos métodos:

`|`(ggsurvfit, ggsurvfit)
`|`(ggsurvfit, ggplot)
`|`(ggplot, ggsurvfit)

Algumas semanas atrás, tive a sorte de estar na mesma sala com Hadley Wickham (que faz parte da equipe R Consortium que desenvolve o S7) e ele gentilmente me forneceu o código abaixo para encapsular o método S3 usando S7. (Eu adicionei a string de texto retornada para sua informação)

method(`|`, list(new_S3_class("ggsurvfit"), new_S3_class("ggsurvfit"))) <- function(e1, e2) { 
  "This is ggsurvfit|ggsurvfit"
}
method(`|`, list(new_S3_class("ggsurvfit"), new_S3_class("ggplot"))) <- function(e1, e2) { 
  "This is ggsurvfit|ggplot"
}
method(`|`, list(new_S3_class("ggplot"), new_S3_class("ggsurvfit"))) <- function(e1, e2) { 
  "This is ggplot|ggsurvfit"
}

O problema que estou tendo é que não consigo iniciar/acionar esses métodos. No exemplo abaixo, eu esperava/esperava que a operação retornasse a string "This is ggsurvfit|ggplot". O que estou perdendo aqui? OBRIGADO!

library(ggsurvfit)
#> Loading required package: ggplot2

S7::method(`|`, list(S7::new_S3_class("ggsurvfit"), S7::new_S3_class("ggplot"))) <- function(e1, e2) { 
  "This is ggsurvfit|ggplot"
}

plot1 <- 
  survfit2(Surv(time, status) ~ sex, data = df_lung) |> 
  ggsurvfit() +
  add_risktable()
class(plot1)
#> [1] "ggsurvfit" "gg"        "ggplot"

plot2 <- 
  ggplot(mtcars, aes(mpg, cyl)) +
  geom_point()
class(plot2)
#> [1] "gg"     "ggplot"

ret <- plot1 | plot2
#> Error in plot1 | plot2: operations are possible only for numeric, logical or complex types

^{Criado em 10/10/2023 com reprex v2.0.2}

Eu tenho a seguinte sequência de números

dat = c(-0.958694836980719, -0.105869068515775, -0.980669802804642, 
0.028491800336812, -0.635061963060457, 0, -0.930716072199491, 
0, 0.588929981219519, 0, 0.282785133581983, 0.611611557545295, 
0.0378059192851003, -0.797706616778708, 0, 0, 0, 0, 0.517465164205096, 
0, -0.488017358301909, 0, 0, -0.25055111810459, -0.649502253262175, 
-0.665111940088685, 0, 0.0833606598934977, -0.514514991719384, 
0.317596020495366, 0.794602807208168, 0, 0, -0.694999957450694, 
0.68257063515541, 0, -0.624026837516857, 0, 0, 0.450339396971535, 
-0.0302201203415504, -0.579393349186543, -0.844405771995823, 
0.315863139331068, -0.171564746000156, -0.0996391017024767, 0, 
0.0838315913186335, -0.36374768393003, 0, -0.572951822576261, 
-0.352439656458088, -0.637019777744324, 0, 0, -0.0952080968332089, 
0.617610001126072, -0.0816285346831291, 0.365239637846338, -0.0470848081799582, 
-0.925681187001364, 0, 0, 0.516154738675926, 0, 0.335416263139046, 
0.532290710398372, 0.18945326903775, 0.288998846320578, 0.125846440933334, 
-0.279555383136218, -0.456389602581116, -0.716237311784933, -0.0920396169199712, 
-0.2813560662731, 0.345024808219092, 0.338383493565635, 0.0058064242368383, 
0, 0.967537135446715, 0, 0.875822485251258, -0.431060076692186, 
-0.822882194591966, -0.62446221874739, -0.348475036137595, 0, 
0, 0.560600291351039, -0.855141781405395, 0, -0.706490388562219, 
0, -0.0451735735541755, 0.113810585454296, 0, -0.283307362362865, 
0.557656832607336, 0, 0, -0.909282421745824, -0.638976539326668, 
0.393719257131686, 0.301397306195678, 0, -0.74000532620085, 0.831188707386854, 
0.786577908437602, 0.296505948686095, 0.139539200765132, 0.88548929301196, 
0, 0.416614048955629, -0.316088049464881, 0, -0.323222691008726, 
-0.227387382853164, -0.562929988503375, 0, 0.283457267127375, 
0.713770547038207, 0.390959387881678, 0, 0, 0, 0.130514217066274, 
0.511687471126713, 0, 0.259730193040464, 0.741689274343481, -0.775924686373506, 
-0.495098678357968, 0.284476197633141, -0.900591805602638, -0.276707687274933, 
-0.191991699142624, 0, -0.916979262244761, 0.769473198941637, 
-0.241554713076157, 0, 0, 0, -0.231727168460227, -0.761155897450598, 
-0.678432614215555, -0.934782559884297, 0, 0, -0.314088267640064, 
0.186322473577494, 0, -0.235062452954516, 0, -0.314446614967701, 
-0.290302655565895, 0, 0, 0.144997859475891, 0, -0.840827052729484, 
0.88274732032249, 0.228399769981503, 0, 0.109512538112691, 0.671159365334607, 
0, 0, 0.0383683666391103, -0.798745428998881, 0, 0, 0, 0.244742671600118, 
-0.567358245295884, 0.509559617984882, 0.909915275452086, 0, 
0.904785111614818, 0, 0.207396095012435, 0, -0.156956691582582, 
0.776618542355675, -0.555791786131894, 0, 0.932355178469579, 
0.429624993163275, 0.0220608551322564, 0.146385826283492, 0, 
0.111119149224947, 0, 0.200025553735095, -0.429542452648371, 
-0.0528214778849886, 0, 0.353971870563417, 0, 0.768878060423797
)

Estou tentando calcular, por mais que 'n' consecutive zerostenham ocorrido muitas vezes na sequência acima.

Existe alguma função direta disponível em R para conseguir o mesmo?

Este é o exercício em questão

Defina a função compose :: [a → a] → (a → a), que compõe uma lista de funções em uma única função, assim, por exemplo: compose [f0,f1,f2] x = f0 (f1 (f2 x))

O que eu codifiquei é assim

compose :: [a -> a] -> (a -> a)
compose (f:fs) = f . (compose fs)

Agora preciso retornar de algo se o argumento [a -> a] estiver vazio, mas não sei o quê. Então, por caso compose [].

Desde já, obrigado!

Eu tenho um DataFrameassim:

index B
0     1
1     2
2     5
3     6
4     7
5     10

E preciso mesclar as linhas onde a diferença é menor ou igual a 2, selecionar a linha com o valor menor e definir a contagem de mesclagens

O resultado deve ser assim:

index B count
0     1   2
1     5   3
2     10  1

Como isso pode ser resolvido usando pandas?

Peço desculpas se já foi perguntado, mas estou tentando "mudar" a ordem dos dígitos dos números em um vetor.

Tomemos como exemplo este vetor:

vector = c("5213456","17235896","23731074")

Eu gostaria de ter resultados da seguinte forma:

"1234556","12356789","01233477"   

Eu sei que é um pouco estranho perguntar isso, mas tenho combinações de números em uma coluna do meu dataframe e localizei alguns casos duplicados, mas não podem ser filtrados com uma função simples () ou outra coisa, pois os dígitos não são ordenados da mesma forma. caminho.

Muito obrigado.

Dado um vetor de números complexos, quero obter seus valores absolutos:

std::vector<std::complex<double>> in; // filling omitted
std::vector<double> out(in.size());
std::transform(in.begin(), in.end(), out.begin(),
                 &std::abs<std::complex<double>> // (1)
//                 [](std::complex<double> z){ return std::abs(z); } // (2)
               );

No meu entendimento, as linhas (1) e (2) deveriam ter o mesmo efeito.

No entanto, enquanto a linha (2) é compilada corretamente, a linha (1) produz um erro:

../../../include/c++/12/bits/stl_algo.h:4263:31: error: cannot convert 'std::complex<double>' to 'double' in assignment
 4263 |         *__result = __unary_op(*__first);
      |                     ~~~~~~~~~~^~~~~~~~~~
      |                               |
      |                               std::complex<double>

Por que recebo esse erro? Por que a função anônima é necessária aqui?

No pacote dplyr do R, existe a opção .keep = "unused"de criar novas colunas com a função mutate()(que é equivalente a assign).

Um exemplo, para quem ainda não usou:

> head(iris)
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

# any column used in creating `new_col` is dropped afterwards automatically
> mutate(.data = head(iris), new_col = Sepal.Length + Petal.Length * Petal.Width, .keep = "unused")
  Sepal.Width Species new_col
1         3.5  setosa    5.38
2         3.0  setosa    5.18
3         3.2  setosa    4.96
4         3.1  setosa    4.90
5         3.6  setosa    5.28
6         3.9  setosa    6.08

Eu digo que eles são equivalentes, mas não parece haver a opção de fazer isso assignna documentação do Pandas , então presumo que não exista. Eu estava curioso em criar uma maneira de fazer algo semelhante.

Uma maneira de fazer isso é criar uma lista de nomes com antecedência e eliminá-los depois, assim:

from sklearn import datasets
import pandas as pd

used_columns = ['sepal length (cm)', 'petal length (cm)', 'petal width (cm)']

iris = pd.DataFrame(datasets.load_iris().data, columns=datasets.load_iris().feature_names)

iris.assign(new_col = lambda x: x['sepal length (cm)'] + x['petal length (cm)'] * x['petal width (cm)']).drop(used_columns, axis=1)

ou

iris.assign(new_col = lambda x: x[used_columns[0]] + x[used_columns[1]] * x[used_columns[2]]).drop(used_columns, axis=1)

O que parece ~ bom ~, mas requer uma lista separada, e com a primeira, mantendo duas coisas atualizadas, e com a segunda, a carga cognitiva de acompanhar qual é o enésimo item da lista na minha cabeça.

Então, fiquei curioso para saber se existe outra maneira que não conheço de fazer isso, que seria mais fácil de manter? Ambos os itens acima não parecem muito pitônicos?

Pesquisa que fiz: pesquisei bastante sobre isso no Google, sem sorte. Parece que há muitas maneiras de descartar columns , mas nenhuma que encontrei parece particularmente adequada para esse tipo de situação. Qualquer ajuda que você possa fornecer será muito apreciada! Respostas que usam outros pacotes Python (por exemplo ) também são aceitáveis. janitor