Try to os.chdir(path) before invoking the command.

From here:

os.chdir(path) Change the current working directory to path.

Availability: Unix, Windows

EDIT

This will change the current working dir, you can get the current working by:

os.getcwd()

If you want to save it and restore it later, if you need to do some work in the original working dir.

EDIT 2

In any case you should probably move to subprocess (doc) as suggested here. If you use subprocess's Popen you have the choice of providing cwd parameter to specify the working directory for the subprocess: read this.

subprocess.Popen(args, bufsize=0, executable=None, stdin=None,
stdout=None, stderr=None, preexec_fn=None, close_fds=False,
shell=False, cwd=None, env=None, universal_newlines=False,
startupinfo=None, creationflags=0)

...

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.

There are a couple of ways around this directly in your Python script.

1. If your script is always going to be in "/home/username/projectname/subfolder", you can simply add that to your search path inside Python:

   import sys
   sys.path.append("/home/username/projectname/subfolder")
   

   I suspect, however, that you might have this in multiple "projectname" directories, so a more generic solution is something like this:

   import sys
   import os
   sys.path.append(os.path.join(os.path.dirname(sys.argv[0]), "subfolder"))
   

   This finds the directory where the Python script is (in sys.argv[0]), extracts the directory part, appends "subfolder" onto it, and puts it into the search path.

   Note that some operating systems may only give the executable name in sys.argv[0]. I don't have a good solution for this case, perhaps someone else does. You may also need to inject a os.path.abspath() call in there if sys.argv[0] has a relative path, but play around with it a bit and you should be able to get it working.

2. Similar to the above answer, you can have the Python script change directories all by itself with no need for a wrapper script:

   import os
   os.chdir("/home/username/projectname")
   

The Popen has a cwd keyword argument .

result = subprocess.Popen("command", cwd="path/to/folder")

And the error you are getting is because the Popen's shell keyword argument is set to false by default, so it doesn't know the cd command.

To add to tripleees excellent answer, you can solve this in 3 ways:

1. Use subprocess' cwd argument
2. Change dir before, using os.chdir
3. Run the shell command to the exact dir you want, e.g. ls /path/to/dir OR cd /path/to/dir; ls, but note that some shell directives (e.g. &&, ;) cannot be used without adding shell=True to the method call

PS as tripleee commented, using shell=True is not encouraged and there are a lot of things that should be taken into consideration when using it

Here is a summary of ways to call external programs, including their advantages and disadvantages:

1. os.system passes the command and arguments to your system's shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection. For example:

   os.system("some_command < input_file | another_command > output_file")
   

   However, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, et cetera. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs.

2. os.popen will do the same thing as os.system except that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don't need to worry about escaping anything. Example:

   print(os.popen("ls -l").read())
   

3. subprocess.Popen. This is intended as a replacement for os.popen, but has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you'd say:

   print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
   

   instead of

   print os.popen("echo Hello World").read()
   

   but it is nice to have all of the options there in one unified class instead of 4 different popen functions. See the documentation.

4. subprocess.call. This is basically just like the Popen class and takes all of the same arguments, but it simply waits until the command completes and gives you the return code. For example:

   return_code = subprocess.call("echo Hello World", shell=True)
   

5. subprocess.run. Python 3.5+ only. Similar to the above but even more flexible and returns a CompletedProcess object when the command finishes executing.

6. os.fork, os.exec, os.spawn are similar to their C language counterparts, but I don't recommend using them directly.

The subprocess module should probably be what you use.

Finally, please be aware that for all methods where you pass the final command to be executed by the shell as a string and you are responsible for escaping it. There are serious security implications if any part of the string that you pass can not be fully trusted. For example, if a user is entering some/any part of the string. If you are unsure, only use these methods with constants. To give you a hint of the implications consider this code:

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

and imagine that the user enters something "my mama didnt love me && rm -rf /" which could erase the whole filesystem.