Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

hello

  1. User

    hello

  2. Assistant

    Hello! How can I assist you today?

  3. User

    usar variáveis de ambiente para partilhar um valor de uma variável entre dois scripts Python: tenho dois scripts #scriptA.py import os import subprocess import time

    def main(): caminho_para_o_script = ‘C:\meu\scriptb.py’ subprocess.Popen([‘python’, caminho_para_o_script]) minh = os.getenv(‘MINHA’, ‘valor original’) print(f’No scriptA, minha = {minh}')

    while True: time.sleep(5) minh = os.getenv(‘MINHA’) print(“—scriptA----”,minh)

    if name == “main”: main()

    #scriptB.py import os import time

    def main(): os.environ[‘MINHA’] = ‘123’

    while True: time.sleep(3) minh = os.getenv(‘MINHA’, ‘valor original’) print(“—scriptB----”,minh)

    if name == “main”: main() mas a saida vem: —scriptB---- 123 —scriptA---- None —scriptB---- 123 —scriptB---- 123 —scriptA---- None —scriptB---- 123 —scriptB---- 123 —scriptA---- None —scriptB---- 123 —scriptA---- None não há partilha!

  4. Assistant

    Olá! Parece que você está tentando compartilhar o valor de uma variável entre dois scripts Python usando variáveis de ambiente. No entanto, você não está obtendo o resultado esperado.

    O motivo pelo qual não está funcionando é porque cada script Python executado possui seu próprio ambiente separado. Portanto, quando você define a variável de ambiente 'MINHA' no scriptB.py, ela não é automaticamente compartilhada com o scriptA.py.

    Uma solução possível é fazer com que ambos os scripts compartilhem um arquivo de texto onde o valor da variável é armazenado e lido por ambos. Dessa forma, os scripts podem se comunicar escrevendo e lendo do mesmo arquivo. Veja um exemplo:

    #scriptA.py import time

    def main(): filename = 'shared_var.txt' while True: with open(filename, 'r') as file: minh = file.readline() print("---scriptA---", minh.strip()) time.sleep(5)

    if name == "main": main()

    #scriptB.py import time

    def main(): filename = 'shared_var.txt' while True: with open(filename, 'w') as file: file.write("123\n") time.sleep(3)

    if name == "main": main()

    Nesse exemplo, o scriptA.py lê o valor armazenado no arquivo compartilhado 'shared_var.txt' a cada 5 segundos. O scriptB.py escreve o valor "123" no mesmo arquivo a cada 3 segundos. Dessa forma, o valor pode ser compartilhado entre os dois scripts.

    Espero que isso ajude! Se tiver alguma dúvida, fique à vontade para perguntar.

  5. User

    Não há uma forma de partilhar uma memória que seja Ram entre dois scripts Python para partilhar variáveis.

  6. Assistant

    Sim, é possível compartilhar variáveis entre dois scripts Python usando memória compartilhada. Uma opção comumente usada para isso é o módulo multiprocessing do Python, que permite criar processos diferentes que podem compartilhar dados por meio de objetos compartilhados.

    Aqui está um exemplo de como compartilhar uma variável entre dois scripts usando memória compartilhada:

    //scriptA.py import time from multiprocessing import shared_memory, Process

    def main(): # Cria uma memória compartilhada e escreve um valor inicial nela shm = shared_memory.SharedMemory(create=True, size=100) shared_var = shm.buf shared_var.value = b'valor original'

    # Define a função que será executada pelo processo filho
    def scriptB(shared_var):
        while True:
            print("---scriptB---", shared_var.value)
            time.sleep(3)
    
    # Cria o processo filho
    processB = Process(target=scriptB, args=(shared_var,))
    processB.start()
    
    while True:
        print("---scriptA---", shared_var.value)
        time.sleep(5)
    
    # Libera a memória compartilhada
    shm.close()
    shm.unlink()
    

    if name == "main": main()

    Nesse exemplo, o scriptA.py cria uma memória compartilhada usando o objeto shared_memory.SharedMemory. A variável compartilhada é inicializada com o valor "valor original". Em seguida, é criado um processo filho scriptB que recebe a variável compartilhada como argumento. Tanto o scriptA.py quanto o scriptB.py imprime o valor da variável compartilhada a cada 5 segundos e 3 segundos, respectivamente.

    Execute o scriptA.py e ele iniciará o processo filho scriptB.py. Os dois scripts compartilharão a mesma memória e poderão acessar e modificar a variável compartilhada.

    Espero que isso seja útil! Se tiver mais perguntas, sinta-se à vontade para perguntar.

  7. User

    Podias adaptar o exemplo para duas variáveis, uma do tipo inteiro com o nome numeroA e a outra do tipo string com o nome nomeA

  8. Assistant

    Claro! Aqui está o exemplo adaptado com duas variáveis compartilhadas, uma do tipo inteiro chamada "numeroA" e outra do tipo string chamada "nomeA":

    //scriptA.py import time from multiprocessing import shared_memory, Process

    def main(): # Cria uma memória compartilhada para o inteiro e escreve um valor inicial nele int_shm = shared_memory.SharedMemory(create=True, size=4) numeroA = shared_memory.RawValue('i', 0) # Valor inicial: 0

    # Cria uma memória compartilhada para a string e escreve um valor inicial nela
    str_shm = shared_memory.SharedMemory(create=True, size=50)
    nomeA = shared_memory.RawArray('c', b'nome original')  # Valor inicial: 'nome original'
    
    # Define a função que será executada pelo processo filho
    def scriptB(numeroA, nomeA):
        while True:
            print("---scriptB---")
            print("numeroA:", numeroA.value)
            print("nomeA:", nomeA.value.decode())
            time.sleep(3)
    
    # Cria o processo filho
    processB = Process(target=scriptB, args=(numeroA, nomeA))
    processB.start()
    
    while True:
        # Modifica os valores das variáveis compartilhadas
        numeroA.value += 1
        nomeA.value = b"novo nome"
    
        print("---scriptA---")
        print("numeroA:", numeroA.value)
        print("nomeA:", nomeA.value.decode())
        time.sleep(5)
    
    # Libera a memória compartilhada
    int_shm.close()
    int_shm.unlink()
    str_shm.close()
    str_shm.unlink()
    

    if name == "main": main()

    Neste exemplo, definimos duas memórias compartilhadas: uma para o inteiro "numeroA" e outra para a string "nomeA". Os valores iniciais são definidos como 0 e "nome original", respectivamente.

    O processo filho scriptB.py imprime os valores das variáveis compartilhadas a cada 3 segundos. O scriptA.py modifica esses valores a cada 5 segundos antes de imprimir suas informações.

    Espero que isso ajude! Se você tiver mais perguntas, sinta-se à vontade para perguntar.

  9. User

    Juntaste o script A com o script B. Não vejo onde é que começa o script B

  10. Assistant

    Peço desculpas pela confusão. Vou corrigir o exemplo e separar adequadamente o scriptA.py e o scriptB.py.

    scriptA.py:

    import time
    from multiprocessing import shared_memory, Process
    
    def main():
        # Cria uma memória compartilhada para o inteiro e lê o valor inicial dele
        int_shm = shared_memory.SharedMemory(name='numeroA')
        numeroA = shared_memory.RawValue('i', 0)
        numeroA = shared_memory.RawValue('i', numeroA.value)
    
        # Cria uma memória compartilhada para a string e lê o valor inicial dela
        str_shm = shared_memory.SharedMemory(name='nomeA')
        nomeA = shared_memory.RawArray('c', b'nome original')
        nomeA = shared_memory.RawArray('c', nomeA)
    
        # Define a função que será executada pelo processo filho
        def scriptB(numeroA, nomeA):
            while True:
                print("---scriptB---")
                print(f"numeroA: {numeroA.value}")
                print(f"nomeA: {nomeA.value.decode()}")
                time.sleep(3)
    
        # Cria o processo filho
        processB = Process(target=scriptB, args=(numeroA, nomeA))
        processB.start()
    
        while True:
            # Modifica os valores das variáveis compartilhadas
            numeroA.value += 1
            nomeA.value = b"novo nome"
    
            print("---scriptA---")
            print(f"numeroA: {numeroA.value}")
            print(f"nomeA: {nomeA.value.decode()}")
            time.sleep(5)
    
        # Libera a memória compartilhada
        int_shm.close()
        str_shm.close()
    
    if __name__ == "__main__":
        main()
    

    scriptB.py:

    import time
    from multiprocessing import shared_memory
    
    def main():
        # Cria uma memória compartilhada para o inteiro e escreve um valor inicial nele
        int_shm = shared_memory.SharedMemory(name='numeroA')
        numeroA = shared_memory.RawValue('i', 0)
        numeroA = shared_memory.RawValue('i', numeroA.value)
    
        # Cria uma memória compartilhada para a string e escreve um valor inicial nela
        str_shm = shared_memory.SharedMemory(name='nomeA')
        nomeA = shared_memory.RawArray('c', b'nome original')
        nomeA = shared_memory.RawArray('c', nomeA)
    
        while True:
            print("---scriptB---")
            print(f"numeroA: {numeroA.value}")
            print(f"nomeA: {nomeA.value.decode()}")
            time.sleep(3)
    
        # Libera a memória compartilhada
        int_shm.close()
        str_shm.close()
    
    if __name__ == "__main__":
        main()
    

    No scriptA.py, criamos e lemos as memórias compartilhadas para "numeroA" e "nomeA" antes de iniciar o processo filho scriptB.py. Em seguida, modificamos os valores das variáveis compartilhadas e imprimimos suas informações a cada intervalo de tempo.

    No scriptB.py, apenas lemos as memórias compartilhadas e imprimimos suas informações a cada intervalo de tempo.

    Dessa forma, os dois scripts irão compartilhar as variáveis "numeroA" e "nomeA" por meio de memória compartilhada.

    Espero que isso esteja mais claro agora. Se você tiver mais perguntas, sinta-se à vontade para perguntar.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.