Swawa's questions

Gostaria

• para obter um subconjunto de um Pandas Dataframe
• com base na consulta, se possível
• fornecendo várias condições com base nos valores das colunas
• onde somente linhas precisam ser selecionadas até que as condições apareçam pela primeira vez.

Provavelmente isso não é novidade. Eu simplesmente não encontro as respostas certas em outras postagens.

O Dataframe de exemplo:

import pandas as pd
df_GPS = pd.DataFrame([['2024-06-21 06:22:38', 22958, 605.968389, 1, 2, 1],
                       ['2024-06-21 06:22:39', 22959, 606.009398, 3, 0, 1],
                       ['2024-06-21 06:22:40', 22960, 605.630573, 1, 2, 0],
                       ['2024-06-21 06:22:41', 22961, 605.476367, 3, 3, 0],
                       ['2024-06-21 06:22:42', 22962, 605.322161, 2, 1, 1],
                       ['2024-06-21 06:22:43', 22963, 605.268389, 4, 1, 0],
                       ['2024-06-21 06:22:44', 22964, 605.559398, 1, 3, 1],
                       ['2024-06-21 06:22:45', 22965, 606.630573, 2, 9 , 0],
                       ['2024-06-21 06:22:46', 22966, 607.476367, 15, 13, 3],
                       ['2024-06-21 06:22:47', 22967, 609.322161, 23, 19, 12],
                       ['2024-06-21 06:22:48', 22968, 607.155939, 20, 21, 16],
                       ['2024-06-21 06:22:49', 22969, 606.763057, 18, 14, 8],
                       ['2024-06-21 06:22:50', 22970, 605.333781, 1, 1, 1],
                       ['2024-06-21 06:22:50', 22971, 604.333781, 15, 1, 1]
                      ], columns=['time', '__UTCs__','Altitude', 's01[m]', 's5.5[m]', 's10[m]'])
df_GPS

    time    __UTCs__    Altitude    s01[m]  s5.5[m]     s10[m]
0   2024-06-21 06:22:38     22958   605.968389  1   2   1
1   2024-06-21 06:22:39     22959   606.009398  3   0   1
2   2024-06-21 06:22:40     22960   605.630573  1   2   0
3   2024-06-21 06:22:41     22961   605.476367  3   3   0
4   2024-06-21 06:22:42     22962   605.322161  2   1   1
5   2024-06-21 06:22:43     22963   605.268389  4   1   0
6   2024-06-21 06:22:44     22964   605.559398  1   3   1
7   2024-06-21 06:22:45     22965   606.630573  2   9   0
8   2024-06-21 06:22:46     22966   607.476367  15  13  3
9   2024-06-21 06:22:47     22967   609.322161  23  19  12
10  2024-06-21 06:22:48     22968   607.155939  20  21  16
11  2024-06-21 06:22:49     22969   606.763057  18  14  8
12  2024-06-21 06:22:50     22970   605.333781  1   1   1
13  2024-06-21 06:22:50     22971   604.333781  15  1   1

O resultado que pretendo obter é o seguinte:

    time    __UTCs__    Altitude    s01[m]  s5.5[m]     s10[m]
1   2024-06-21 06:22:40     22960   605.630573  1   2   0
2   2024-06-21 06:22:41     22961   605.476367  3   3   0
3   2024-06-21 06:22:42     22962   605.322161  2   1   1
4   2024-06-21 06:22:43     22963   605.268389  4   1   0
5   2024-06-21 06:22:44     22964   605.559398  1   3   1
6   2024-06-21 06:22:45     22965   606.630573  2   9   0
7   2024-06-21 06:22:46     22966   607.476367  15  13  3

Eu tentei com query(o que eu achava que seria a maneira mais elegante):

df_sub = df_GPS.query('__UTCs__ >= 22960 & s01[m] < 16')

que dá um UndefinedVariableError: name 's01' is not definedtalvez devido aos sublinhados ou aos colchetes nos nomes das colunas? Como eu definiria que essas são colunas de df_GPS?
Por outro lado

df_sub = df_GPS[((df_GPS['__UTCs__'] >= 22960) & (df_GPS['s01[m]'] < 16))].copy()

O que resulta em:

    time    __UTCs__    Altitude    s01[m]  s5.5[m]     s10[m]
