मॉड्यूल (पायथन में) के बीच यादृच्छिक के बीज को साझा करने का कोई अच्छा तरीका है?

Question

मेरे पास विभिन्न मुख्य फ़ाइलों (विभिन्न सिमुलेशन के लिए) के साथ एक प्रोजेक्ट है। जब मैं मेनफाइल में से किसी एक को चलाता हूं, तो इसे बीज को यादृच्छिक (और numpy.random) पर सेट करना चाहिए, और प्रोजेक्ट के सभी मॉड्यूल को उस बीज का उपयोग करना चाहिए।

मुझे ऐसा करने का कोई अच्छा तरीका नहीं मिला है। मैं इस के साथ एक फ़ाइल globals.py है:

import random 

myRandom=None 


def initSeed(seed): 
    global myRandom 
    myRandom =random.Random(seed) 

तो एक मुख्य से

मुझे क्या करना:

if __name__ == "__main__": 

    seed=10 
    globals.initSeed(seed) 
... 

फिर मॉड्यूल है कि मुख्य कॉल, मैं क्या में

:

from globals import myRandom 

लेकिन myRandom में मान है मॉड्यूल में कोई नहीं (भले ही मैंने इसे मुख्य रूप में संशोधित किया हो!)। क्यों, और इसे कैसे ठीक करें? क्या कोई अच्छा रास्ता है?

Answer 1

1. टिप्पणी में @jDo से उल्लेख किया है, randGlobal.py में globals.py नाम दिया।

2. परीक्षण के लिए एक मॉड्यूल testResult.py जोड़ा गया।

---

randGlobal.py

import random 

def initSeed(seed): 
    # declare 
    global myRandom 
    myRandom = random.Random(seed) 

testResult.py

import randGlobal 

def randOutput(): 
    return randGlobal.myRandom.random() 

main.py

import randGlobal 

# Add a module for testing 
import testResult 


def test(): 
    result = testResult.randOutput() 
    print result 


# main 
if __name__ == "__main__": 

    seed=10 
    randGlobal.initSeed(seed) 
    # after init, hava a test 
    test() 

Answer 2

मैं एक फ़ाइल का उपयोग करेंगे 01,235,309 से बचने के लिएऔर डेटा और तर्क को थोड़ा अलग करने के लिए।

seed_handler.py

# file that stores the shared seed value 
seed_val_file = "seed_val.txt" 

def save_seed(val, filename=seed_val_file): 
    """ saves val. Called once in simulation1.py """ 
    with open(filename, "wb") as f: 
     f.write(str(val)) 

def load_seed(filename=seed_val_file): 
    """ loads val. Called by all scripts that need the shared seed value """ 
    with open(filename, "rb") as f: 
     # change datatype accordingly (numpy.random.random() returns a float) 
     return int(f.read()) 

simulation1.py

import random 
import seed_handler 

def sim1(): 
    """ creates a new seed and prints a deterministic "random" number """ 
    new_seed = int("DEADBEEF",16) # Replace with numpy.random.random() or whatever 
    print "New seed:", new_seed 
    # do the actual seeding of the pseudo-random number generator 
    random.seed(new_seed) 
    # the result 
    print "Random: ", random.random() 
    # save the seed value so other scripts can use it 
    seed_handler.save_seed(new_seed) 

if __name__ == "__main__": 
    sim1() 

simulation2.py

import random 
import seed_handler 

def sim2(): 
    """ loads the old seed and prints a deterministic "random" number """ 
    old_seed = seed_handler.load_seed() 
    print "Old seed:", old_seed 
    # do the actual seeding of the pseudo-random number generator 
    random.seed(old_seed) 
    # the result 
    print "Random: ", random.random() 

if __name__ == "__main__": 
    sim2() 

आउटपुट:

user@box:~/$ python simulation1.py 
New seed: 3735928559 
Random: 0.0191336454935 

user@box:~/$ python simulation2.py 
Old seed: 3735928559 
Random: 0.0191336454935 

परिशिष्ट

मैं सिर्फ टिप्पणी में पढ़ा है कि इस शोध के लिए है। फिलहाल, सिमुलेशन 1.py निष्पादित संग्रहित बीज मान को ओवरराइट करता है; यह वांछनीय नहीं हो सकता है। कोई इन सुविधाओं में से एक जोड़ सकता है:

1. जेसन के रूप में सहेजें और शब्दकोश में लोड करें; इस तरह कुछ भी अधिलेखित नहीं होगा और प्रत्येक बीज मूल्य में नोट्स, एक टाइमस्टैम्प और इसके साथ जुड़े उपयोगकर्ता द्वारा जेनरेट किए गए लेबल हो सकते हैं।
2. उपयोगकर्ता को मौजूदा मान को ओवरराइट करने के लिए बस हाँ/नहीं के लिए संकेत दें।