AskOverflow.Dev

AskOverflow.Dev Logo AskOverflow.Dev Logo

AskOverflow.Dev Navigation

    • Início
    • system&network
    • Ubuntu
    • Unix
    • DBA
    • Computer
    • Coding
    • LangChain

Mobile menu

Close
  • Início
  • system&network
    • Recentes
    • Highest score
    • tags
  • Ubuntu
    • Recentes
    • Highest score
    • tags
  • Unix
    • Recentes
    • tags
  • DBA
    • Recentes
    • tags
  • Computer
    • Recentes
    • tags
  • Coding
    • Recentes
    • tags
Início / coding / 问题

Perguntas[dataframe](coding)

Martin Hope
Roger V.
Asked: 2025-02-24 21:28:16 +0800 CST

Renomeando uma única coluna com nome desconhecido em Polars-Rust

  • 7

O seguinte renomeia uma coluna em um dataframe Polars-Rust:

#![allow(unused_variables)]
use polars::prelude::*;

fn main() {
    println!("Hello, world!");
    let mut df = df! [
        "names" => ["a", "b", "c"],
        "values" => [1, 2, 3],
    ].unwrap();

    println!("{:?}", df);

    let new_name = <PlSmallStr>::from_str("letters");
    let _ = df.rename("names", new_name);
    println!("{:?}", df);
}

Suponha agora que o nome da primeira coluna seja desconhecido (por exemplo, o dataframe é lido de um arquivo csv/excel, onde não tem nome) e eu gostaria de renomeá-lo para uso futuro:

fn main() {
    println!("Hello, world!");
    let mut df = df! [
        "names" => ["a", "b", "c"],
        "values" => [1, 2, 3],
    ].unwrap();

    println!("{:?}", df);

    let old_name = df.get_column_names_str()[0];
    // let old_name = df.get_column_names_str()[0].clone();
    // let old_name = &mut df.get_column_names_str()[0].clone();
    // let mut old_name = &mut df.get_column_names_str()[0].clone();
    let new_name = <PlSmallStr>::from_str("letters");
    let _ = df.rename(old_name, new_name);
    println!("{:?}", df);
}

Isso resulta em um erro

error[E0502]: cannot borrow `df` as mutable because it is also borrowed as immutable
  --> src/main.rs:32:13
   |
27 |     let old_name = df.get_column_names_str()[0];
   |                    -- immutable borrow occurs here
...
32 |     let _ = df.rename(old_name, new_name);
   |             ^^^------^^^^^^^^^^^^^^^^^^^^
   |             |  |
   |             |  immutable borrow later used by call
   |             mutable borrow occurs here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `rename_col` (bin "rename_col") due to 1 previous error

Está mais ou menos claro por que o erro ocorre, mas não está claro como corrigi-lo...
As linhas comentadas mostram minhas várias tentativas malsucedidas de resolver esse problema.

Relacionado:
Em Rust, como renomear todas as colunas de um Polars Dataframe?
Como renomear nomes de colunas com a primeira linha em polars?

dataframe
  • 2 respostas
  • 70 Views
Martin Hope
Roger V.
Asked: 2025-02-14 16:12:05 +0800 CST

Como somar uma coluna?

  • 6

Tenho dificuldade em somar uma coluna no dataframe Polars-Rust. Por exemplo, o seguinte snippet:

use polars::prelude::*;

fn main() {

    // let numbers = [1, 2, 3, 4, 5];
    let n = 5;
    let numbers: Vec<u32> = (1..=n).collect();
    let sum: u32 = numbers.iter().sum();
    println!("the sum is: {}", sum);

    let names: Vec<String> = (1..=n).map(|v| format!("row{v}")).collect();

    // creating dataframe
    let c1 = Column::new("names".into(), &names);
    let c2 = Column::new("numbers".into(), &numbers);
    let df = DataFrame::new(vec![c1, c2]).unwrap();
    println!("{:?}", df);

    let column_sum: u32 = df.column("numbers").iter().sum();
    println!("the columns sum is: {}", column_sum);

}