2   2024-06-21 06:22:40     22960   605.630573  1   2   0
3   2024-06-21 06:22:41     22961   605.476367  3   3   0
4   2024-06-21 06:22:42     22962   605.322161  2   1   1
5   2024-06-21 06:22:43     22963   605.268389  4   1   0
6   2024-06-21 06:22:44     22964   605.559398  1   3   1
7   2024-06-21 06:22:45     22965   606.630573  2   9   0
8   2024-06-21 06:22:46     22966   607.476367  15  13  3
12  2024-06-21 06:22:50     22970   605.333781  1   1   1
13  2024-06-21 06:22:50     22971   604.333781  15  1   1

funciona em princípio, mas deixa todas as linhas atendendo ao último critério. Quero parar a consulta após a primeira descoberta de todos os critérios de atendimento. Existe uma maneira sem realizar um groupby de ['s01[m]']?

A última maneira que tentei foi com loc. Isso também redefiniria o índice, mas resultaria no mesmo conteúdo de linha:

df_sub = df_GPS.loc[(df_GPS['__UTCs__'] >= 0) & (df_GPS['s01[m]'] <= 16)]

    time    __UTCs__    Altitude    s01[m]  s5.5[m]     s10[m]
0   2024-06-21 06:22:38     22958   605.968389  1   2   1
1   2024-06-21 06:22:39     22959   606.009398  3   0   1
2   2024-06-21 06:22:40     22960   605.630573  1   2   0
3   2024-06-21 06:22:41     22961   605.476367  3   3   0
4   2024-06-21 06:22:42     22962   605.322161  2   1   1
5   2024-06-21 06:22:43     22963   605.268389  4   1   0
6   2024-06-21 06:22:44     22964   605.559398  1   3   1
7   2024-06-21 06:22:45     22965   606.630573  2   9   0
8   2024-06-21 06:22:46     22966   607.476367  15  13  3
12  2024-06-21 06:22:50     22970   605.333781  1   1   1
13  2024-06-21 06:22:50     22971   604.333781  15  1   1

Como posso finalizar a consulta com um loop while?

Tenho um arquivo csv que leio com pandas para um dataframe. A coluna de tempo é formatada em dias desde 01-01-1900. O objetivo é obter uma coluna isoformatada com o "T" entre data e hora.

O arquivo csv se parece com:

DateTime,column1,column2,column3,column4,column5
43621.6210327662,1.234,2.665,0.888,3.891,3.762
43621.6210445023,2.232,1.233,0.888,3.789,3.524

Meu código para leitura é:

import pandas as pd
df = pd.read_csv(myfile.csv)
df

e o dataframe contém dias desde 01-01-1900:

    DateTime    column1     column2     column3     column4     column5
0   43621.621033    1.234   2.665   0.888   3.891   3.762
1   43621.621045    2.232   1.233   0.888   3.789   3.524

Agora eu converto a data formatada em dias para uma aparência mais comum:

from datetime import datetime, timedelta
df['DateTime'] =  pd.to_datetime('1900-01-01') + pd.to_timedelta(df['DateTime'],'D')
df
    DateTime    column1     column2     column3     column4     column5
0   2019-06-07 14:54:17.230999464   1.234   2.665   0.888   3.891   3.762
1   2019-06-07 14:54:18.244998936   2.232   1.233   0.888   3.789   3.524

Meu objetivo é ter uma coluna DateTime isoformatada que tenha o "T" entre data e hora como:

    DateTime    column1     column2     column3     column4     column5
0   2019-06-07T14:54:17.230999464   1.234   2.665   0.888   3.891   3.762
1   2019-06-07T14:54:18.244998936   2.232   1.233   0.888   3.789   3.524

Mas a coluna DateTime parece ser uma série em vez de uma data? Não consigo aplicar algo como:

df['DateTime'].isoformat()

Como devo proceder?

Gostaria de ler em um arquivo csv. Infelizmente, isso é criado por um software com bugs: Minha linha de cabeçalho contém vários separadores ";" e ",". O que não seria um problema se meu conjunto de dados não tivesse um decimal ",".

Gostaria de ler os arquivos automaticamente sem alterar o cabeçalho manualmente, mas não encontrei nada de acordo com a documentação do Pandas.

Os dados de exemplo:

some file header row number 1
some file header row number two
some more information about data in that file
column1;column2;column3,column4,column5
1,234;2,665;0,888;3,891;3,762
2,232;1,233;0,888;3,789;3,524

