linkey apiacess's questions

No momento, estou tentando entender metaclasses e, por isso, voltei para atualizar meu conhecimento sobre super() e type.

Enquanto atualizava, me deparei com um artigo super() do geeksforgeeks e ele tinha um exemplo um tanto estranho.

aqui está o exemplo

class Animals:
    # Initializing constructor
    def __init__(self):
        self.legs = 4
        self.domestic = True
        self.tail = True
        self.mammals = True

    def isMammal(self):
        if self.mammals:
            print("It is a mammal.")

    def isDomestic(self):
        if self.domestic:
            print("It is a domestic animal.")

class Dogs(Animals):
    def __init__(self):
        super().__init__()

    def isMammal(self):
        super().isMammal()                        <- Why do this?

Entendo que, ao herdar de uma classe pai, funções como essa __init__precisam ser chamadas para serem inicializadas, daí a pergunta: " super().__init__()mas por que fazer isso também na função?"? Eu pensava que funções eram herdadas. Isso é para que possamos executar a função pai junto com as modificações?

Por que não chamar uma função pai dentro de uma nova função?

def mammal_can_dance(self):
    self.isMammal()
    print("and can dance")

Tenho uma função que retorna múltiplas variáveis ​​e estou tentando mapeá-la para um dataframe para acelerar o processamento de dados. No entanto, quando executo o código, ele não descompacta os dados e os adiciona às colunas.

código

import pandas as pd

def last_3_divisions(number: int, divide_by: int):
    last_3 = {3: None, 2: None, 1: None}
    for x in range(3, 0,-1):
        number = number / divide_by
        last_3[x] = number 
    return last_3[3], last_3[2], last_3[1]

mydf = pd.DataFrame([8,6,7,5,3,0,9], columns=["mynum"])

mydf["d3"], mydf["d2"], mydf["d1"] = mydf["mynum"].map(lambda x: last_3_divisions(x, 2))

executar o código funciona bem e irá gerar uma saída, no entanto, quando tento enviar as tuplas para colunas diferentes, ele produz um erro de valor

ValueError: muitos valores para descompactar (esperado 3)

Como descompactar as tuplas para classificá-las em colunas diferentes?

Tenho um conjunto de dados que contém 3 colunas. Essas são conexões de aresta entre nós e a força da conexão. O que estou tentando fazer é encontrar e mesclar as arestas extras que podem ocorrer quando a direção vai na direção oposta.

como um pequeno exemplo

data_frame = pd.DataFrame({"A":["aa", "aa", "aa", "bb", "bb", "cc", "dd", "dd"],
                           "B":["bb", "cc", "dd", "aa", "dd", "aa", "ee", "aa"],
                           "C":[4,3,4,5,3,4,2, 5]})

o gráfico de nós resultante

 aa - bb
 |  \  |
 cc   dd -- ee

Dos nós, temos sobreposição, pois "aa - bb" é o mesmo que "bb - aa" e o mesmo com "aa - dd" e "dd - aa"

Pensei em mesclar A e B, tanto para frente quanto para trás, concatenar os dois dataframes e então executar a, group_by().sum()mas acabei com extras que precisam ser removidos depois.

o ideal seria que funcionasse assim

 A  |  B   |   C                                A  |  B   |   C
aa     bb      4                               aa     bb      9
aa     cc      3                               aa     cc      7
aa     dd      4                               aa     dd      9
bb     aa      5                               bb     dd      3
bb     dd      3                 -->           dd     ee      2
cc     aa      4                               
dd     ee      2
dd     aa      5

É possível realizar uma atualização de matriz de forma numpysemelhante à forma como o Pandas pode atualizar um dataframe?

Se pandaseu tiver dois dataframes, posso filtrar um para os valores de atualização e então aplicar o dataframe ao primeiro com a update()função.

    df = pd.DataFrame({'A': [1, 2, 3],
                   'B': [400, 500, 600]})
    new_df = pd.DataFrame({'B': [4, 5, 6]})

    df.update(new_df[new_df["B"] > 4])