gera este erro:

error[E0277]: a value of type `u32` cannot be made by summing an iterator over elements of type `&&polars::prelude::Column`
  --> src/sum_column.rs:19:55
   |
19 |     let column_sum: u32 = df.column("numbers").iter().sum();
   |                                                       ^^^ value of type `u32` cannot be made by summing a `std::iter::Iterator<Item=&&polars::prelude::Column>`
   |
   = help: the trait `std::iter::Sum<&&polars::prelude::Column>` is not implemented for `u32`
   = help: the following other types implement trait `std::iter::Sum<A>`:
             `u32` implements `std::iter::Sum<&u32>`
             `u32` implements `std::iter::Sum`
note: required by a bound in `std::iter::Iterator::sum`
  --> /rustc/9fc6b43126469e3858e2fe86cafb4f0fd5068869/library/core/src/iter/traits/iterator.rs:3515:5

For more information about this error, try `rustc --explain E0277`.
error: could not compile `sum_column` (bin "sum_column") due to 1 previous error

Parece, por esta mensagem, que este é um problema menor... mas sou novo em Rust, e não está claro o que esta mensagem sugere exatamente. Sua ajuda será apreciada.

dataframe
  • 2 respostas
  • 57 Views
Martin Hope
David Regan
Asked: 2024-11-21 16:25:28 +0800 CST

Problemas de conversão de estrutura Spark para classe case com getAs[T]

  • 7

Eu costumo usar a mapfunção em spark Dataset rows para fazer transformações em Scala em objetos tipados. Meu padrão usual é converter resultados intermediários criados a partir de transformações de dataframe ( withColumn, groupBy, etc.) e criar um Dataset tipado do resultado intermediário para que eu possa usar map.

Isso funciona bem, mas leva a muitas classes de casos "temporárias" para resultados intermediários ou tipos de tuplas difíceis de manejar.

Uma alternativa seria executar mapem um quadro de dados e recuperar campos digitados da linha usando, getAs[T]mas isso não parece funcionar com spark.implicitsif Té uma classe de caso.

Por exemplo, isso dá o erroClassCastException: org.apache.spark.sql.catalyst.expressions.GenericRowWithSchema cannot be cast to Person

import org.apache.spark._
import org.apache.spark.sql._
import org.apache.spark.sql.functions.{round => colRound, min => colMin, max => colMax, _}
import org.apache.spark.sql.expressions.Window

import spark.implicits._

final case class Person(name: String, age: Integer)
val people = Seq(Person("Alice", 20), Person("Bob", 30), Person("Charlie", 40)).toDS

val df = people.alias("p")
               .select($"p.name", struct($"p.*").alias("person"))
val ds = df.map(row => {
  val name = row.getAs[String]("name")
  val person = row.getAs[Person]("person")
  (name, person)
})

display(ds)

enquanto isso funciona bem:

import org.apache.spark._
import org.apache.spark.sql._
import org.apache.spark.sql.functions.{round => colRound, min => colMin, max => colMax, _}
import org.apache.spark.sql.expressions.Window

import spark.implicits._

final case class Person(name: String, age: Integer)
val people = Seq(Person("Alice", 20), Person("Bob", 30), Person("Charlie", 40)).toDS

val df = people.alias("p")
               .select($"p.name", struct($"p.*").alias("person"))
               .as[Tuple2[String, Person]]
val ds = df.map(row => {
  val name = row._1
  val person = row._2
  (name, person)
})

display(ds)

Então o spark está convertendo alegremente a estrutura person do dataframe para a Personclasse case no segundo exemplo, mas não fará isso no primeiro exemplo. Alguém sabe uma maneira simples de consertar isso?

Obrigado,

Davi

dataframe
  • 1 respostas
  • 18 Views
Martin Hope
dark.vador
Asked: 2024-11-01 18:29:34 +0800 CST

Falha ao resolver polars_core, arrow::legacy, Dataframe é polars-lazy = "0.44.2"

  • 5

