The easiest answer is probably to change your working directory, then call the second .py file from where it is:

python a.py && cd testA && python ../b.py

Of course you might find it even easier to write a script that does it all for you, like so:

Save this as runTests.sh in the same directory as a.py is:

#!/bin/sh
python a.py
cd testA
python ../b.py

Make it executable:

chmod +x ./runTests.sh

Then you can simply enter your directory and run it:

./runTests.sh

No you don't need to use:

cd home/directoryA/directoryB/directoryC/DirectoryD
./somefile 

You can simply run the command by prefixing it with its path:

/home/directoryA/directoryB/directoryC/DirectoryD/somefile

Because you are already in the /home/directoryA you can use the current directory shortcut . and run the command like this:

./directoryB/directoryC/DirectoryD/somefile

I noticed OP has expanded scope via comments under other answers. Here is some additional information:

• To find out where somefile is located use: locate somefile.
• If somefile was added today you need to first update the locate database by running sudo updatedb.
• When there are multiple versions of somefile located in the PATH you can find out which one is executed first use which somefile.
• If you want to run somefile without specifying a directory name in front put it in the path. To check the path use echo $PATH. Common path locations to put somefile are /usr/local/bin (if it uses sudo powers) and /home/your_user_name/bin (you might have to create the directory first).
• You can also add /home/directoryA/directoryB/directoryC/DirectoryD/ to your path but that would be highly unusual. However you could then simply type somefile no matter what directory you are in and it will run.
• Of course somefile must be executable which you set with the command: chmod a+x /home/directoryA/directoryB/directoryC/DirectoryD/somefile

The subprocess module is a very good solution.

import subprocess
p = subprocess.Popen([command, argument1,...], cwd=working_directory)
p.wait()

It has also arguments for modifying environment variables, redirecting input/output to the calling program, etc.

Yes, simply pass the cwd parameter to any of the subprocess APIs to set the current working directory.

If cwd is not None, the child’s current directory will be changed to cwd before it is executed. Note that this directory is not considered when searching the executable, so you can’t specify the program’s path relative to cwd.

E.g.

import subprocess

subprocess.call(['/path/to/prog', 'arg'], cwd=some_dir)

The subprocess module supports setting current working directory for the subprocess, fx:

subprocess.call("./Upgrade", cwd="/home/bin")

If you don't care about the current working directory of your subprocess you could of course supply the fully qualified name of the executable:

subprocess.call("/home/bin/Upgrade")

You might also want to use the subprocess.check_call function (if you want to raise an exception if the subprocess does not return a zero return code).

The problem with your solution is that you start a subprocess in which you try to execute "cd /home/bin" and then start ANOTHER subprocess in which you try to execute "./Upgrade" - the current working directory of the later is not affected by the change of directory in the former.

Note that supplying shell to the call method has a few drawbacks (and advantages too). The drawback (or advantage) is that you'll get various shell expansions (wildcard and such). One disadvantage may be that the shell may interpret the command differently depending on your platform.

You need to find out where your script is and assemble an absolute path:

import os
import subprocess

dirname = os.path.dirname(os.path.abspath(__file__))
cmd = os.path.join(dirname, 'mybatch_file')

subprocess.call(cmd)

In Steps

You can find out the name of script with:

__file__

Now make it an absolute path:

os.path.abspath

and get the directory it is in:

os.path.dirname

Finally, join this path with your batch file name:

os.path.join

before you feed it to:

subprocess.call

If you want to run your Python script (let me call it myScript.py) on each *.grd file in all subfolders (recursively) of a given folder, then find is the right command to do it:

find . -name '*.grd' -exec python myScript.py {} \;

This command recursively finds each file in the given path¹ with the name matching *.grd and calls python myScript.py <found .grd file>² for each found file. You can test this by adding echo right after -exec, then it will just print the commands.

¹ I used . in my example and you can use it, too, if you cd to the specified folder first. Otherwise, you can use any appropriate relative or absolute path here.

² If your script is executable and has the correct shebang, you can leave out python and call myScript.py directly.

See also

• How to Search for Files Recursively into Subdirectories
• How can I recursively find a directory by name and delete its contents (including all sub-directories and files) while keeping the directory itself?

Your problem is the same as: Relative imports for the billionth time

TL;DR: you can't do relative imports from the file you execute since main module is not a part of a package.

As main:

python B/fileB.py

Output:

Traceback (most recent call last):
  File "p2/m2.py", line 1, in <module>
    from p1.m1 import funA
ImportError: No module named p1.m1

As a module (not main):

python -m B.fileB

Output:

hello from A