Как совместно использовать переменные через сценарии в Python?

Если Вы хотите чтение и изменяете совместно используемые данные между 2 сценариями, которые работают отдельно, хорошее решение состояло бы в том, чтобы использовать в своих интересах модуль многопроцессорной обработки Python и использовать Канал () или Очередь () (см. различия здесь ). Таким образом, Вы добираетесь, чтобы синхронизировать сценарии и избежать проблем относительно параллелизма и глобальных переменных (как то, что происходит, если оба сценария хотят изменить переменную одновременно).

большая часть об использовании каналов/очередей - то, что можно передать объекты Python через них.

Также существуют методы, чтобы не ожидать данных, если там еще не был передан ( queue.empty () и pipeConn.poll () ).

Посмотрите, что пример использует Очередь () ниже:

    # main.py
    from multiprocessing import Process, Queue
    from stage1 import Stage1
    from stage2 import Stage2


    s1= Stage1()
    s2= Stage2()

    # S1 to S2 communication
    queueS1 = Queue()  # s1.stage1() writes to queueS1

    # S2 to S1 communication
    queueS2 = Queue()  # s2.stage2() writes to queueS2

    # start s2 as another process
    s2 = Process(target=s2.stage2, args=(queueS1, queueS2))
    s2.daemon = True
    s2.start()     # Launch the stage2 process

    s1.stage1(queueS1, queueS2) # start sending stuff from s1 to s2 
    s2.join() # wait till s2 daemon finishes

    # stage1.py
    import time
    import random

    class Stage1:

      def stage1(self, queueS1, queueS2):
        print("stage1")
        lala = []
        lis = [1, 2, 3, 4, 5]
        for i in range(len(lis)):
          # to avoid unnecessary waiting
          if not queueS2.empty():
            msg = queueS2.get()    # get msg from s2
            print("! ! ! stage1 RECEIVED from s2:", msg)
            lala = [6, 7, 8] # now that a msg was received, further msgs will be different
          time.sleep(1) # work
          random.shuffle(lis)
          queueS1.put(lis + lala)             
        queueS1.put('s1 is DONE')

    # stage2.py
    import time

    class Stage2:

      def stage2(self, queueS1, queueS2):
        print("stage2")
        while True:
            msg = queueS1.get()    # wait till there is a msg from s1
            print("- - - stage2 RECEIVED from s1:", msg)
            if msg == 's1 is DONE ':
                break # ends loop
            time.sleep(1) # work
            queueS2.put("update lists")             

РЕДАКТИРОВАНИЕ : просто найденный, что можно использовать queue.get (Ложь) для предотвращения блокировки при получении данных. Таким образом, там не является никакая потребность проверить сначала, пуста ли очередь. Это не возможно при использовании каналов.

Вы не сможете делать то, что хотите, не сохраняя информацию где-то вне двух экземпляров интерпретатора.
Если вам нужны просто простые переменные, вы можете легко выгрузить python dict в файл с модулем pickle в первом сценарии, а затем повторно загрузить его во втором сценарии. Пример:

one.py

import pickle

shared = {"Foo":"Bar", "Parrot":"Dead"}
fp = open("shared.pkl","w")
pickle.dump(shared, fp)

two.py

import pickle

fp = open("shared.pkl")
shared = pickle.load(fp)
print shared["Foo"]

То, что вы здесь пытаетесь сделать (сохранить общее состояние в модуле Python над отдельными интерпретаторами Python), не будет работать.

Значение в модуле может быть обновлено одним модуль, а затем читается другим модулем, но он должен находиться в том же интерпретаторе Python. Кажется, что вы здесь делаете своего рода межпроцессное взаимодействие; это может быть выполнено через сокетную связь между двумя процессами, но это значительно менее тривиально, чем то, что вы ожидаете от работы здесь.

Вам нужно сохранить переменную в каком-то постоянном файле. Для этого есть несколько модулей, в зависимости от ваших конкретных потребностей.

Модуль pickle и cPickle может сохранять и загружать большинство объектов Python в файл.

Модуль полки может хранить объекты Python в структуре, подобной словарю (с использованием pickle за кулисами).

Модули dbm / bsddb / dbhash / gdm могут хранить строковые переменные в структуре, подобной словарю.

Модуль sqlite3 может хранить данные в облегченной базе данных SQL.

Самая большая проблема с большинством из них заключается в том, что они не синхронизируются между разными процессами - если один процесс считывает значение, а другой записывает в хранилище данных, вы можете получить неверные данные или их повреждение. Чтобы обойти это, вам нужно будет написать собственный механизм блокировки файлов или использовать полноценную базу данных.

Я бы посоветовал вам использовать модуль multiprocessing . Вы не можете запустить два сценария из командной строки, но вы можете заставить два отдельных процесса легко взаимодействовать друг с другом.

Из примеров документа:

from multiprocessing import Process, Queue

def f(q):
    q.put([42, None, 'hello'])

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print q.get()    # prints "[42, None, 'hello']"
    p.join()

Использовать текстовые файлы или переменные среды. Поскольку они работают по отдельности, вы не можете делать то, что пытаетесь сделать.

In your example, the first script runs to completion, and then the second script runs. That means you need some sort of persistent state. Other answers have suggested using text files or Python's pickle module. Personally I am lazy, and I wouldn't use a text file when I could use pickle; why should I write a parser to parse my own text file format?

Instead of pickle you could also use the json module to store it as JSON. This might be preferable if you want to share the data to non-Python programs, as JSON is a simple and common standard. If your Python doesn't have json, get simplejson.

If your needs go beyond pickle or json -- say you actually want to have two Python programs executing at the same time and updating the persistent state variables in real time -- I suggest you use the SQLite database. Use an ORM to abstract the database away, and it's super easy. For SQLite and Python, I recommend Autumn ORM.