Apesar de:

  1. leitura do polar_lazy 0.44.2

  2. instalação bem-sucedida decargo add polars-lazy

o código a seguir resulta em erros:

  • erro[E0433]: falha na resolução: não foi possível encontrar legacyemarrow

  • erro[E0433]: falha na resolução: uso de caixa ou módulo não declaradopolars_core

  • erro[E0412]: não é possível encontrar o tipo PolarsResultneste escopo

  • erro[E0412]: não é possível encontrar o tipo DataFrameneste escopo

    use polars_core::prelude::*;
    use polars_core::df;
    use polars_lazy::prelude::*;
    use arrow::legacy::prelude::QuantileMethod;
    
    fn main() {
      let test = example()
      println!("show dataframe: {:?}", test);
    
    }
    
    fn example() -> PolarsResult<DataFrame> {
     let df = df!(
         "date" => ["2020-08-21", "2020-08-21", "2020-08-22", "2020-08-23", "2020-08-22"],
         "temp" => [20, 10, 7, 9, 1],
         "rain" => [0.2, 0.1, 0.3, 0.1, 0.01]
     )?;
    
     df.lazy()
     .group_by([col("date")])
     .agg([
         col("rain").min().alias("min_rain"),
         col("rain").sum().alias("sum_rain"),
         col("rain").quantile(lit(0.5), QuantileMethod::Nearest).alias("median_rain"),
     ])
     .sort(["date"], Default::default())
     .collect()
    }
    

Nota:Cargo.toml

[dependencies]
arrow = "53.2.0"
polars-lazy = "0.44.2"
dataframe
  • 2 respostas
  • 42 Views
Martin Hope
Cristian Scutaru
Asked: 2024-10-31 01:16:23 +0800 CST

Snowpark DataFrame: Por que tantos sinônimos para os mesmos métodos de classe?

  • 7

Suspeito que deve ser por alguma compatibilidade com versões anteriores. E eu simplesmente tento descobrir qual foi o motivo por trás. A API Snowpark DataFrame foi inspirada na API Apache Spark DataFrame.

Mas por que tantos métodos de classe DataFrame semelhantes , com as mesmas assinaturas e funcionalidades, aparecem com dois nomes diferentes?

Apenas alguns exemplos (mas há tantos):

  • criar_ou_substituir_temp_view e criarOrReplaceTempView
  • to_df e toDF
  • group_by e GroupBy

Além disso, existe uma notação preferida hoje? Uma melhor prática a seguir, relacionada a essas chamadas?

dataframe
  • 1 respostas
  • 39 Views
Martin Hope
John
Asked: 2024-10-14 12:01:55 +0800 CST

Criar coluna de saldo atual no PySpark

  • 5

Tenho o dataframe abaixo criado no código PySpark:

+---------------+-------------+---------------+------+
|TransactionDate|AccountNumber|TransactionType|Amount|
+---------------+-------------+---------------+------+
|     2023-01-01|          100|         Credit|  1000|
|     2023-01-02|          100|         Credit|  1500|
|     2023-01-03|          100|          Debit|  1000|
|     2023-01-02|          200|         Credit|  3500|
|     2023-01-03|          200|          Debit|  2000|
|     2023-01-04|          200|         Credit|  3500|
|     2023-01-13|          300|         Credit|  4000|
|     2023-01-14|          300|          Debit|  4500|
|     2023-01-15|          300|         Credit|  5000|
+---------------+-------------+---------------+------+

Preciso imprimir outra coluna como CurrentBalance .

Saída esperada:

+---------------+-------------+---------------+------+--------------+
|TransactionDate|AccountNumber|TransactionType|Amount|CurrentBalance|
+---------------+-------------+---------------+------+--------------+
|     2023-01-01|          100|         Credit|  1000|          1000|
|     2023-01-02|          100|         Credit|  1500|          2500|
|     2023-01-03|          100|          Debit|  1000|          1500|
|     2023-01-02|          200|         Credit|  3500|          3500|
|     2023-01-03|          200|          Debit|  2000|          1500|
|     2023-01-04|          200|         Credit|  3500|          5000|
|     2023-01-13|          300|         Credit|  4000|          4000|
|     2023-01-14|          300|          Debit|  4500|          -500|
|     2023-01-15|          300|         Credit|  5000|          1000|
+---------------+-------------+---------------+------+--------------+