Posso especificar um separador diferente para o cabeçalho do que para o próprio conjunto de dados? Meu código:

df = pd.read_csv(
    "mypath\test.csv", 
    skiprows = 3;header= 0, delimiter=';,', decimal = ",")

o que resulta na leitura de tudo em uma coluna

    column1;column2;column3,column4,column5
0   1,234;2,665;0,888;3,891;3,762
1   2,232;1,233;0,888;3,789;3,524

Mas o resultado deve ser cinco colunas:

    column1     column2     column3     column4     column5
0   1.234   2.665   0.888   3.891   3.762
1   2.232   1.233   0.888   3.789   3.524

Encontrei esta postagem que inicialmente parecia ser exatamente o que eu estava procurando, mas não me ajudou: Adicionando cabeçalho e rodapé à saída JSON do Python

Tenho um arquivo csv que leio como Pandas dataframe:

import os
import csv
import json
import pandas as pd
csvFilePath = "Mypath"
track = pd.read_csv(csvFilePath, header = 0, skiprows = 0, delimiter = ";")

O exemplo csv se parece com isto:

Param1;Param2;name;lat;lon;altitude;vert_rate;track;speed;category;Param3;Param4;Param5
999999;9999;rocket;57.878696;11.160667;1089;0;137;2;99;999;16;0
999999;9999;rocket;57.878796;11.160668;2543.963336;152638.0483;137;2;99;999;15;0
999999;9999;rocket;57.878896;11.160670;4226.050004;126781.7063;137;2;99;999;14;0
999999;9999;rocket;57.878796;11.160669;6091.207544;121824.349;137;2;99;999;13;0
999999;9999;rocket;57.878696;11.160667;8098.097372;121471.6581;137;2;99;999;12;0

Agora eu gostaria de proteger esse dataframe com um cabeçalho adicional como um arquivo JSON: O cabeçalho adicional se parece com este dicionário:

headlines={
           "now": 1636008051.9,
           "messages": 6236,
           }

O JSON de destino deve conter as informações fornecidas por "headlines" (mas sem seu nome) e o conteúdo do dataframe:

{
  "now": 1636008051.9,
  "messages": 6236,
  "track": [
    {      
      "Param1": 999999,
      "Param2": "9999",
      "name": "rocket",
      "lat":  57.878696,
      "lon": 11.160667,
      "altitude": 1089,
      "vert_rate": 0,
      "track": 137,
      "speed": 2,
      "category": 99,
      "Param3": 999,
      "Param4": 16,
      "Param5": 0
    }
    {      
      "Param1": 999999,
      "Param2": "9999",
      "name": "rocket",
      "lat":  57.878796,
      "lon": 11.160668,
      "altitude": 2543.963336,
      "vert_rate": 152638.0483,
      "track": 137,
      "speed": 2,
      "category": 99,
      "Param3": 999,
      "Param4": 15,
      "Param5": 0
    }
    {      
      "Param1": 999999,
      "Param2": "9999",
      "name": "rocket",
      "lat":  57.878896,
      "lon": 11.160670,
      "altitude": 4226.050004,
      "vert_rate": 126781.7063,
      "track": 137,
      "speed": 2,
      "category": 99,
      "Param3": 999,
      "Param4": 14,
      "Param5": 0
    }
    {...and so on...}
  ]
}

O próprio dataframe eu posso simplesmente transformar em JSON assim:

json = track.to_json(path_out + "result.json", orient='records')

mas aqui não sei como adicionar as linhas precedentes do dict "header" Como posso juntar o dicionário e o csv para gerar o JSON? Ou há uma maneira mais simples? Ou alguma dica para uma postagem que não encontrei? Preciso fazer isso no pandas, pois o csv-dataframe será necessário posteriormente.

Tenho um pequeno dataframe pandas contendo dados com apenas algumas linhas e três colunas:

import pandas as pd
df_size = pd.DataFrame([[0.510,0.450,0.540],   
                        [0.899,0.820,1.150],   
                        [1.745,1.587,2.020],   
                        [2.020,1.745,2.405],   
                       ], columns=['diameter_mean', 'diameter_min','diameter_max'])

um segundo dataframe contém uma tabela de pesquisa (muito mais longa):

