Perguntas[python](coding)

Então, quando executo o Pytube dentro do script, ele leva 30 segundos para terminar, mas quando executo em uma função, ele leva apenas 0,96 segundos para terminar. Por quê? Alguém pode explicar em termos simples, já que sou iniciante em Python?

aqui levou apenas 0,96 segundos para terminar "dentro de uma função"

aqui demorou 30s para terminar em uma linha normal

e a função realmente pega todos os vídeos? porque eu imprimo o índice aleatório e ele me dá um pequeno número como 60 de 3000 vídeos aqui está o script

import pytube
import time
StarterTick = time.time()
print(StarterTick,type(StarterTick))
VideoList = "list=PLKB9puQeauyBTnMmRWsB4VVfbbWR0tKCc"
PlayList = f"https://www.youtube.com/playlist?{VideoList}"

def getRandomVideo():
    PlayListVideos = pytube.contrib.playlist.Playlist(PlayList,)
    randomIndex = random.randint(0,len(PlayList) -1) # -1 cuz list start with 0 so if we have 5 items it would be 4 but len would return 5 
    print(f"your random index is {randomIndex}")
    return PlayListVideos[randomIndex] # just return a random video from youtube list


# this way it takes 30 s to finish PlayListVideos = pytube.contrib.playlist.Playlist(PlayList)

print(f"here is your random Video {getRandomVideo()}")
print("programm finished")
print(f"THe programm took {time.time() - StarterTick:>3.2f} seconds to finish")

Resumindo um problema maior ao essencial, eu gostaria de fazer o seguinte:

import numpy as np
import pandas as pd

df = pd.DataFrame({'a': np.random.randint(0, 5, 1000), 'b': np.random.random(1000)})

for aval, subdf in df.groupby('a'):
    subdf.to_parquet(f'/tmp/{aval}.parquet')

em Polares usando LazyFrame:

import numpy as np
import pandas as pd
import polars as pl

df = pd.DataFrame({'a': np.random.randint(0, 5, 1000), 'b': np.random.random(1000)})

lf = pl.LazyFrame(df)
# ???

Gostaria de poder controlar o nome dos arquivos de saída de maneira semelhante.

Obrigado!

Veja meu exemplo mínimo abaixo para reproduzir o problema:

import logging
import logging.config


def test_logging(caplog):
    LOGGING_CONFIG = {
        "version": 1,
        "disable_existing_loggers": False,
        "formatters": {
            "default": {
                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
            },
        },
        "handlers": {
            "console": {
                "class": "logging.StreamHandler",
                "formatter": "default",
                "level": "DEBUG",
            },
        },
        "loggers": {
            "": {  # root logger
                "handlers": ["console"],
                "level": "DEBUG",
                "propagate": True,
            },
        },
    }

    logging.config.dictConfig(LOGGING_CONFIG)

    logger = logging.getLogger("root_module.sub1.sub2")
    logger.setLevel(logging.DEBUG)

    assert logger.propagate is True
    assert logger.getEffectiveLevel() == logging.DEBUG

    with caplog.at_level(logging.DEBUG):
        logger.debug("🔥 DEBUG msg")
        logger.info("📘 INFO msg")
        logger.warning("⚠️ WARNING msg")
        logger.error("❌ ERROR msg")
        logger.critical("💀 CRITICAL msg")

    print("🔥 caplog.messages:", caplog.messages)

    # Final assertion
    assert any("CRITICAL" in r or "💀" in r for r in caplog.messages)

Saídas em execução pytest -s:

tests/test_logs.py 2025-04-16 17:06:03,983 - root_module.sub1.sub2 - DEBUG - 🔥 DEBUG msg
2025-04-16 17:06:03,983 - root_module.sub1.sub2 - INFO - 📘 INFO msg
2025-04-16 17:06:03,983 - root_module.sub1.sub2 - WARNING - ⚠️ WARNING msg
2025-04-16 17:06:03,983 - root_module.sub1.sub2 - ERROR - ❌ ERROR msg
2025-04-16 17:06:03,983 - root_module.sub1.sub2 - CRITICAL - 💀 CRITICAL msg
🔥 caplog.messages: []

A versão do Pytest é 8.3.5. Não acho que importe, mas meu setup.cfg:

[tool:pytest]
testpaths =
    tests

Espero caplog.recordsconter todos os 5 logs, mas é uma lista vazia.

Eu escrevi este código apenas para ler um arquivo csv:

import pandas as pd
df = pd.read_table('C:\\XXXXX\\Python_Learn\\pandas.csv')
print(df.to_string())

e a saída para isso vem como abaixo:

  Date|Invoice ID|Customer Name|Product|Category|Quantity|Unit Price|Total Amount|Region|Salesperson
