在 Python 中，使用 subprocess.Popen，当 Popen 的命令行参数为列表形式时，是否可以将文字引号传递给要运行的命令？

Question

In Python, with subprocess.Popen, is it possible to pass literal quotes as an argument, when the command and its parameters are in list form?

I'll explain further what I mean. Some commands can have literal quotes in their arguments eg I'm trying "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --profile-directory="Profile 1" Some might even require them.

Note that one answer points out that technically it is possible to get Chrome from the command line to launch whatever profile, without passing a literal quote C:\Users\User>"C:\Program Files....\chrome.exe" "--profile-directory=Profile 2"

Nevertheless, i'm asking about passing literal quotes so "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" --profile-directory="Profile 1"

For simplicity's sake i'll use calc.exe since it's in the path.

import time
import subprocess

proc=subprocess.Popen("calc.exe"+" "+'--profile-directory="Profile 3"')
proc2=subprocess.Popen(["calc.exe",'--profile-directory="Profile 4"'])

time.sleep(3)

proc.wait()
proc2.wait()

Now look at the difference in the command line as visible in task manager or via wmic.

    C:\Users\User>wmic process where caption="calc.exe" get commandline  | findstr calc
    c:\windows\system32\calc.exe --profile-directory="Profile 3"
    c:\windows\system32\calc.exe "--profile-directory=\"Profile 4\""
    
    C:\Users\User>

You can see this from the python interpreter

    >>> subprocess.Popen(["c:/windows/system32/calc.exe","abc"+'"'+"def"])
    ...
    >>>
    >>> subprocess.run("C:\Windows\System32\wbem\WMIC.exe process where caption=\"calc.exe\" get commandline")
    ...
    c:/windows/system32/calc.exe abc\"def
    
    ....
    >>>

You see it's sticking a backslash in there.

---

Some comments regarding some suggestions given.

One suggestion assumes that --profile-directory="Profile 1" is the same as --profile-directory "Profile 1" ie the assumption that you can replace the = with a space and chrome will work the same. But that isn't the case. So writing subprocess.Popen(["C:\...\chrome.exe", "--profile-directory", "Profile 3"]) will indeed produce "C:\....\chrome.exe" --profile-directory "Profile 1" but that won't work.. it leads chrome to either not open at all, or to open a browser window that offers profiles to click on. The equals sign is necessary.

Another suggestion does

