The ShellExecute API call will spawn a new process, it won't elevate permissions for the current process running.

Let's analyze this code snippet:

if is_admin():
    main()
else:
    ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)

When you first run this Python script without privileges, this initial process will jump to the last line of the code because is_admin returns False. Once there, the UAC prompt is displayed.

• If the UAC prompt is accepted, then a completely new process (with different process ID) is created and the code is executed again (from the beginning), but this time with admin privileges. Now is_admin should return True and main should be called.
• If the UAC prompt is rejected, no new process is created.

Regardless of the UAC response, the initial process will get the return code back, but its privileges will remain unaltered.

If you want to try this yourself, add an input() at the end of the file and you should be able to see two different windows after accepting the UAC prompt.

To avoid having your code being executed twice be sure to keep everything inside the main function. If you want to take an action based on the return code, this only makes sense for failures (code <= 32). If the return code is successfull (> 32), then the process should end gracefully and let the new spawned process do its job.

As of 2017, an easy method to achieve this is the following:

import ctypes, sys

def is_admin():
    try:
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False

if is_admin():
    # Code of your program here
else:
    # Re-run the program with admin rights
    ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)

If you are using Python 2.x, then you should replace the last line for:

ctypes.windll.shell32.ShellExecuteW(None, u"runas", unicode(sys.executable), unicode(" ".join(sys.argv)), None, 1)

Also note that if you converted you python script into an executable file (using tools like py2exe, cx_freeze, pyinstaller) then you should use sys.argv[1:] instead of sys.argv in the fourth parameter.

Some of the advantages here are:

• No external libraries required. It only uses ctypes and sys from standard library.
• Works on both Python 2 and Python 3.
• There is no need to modify the file resources nor creating a manifest file.
• If you don't add code below if/else statement, the code won't ever be executed twice.
• You can get the return value of the API call in the last line and take an action if it fails (code <= 32). Check possible return values here.
• You can change the display method of the spawned process modifying the sixth parameter.

Documentation for the underlying ShellExecute call is here.

I believe myClass WAS executed, but in a separate window/process so you didn't notice.

try using something like input() to see if another window was indeed open.

It looks like types.TupleType and types.ListType do not exist in Python 3. Try the following instead:

elif type(cmdLine) not in (tuple, list)

The value error after saying that "cmdLine is not a sequence" is not exactly accurate because strings are sequences, but should indeed raise a ValueError. I might reword it to "cmdLine should be a non-empty tuple or list, or None." You could update it to more broadly check whether cmdLine is a non-string iterable, but that might be overkill.

Use ShellExecuteW. Your strings are Unicode strings and are passed as wchar_t* to C.

Alternatively, use byte strings with ShellExecuteA, e.g. b'open' and b'PPP.exe'.

If you fully define the arguments and return type (always recommended), then ctypes will type-check for you and return an error if the type is incorrect:

import ctypes as ct
from ctypes import wintypes as w

SW_SHOWNORMAL = 1

shell32 = ct.WinDLL('shell32')
shell32.ShellExecuteA.argtypes = w.HWND, w.LPCSTR, w.LPCSTR, w.LPCSTR, w.LPCSTR, w.INT
shell32.ShellExecuteA.restype = w.HINSTANCE
shell32.ShellExecuteW.argtypes = w.HWND, w.LPCWSTR, w.LPCWSTR, w.LPCWSTR, w.LPCWSTR, w.INT
shell32.ShellExecuteW.restype = w.HINSTANCE

# works
shell32.ShellExecuteA(None, b'open', b'cmd.exe', None, None, SW_SHOWNORMAL)

# works
shell32.ShellExecuteW(None, 'open', 'cmd.exe', None, None, SW_SHOWNORMAL)

# ctypes.ArgumentError: argument 2: <class 'TypeError'>: wrong type
shell32.ShellExecuteA(None, 'open', 'cmd.exe', None, None, SW_SHOWNORMAL)

# ctypes.ArgumentError: argument 2: <class 'TypeError'>: wrong type
shell32.ShellExecuteW(None, b'open', b'cmd.exe', None, None, SW_SHOWNORMAL)