Не работает
one.py
import shared
shared.value = 'Hello'
raw_input('A cheap way to keep process alive..')
two.py
import shared
print shared.value
выполняется в двух командных строках как:
>>python one.py
>>python two.py
(второй получает ошибку атрибута, правильно).
Есть ли способ выполнить это, то есть поделиться переменной между двумя скриптами?
Надеюсь, что это хорошо, чтобы записать мои заметки об этой проблеме.
Прежде всего, я очень ценю пример в OP, потому что именно там я и начал - хотя это заставило меня думать, что shared - это какой-то встроенный модуль Python, пока я не нашел полный пример в [Tutor] Глобальные переменные между модулями?.
Однако, когда я искал "совместное использование переменных между скриптами" (или процессов) - помимо случая, когда Python script должен использовать переменные, определенные в других исходных файлах Python (но не обязательно запущенные процессы) - я в основном споткнулся в двух других случаях использования:
Таким образом, большинство обращений относительно "общих переменных" и "межпроцессного общения" (IPC) обсуждают такие случаи, как эти два; однако в обоих случаях можно наблюдать "родителя", к которому "дети" обычно имеют ссылку.
В то же время я заинтересован в нескольких вызовах одного и того же script, запускался независимо и обменивался данными между ними (как в Python: как разделить объект экземпляр через несколько вызовов script) в режиме singleton/single instance. Эта проблема на самом деле не устранена вышеупомянутыми двумя случаями - вместо этого она существенно сводится к примеру в OP (обмен переменными через два сценария).
Теперь, имея дело с этой проблемой в Perl, есть IPC::Shareable; который "позволяет привязать переменную к общей памяти", используя "целое число или 4 символьную строку [1], которая служит общим идентификатором для данных в пространстве процесса". Таким образом, нет временных файлов, а также сетевых настроек, которые я считаю отличными для моего варианта использования; поэтому я искал то же самое в Python.
Однако, как принятый ответ от @Drewfer отмечает: "Вы не сможете делать то, что хотите, не сохраняя информацию где-то внешнюю по отношению к двум экземпляры переводчика"; или другими словами: либо вы должны использовать настройку сети/сокета, либо вам нужно использовать временные файлы (ergo, нет общей RAM для "полностью отдельных сеансов python" ).
Теперь даже с этими соображениями трудно найти рабочие примеры (кроме pickle) - также в документах для mmap и multiprocessing. Мне удалось найти другие примеры, которые также описывают некоторые подводные камни, о которых не говорится в документах:
mmap: рабочий код в двух разных сценариях в Обмен данными Python между процессами с помощью mmap | блог schmichael
mmap - это просто специальный интерфейс для доступа к этому временному файлу.multiprocessing: рабочий код по адресу:
SyncManager (через manager.start()) с общим Queue; сервер пишет, клиенты читают (общие данные)BaseManager (через server.serve_forever()) с общим пользовательским классом; сервер пишет, клиент читает и пишетmultiprocessing и является рабочим примером SyncManager (через manager.start()) с общим dict; сервер ничего не делает, клиент читает и пишетБлагодаря этим примерам я привел пример, который по существу делает то же самое, что и пример mmap, с подходами из примера "синхронизировать python dict" - используя BaseManager (через manager.start() через файл адрес пути) с общим списком; как для чтения, так и для чтения и записи на сервере и клиенте (вставка ниже). Обратите внимание:
multiprocessing могут запускаться либо через manager.start(), либо server.serve_forever()
serve_forever() locks - start() неmultiprocessing есть средство автозапуска: он отлично работает с процессами start() ed, но, похоже, игнорирует те, что serve_forever()multiprocessing может быть IP (сокет) или временным файлом (возможно, с каналом?); в multiprocessing docs:
multiprocessing.Manager() - это просто функция (не экземпляр класса), которая возвращает SyncManager, который является специальным подклассом BaseManager; и использует start() - но не для IPC между независимо запущенными скриптами; здесь используется путь к файлуserve_forever() подход для IPC между сценариями с независимым запуском; здесь используется IP/адрес сокетаВ дополнение ко всем ловушкам в записи "synchronize a python dict" в случае списка есть дополнительные. Это сообщение отмечает:
Все манипуляции с dict должны выполняться с помощью методов, а не диктовых назначений (syncdict [ "blast" ] = 2 терпит неудачу из-за того, что многопроцессорность делится пользовательскими объектами)
Обходным путем для dict['key'] получения и настройки является использование открытых методов dict get и update. Проблема в том, что нет таких общедоступных методов, как альтернатива для list[index]; таким образом, для общего списка, кроме того, мы должны регистрировать методы __getitem__ и __setitem__ (которые являются частными для list) как exposed, что означает, что нам также необходимо перерегистрировать все общедоступные методы для list, а также :/
Ну, я думаю, что это были самые важные вещи; это два сценария - их можно просто запустить в отдельных терминалах (сначала сервер); примечание, разработанное на Linux с Python 2.7:
a.py (сервер):
import multiprocessing
import multiprocessing.managers
import logging
logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)
class MyListManager(multiprocessing.managers.BaseManager):
pass
syncarr = []
def get_arr():
return syncarr
def main():
# print dir([]) # cannot do `exposed = dir([])`!! manually:
MyListManager.register("syncarr", get_arr, exposed=['__getitem__', '__setitem__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'])
manager = MyListManager(address=('/tmp/mypipe'), authkey='')
manager.start()
# we don't use the same name as `syncarr` here (although we could);
# just to see that `syncarr_tmp` is actually <AutoProxy[syncarr] object>
# so we also have to expose `__str__` method in order to print its list values!
syncarr_tmp = manager.syncarr()
print("syncarr (master):", syncarr, "syncarr_tmp:", syncarr_tmp)
print("syncarr initial:", syncarr_tmp.__str__())
syncarr_tmp.append(140)
syncarr_tmp.append("hello")
print("syncarr set:", str(syncarr_tmp))
raw_input('Now run b.py and press ENTER')
print
print 'Changing [0]'
syncarr_tmp.__setitem__(0, 250)
print 'Changing [1]'
syncarr_tmp.__setitem__(1, "foo")
new_i = raw_input('Enter a new int value for [0]: ')
syncarr_tmp.__setitem__(0, int(new_i))
raw_input("Press any key (NOT Ctrl-C!) to kill server (but kill client first)".center(50, "-"))
manager.shutdown()
if __name__ == '__main__':
main()
b.py (клиент)
import time
import multiprocessing
import multiprocessing.managers
import logging
logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)
class MyListManager(multiprocessing.managers.BaseManager):
pass
MyListManager.register("syncarr")
def main():
manager = MyListManager(address=('/tmp/mypipe'), authkey='')
manager.connect()
syncarr = manager.syncarr()
print "arr = %s" % (dir(syncarr))
# note here we need not bother with __str__
# syncarr can be printed as a list without a problem:
print "List at start:", syncarr
print "Changing from client"
syncarr.append(30)
print "List now:", syncarr
o0 = None
o1 = None
while 1:
new_0 = syncarr.__getitem__(0) # syncarr[0]
new_1 = syncarr.__getitem__(1) # syncarr[1]
if o0 != new_0 or o1 != new_1:
print 'o0: %s => %s' % (str(o0), str(new_0))
print 'o1: %s => %s' % (str(o1), str(new_1))
print "List is:", syncarr
print 'Press Ctrl-C to exit'
o0 = new_0
o1 = new_1
time.sleep(1)
if __name__ == '__main__':
main()
Как последнее замечание, в Linux /tmp/mypipe создан - но он равен 0 байтам и имеет атрибуты srwxr-xr-x (для сокета); Я думаю, это радует меня, так как мне не нужно беспокоиться о сетевых портах, а также о временных файлах как таковых :)
Другие связанные вопросы:
Вы не сможете делать то, что хотите, не сохраняя информацию где-то внешнюю по отношению к двум экземплярам интерпретатора.
Если это просто простые переменные, которые вы хотите, вы можете легко сбрасывать питон python в файл с помощью модуля pickle в script one, а затем повторно загружать его в script два.
Пример:
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"]
sudo apt-get install memcached python-memcache
one.py
import memcache
shared = memcache.Client(['127.0.0.1:11211'], debug=0)
shared.set('Value', 'Hello')
two.py
import memcache
shared = memcache.Client(['127.0.0.1:11211'], debug=0)
print shared.get('Value')
То, что вы пытаетесь сделать здесь (сохранение общего состояния в модуле Python над отдельными интерпретаторами python), не будет работать.
Значение в модуле может быть обновлено одним модулем, а затем прочитано другим модулем, но это должно быть в пределах одного интерпретатора Python. То, что вы, кажется, делаете здесь, на самом деле своего рода межпроцессное общение; это может быть достигнуто через сокетную связь между двумя процессами, но это значительно менее тривиально, чем то, что вы ожидаете иметь здесь.
Вы можете использовать относительный простой файл mmap. Вы можете использовать shared.py для хранения общих констант. Следующий код будет работать с разными интерпретаторами Python\scripts\process
shared.py:
MMAP_SIZE = 16*1024
MMAP_NAME = 'Global\\SHARED_MMAP_NAME'
* "Глобальный" - это синтаксис Windows для глобальных имен
one.py:
from shared import MMAP_SIZE,MMAP_NAME
def write_to_mmap():
map_file = mmap.mmap(-1,MMAP_SIZE,tagname=MMAP_NAME,access=mmap.ACCESS_WRITE)
map_file.seek(0)
map_file.write('hello\n')
ret = map_file.flush() != 0
if sys.platform.startswith('win'):
assert(ret != 0)
else:
assert(ret == 0)
two.py:
from shared import MMAP_SIZE,MMAP_NAME
def read_from_mmap():
map_file = mmap.mmap(-1,MMAP_SIZE,tagname=MMAP_NAME,access=mmap.ACCESS_READ)
map_file.seek(0)
data = map_file.readline().rstrip('\n')
map_file.close()
print data
* Этот код был написан для Windows, Linux может нуждаться в небольших корректировках
больше информации на - https://docs.python.org/2/library/mmap.html
Вам нужно сохранить переменную в каком-то постоянном файле. Для этого есть несколько модулей, в зависимости от вашей конкретной потребности.
Модуль pickle и cPickle может сохранять и загружать большинство объектов python в файл.
Модуль полки может хранить объекты python в словаре-подобной структуре (используя рассол за кулисами).
Модули 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()
Используйте текстовые файлы или переменные среды. Поскольку эти два варианта выполняются отдельно, вы не можете делать то, что вы пытаетесь сделать.
В вашем примере первый script запускается до завершения, а затем запускается второй script. Это означает, что вам нужно какое-то постоянное состояние. Другие ответы предложили использовать текстовые файлы или Python pickle. Лично я ленив, и я бы не использовал текстовый файл, когда мог использовать pickle; почему я должен писать парсер для анализа собственного формата текстового файла?
Вместо pickle вы также можете использовать модуль json для хранения его как JSON. Это может быть предпочтительнее, если вы хотите поделиться данными с программами, отличными от Python, поскольку JSON - простой и общий стандарт. Если ваш Python не имеет json, получите simplejson.
Если ваши потребности превышают pickle или json - скажем, вы действительно хотите, чтобы одновременно выполнялись две программы Python и обновляли постоянные переменные состояния в реальном времени - я предлагаю вам использовать SQLite. Используйте ORM для абстрагирования базы данных, и это очень просто. Для SQLite и Python я рекомендую Autumn ORM.
Redis для предоставления динамической переменной:from redis import Redis
from time import sleep
cli = Redis('localhost')
shared_var = 1
while True:
cli.set('share_place', shared_var)
shared_var += 1
sleep(1)
$ python script_one.py
from time import sleep
from redis import Redis
cli = Redis('localhost')
while True:
print(int(cli.get('share_place')))
sleep(1)
$ python script_two.py
Out:
1
2
3
4
5
...
$ pip install redis
$ apt-get install redis-server
Если вы хотите читать и изменять общие данные между двумя сценариями, которые выполняются отдельно, хорошим решением было бы воспользоваться модулем многопроцессорной обработки python и использовать Pipe() или Queue() (см. различия здесь). Таким образом вы сможете синхронизировать сценарии и избежать проблем, связанных с параллелизмом и глобальными переменными (например, что произойдет, если оба сценария захотят изменить переменную одновременно).
Лучшее в использовании каналов/очередей - то, что вы можете передавать через них объекты Python.
Также есть методы, позволяющие избежать ожидания данных, если они еще не были переданы (queue.empty() и pipeConn.poll()).
Смотрите пример использования Queue() ниже:
# 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(False), чтобы избежать блокировки при получении данных. Таким образом, нет необходимости сначала проверять, пуста ли очередь. Это невозможно, если вы используете pipes.