If your code needs to be written just as it is (including the rather odd way of stringing together the ZPL code, and calling a separate script via a shell intermediary, and the avoidance of subprocess, for that matter), you can resolve your issue with a few small adjustments:

First, wrap your code string in double-quotes.

label= '"^XA'+"^FO20,20^BQ,2,3^FDQA,"+"001D4B02107A;1001000;49681207"+"^FS"+"^FO50,50"+"^ADN,36,20"+"^FD"+"MAC: "+"001D4B02107A"+"^FS"+"^FO50,150"+"^ADN,36,20"+"^FD"+"SN: "+"1001000"+"^FS"+"^FO50,250"+"^ADN,36,20"+"^FD" + "Code: "+"49681207"+"^FS"+'^XZ"'

Second, make sure you're actually calling python from the shell:

command = "python script2.py "+label

Finally, if you're concerned about special characters not being read in correctly from the command line, use unicode_escape from codecs.decode to ensure correct transmission.
See this answer for more on unicode_escape.

# contents of second script
if __name__ == "__main__":
    from codecs import decode
    import sys
    zplString = decode(sys.argv[1], 'unicode_escape')
    print(zplString)

Now the call from your first script will transmit the code correctly:

import sys
import os

sys.stdout.flush()
exitCode = os.system(str(command))

Output:

^XA^FO20,20^BQ,2,3^FDQA,001D4B02107A;1001000;49681207^FS^FO50,50^ADN,36,20^FDMAC: 001D4B02107A^FS^FO50,150^ADN,36,20^FDSN: 1001000^FS^FO50,250^ADN,36,20^FDCode: 49681207^FS^XZ

This worked for me:

import sys
firstarg=sys.argv[1]
secondarg=sys.argv[2]
thirdarg=sys.argv[3]

Make it a shell function instead. Paste this into your terminal, or add to your shell's configuration files (e.g. ~/.bashrc for bash)

pipeline_test(){
  python -c 'from sys import argv; from pipeline_runs.z_full_pipeline import test; test(argv[1])' "$@"
}

And then run as

pipeline_test "$a"

The string you receive in sys.argv[1] is exactly what you typed on the command line. Its backslash sequences are left intact, not interpreted.

To interpret them, follow this answer: basically use .decode('string_escape').

Your bash needs to look like this:

if [ -n "${my_param}" ]
then
    my_param_str="--my_param \"${my_param}\""
fi

echo ${my_param_str}|xargs python -u my_script.py

Otherwise, the quotes around the parameter string will not be preserved, and "Some", "--" and "thing" will be passed as three separate arguments.

argv will be a list of all the arguments that the shell parses.

So if I make

#script.py
from sys import argv
print argv

$python script.py hello, how are you
['script.py','hello','how','are','you]

the name of the script is always the first element in the list. If we don't use quotes, each word will also become an element of the list.

print argv[1]
print argv[2]
$python script.py hello how are you
hello
how

But if we use quotes,

$python script.py "hello, how are you"
 ['script.py','hello, how are you']

The all words are now one item in the list. So do something like this

print "The script is called:", argv[0] #slicing our list for the first item
print "Your first variable is:", argv[1]

Or if you don't want to use quotes for some reason:

print "The script is called:", argv[0] #slicing our list for the first item
print "Your first variable is:", " ".join(argv[1:]) #slicing the remaining part of our list and joining it as a string.

$python script.py hello, how are you
$The script is called: script.py
$Your first variable is: hello, how are you

First (and probably most preferable) solution is to put the second and third argument in quotes as Susmit Agrawal suggested. Then the shell itself will split the command line into arguments appropriately.

python mytest.py [email protected]  "value of file 1"  "value of file 2"

In case you really need to pass arguments without quotes though, you will have to accept that the shell will be splitting your second and third argument at spaces, so you will need to reconstruct them from sys.argv yourself.

Lastly, you may want to explore argparse library to help you with parsing the command line arguments. In this case you may want to use optional arguments with nargs set to '+' or some certain number based on your command line API. For example, if you define and parse your arguments the following way,

parser = argparse.ArgumentParser()
parser.add_argument('--value-1', nargs=4)
parser.add_argument('--value-2', nargs=4)
parser.add_argument('email', nargs='+')
args = parser.parse_args()

print(args)

then you can call your Python program as

python mytest.py [email protected]  --value-1 value of file 1  --value-2 value of file 2

And get the following result,

Namespace(email=['[email protected]'], value_1=['value', 'of', 'file', '1'], value_2=['value', 'of', 'file', '2'])

which you can then conveniently access as

print(args.value_1)
print(args.value_2)
print(args.email)

There are a few modules specialized in parsing command line arguments: getopt, optparse and argparse. optparse is deprecated, and getopt is less powerful than argparse, so I advise you to use the latter, it'll be more helpful in the long run.

Here's a short example:

import argparse

# Define the parser
parser = argparse.ArgumentParser(description='Short sample app')

# Declare an argument (`--algo`), saying that the 
# corresponding value should be stored in the `algo` 
# field, and using a default value if the argument 
# isn't given
parser.add_argument('--algo', action="store", dest='algo', default=0)

# Now, parse the command line arguments and store the 
# values in the `args` variable
args = parser.parse_args()

# Individual arguments can be accessed as attributes...
print args.algo

That should get you started. At worst, there's plenty of documentation available on line (say, this one for example)...

Your shell will eat those quotes before python ever sees them. Try like this:

python test.py '"one"' '"two"'

As an aside, command-line args are passed as strings anyway. It is odd to literal_eval them like this; a better pattern is to convert the strings to numbers when you need the numbers, and to just leave them as strings otherwise. This will also save you from having to quote-pad the strings twice on the command line.

The argparse module can handle that stuff for you automatically.

You can use the sys module like this to pass command line arguments to your Python script.

import sys

name_of_script = sys.argv[0]
position = sys.argv[1]
sample = sys.argv[2]

and then your command line would be:

./myscript.py 10 100