0      2025-04-01|INV1001|John Smith|Apple iPhone 14|Electronics|1|999.00|999.00|North|Alice Johnson
1           2025-04-01|INV1002|Jane Doe|Samsung TV 55|Electronics|2|600.00|1200.00|NULL|Bob Williams
2               2025-04-02|INV1003|Michael Lee|Nike Sneakers|Apparel|3|120.00|360.00|West|Carol Chen
3             2025-04-02|INV1004|Emma Brown|Office Chair|Furniture|1|150.00|150.00|South|David Patel
4          2025-04-03|INV1005|Olivia Green|HP Laptop|Electronics|1|850.00|850.00|North|Alice Johnson
5             2025-04-03|INV1006|Noah White|Dining Table|Furniture|1|450.00|450.00|NULL|Bob Williams
6                    2025-04-04|INV1007|Ava Scott|Levis Jeans|Apparel|2|80.00|160.00|West|Carol Chen
7             2025-04-04|INV1008|Liam Davis|AirPods Pro|Electronics|2|250.00|500.00|NULL|David Patel

Por que minha saída está sendo alinhada à direita?

Adicionei .strip(), mas ainda dá o mesmo resultado.

Atualização: Atualizei meu código com .read_csv() em vez de .read_table() e isso melhorou a saída em termos de alinhamento, mas agora ele não mostra caracteres no lado direito do arquivo.

import pandas as pd
df = pd.read_csv('C:\\XXXXX\\Python_Learn\\pandas.csv')
print(df)

Saída como abaixo,

  Date|Invoice ID|Customer Name|Product|Category|Quantity|Unit Price|Total Amount|Region|Salesperson
0  2025-04-01|INV1001|John Smith|Apple iPhone 14|...
1  2025-04-01|INV1002|Jane Doe|Samsung TV 55|Elec...
2  2025-04-02|INV1003|Michael Lee|Nike Sneakers|A...
3  2025-04-02|INV1004|Emma Brown|Office Chair|Fur...
4  2025-04-03|INV1005|Olivia Green|HP Laptop|Elec...
5  2025-04-03|INV1006|Noah White|Dining Table|Fur...
6  2025-04-04|INV1007|Ava Scott|Levis Jeans|Appar...
7  2025-04-04|INV1008|Liam Davis|AirPods Pro|Elec...

Por que ele mostra ... em vez de ler o conteúdo no lado direito do arquivo?

Estou tentando criar um arquivo oculto no Windows usando Python, mas depois de ocultá-lo, fica impossível escrever. No entanto, ler este arquivo é possível.

import ctypes

with open("test.txt", "r") as f: print('test')

ctypes.windll.kernel32.SetFileAttributesW("test.txt", 0x02) # adding h (hidden) attribute to a file

with open("test.txt", "r") as f: print('test') # works
with open("test.txt", "w") as f: print('test') # error

Erro:

Traceback (most recent call last):
  File "C:\Users\user\Documents\client\test.py", line 8, in <module>
    with open("test.txt", "w") as f: print('test') # error
PermissionError: [Errno 13] Permission denied: 'test.txt'

Usar 0x22(que é aatributo e hatributo) em vez de 0x02não ajuda. O mesmo erro ocorre. Depois de tornar o arquivo visível novamente via , attrib -H test.txttorna-se possível abri-lo em modo de gravação. No entanto, até onde eu sei, arquivos ocultos devem ser graváveis ​​no Windows.

SO: Windows 11

Versão do Python: Python 3.10.2

Quero ler dados do meu Arduino e mostrá-los em uma janela do Tkinter. Funciona bem, mas quando envio os dados para o Arduino a cada 10 ms, ele revisa muitas linhas que não estão completas, como esta:

 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']
⚠️ Invalid line, skipped: ['0', '0', '0', '0', '0', '0', '0', '0', '0', 'Malik']

O estranho é que quando envio a 10 ms, funciona, mas às vezes não funciona quando movo a janela. Espero que alguém possa me ajudar. Aqui está o meu código:

    def read_Serial_Values(self):
        read_Line = ReadLine(ser)
        self.raw_Input = read_Line.readline().decode('utf-8').strip()
        # if self.is_Data_Here():
        #     print("!Overload!")
        #     self.trash = ser.read_all()
        self.raw_Listet_Input = [x for x in self.raw_Input.split(",") if x]
        if len(self.raw_Listet_Input) < 21:
            print("⚠️ Invalid line, skipped:", self.raw_Listet_Input)
            return
        self.Inp_manager.save_Repeating_Input(self.raw_Listet_Input)

    def is_Data_Here(self):
        if ser.in_waiting >0:
            return True
        return False
               

class ReadLine:
    def __init__(self, s):
        self.buf = bytearray()
        self.s = s
    
    def readline(self):
        i = self.buf.find(b"\n")
        if i >= 0:
            r = self.buf[:i+1]
            self.buf = self.buf[i+1:]
            return r
        while True:
            i = max(1, min(2048, self.s.in_waiting))
            data = self.s.read(i)
            i = data.find(b"\n")
            if i >= 0:
                r = self.buf + data[:i+1]
                self.buf[0:] = data[i+1:]
                return r
            else:
                self.buf.extend(data)