Tentei usar a data mínima e passar a data na condição when para calcular o crédito e o débito, mas parece que não está funcionando.

# Find minimum date in TransactionDate column, grouped by AccountNumber column
df_new.groupBy('AccountNumber').agg(f.min('TransactionDate').alias('min_date'))
dataframe
  • 1 respostas
  • 12 Views
Martin Hope
DJDuque
Asked: 2024-09-12 12:09:59 +0800 CST

Junte carimbos de data/hora entre 2 conjuntos de dados, mantendo a diferença de tempo

  • 6

Tenho os 2 conjuntos de dados a seguir:

  1. Este é muito confiável para me dizer se um evento aconteceu, mas seu registro de data e hora só é válido com uma precisão de alguns segundos (vamos supor 2 segundos):
    coarse = {
        "name": ["a", "a", "b", "c", "a"],
        "timestamp": [100, 103, 195, 220, 221],
    }
    coarse_df = pl.DataFrame(coarse)
    """
    ┌──────┬───────────┐
    │ name ┆ timestamp │
    │ ---  ┆ ---       │
    │ str  ┆ i64       │
    ╞══════╪═══════════╡
    │ a    ┆ 100       │
    │ a    ┆ 103       │
    │ b    ┆ 195       │
    │ c    ┆ 220       │
    │ a    ┆ 221       │
    └──────┴───────────┘
    """
    
  1. Este tem um tempo muito preciso, mas tem alguns ruídos/falsos positivos (observe que t=0é diferente para ambos os conjuntos de dados, há um deslocamento arbitrário):
    fine = {
        "name": ["a", "a", "a", "a", "b", "c", "b", "a"],
        "time": [0.05, 10.05, 12.51, 51.12, 106.0, 128.01, 130.0, 132.9],
    }
    fine_df = pl.DataFrame(fine)
    """
    ┌──────┬────────┐
    │ name ┆ time   │
    │ ---  ┆ ---    │
    │ str  ┆ f64    │
    ╞══════╪════════╡
    │ a    ┆ 0.05   │
    │ a    ┆ 10.05  │
    │ a    ┆ 12.51  │
    │ a    ┆ 51.12  │
    │ b    ┆ 106.0  │
    │ c    ┆ 128.01 │
    │ b    ┆ 130.0  │
    │ a    ┆ 132.9  │
    └──────┴────────┘
    """
    
    

Estou tentando de alguma forma juntar esses conjuntos de dados para obter algo como o seguinte. Essencialmente, obtendo os timestamps do segundo conjunto de dados e usando as diferenças de tempo no primeiro conjunto de dados para filtrar os falsos positivos.

"""
┌──────┬────────┐
│ name ┆ time   │
│ ---  ┆ ---    │
│ str  ┆ f64    │
╞══════╪════════╡
│ a    ┆ 10.05  │
│ a    ┆ 12.51  │
│ b    ┆ 106.0  │
│ c    ┆ 128.01 │
│ a    ┆ 132.9  │
└──────┴────────┘
"""

EDITAR

O que estou fazendo atualmente para identificar falsos positivos (em palavras, porque este é um loop for aninhado feio):

Dado que o deslocamento entre ambos os conjuntos de dados é arbitrário, suponha que o primeiro evento "a" seja o real:

Agora coarseparece que o tempo mudou em 100:

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 0         │  -> Good, there is a timestamp in `fine` within 2s
│ a    ┆ 3         │  -> Bad, no timestamp in `fine` matches
│ b    ┆ 95        │  -> Bad, ditto
│ c    ┆ 120       │  -> Bad, ditto
│ a    ┆ 121       │  -> Bad, ditto
└──────┴───────────┘

