Python function for 7zip compression I wrote a function in Python to call 7zip to compress a folder. The code works and is able to perform the task, however I do not know if this is the most optimal way. Are there any ways to improve the code, any redundant steps?

def Compress_7z(Initial_path,Container_Name,File_List, compression_level = -1,DAC = False):
 """Compression level = -1 standard, 0-9 compression level
       DAC : Delete After Compression - Remove File after being compressed
    """ 
    try:
        chdir(Initial_path)
    except:
        return('Path does not exist')

    # write a listfile
    with open('list.txt', 'w') as f:
        for item in File_List:
            f.write("%s\n" % item)

    cmd = ['7z', 'a', Container_Name,'@list.txt']

    if compression_level != -1 and compression_level &lt;= 9:
        cmd.append('-mx{0}'.format(compression_level))
    elif compression_level &gt; 9 or compression_level &lt; -1:
        return("Compression not standard: aborting compression")

    system = subprocess.Popen(cmd, stderr=subprocess.STDOUT, stdout=subprocess.PIPE,shell=True)

    while system.poll() == None:  # .poll() will return a value once it's complete. 
        time.sleep(1)
    if DAC:
        for f in File_List:
            remove(f)

    # Clean up from compression
    remove('list.txt')
    return(system.communicate())
Simply reading the code already has a few things which stand out to me
(in general this all goes towards the style described in
this document, which is
standard to follow for Python code):


Compress_7z should start lower-case and probably should also say
compress_7zip.  I'm agreeing that the literal "7" would be
appropriate here, given the format name.
DAC is a bad variable name, as you've to read the docstring to even
begin to understand what this parameter is doing.  A better name might
be, well, delete_files_after perhaps.
The rest of the parameters should also all be lower-case.
Try and apply consistent formatting, or use an IDE or
command-line tool to do it
for you (right now there's no whitespace after some of the commas for
example, also some of the quotes are single and some are double for no
good reason).
The docstring is not very standard, though at least it mentions the
value range of the parameters, which is obviously good.


Next up, actual functionality:

Shelling out to the 7z utility is of course an option, although there
are also pure Python libraries for this as far as I can see.  The reason
I point this out is that for one the command-line utility might not be
installed and e.g. pip or a similar tool for Python might make it
easier to handle the dependency.

Since you've already settled on it though, a few more points about the
current implementation:


chdir in a library function is almost certainly a bad idea.  It's
completely not expected that "compress these files" also means "change
my current working directory".  Instead make sure that the function
works without by specifying file names reliably (that is, using
absolute path names, or by specifying the working directory for the
invoked process only).
Using strings as error values is a big no.  Use exceptions, or if you
absolutely do not want to do that, a properly structured return
value.  Right now you couldn't distinguish the return value of the
tool from the strings "Path does not exist" and that's generally to
be avoided.
If the compression level is a string the list.txt file will not be
cleaned up.  That's why you generally want to handle exceptions
properly, look up how
try, catch and finally work
for that.
Finally it seems like the subprocess.Popen invocation is too much
work.  If you don't have to communicate with the invoked process,
simply run it and wait for the result. time.sleep is an extremely
wasteful way of accomplishing the same.  Instead I think you might
just be able to use subprocess.run with the cwd argument (see
above) and be done with it.  You don't need shell=True either, since
the invocation doesn't use any shell features at all.