df_lookup = pd.DataFrame([[0.450,0.021548],
                          [0.510,0.021791],
                          [0.540,0.022038],
                          [0.565,0.022289],
                          [0.695,0.022545],
                          [0.720,0.034321],
                          [0.770,1.292340],
                          [0.820,1.296070],
                          [0.899,1.302340],
                          [1.150,2.311770],
                          [1.361,3.325140],
                          [1.587,4.144621],
                          [1.745,3.498933],
                          [2.020,3.512665],
                          [2.405,3.610773],
                        ], columns=['diameter', 'SMS'])

Isso significa que, para qualquer entrada da tabela de consulta, pode não haver um ponto de dados existente em df_size.

Com base em, df_lookup['diameter']desejo encontrar automaticamente os valores SMS correspondentes para todas as três colunas de df_size['diameter_mean']e df_size['diameter_min']anexar df_size['diameter_max'] os valores encontrados como três novas colunas ['SMS'], ['SMS_min'], ['SMS_max'] ao conjunto de dados dataframe 'df_size'.

Tentei criar as três novas colunas com merge, mas isso causa - como esperado - um valueError:

df_size['SMS'] = df_size.merge(df_lookup, left_on='diameter_mean', right_on='diameter')
df_size['SMS_min'] = df_size.merge(df_lookup, left_on='diameter_min', right_on='diameter')
df_size['SMS_max'] = df_size.merge(df_lookup, left_on='diameter_max', right_on='diameter')

devido a múltiplas colunas que seriam definidas como uma para todas as três linhas de código.

Como alternativa, tentei soluções com applye com map, mas parece que esqueci de algo (aqui, exemplo apenas para a coluna diameter_mean):

df_size['SMS'].apply(lambda df_lookup.SMS: df_lookup['diameter'][(df_size['diameter_mean'])].values[0])

causa um erro de chave.

O df_size pretendido ficaria assim:

df_size
'diameter_mean' 'diameter_min' 'diameter_max' 'SMS'     'SMS_min'    'SMS_max'
0.510           0.450           0.540         0.021791  0.021548     0.022038
0.899           0.820           1.150         1.302340  1.296070     2.311770
1.745           1.587           2.020         3.498933  4.144621     3.512665
2.020           1.745           2.405         3.512665  3.498933     3.610773

A propósito, é necessário que ambos os dataframes tenham comportamento fortemente monotônico em termos do parâmetro de pesquisa (=diâmetro)?

Eu tenho um dataframe python df_A cuja coluna de índice contém dados inteiros e representa um carimbo de data / hora na linha de segundos (pode não ter um gradiente estritamente monotônico).

E eu tenho outro dataframe df_B que contém apenas um conjunto de dados. Uma de suas "células" me dá um horário de início. Meu objetivo é pegar esse horário de início do df_B, colocá-lo na primeira linha de uma nova coluna a ser criada no df_A e iniciar um cálculo a partir daí com base na linha do índice.

A coluna de índice de df_A contém números inteiros como este:

Int64Index([ 2374,  2376,  2377,  2378,  2379,  2380,  2381,  2383,  2384,
             2385,
            ...
            10531, 10532, 10533, 10535, 10536, 10537, 10538, 10539, 10540,
            10541],
           dtype='int64', name='TimePeak', length=7107)

df_B fica assim:

df_B = pd.DataFrame([['2021-07-08T08:56:46.637', 590, 0, 4270.29]], columns=['BeginTime', 'Altitude', 'Status', 'Duration'])

Primeiro, obtenho meu valor de tempo inicial por df_B: Para cálculos adicionais, preciso que a entrada do tipo string "BeginTime" seja compatível com números inteiros de df_B.index. É por isso que converto tudo para o formato data e hora:

# Gain the first entry of the new dataframe column 'time'
df_A['time'].iloc[0] = pd.to_datetime(df_B.BeginTime)

Mas a primeira entrada não é colocada na primeira linha da nova coluna, pois produz uma mensagem ValueError: Could not convert object to NumPy datetime Não entendo por que não foi convertida. Devo definir seu conteúdo mais especificamente? Outros valores de data e hora deste formato são convertidos sem qualquer mensagem de erro para o formato AAAA-MM-DD hh:mm:ss.sss (sem o "T" no meio)

Então eu calcularia o tempo delta:

# calculate timedelta according to the index column values starting in the second
# row as the first row has no reference to be calculated from
for i in range(1, len(df_A)):
    df_A['deltaT'][i] = df_A.index[i] - df_A.index[i-1] 

