How can I stop my python script when another python script is running?

Instead of using grep, why not create a lock file? One instance of your program creates a file in a known location, and deletes it upon exit. Any other instance has to check for the existence of that file, and should only continue running if it already exists.

The os.open() function has specific flags for this:

import os

LOCKFILE_LOCATION = "/path/to/lockfile"

try:
    os.open(LOCKFILE_LOCATION, os.O_CREAT|os.O_WRONLY|os.O_EXCL)
    # Maybe even write the script's PID to this file, just in case you need
    # to check whether the program died unexpectedly.
except OSError:
    # File exists or could not be created. Can check errno if you really
    # need to know, but this may be OS dependent.
    print("Failed to create lockfile. Is another instance already running?")
    exit(1)
else:
    print("Pass")
    # Run the rest of the program.
    # Delete the file
    os.remove(LOCKFILE_LOCATION)

Try this out by putting, say, import time; time.sleep(20) after `print("Pass") and running multiple instances of this script; all but one should fail.

You can use the cross-platform library psutil to iterate over the processes running on the system, check the command line of each process to see if it's a python process, and has the same script path, if so, then, you can either terminate the current script OR you can terminate the old instances and continue running the new instance.

import os
import sys
import time
import psutil

def absolutize_path(some_path, process_working_directory_path):
    if os.path.isabs(some_path): return some_path
    return os.path.normpath(os.path.join(process_working_directory_path, some_path))

script_path = absolutize_path(sys.argv[0], os.getcwd())
print("this instance script path (absolute):", script_path)

for proc in psutil.process_iter():
    if proc.pid == os.getpid():
        continue
    if "python" in proc.name():
        if len(proc.cmdline()) > 1:
            proc_script_path = absolutize_path(proc.cmdline()[1], proc.cwd())
            print("OTHER instance script path (absolute):", proc_script_path)
            if  script_path == proc_script_path:
                # you can terminate this newer instance here
                print("an instance of this script is already running. exiting..")
                sys.exit()
                # OR you can terminate all the other instances
                # proc.kill() # <-- by having this line in the loop instaed
                # whatever you want to do

print("doing stuff, this is not gonna take a while...")
time.sleep(1_000_000_000)

More pythonic way:

import os
import psutil

script_name = os.path.basename(__file__)
if script_name in [p.name() for p in psutil.get_process_list()]:
   print "Running"

os.system() returns the exit value of the command that was run. If the ps was successful, it returns 0, which is not equivalent to True. You could explicitly test if the command returned zero, which should bring you into the if block.

Edit: To do this needs os.subprocess. These four commands should get what you want.

p1 = subprocess.Popen(['ps', 'ax'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['grep', 'bash'], stdin=p1.stdout, stdout=subprocess.PIPE)
p3 = subprocess.Popen(['wc', '-l'], stdin=p2.stdout, stdout=subprocess.PIPE)
count = int(p3.stdout.read())
if count > 1:
    print('yes')

Replace "bash" with the name of your script. What this does is get the list of running processes, pipes that output to grep to winnow out all but your script (or bash instances in the code sample), pipes that output to wc to get a count of lines, and then asks that process for its stdout which is the count of the instances of the script that are currently running. You can then use that count variable in an if statement, where if there is more than one instance running, you could abort the run.

Because os.system("ps ax | grep sample_python.py") return 0. It is not true.

Look this question: Assign output of os.system to a variable and prevent it from being displayed on the screen

You must write

os.popen('cat /etc/services').read() 

But such way you will always go to the "failed" because your script already started. You'll must count number of returned lines...

Look here as a variant of single instance:

Python: single instance of program

I wrote such script. I created a file with any name on start, and deleted at the end. It was the daemon script. On start I checked if that file exists.

Not bad variant is here Ensure a single instance of an application in Linux:

import fcntl
pid_file = 'program.pid'
fp = open(pid_file, 'w')
try:
    fcntl.lockf(fp, fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError:
    # another instance is running
    sys.exit(1)