Why doesn't a global variable keep its value when passed to a child process launched with multiprocessing.Process?

Rounding out Trauma's answer a bit.

There are different ways to implement the new process and it basically depends on the operating system in turn, the two main and best known ways (in very broad strokes) are:

• fork: in this case a copy of the parent process is created, the child process is already in possession of exactly the same resources as the parent, every data structure, open file, connection, etc. that existed in the parent process is still there and you can use on the secondary immediately. From here a fork occurs (hence the "fork") and each process continues its work on its own. Process creation is much faster and lighter on resources.

• spawn: in this case a new process is created from scratch, with its own Python interpreter and loads all the modules again .

The method forkis typical of POSIX systems and will therefore not be available in some cases, such as in Windows, which lacks the ability to call fork().

In the case of using spawn, a new interpreter is launched and it executes the module again (imports everything again, instantiates global objects from scratch, etc), it is almost as if we execute the module in a new terminal, I say "almost" because logically there are some special instructions. The child process does not execute the sectionif __name__ == '__main__' , which is where you define your variable, simply because the child process's interpreter does not execute the module as a "parent module" . By not executing the conditional, the variable will not exist when the function is called.

In fact, the conditional if __name__ == '__main__'is used to protect the entry point from executing things that shouldn't be executed in the child process, most obviously not being called Processfrom the child process again. The use of this conditional, although it is always a good idea, is especially relevant in Windows or when we force the use of spawn.

From this it follows that if you declare the variable in the global space, but outside the conditional, you will not have the problem mentioned:

#!/usr/bin/python3.5
import multiprocessing as mp


mi_variable = "hola"


def funcion1():
    print(mi_variable)


def funcionProceso():

    try:

        evaluacion = mp.Process(target=funcion1)
        evaluacion.start()
        evaluacion.join()     

    except Exception as e:
        e = str(e)      
        print(e)     


if __name__ == '__main__':        
    funcion1()
    funcionProceso()

In POSIX systems the creation of processes can use the fork as we have said and all the global state of the parent is kept intact from start . In this case, the variable does exist because it was created by the parent process, which you executed as the main module, and then "copied" by the child to prepare the fork, so it doesn't show the error you describe.

The consequences and benefits of one system or another when setting up a new process go further and it is a long discussion.

If someone wants to reproduce the error in POSIX, just change the process creation mode, which is forkby default, to use spawn:

import multiprocessing as mp



def funcion1():
    print(mi_variable)

def funcionProceso():  
    try:    
        evaluacion = mp.Process(target=funcion1)
        evaluacion.start()
        evaluacion.join()     
    except Exception as e:
        e = str(e)      
        print(e)     


if __name__ == '__main__':        
    mp.set_start_method('spawn')

    mi_variable = 'Hola'
    funcion1()
    funcionProceso()

In any case, be careful with global variables, if you also join them to multiprocess/multithread... Keep in mind that the variable is "copied" in any case, it is never shared between processes , if the child process modifies it by the parent it won't find out and vice versa no matter what forkor is used spawn. As Trauma comments in his answer , in no case can you assume that the variable has the same value in both processes, not even at the beginning , for example assuming that it is used spawnand your variable is defined by mi_variable = random.randint(1, 100)the safest thing is that in each process it has a different value . It is generally more appropriate to pass variables as an argument, as long as the object is picklable, but they will be different variables anyway:

#!/usr/bin/python3.5
import multiprocessing as mp



def funcion(lista_compartida):
    lista_compartida.append(3)
    print("Desde proceso hijo:", lista_compartida)



if __name__ == '__main__':        
    lista_compartida = [1, 2]
    evaluacion = mp.Process(target=funcion, args=(lista_compartida, ))
    evaluacion.start()
    evaluacion.join()
    print("Desde proceso padre:", lista_compartida)

From child process: [1, 2, 3]
From parent process: [1, 2]

If you really need to share the variable, you must use adequate and safe methods for this, such as queues, shared memory ( multiprocesing.Value, multiprocesing.Array), Manager, etc.

#!/usr/bin/python3.5
import multiprocessing as mp


def funcion(lista_compartida):
    lista_compartida.append(3)
    print("Desde proceso hijo:", lista_compartida)


if __name__ == '__main__':        
    manager = mp.Manager()
    lista_compartida = manager.list([1, 2])

    evaluacion = mp.Process(target=funcion, args=(lista_compartida, ))
    evaluacion.start()
    evaluacion.join()
    print("Desde proceso padre:", lista_compartida)

From child process: [1, 2, 3]
From parent process: [1, 2, 3]

From the python documentation:

The spawn and forkserver start methods

There are a few extra restrictions which don't apply to the fork start method.
...

Global variables

Bear in mind that if code run in a child process tries to access a global variable, then the value it sees (if any) may not be the same as the value in the parent process at the time that Process.start was called.

However, global variables which are just module level constants cause no problems.

Broadly speaking, the way python implements process duplication varies from platform to platform; Even on the same platform, there may be more than one way to duplicate the program.

Some of these methods are more restrictive than others: specifically, the spawnand methods forkserverinclude the following warning :

Note that if code running in a child process tries to access a global variable, its value (if any) may or may not be the same as the value of the same variable in the parent process .

The effect you're seeing is due to that: on your platform, the method used to clone your process causes that effect.

From this we also deduce one thing: the effect does not have to occur on different platforms . In yours we see that yes, in a different one it doesn't have to.