subprocess.Popen(
    " ".join(
        [
            "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
            '--profile-directory="Person 1"',
        ]
    )

That's not passing a list to Popen, that's passing a list to join, and join is converting it to a string.

Another suggestion is

subprocess.Popen('C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe --profile-directory="Profile 3"')

That's using a string. But as you see from my question, I managed it using a string. I'm asking about using a list.

Another suggestion suggested "--profile-directory='Profile 1'"

If I run chrome with --profile-directory="Profile 1" I get a particular profile that I use sometimes. But if running chrome with "--profile-directory='Profile 1'" Then it doesn't load up that profile. It loads up a blank profile. And going to chrome://version shows "'profile 1'" rather than "profile 1" It's like a different profile, like you may as well have said chrome.exe --profile-directory="profile A" . And it also creates directories starting with ' like C:\Users\User\AppData\Local\Google\Chrome\User Data\'Profile 1234' that should be removed.

Another suggestion suggested

subprocess.Popen(
    [
        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
        "--profile-directory=Profile 1",
    ]

That is interesting because it does "C:\...chrome.exe" "--profile-directory=Profile 1"

And it does infact load chrome with the specified profile. Though it doesn't try to pass literal quotes!

---

My question asks about when passing literal quotes. It's as if maybe it assumes it's a linux shell and inserts a backslash before it, which in a linux would ensure the quote makes it past the shell and to the program being run. Though i'm not sure it'd even go to the linux shell on linux. eg on Windows if I stick a cmd escape character in there like ^ so "--pro^file-directory=Profile 1" then the ^ just gets passed literally. So the cmd shell doesn't intervene.

Why is it that on Windows, subprocess.Popen calls list2cmdline when passed a list, which(and here's the big 'why'), then adds a backslash to any literal double quote within a string, meaning that when using the 'method' of passing a list to to Popen rather than passing a string to it, there is this problem, that you can't pass a literal double quote, So, why does it add that backslash!

I did here a suggestion that looking at argsv in windows vs linux might show a difference. I'm not sure that they would since both implement C.

I don't see why POpen in any situation should behave like Windows needs a backslash inserted more than Linux does.

    $ cat ./testargs.py
    #!/usr/bin/env python3
    import sys
    print(sys.argv)
    
    C:\blah>type .\testargsw.py
    import sys
    print(sys.argv)

in both cases

    C:\blah>.\testargsw.py abc\^"def
    ['C:\\Users\\User\\testargsw.py', 'abc"def']
    
    >.\testargsw.py abc\"def
    ['C:\\Users\\User\\testargsw.py', 'abc"def']
    
    C:\blah>
    
    $ ./testargs.py abc\"def
    ['./testargs.py', 'abc"def']

Maybe Windows, specifically the MS C Runtime.. The Code responsible for sending a program's arguments received from the shell, to the main method into argv, is requiring an extra backslash, in a sense because after escaping the double quote, a backslash is then required. (And [here] is put in by the user).

That said, I have heard though that looking at what a shell does on Linux is basically misleading, because a major part of the purpose of the subprocess module is to ensure that you can avoid using a shell entirely.

The script example is perhaps not that relevant(it was just something somebody suggested I check), but my issue is that POpen when passed a list is adding in a backslash as shown by WMIC output(also visible in task manager in the command line column).

Answer 1

I spoke to a person that has used python for a long time. They said subprocess was added somewhere in 2.x They still use os.popen(). That takes a string not a list. There have been moves to shift people from os.popen to subprocess.Popen https://docs.python.org/3/library/subprocess.html#replacing-os-popen-os-popen2-os-popen3

An issue with subprocess.Popen in Windows, is it has this list feature, that I think behaves funny.

The easy workaround to that is to not use the list feature of it. To not pass it a list. It's a new feature and not necessary. You can pass it a string.

The question includes an example from the python interpreter and shows how (on windows at least), python adds a backslash to the literal quote.

The person I spoke to pointed out to me two documents that relate to that.

A string is a sequence. A sequence could be a string or list or tuple, though in this document they use the term sequence to just mean list or tuple, and they don't mean string when they say sequence.

https://peps.python.org/pep-0324/

"class Popen(args........."
"args should be a string, or a sequence of program arguments"

It mentions about on unix, shell=True and shell=False

And then it says "On Windows: the Popen class uses CreateProcess() to execute the child program, which operates on strings. If args is a sequence, it will be converted to a string using the list2cmdline method. Please note that not all MS Windows applications interpret the command line the same way: The list2cmdline is designed for applications using the same rules as the MS C runtime."

Technically a string is a sequence, but that document uses the term sequence in a funny way. But what it means is it's that on Windows, if args is not given a string, but is given a list or tuple, then it uses the list2cmdline method.

Be sure to use print otherwise it uses repr() of the string

    >>> print(subprocess.list2cmdline(['a', '"b c"']))
    a "\"b c\""
    >>>

so that's the function that it's using behind the scenes, on windows, that is inserting a backslash in there.

The guy I spoke to pointed me to this document too

https://bugs.python.org/issue11827

a technical user comments, "list2cmdline() in subprocess is publicly accessible (doesn't begin with underscores) but it isn't documented."

And the point is made there that, let's say they made list2cmdline() private, the fact is that what Popen is doing to the list, in Windows, to get the command line, is undocumented.

So it seems to be a bad design, I can't see a justification for the insertion of backslash. If a programmer wanted to insert a backslash they could do so. It seeems to me to make more sense then to avoid passing a list to subprocess.POpen.

Windows cmd doesn't even use backslash as an escape character.!!! It uses caret.

C:\Users\User>echo \\
\\

C:\Users\User>echo ^\
\

C:\Users\User>

it's linux eg bash, that uses backslash as an escape character

$ echo \\
\

$

Some executables in windows might want a quote escaped and with a backslash, but then the technical user can do that just as a technical linux user does.

So given that they haven't even documented the "feature" (or bug), how they would justify it, I don't know, but they could start by documenting it!

Answer 2

Should do the trick ( might wanna pass shell=True to Popen if it doesn't ):

subprocess.Popen(["C:\Program Files (x86)\Google\Chrome\Application\chrome.exe", "--profile-directory", "Profile 3"]);

This is possible because --some-flag="some value" is the same as --some-flag "some value"

ChRomE solution (working, omg):

import subprocess

subprocess.Popen(
    [
        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
        "--profile-directory=Profile 1",
    ]
)