Why objects are same in 2 different process of multiprocessing?

I have next code:

test.py:

import multiprocessing
import time

class A:
    def __action(self):
        print("another process:")
        print(id(self))

    def run(self):
        print("this process")
        print(id(self))
        p = multiprocessing.Process(target=self.__action, daemon=True)
        p.start()

a = A()
print("main")
print(id(a))
a.run()
time.sleep(3)

It runs as next:

$ python3 test.py
main
140643898766000
this process
140643898766000
another process:
140643898766000

But from doc next:

> As mentioned above, when doing concurrent programming it is usually best to avoid using shared state as far as possible. This is particularly true when using multiple processes.
>
> However, if you really do need to use some shared data then multiprocessing provides a couple of ways of doing so.
>
> Shared memory
>
> Data can be stored in a shared memory map using Value or Array.

So it looks only with explicitly define Value/Array can the 2 processes have the same object. Then, why the A object in 2 different processes now have same id?

You're apparently running under some Linux-like OS, where multiprocessing uses fork() to create a worker process. Under fork(), the new process gets a copy-on-write clone of the parent process's address space. So, yes, objects inherited from the parent process after a fork() will have the same id(), but they're nevertheless entirely distinct objects. Addresses are virtual. The self in the main process lives in different physical memory than the self in the worker process. That they have the same virtual address in each process is just a consequence of how the OS implements fork(). Changes made to the object in one process will not be seen in the other.

On a system without fork() (chiefly Windows), or if you tell multiprocessing to use "spawn" instead of "fork", then it's very unlikely (although still possible) that self will retain the same virtual address.