I would use subprocess this way:

import subprocess
subprocess.call(['java', '-jar', 'Blender.jar'])

But, if you have a properly configured /proc/sys/fs/binfmt_misc/jar you should be able to run the jar directly, as you wrote.

So, which is exactly the error you are getting? Please post somewhere all the output you are getting from the failed execution.

Do you want to execute code from .jar, or open it?

If open, then .jar file is the same format as .zip files and you can use zipfile module to manipulate it. Example:

def show_jar_classes(jar_file):
    """prints out .class files from jar_file"""
    zf = zipfile.ZipFile(jar_file, 'r')
    try:
        lst = zf.infolist()
        for zi in lst:
            fn = zi.filename
            if fn.endswith('.class'):
                print(fn)
    finally:
        zf.close()

If you want to execute it then I prefer creating simple batch/shell script which execute java with some parameters like -Xmx and with environment settings required by application.

get_path_lists uses recursion as so:

for d in dirs:
    get_path_list(d)

Namely, for every directory you do a full traversal of the whole tree: walk is already recursive! Or you would, if you actually passed in a full path os.path.join(root, d). You don't even use the result, so remove it.

Your

for f in files:
    if f.endswith(".jar"):
        app_list.append(root)
        break

can be simplified to

if any(f.endswith(".jar") for f in files):
    app_list.append(root)

I would convert get_path_list to an iterator:

def get_path_list(base_path):
    for root, dirs, files in os.walk(base_path):
        if any(f.endswith(".jar") for f in files):
            yield root

Success!

I would also consider a move to pathlib for its extended globbing:

def get_path_list(base_path):
    return set(path.parent for path in Path(base_path).glob("**/*.jar"))

although this comes with its own disadvantages.

get_app_name can be prettier more platform independent with pathlib.PurePath:

def get_app_name(lib_path):
    path = PurePath(lib_path)
    path = path.relative_to(path.anchor)

    return "-".join(path.parts)

The .relative_to stuff removes any drive or root, and then you can just join the parts.

In create_command you check if len(app_list) > 0; it's more idiomatic to just check if app_list.

You implicitly return None when empty; it seems to me you should be throwing an error. You should also use early exit to keep things cleaner.

Your formatting strings don't need numbers:

command = "{}{} Core -a {} -o {}".format(full_path, get_extension(), app_name, output_file)
for app_path in app_list:
    command += " -s {}".format(app_path)

Your for loop is non-idiomatic; you should never use += on immutable objects in a list without good reason. Here, just use:

command = "{}{} Core -a {} -o {}".format(full_path, get_extension(), app_name, output_file)
command += "".join(" -s {}".format(app_path) for app_path in app_list)

Even so, the real problem is that dependency_check uses shell=True; it shouldn't. Pass in a list instead:

command = [full_path + get_extension(), "Core", "-a", app_name, "-o", output_file]

for app_path in app_list:
    command.append("-s")
    command.append(app_path)

return command

The old method broke when any of the inputs had, say, spaces or asterisks in.