Tentei alterar o tempo limite, mas isso não mudou nada e também mudei a maneira como o programa recebe as linhas.

Tenho uma página NiceGUI com uma imagem SVG composta por dois elementos (um círculo e um quadrado). Preciso verificar qual elemento dessa imagem foi clicado quando a imagem SVG foi clicada, para que eu possa lidar com isso.

Quero que o evento "círculo clicado" seja acionado quando o círculo for clicado, e o evento "quadrado clicado" seja acionado quando o quadrado for clicado. Estou tentando implementar isso por meio de um manipulador, mas não sei o que escrever na função do manipulador. Estou anexando o código.

Meu método 1:

from nicegui import ui

def my_handler(event_args):
    print("Button clicked!")

with ui.row():
    svg_element = ui.html('''
        <svg width="200" height="200" style="border: 1px solid black;">
            <circle cx="50" cy="50" r="40" fill="red" class="clickable-circle"/>
            <rect x="100" y="10" width="80" height="80" fill="blue" class="clickable-square"/>
        </svg>
    ''')

    svg_element.on('click', js_handler='(click) => { console.log(event.target.clickable-circle); }')

ui.run(port = 8082)

Meu método 2:

from nicegui import ui


def my_handler(event_args):
    element = event_args.sender
    # ???????


with ui.row():
    svg_element = ui.html('''
        <svg width="200" height="200" style="border: 1px solid black;">
            <circle cx="50" cy="50" r="40" fill="red" class="clickable-circle"/>
            <rect x="100" y="10" width="80" height="80" fill="blue" class="clickable-square"/>
        </svg>
    ''')

    svg_element.on('click', handler=my_handler)

ui.run(port=8082)

Obrigado a todos pela ajuda.

Estou tentando criar um projeto com imagens armazenadas e, entre elas, precisamos encontrar uma imagem semelhante/igual à imagem de entrada. Para a entrada, estou tentando encontrar uma maneira de garantir que a entrada seja, de fato, o caminho para a imagem (imagem de entrada) e, caso contrário, uma imagem mostre um erro ao usuário. Consigo garantir que o caminho inserido exista, mas não se o caminho mostra uma imagem ou algum outro arquivo. Alguém pode me ajudar?

Estou quebrando a cabeça com essa pergunta, provavelmente bem simples, e não consigo encontrar a resposta em lugar nenhum. Quero criar uma nova coluna com a soma agrupada de outra coluna, mas quero manter todas as linhas individuais. Então, aqui está o que a documentação diz:

import polars as pl

df = pl.DataFrame(
    {
        "a": ["a", "b", "a", "b", "c"],
        "b": [1, 2, 1, 3, 3],
    }
)

df.group_by("a").agg(pl.col("b").sum())  

O resultado disso seria:

shape: (3, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ a   ┆ 2   │
│ c   ┆ 3   │
│ b   ┆ 5   │
└─────┴─────┘

No entanto, o que eu preciso é disto:

shape: (5, 3)
┌─────┬─────┬────────┐
│ a   ┆ b   ┆ sum(b) │
│ --- ┆ --- ┆ ------ │
│ str ┆ i64 ┆ i64    │
╞═════╪═════╪════════╡
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 2   ┆ 5      │
│ a   ┆ 1   ┆ 2      │
│ b   ┆ 3   ┆ 5      │
│ c   ┆ 3   ┆ 3      │
└─────┴─────┴────────┘

Eu poderia criar a soma em um df separado e depois uni-la ao original, mas tenho certeza de que há uma solução mais fácil.

Estou experimentando usar a API C do CPython e gerenciar dependências (por exemplo, setuptools) via poetry.

Para compilar meu código, escrevi um Makefile parecido com isto:

PYTHON = poetry run python

build: setup.py ...some C extension files...
    $(PYTHON) setup.py build_ext
    $(PYTHON) setup.py build_ext -i

O problema é que quando vou executá-lo, recebo isto:

$ make
poetry run python setup.py build_ext
make: poetry: No such file or directory
make: *** [build] Error 1

Ainda mais estranho:

$ type poetry
poetry is /Users/rusty/.local/bin/poetry
$ which poetry
$ echo $?
1

Pensei nisso whiche typeretornaria exatamente os mesmos resultados.

Verifiquei meu $PATHe ele contém o diretório ~/.local/bin(não /Users/rusty/.local/bin, literalmente, ~/.local/bincaso isso ajude) (onde o pypoetry está instalado) duas vezes.

Estou no macOS 15.3.2.

Por favor, não me dê sugestões como "não use poesia".

EDIT: Quando executo poetryno meu terminal, funciona bem:

$ poetry --version
Poetry (version 2.0.1)

Além disso, ~/.local/bin/poetryé um link simbólico para outro arquivo que pode ser lido e executado por todos.