Não sei se numpytem uma função similar. Atualmente, tenho que fazer um loop pelo array em cada elemento.

    narr = np.random.rand(10)
    new_narr = np.random.rand(10)
    for i, c in enumerate(new_narr > narr):
         if c:
             narr[i] = new_narr[i]

Estou tentando escrever uma matriz de dados em um arquivo binário com a intenção de acessar posteriormente esse arquivo para localizar dados. Procurei online e encontrei vários métodos para salvar dados usando df.to_pickle, struct.pack, np.to_bytes(). Agora vem a parte de lê-lo. Encontrei outros posts solicitando leitura, mas até agora nenhum ajudou na recuperação dos dados. Tenho a impressão de que isso pode ter a ver com a forma como comprimo os dados.

formato de dados

      0      1      2     3     .      .      .    n
0   
1  -0.111 
2   0.84   0.1
3   0.25   0.6   -0.2
.
.
.
n

Este é um conjunto de dados de comparação, portanto, no cruzamento das variáveis, é 1. Devido a restrições de alocação de memória e tamanho dos dados, resultou na geração de uma tabela de dados como esta em um arquivo de texto. Armazenar na memória não foi possível porque n pode ser muito grande.

Para converter para binário, leio cada linha do texto, converto os valores para o formato correto e uso numpy.array.tobytes()

save_path = Path(save_loc)
save_data = save_path.open()
with load_data_path.open() as data_chunk:
    for idx, data in enumerate(data_chunk,0):
        if idx == 0:
           save_data.write(b"\n")
           continue
        dlist = data.strip("\n").split(",")
        d_array = [np.float64(x) for x in dlist]
        save_data.write(d_array.tobytes())
save_data.close()

para ler os dados, tentei usar np.frombuffer e struct.unpack mas ambos resultaram em erros. Além disso, pelo que entendi, a leitura colocaria todos os dados na memória, o que não funcionaria para os meus dados. Optei por abrir o binário usando path, localizando a linha e lendo diretamente. Aqui está o código

find_line = 7984
load_data = Path(data_loc)
with load_data.open("rb") as data_chunk:
     for idx, data in enumerate(data_chunk,0):
         if idx < find_line:
              continue
         else:
              my_line = np.frombuffer(data, "f", idx)
              break

isso, no entanto, resulta em um erro

ValueError: buffer is smaller than requested size

editar: Após uma investigação mais aprofundada, encontrei três problemas em meu código. 1 é que minha formatação estava incorreta ao usar o frombuffer. Como codifico como np.float64, chamar "f" tenta retornar um float32.

a segunda é que presumi que escrever o arquivo binário manteria os blocos de escrita (com um "\n" como delimitador para cada bloco), mas este não é o caso, pois quando tentei olhar minhas primeiras linhas, cada uma delas tinha 2.000 bits quando deveriam ter apenas ~ 16.

finalmente, parece que "\n" está sendo adicionado em algum lugar do processo, pois ao carregar mais abaixo na lista, encontro mais valores "\n" que dividem os bytes. Eu deveria ter cerca de 60.000 bytes para serem carregados, mas uma quebra de linha retorna apenas cerca de 2.500 bytes

No Excel, quando desejo somar valores em uma tabela, posso realizar uma soma se uma condição for excluída com base no nome da variável. O Pandas tem uma função semelhante?

Para dar mais contexto, estou analisando uma matriz de confusão e determinando a porcentagem de classificações corretas versus incorretas.

Exemplo de Excel:

        Fantasy  Horror  RPG
Fantasy   25      3       1
Horror    1       13      0
RPG       11      1       7

 ==(sum(B2:B4) - SUMIF($A2:$A4,"<>"&B$1,B2:B4))/sum(B2:B4)

Resultados:

       0.68    0.76    0.88

Conheço a groupbyfunção, mas pelo que entendi ela agrupa com base em variáveis ​​​​categóricas, não por exclusão como o que pode ser feito com sumif.

Exemplo:

import pandas as pd


my_data: pd.DataFrame = pd.read_excel("c:/mydata.xlsx")
mydata.groupby("genre").count()