Ok, não encontrei todos os resultados, então o segundo "a" deve ser o real (deslocado em 90 segundos):

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 10        │  -> Good, it matches 10.05
│ a    ┆ 13        │  -> Good, it matches 12.51
│ b    ┆ 105       │  -> Good, it matches 106.0
│ c    ┆ 130       │  -> Good, it matches 128.01
│ a    ┆ 131       │  -> Good it matches 132.9
└──────┴───────────┘

Basicamente, estou deslizando o segundo conjunto de dados pelo tempo até encontrar um "padrão de tempo" que corresponda a todos os eventos no primeiro quadro de dados em um subconjunto do segundo.

dataframe
  • 1 respostas
  • 57 Views
Martin Hope
Dante
Asked: 2024-08-24 01:42:57 +0800 CST

Como posso substituir várias linhas em um dataframe polar por um mapeamento de ditado?

  • 6

Então, digamos que eu tenha uma planilha Excel/csv de usuários e seus registros de salários. Criei uma conta para cada usuário em um banco de dados e quero criar um registro salarial para cada um usando os IDs do banco de dados.

import polars as pl

# Create the DataFrame with repeated entries for John and Jane
df = pl.DataFrame({
    "first_name": ["John", "Jane", "Alice", "Bob", "John", "Jane", "John", "Jane"],
    "middle_name": ["A.", "B.", "C.", "D.", "A.", "B.", "A.", "B."],
    "last_name": ["Doe", "Smith", "Johnson", "Brown", "Doe", "Smith", "Doe", "Smith"],
    "salary": [50000, 60000, 55000, 62000, 50000, 60000, 50000, 60000],
    "date": ["2023-01-15", "2023-02-20", "2023-03-05", "2023-04-10", "2023-05-15", "2023-06-20", "2023-07-15", "2023-08-20"]
})
print(df)
shape: (8, 5)
┌────────────┬────────────┬────────────┬────────┬────────────┐
│ first_name │ middle_name│ last_name  │ salary │ date       │
│ ---        │ ---        │ ---        │ ---    │ ---        │
│ str        │ str        │ str        │ i64    │ date       │
├────────────┼────────────┼────────────┼────────┼────────────┤
│ John       │ A.         │ Doe        │ 50000  │ 2023-01-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-02-20 │
│ Alice      │ C.         │ Johnson    │ 55000  │ 2023-03-05 │
│ Bob        │ D.         │ Brown      │ 62000  │ 2023-04-10 │
│ John       │ A.         │ Doe        │ 50000  │ 2023-05-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-06-20 │
│ John       │ A.         │ Doe        │ 50000  │ 2023-07-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-08-20 │
└────────────┴────────────┴────────────┴────────┴────────────┘

#Get unique values
 subset_df = df.select(["first_name", "middle_name", "last_name"])
 unique_subset_df = subset_df.unique()
 for row in subset_df.select(pl.struct(pl.all()).value_counts()):
    # create acoount

A lista de usuários com seus IDs correspondentes é a seguinte

users = [
    {'id': 1, 'first_name': 'John', 'middle_name': 'A.', 'last_name': 'Doe'},
    {'id': 2, 'first_name': 'Jane', 'middle_name': 'B.', 'last_name': 'Smith'},
    {'id': 3, 'first_name': 'Alice', 'middle_name': 'C.', 'last_name': 'Johnson'},
    {'id': 4, 'first_name': 'Bob', 'middle_name': 'D.', 'last_name': 'Brown'}
]
# Note:The data above can also be transformed into a list of tuples

Como posso substituir os valores nas colunas first_name, middle_namee last_namedo dataframe pelos IDs correspondentes desta lista de dicionários?

dataframe
  • 1 respostas
  • 25 Views
Martin Hope
Phil-ZXX
Asked: 2024-08-20 23:33:20 +0800 CST

Polars Dataframe full-join (externo) em múltiplas colunas sem sufixo

  • 7

