Pro Q's questions

Eu tenho esse código e me irrita ter que fazer o cast fduas vezes:

    with h5py.File(computed_properties_path, "r") as f:
        # get the set of computed metrics
        computed_metrics = set()
        # iterating through the file iterates through the keys which are dataset names
        f = cast(Iterable[str], f)
        dataset_name: str
        for dataset_name in f:
            # re-cast it as a file
            f = cast(h5py.File, f)
            dataset_group = index_hdf5(f, [dataset_name], h5py.Group)
            for metric_name in dataset_group:
                logger.info(f"Dataset: {dataset_name}, Metric: {metric_name}")

Só quero poder dizer ao verificador de tipo estático que, se eu iterar por um arquivo, obterei strings (que são chaves para os grupos e conjuntos de dados no arquivo).

Tentei criar este .pyistub para criar uma classe que faz isso, mas recebo um erro dizendo que File não está definido. Meu palpite é que isso ocorre porque o Pylance agora depende somente do meu stub, em vez de procurar definições extras no arquivo original.

Tentei várias opções diferentes por meio do Claude e do ChatGPT, mas não consigo descobrir como estender a sugestão de tipo para que o Pylance saiba que iterar por um h5py.Fileobjeto produzirá strings.

Eu odeio escrever as coisas duas vezes, então eu inventei uma maneira decente de não ter que escrever as coisas duas vezes. No entanto, isso parece quebrar meu type-hinting:

from enum import Enum
from dataclasses import make_dataclass, field, dataclass

class DatasetNames(Enum):
    test1 = "test1_string"
    test2 = "test2_string"
    test3 = "test3_string"

def get_path(s: str) -> str:
    return s + "_path"

# the normal way to do this, but I have to type every new dataset name twice
# and there's a lot of duplicate code
@dataclass(frozen=True)
class StaticDatasetPaths:
    test1 = get_path("test1_string")
    test2 = get_path("test2_string")
    test3 = get_path("test3_string")

# mypy recognizes that `StaticDatasetPaths` is a class
# mypy recognizes that `StaticDatasetPaths.test2` is a string
print(StaticDatasetPaths.test2) # 'test2_string_path'

# this is my way of doing it, without having to type every new dataset name twice and no duplicate code
DynamicDatasetPaths = make_dataclass(
    'DynamicDatasetPaths', 
    [
        (
            name.name,
            str,
            field(default=get_path(name.value))
        )
        for name in DatasetNames
    ],
    frozen=True
)

# mypy thinks `DynamicDatasetPaths` is a `variable` of type `type`
# mypy thinks that `DynamicDatasetPaths.test2` is an `function` of type `Unknown`
print(DynamicDatasetPaths.test2) # 'test2_string_path'

Como posso informar ao mypy que DynamicDatasetPaths é uma classe de dados congelada cujos atributos são strings?

Normalmente, quando me deparo com casos como esse, consigo simplesmente usar a caste dizer ao mypy qual é o tipo correto, mas não sei o tipo correto para "classe de dados congelada cujos atributos são strings".

(Além disso, se houver uma maneira melhor de não ter o código duplicado, ficaria feliz em saber sobre isso também.)

Eu tenho o seguinte código:

import pandas as pd

series_source = pd.Series([1, 2, 3, 4], dtype=int)
normal_index = pd.Series([True, False, True, True], dtype=bool)
big_index = pd.Series([True, False, True, True, False, True], dtype=bool)

# Both indexes give back: pd.Series([1, 2, 3, 4], dtype=int)
# no warnings are raised!
assert (series_source[normal_index] == series_source[big_index]).all() 

df_source = pd.DataFrame(
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12],
        [13, 14, 15, 16]
    ]
)

# no warning - works as expected: grabs rows 0, 2, and 3
df_normal_result = df_source[normal_index]

# UserWarning: Boolean Series key will be reindexed to match DataFrame index.
# (but still runs)
df_big_result = df_source[big_index]

# passes - they are equivalent
assert df_normal_result.equals(df_big_result)
print("Complete")

Por que indexar the series_sourcecom the big_indexnão gera um aviso, mesmo que o índice grande tenha mais valores que a fonte? O que os pandas estão fazendo nos bastidores para fazer a indexação da série?

(Compare isso com a indexação do df_source, onde é gerado um aviso explícito que big_indexprecisa ser reindexado para que a operação funcione.)

Nos documentos de indexação , afirma que:

Usar um vetor booleano para indexar uma série funciona exatamente como em um ndarray NumPy

No entanto, se eu fizer

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([True, False, True, True, False])
c = np.array([True, False, True, True, False, True, True])

# returns an ndarray of [1,3, 4] as expected
print(a[b])

# raises IndexError: boolean index did not match indexed array along axis 0;
# size of axis is 5 but size of corresponding boolean axis is 7
print(a[c])

Portanto, não parece que essa funcionalidade corresponda ao Numpy, como afirmam os documentos. O que está acontecendo?

(Minhas versões são pandas==2.2.2e numpy==2.0.0.)

Eu tenho um Pandas DataFrame, conforme definido aqui :

df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Aritra'],
                   'Age': [25, 30, 35],
                   'Location': ['Seattle', 'New York', 'Kona']},
                  index=([10, 20, 30]))

No entanto, quando indexo this DataFrame, não posso prever com precisão que tipo de objeto resultará da indexação:

# (1) str
df.iloc[0, df.columns.get_loc('Name')]
# (2) Series
df.iloc[0:1, df.columns.get_loc('Name')]

# (3) Series
df.iloc[0:2, df.columns.get_loc('Name')]
# (4) DataFrame
df.iloc[0:2, df.columns.get_loc('Name'):df.columns.get_loc('Age')]

# (5) Series
df.iloc[0, df.columns.get_loc('Name'):df.columns.get_loc('Location')]
# (6) DataFrame
df.iloc[0:1, df.columns.get_loc('Name'):df.columns.get_loc('Location')]

Observe que cada um dos pares acima contém os mesmos dados . (por exemplo, (2)é uma série que contém uma única string, (4)é um DataFrame que contém uma única coluna, etc.)

Por que eles produzem diferentes tipos de objetos? Como posso prever que tipo de objeto será gerado?

Dados os dados, parece que a regra é baseada em quantas fatias (dois pontos) você tem no índice:

• 0 fatias ( (1)): valor escalar
• 1 fatia ( (2), (3), (5)):Series
• 2 fatias ( (4), (6)):DataFrame

No entanto, não tenho certeza se isso é sempre verdade e, mesmo que seja sempre verdade, quero saber o mecanismo subjacente que explica por que isso acontece.

Passei um tempo olhando a documentação de indexação , mas ela não parece descrever esse comportamento com clareza. A documentação da ilocfunção também não descreve os tipos de retorno.

Também estou interessado na mesma pergunta forloc em vez de iloc, mas, como locé inclusive , os resultados não são tão desconcertantes. (Ou seja, você não pode obter pares de índices com tipos diferentes nos quais os índices deveriam extrair exatamente os mesmos dados.)

Eu tenho o seguinte código:

    if 0 in df[RATING_COL]:
        rating_col_list = df[RATING_COL].to_list()
        assert 0 in rating_col_list

A afirmação está acionando um arquivo AssertionError. Como isso pode ser possível? Como pode haver um 0 na coluna, mas quando converto a coluna em uma lista, o 0 desaparece?

O dataframe que estou carregando é baseado no MovieLens-1M e se parece com:

user_id,item_id,rating
1,1193000,2
1,1193001,3
1,1193002,4
1,1193003,5
1,1193004,6
1,1193005,7
1,1193006,8
1,1193007,9
1,1193008,10
1,661000,6
1,661001,7
1,661002,8
1,661003,9
1,661004,10
1,661005,9
1,661006,8
1,661007,7
1,661008,6

Neste formato, 1,1193008,10indica que o usuário 1 avaliou o item 1193 com 8. O 10 indica que esta é a classificação, e todos os outros itens começando com 1193 terão uma classificação inferior a 10. (Portanto, indica que o usuário 1 avaliou o item 661 com 1,661004,10um 4.)

(Além disso, verifiquei com CTRL-F: não há classificação 0 na coluna de classificação.)

Eu tenho o seguinte código:

        try:
            # faster, but requires more memory
            G = self.sparse.to_dense().t() @ self.sparse.to_dense()
        except torch.cuda.OutOfMemoryError:
            # slower, but requires less memory
            G = torch.sparse.mm(self.sparse.t(), self.sparse)

Meu pylance parece pensar que essa torch.cuda.OutOfMemoryErrornão é uma classe de erro válida. (Veja a imagem.)

Porém, quando executo o código, ele é torch.sparse.mmexecutado, mostrando que a exceção foi detectada.

Por que o pylance pensa que é inválido quando funciona claramente?