പൈത്തണിൽ ബാഹ്യ കമാൻഡുകൾ എങ്ങനെ എക്സിക്യൂട്ട് ചെയ്യാം

പൈത്തണിൽ നിന്ന് സിസ്റ്റം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നു

നിങ്ങളുടെ സ്ക്രിപ്റ്റുകളിൽ നിന്ന് നേരിട്ട് ബാഹ്യ പ്രോഗ്രാമുകളും സിസ്റ്റം കമാൻഡുകളും നടപ്പിലാക്കുന്നതിനുള്ള ശക്തമായ കഴിവുകൾ പൈത്തൺ നൽകുന്നു. നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ ലഭ്യമായ വിപുലമായ ടൂളുകൾ പ്രയോജനപ്പെടുത്തുമ്പോൾ പൈത്തണിൻ്റെ ലാളിത്യം പ്രയോജനപ്പെടുത്താൻ ഈ സവിശേഷത നിങ്ങളെ അനുവദിക്കുന്നു.

നിങ്ങൾ ആവർത്തിച്ചുള്ള ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യുകയോ സങ്കീർണ്ണമായ വർക്ക്ഫ്ലോകൾ സമന്വയിപ്പിക്കുകയോ ചെയ്യുകയാണെങ്കിൽ, പൈത്തണിൽ സിസ്റ്റം കമാൻഡുകൾ എങ്ങനെ വിളിക്കാമെന്ന് മനസിലാക്കുന്നത് നിങ്ങളുടെ ഉൽപ്പാദനക്ഷമതയെ ഗണ്യമായി വർദ്ധിപ്പിക്കും. ഈ ഗൈഡിൽ, ഇത് ഫലപ്രദമായി നേടുന്നതിനുള്ള വ്യത്യസ്ത രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.

പൈത്തണിലെ സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ മനസ്സിലാക്കുന്നു

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ പൈത്തൺ ഉപയോഗിച്ച് ബാഹ്യ കമാൻഡുകൾ നടപ്പിലാക്കുന്നതിനുള്ള വിവിധ മാർഗങ്ങൾ കാണിക്കുന്നു. ദി subprocess.run കമാൻഡ് ബഹുമുഖമാണ്, നിങ്ങളുടെ പൈത്തൺ സ്ക്രിപ്റ്റിൽ നിന്ന് നേരിട്ട് ഷെൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, subprocess.run(['echo', 'Hello, World!']) കൺസോളിലേക്ക് ഒരു സന്ദേശം പ്രിൻ്റ് ചെയ്യുന്നു subprocess.run(['ls', '-l'], capture_output=True, text=True) യുടെ ഔട്ട്പുട്ട് പിടിച്ചെടുക്കുന്നു ls -l കമാൻഡ്, വിശദമായ ഡയറക്‌ടറി ലിസ്റ്റിംഗ് പ്രദർശിപ്പിക്കുന്നു. ഉപയോഗിക്കുന്നത് shell=True കൂടെ subprocess.run വൈൽഡ്കാർഡ് വിപുലീകരണം പോലെയുള്ള ഷെൽ ഫീച്ചറുകളുടെ ഉപയോഗം അനുവദിക്കുന്നു, ഇത് കൂടുതൽ സങ്കീർണ്ണമായ കമാൻഡുകൾക്ക് ഉപയോഗപ്രദമാക്കുന്നു.

ദി subprocess.Popen അസിൻക്രണസ് കമാൻഡ് പ്രവർത്തിപ്പിക്കാനും പ്രോസസ്സിൻ്റെ ഇൻപുട്ട്, ഔട്ട്പുട്ട് സ്ട്രീമുകളുമായുള്ള ഇടപെടൽ എന്നിവ അനുവദിക്കുന്നതിലൂടെ കമാൻഡ് എക്‌സിക്യൂഷനിൽ കൂടുതൽ നിയന്ത്രണം നൽകുന്നു. ഉദാഹരണത്തിന്, സ്ക്രിപ്റ്റ് ഉദാഹരണം subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE) ലോക്കൽ മെഷീനിൽ തുടർച്ചയായി പിംഗ് ചെയ്യുകയും ഔട്ട്പുട്ടിൻ്റെ ഓരോ വരിയും വായിക്കുകയും ചെയ്യുന്നു. കൂടാതെ, os.system ലളിതമായ കമാൻഡ് എക്‌സിക്യൂഷനാണ് ഉപയോഗിക്കുന്നത്, എന്നാൽ ഇതിന് വഴക്കമില്ല subprocess. എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ പരിഷ്‌ക്കരിച്ച് ഉപപ്രോസസിലേക്ക് കൈമാറാൻ കഴിയും os.environ.copy() കൂടാതെ env പരാമീറ്റർ ഇൻ subprocess.run, പരിസ്ഥിതിയെ അടിസ്ഥാനമാക്കി ഡൈനാമിക് കമാൻഡ് എക്സിക്യൂഷൻ അനുവദിക്കുന്നു.

import subprocess
# Example 1: Running a simple shell command
subprocess.run(['echo', 'Hello, World!'])
# Example 2: Capturing the output of a command
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
# Example 3: Running a command with shell=True
subprocess.run('echo Hello from the shell', shell=True)
# Example 4: Checking the return code
result = subprocess.run(['ls', 'nonexistentfile'], capture_output=True)
if result.returncode != 0:
    print('Command failed')
# Example 5: Using subprocess.Popen for more control
process = subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE)
while True:
    output = process.stdout.readline()
    if output == b'' and process.poll() is not None:
        break
    if output:
        print(output.strip().decode())

import os
import subprocess
# Example 1: Using os.system to run a command
os.system('echo This is a test')
# Example 2: Running a command and capturing output with subprocess
result = subprocess.run(['date'], capture_output=True, text=True)
print('Current date and time:', result.stdout)
# Example 3: Executing multiple commands
commands = ['echo First command', 'echo Second command']
for cmd in commands:
    os.system(cmd)