Eu tenho este código:

import polars as pl

df1 = pl.DataFrame({
    'type':   ['A', 'O', 'B', 'O'],
    'origin': ['EU', 'US', 'US', 'EU'],
    'qty1':   [343,11,22,-5]
})

df2 = pl.DataFrame({
    'type':   ['A', 'O', 'B', 'S'],
    'origin': ['EU', 'US', 'US', 'AS'],
    'qty2':   [-200,-12,-25,8]
})

df1.join(df2, on=['type', 'origin'], how='full')

o que dá

┌──────┬────────┬──────┬────────────┬──────────────┬──────┐
│ type ┆ origin ┆ qty1 ┆ type_right ┆ origin_right ┆ qty2 │
│ ---  ┆ ---    ┆ ---  ┆ ---        ┆ ---          ┆ ---  │
│ str  ┆ str    ┆ i64  ┆ str        ┆ str          ┆ i64  │
╞══════╪════════╪══════╪════════════╪══════════════╪══════╡
│ A    ┆ EU     ┆ 343  ┆ A          ┆ EU           ┆ -200 │
│ O    ┆ US     ┆ 11   ┆ O          ┆ US           ┆ -12  │
│ B    ┆ US     ┆ 22   ┆ B          ┆ US           ┆ -25  │
│ null ┆ null   ┆ null ┆ S          ┆ AS           ┆ 8    │
│ O    ┆ EU     ┆ -5   ┆ null       ┆ null         ┆ null │
└──────┴────────┴──────┴────────────┴──────────────┴──────┘

Mas a saída que procuro é esta:

┌──────┬────────┬──────┬──────┐
│ type ┆ origin ┆ qty1 ┆ qty2 │
│ ---  ┆ ---    ┆ ---  ┆ ---  │
│ str  ┆ str    ┆ i64  ┆ i64  │
╞══════╪════════╪══════╪══════╡
│ A    ┆ EU     ┆ 343  ┆ -200 │
│ O    ┆ US     ┆ 11   ┆ -12  │
│ B    ┆ US     ┆ 22   ┆ -25  │
│ S    ┆ AS     ┆ null ┆ 8    │
│ O    ┆ EU     ┆ -5   ┆ null │
└──────┴────────┴──────┴──────┘

Eu tentei suffix=''via df1.join(df2, on=['type', 'origin'], how='full', suffix=''), mas isso gera um erro:

DuplicateError: unable to hstack, column with name "type" already exists

Como posso conseguir isso?

dataframe
  • 1 respostas
  • 28 Views
Martin Hope
Phil-ZXX
Asked: 2024-07-31 20:18:14 +0800 CST

Crie um dataframe polar a partir de dict (com chaves e valores sendo suas próprias colunas)

  • 7

eu tenho o seguinte código

import polars as pl

mapping = {
    'CASH':  {'qty':  1, 'origin': 'E'},
    'ITEM':  {'qty': -9, 'origin': 'A'},
    'CHECK': {'qty': 46, 'origin': 'A'},
}

df = pl.DataFrame([{'type': k} | v for k, v in mapping.items()])\
         .with_columns(pl.struct(['qty', 'origin']).alias('mapping'))\
         .select(pl.col(['type', 'mapping']))

Portanto, as chaves do dict devem se tornar uma nova coluna chamada typee os valores do dict devem estar em sua própria mappingcoluna. Minha implementação acima funciona e dfse parece com isto:

shape: (3, 2)
┌───────┬───────────┐
│ type  ┆ mapping   │
│ ---   ┆ ---       │
│ str   ┆ struct[2] │
╞═══════╪═══════════╡
│ CASH  ┆ {1,"E"}   │
│ ITEM  ┆ {-9,"A"}  │
│ CHECK ┆ {46,"A"}  │
└───────┴───────────┘

Mas minha implementação é muito longa e não parece muito eficiente. Existe uma maneira polar mais idiomática de criar esse dataframe?

dataframe
  • 2 respostas
  • 30 Views

Sidebar