Isso me dá um erro importante para deltaT. Por que?

Posso definir uma coluna vazia primeiro:

df_A['deltaT'] = pd.to_timedelta(pd.Series(dtype='float'), unit='s')
for i in range(1, len(df_A)):
    df_A['deltaT'][i] = df_A.index[i] - df_A.index[i-1] 

Mas isso terminaria em uma série de advertências:

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df_A['deltaT'][i] = df_A.index[i] - df_A.index[i-1] 

O que eu poderia suprimir: pd.options.mode.chained_assignment = None mas acho que o problema principal está localizado em algum lugar acima do código... (?)

Depois eu calcularia as linhas adicionais com base na diferença deltaT por duas linhas consecutivas:

# calculate the further rows 
for i in range (1, len(df_A)):
    df_A[i,'time'] = df_A.iloc[i-1]['time'] + pd.to_timedelta(df_A.iloc[i]['deltaT'](1, unit='s'))
df_A['time']

Mas este cálculo também não será realizado.

O código completo:

import pandas as pd
import numpy as np

# df_B:
df_B = pd.DataFrame([['2021-07-08T08:56:46.637', 590, 0, 4270.29]], columns=['BeginTime', 'Altitude', 'Status', 'Duration'])

# df_A
df_A = pd.DataFrame([[2374, 4.5],[2376, 5.7],[2377,23.0],[2378,9.2],[2379,18.7],[2380,10.4],[2381,12.2],[2383,23.9],[2384,21.6],
             [2385, 12.1]], columns=['TimePeak', 'data'])
df_A.set_index('TimePeak') # indeed, the index is set earlier due to a merge of several *.csv files

# Gain the first entry of the new dataframe column 'time' and convert it to timedate format
df_A['time'].iloc[0] = pd.to_datetime(df_B.BeginTime)

# calculate timedelta according to the index column values starting in the second
# row as the first row has no reference to be calculated from
for i in range(1, len(df_A)):
    df_A['deltaT'][i] = df_A.index[i] - df_A.index[i-1] 

# calculate the further rows 
for i in range (1, len(df_A)):
    df_A[i,'time'] = df_A.iloc[i-1]['time'] + pd.to_timedelta(df_A.iloc[i]['deltaT'](1, unit='s'))
df_A['time']

Também tentei redefinir o índice, mas não funcionou. Alguma dica para eu entender onde fui enganado?

A saída final deve ficar assim:

Eu gostaria de fazer um cálculo por linha com elementos únicos de um dataframe do pandas e elementos de uma lista e, finalmente, fazer a soma por linha de todos esses cálculos:

O número de itens da lista x_i é idêntico ao número de colunas n_i no dataframe. Eu gostaria de calcular somas por linha como

Minha solução resulta apenas em 4 valores conforme faço um loop no número de colunas. Mas eu também poderia percorrer o número de elementos da lista, o que não altera o resultado.

result = []
for i in range(len(df_n.columns)):   # these are 4
        total = sum(2/3 * x[i]**2 * df_n.iloc[i])
        result.append(total)
print(result)

usando mass = (math.pi/6 * binning[i]**3 * roh_solid * counts_nc.iloc[i]).sum()resultados no mesmo

O próximo teste seria um loop adicional ao longo do comprimento do dataframe. Um loop dentro de um loop parece uma programação Python muito ruim. Preciso usar duas variáveis ​​de loop para resolver isso?

Existe uma maneira otimizada do Python para resolver isso? Ou você pode me dar uma dica para uma pergunta semelhante sobre qual solução não encontrei com a função de pesquisa?

um exemplo de lista:

list = [0.4012, 0.551, 0.8124, 1.1402] 

Um exemplo de quadro de dados:

                        n_1          n_2            n_3            n_4  \
time                                                                          
2022-03-18 07:16:54  1.000000e-15  1.000000e-15  1.000000e-15  1.000000e-15   
2022-03-18 07:16:55  7.887821e-01  4.929888e-02  1.000000e-15  1.000000e-15   
2022-03-18 07:16:56  2.030013e+00  1.268758e-01  1.000000e-15  1.000000e-15   
2022-03-18 07:16:57  2.944119e+00  3.236459e-01  1.000000e-15  4.654615e-02   
2022-03-18 07:16:58  3.318537e+00  4.064088e-01  1.000000e-15  6.206153e-02

(a coluna de tempo é uma coluna de índice aqui.)