# Example 4: Running a command with environment variables
env = os.environ.copy()
env['MY_VAR'] = 'Hello'
subprocess.run('echo $MY_VAR', shell=True, env=env)
# Example 5: Handling command errors
try:
    subprocess.check_output(['false_command'], stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
    print('An error occurred:', e.output.decode())

സിസ്റ്റം കമാൻഡ് എക്‌സിക്യൂഷനുള്ള നൂതന സാങ്കേതിക വിദ്യകൾ

പൈത്തണിൽ സിസ്റ്റം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിൻ്റെ മറ്റൊരു വശം ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു shlex ഷെൽ കമാൻഡ് പാഴ്‌സിംഗ് കൈകാര്യം ചെയ്യുന്നതിനുള്ള മൊഡ്യൂൾ. ഷെൽ കമാൻഡുകൾ ഒരു ലിസ്റ്റ് ഫോർമാറ്റിലേക്ക് വിഭജിക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഈ മൊഡ്യൂൾ നൽകുന്നു, അത് പിന്നീട് കൈമാറാം subprocess പ്രവർത്തനങ്ങൾ. സ്‌പെയ്‌സുകളുള്ള ആർഗ്യുമെൻ്റുകൾ ശരിയായി കൈകാര്യം ചെയ്യപ്പെടുന്നുവെന്ന് ഇത് ഉറപ്പാക്കുന്നു. കൂടാതെ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം subprocess.PIPE സാധാരണ ഇൻപുട്ട്, ഔട്ട്പുട്ട്, പിശക് സ്ട്രീമുകൾ എന്നിവ പാരൻ്റ് പ്രോസസിലേക്ക് നയിക്കുന്നതിന്, കൂടുതൽ സങ്കീർണ്ണമായ ഇൻ്റർ-പ്രോസസ് ആശയവിനിമയത്തിന് അനുവദിക്കുന്നു.

ഉദാഹരണത്തിന്, ഒരു കമാൻഡിൻ്റെ ഔട്ട്‌പുട്ട് മറ്റൊന്നിലേക്ക് പൈപ്പ് ചെയ്യുന്നതിലൂടെ കമാൻഡുകൾ ചെയിൻ ചെയ്യുകയും അവയുടെ ഔട്ട്‌പുട്ട് തുടർച്ചയായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യാം. subprocess.Popen. ഒരു ഷെൽ സ്ക്രിപ്റ്റിൽ നിങ്ങൾ ചെയ്യുന്നതുപോലെ ശക്തമായ കമാൻഡ് സീക്വൻസുകൾ സൃഷ്ടിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. നിങ്ങൾക്ക് ഉപയോഗിക്കാനും കഴിയും threading ഒന്നിലധികം സബ്പ്രോസസ് കമാൻഡുകൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങളുടെ സ്ക്രിപ്റ്റിൻ്റെ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നു, പ്രത്യേകിച്ചും I/O-ബൗണ്ട് ടാസ്ക്കുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.

സിസ്റ്റം കമാൻഡ് എക്‌സിക്യൂഷനുള്ള നൂതന സാങ്കേതിക വിദ്യകൾ

പൈത്തണിൽ സിസ്റ്റം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിൻ്റെ മറ്റൊരു വശം ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു shlex ഷെൽ കമാൻഡ് പാഴ്‌സിംഗ് കൈകാര്യം ചെയ്യുന്നതിനുള്ള മൊഡ്യൂൾ. ഷെൽ കമാൻഡുകൾ ഒരു ലിസ്റ്റ് ഫോർമാറ്റിലേക്ക് വിഭജിക്കുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഈ മൊഡ്യൂൾ നൽകുന്നു, അത് പിന്നീട് കൈമാറാം subprocess പ്രവർത്തനങ്ങൾ. സ്‌പെയ്‌സുകളുമായുള്ള ആർഗ്യുമെൻ്റുകൾ ശരിയായി കൈകാര്യം ചെയ്യപ്പെടുന്നുവെന്ന് ഇത് ഉറപ്പാക്കുന്നു. കൂടാതെ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം subprocess.PIPE സാധാരണ ഇൻപുട്ട്, ഔട്ട്പുട്ട്, പിശക് സ്ട്രീമുകൾ എന്നിവ പാരൻ്റ് പ്രോസസിലേക്ക് നയിക്കുന്നതിന്, കൂടുതൽ സങ്കീർണ്ണമായ ഇൻ്റർ-പ്രോസസ് ആശയവിനിമയത്തിന് അനുവദിക്കുന്നു.

ഉദാഹരണത്തിന്, ഒരു കമാൻഡിൻ്റെ ഔട്ട്‌പുട്ട് മറ്റൊന്നിലേക്ക് പൈപ്പ് ചെയ്യുന്നതിലൂടെ കമാൻഡുകളെ ചെയിൻ ചെയ്യുകയും അവയുടെ ഔട്ട്‌പുട്ട് തുടർച്ചയായി പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യാം. subprocess.Popen. ഒരു ഷെൽ സ്ക്രിപ്റ്റിൽ നിങ്ങൾ ചെയ്യുന്നതുപോലെ ശക്തമായ കമാൻഡ് സീക്വൻസുകൾ സൃഷ്ടിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. നിങ്ങൾക്ക് ഉപയോഗിക്കാനും കഴിയും threading ഒന്നിലധികം സബ്പ്രോസസ് കമാൻഡുകൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങളുടെ സ്ക്രിപ്റ്റിൻ്റെ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നു, പ്രത്യേകിച്ചും I/O-ബൗണ്ട് ടാസ്ക്കുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.