Início / user-17580381

DarkKnight's questions

Martin Hope
Adon Bilivit
Asked: 2025-04-23 20:58:07 +0800 CST
  • 6

Tenho uma planilha grande do Excel. Só me interessam certas colunas. Além disso, só me interessam linhas em que colunas específicas atendem a determinados critérios.

As seguintes obras:

import pandas as pd
import warnings

# this suppresses the openpyxl warning that we're seeing
warnings.filterwarnings("ignore", category=UserWarning, module="openpyxl")

# These are the columns we're interested in
COLUMNS = [
    "A",
    "B",
    "C"
]

# the source file
XL = "source.xlsx"
# sheet name in the source file
SHEET = "Sheet1"
# the output file
OUTPUT = "target.xlsx"
# the sheet name to be used in the output file
OUTSHEET = "Sheet1"

# This loads the entire spreadsheet into a pandas dataframe
df = pd.read_excel(XL, sheet_name=SHEET, usecols=COLUMNS).dropna()
# this replaces the original dataframe with rows where A contains "FOO"
df = df[df["A"].str.contains(r"\bFOO\b", regex=True)]
# now isolate those rows where the B contains "BAR"
df = df[df["B"].str.contains(r"\bBAR\b", regex=True)]
# output to the new spreadsheet
df.to_excel(OUTPUT, sheet_name=OUTSHEET, index=False)

Isso funciona. No entanto, não consigo deixar de pensar que pode haver uma maneira melhor de gerenciar os critérios de seleção, especialmente se/quando eles se tornarem mais complexos.

Ou será que o "passo a passo" é bom?

python
Martin Hope
SIGHUP
Asked: 2024-10-09 23:38:56 +0800 CST
  • 5

No exemplo visto em superfastpython.com , o tamanho de um segmento de memória compartilhada a ser usado para dar suporte a uma matriz numpy unidimensional é calculado como o número de elementos multiplicado pelo tamanho do tipo de dados.

Sabemos que o parâmetro de tamanho dado ao construtor SharedMemory é um minimum . Assim, em muitos casos, o tamanho real pode ser maior do que o especificado - e isso é bom.

Mas e se o tamanho especificado for um múltiplo exato do tamanho da página de memória subjacente?

Considere isto:

import numpy as np
from multiprocessing.shared_memory import SharedMemory

n = 2048
s = n * np.dtype(np.double).itemsize
shm = SharedMemory(create=True, size=s)
try:
    assert s == shm.size
    a = np.ndarray((n,), dtype=np.double, buffer=shm.buf)
    a.fill(0.0)
finally:
    shm.close()
    shm.unlink()

Neste caso (Python 13.3.0 no macOS 15.0.1) o valor de s é 16.384, que é um múltiplo preciso do tamanho da página subjacente e, portanto, shm.size é igual a s

Talvez eu não saiba o suficiente sobre numpy, mas imaginei que o ndarray precisaria de mais espaço para estruturas internas/de gerenciamento.

Alguém pode explicar por que isso funciona e por que não há necessidade aparente de permitir espaço extra no segmento de memória compartilhada?

python