Stats

  • Perguntas 205573
  • respostas 270741
  • best respostas 135370
  • utilizador 68524
  • Highest score
  • respostas
  • Marko Smith

    Reformatar números, inserindo separadores em posições fixas

    • 6 respostas
  • Marko Smith

    Por que os conceitos do C++20 causam erros de restrição cíclica, enquanto o SFINAE antigo não?

    • 2 respostas
  • Marko Smith

    Problema com extensão desinstalada automaticamente do VScode (tema Material)

    • 2 respostas
  • Marko Smith

    Vue 3: Erro na criação "Identificador esperado, mas encontrado 'import'" [duplicado]

    • 1 respostas
  • Marko Smith

    Qual é o propósito de `enum class` com um tipo subjacente especificado, mas sem enumeradores?

    • 1 respostas
  • Marko Smith

    Como faço para corrigir um erro MODULE_NOT_FOUND para um módulo que não importei manualmente?

    • 6 respostas
  • Marko Smith

    `(expression, lvalue) = rvalue` é uma atribuição válida em C ou C++? Por que alguns compiladores aceitam/rejeitam isso?

    • 3 respostas
  • Marko Smith

    Um programa vazio que não faz nada em C++ precisa de um heap de 204 KB, mas não em C

    • 1 respostas
  • Marko Smith

    PowerBI atualmente quebrado com BigQuery: problema de driver Simba com atualização do Windows

    • 2 respostas
  • Marko Smith

    AdMob: MobileAds.initialize() - "java.lang.Integer não pode ser convertido em java.lang.String" para alguns dispositivos

    • 1 respostas
  • Martin Hope
    Fantastic Mr Fox Somente o tipo copiável não é aceito na implementação std::vector do MSVC 2025-04-23 06:40:49 +0800 CST
  • Martin Hope
    Howard Hinnant Encontre o próximo dia da semana usando o cronógrafo 2025-04-21 08:30:25 +0800 CST
  • Martin Hope
    Fedor O inicializador de membro do construtor pode incluir a inicialização de outro membro? 2025-04-15 01:01:44 +0800 CST
  • Martin Hope
    Petr Filipský Por que os conceitos do C++20 causam erros de restrição cíclica, enquanto o SFINAE antigo não? 2025-03-23 21:39:40 +0800 CST
  • Martin Hope
    Catskul O C++20 mudou para permitir a conversão de `type(&)[N]` de matriz de limites conhecidos para `type(&)[]` de matriz de limites desconhecidos? 2025-03-04 06:57:53 +0800 CST
  • Martin Hope
    Stefan Pochmann Como/por que {2,3,10} e {x,3,10} com x=2 são ordenados de forma diferente? 2025-01-13 23:24:07 +0800 CST
  • Martin Hope
    Chad Feller O ponto e vírgula agora é opcional em condicionais bash com [[ .. ]] na versão 5.2? 2024-10-21 05:50:33 +0800 CST
  • Martin Hope
    Wrench Por que um traço duplo (--) faz com que esta cláusula MariaDB seja avaliada como verdadeira? 2024-05-05 13:37:20 +0800 CST
  • Martin Hope
    Waket Zheng Por que `dict(id=1, **{'id': 2})` às vezes gera `KeyError: 'id'` em vez de um TypeError? 2024-05-04 14:19:19 +0800 CST
  • Martin Hope
    user924 AdMob: MobileAds.initialize() - "java.lang.Integer não pode ser convertido em java.lang.String" para alguns dispositivos 2024-03-20 03:12:31 +0800 CST

Hot tag

python javascript c++ c# java typescript sql reactjs html

Explore

  • Início
  • Perguntas
    • Recentes
    • Highest score
  • tag
  • help
subwaysurfers
my femboy roommate

Footer

AskOverflow.Dev

About Us

  • About Us
  • Contact Us

Legal Stuff

  • Privacy Policy

Language

  • Pt
  • Server
  • Unix

© 2023 AskOverflow.DEV All Rights Reserve