Python Subprocess का परिचय: मूल बातें और उदाहरण

Python Subprocess कब उपयोग करें

आइए देखें कि Python subprocess मॉड्यूल का उपयोग कब करना चाहिए।

सिस्टम कार्यों का स्वचालन

subprocess मॉड्यूल का उपयोग विभिन्न सिस्टम कार्यों को स्वचालित करने के लिए किया जा सकता है, जैसे बैकअप चलाना, सेवाओं को शुरू और बंद करना, और क्रॉन जॉब्स शेड्यूल करना। उदाहरण के लिए, आप किसी फाइल का बैकअप बनाने के लिए cp कमांड चला सकते हैं या systemctl (आधुनिक Linux) या service (पुराने सिस्टम) का उपयोग करके सेवाओं को शुरू और बंद कर सकते हैं। आप subprocess मॉड्यूल के जरिए शेड्यूलिंग टूल्स (जैसे Linux पर cron या Windows पर Task Scheduler) को भी कॉल कर सकते हैं, पर शेड्यूलिंग स्वयं वे टूल्स संभालते हैं, subprocess नहीं।

कमांड-लाइन टूल्स चलाना

subprocess मॉड्यूल का उपयोग grep, sed, और awk जैसे कमांड-लाइन टूल्स चलाने और उनके आउटपुट को अपने Python कोड में प्रोसेस करने के लिए किया जा सकता है। उदाहरण के लिए, आप grep कमांड चलाकर किसी फाइल में किसी विशेष पैटर्न को खोज सकते हैं और फिर आउटपुट को अपने Python कोड में प्रोसेस कर सकते हैं। यह लॉग विश्लेषण, डेटा प्रोसेसिंग और टेक्स्ट मैनिपुलेशन जैसे कार्यों के लिए उपयोगी है।

बाहरी एक्जिक्यूटेबल्स चलाना

subprocess मॉड्यूल अन्य एक्जिक्यूटेबल्स चला सकता है, जैसे Windows पर .exe फाइलें, और उनके व्यवहार को नियंत्रित कर सकता है। उदाहरण के लिए, आप किसी विशेष कार्य को करने वाले एक्जिक्यूटेबल को चला सकते हैं और फिर उसके आउटपुट का उपयोग अपने कोड में कर सकते हैं। यह इमेज प्रोसेसिंग, डेटा विश्लेषण और मशीन लर्निंग जैसे कार्यों में उपयोगी है।

स्क्रिप्ट्स को बैकग्राउंड प्रोसेस के रूप में चलाना

आप subprocess मॉड्यूल का उपयोग करके स्क्रिप्ट्स को बैकग्राउंड प्रोसेस के रूप में चला सकते हैं ताकि वे मुख्य प्रोग्राम के बंद होने के बाद भी चलती रहें। उदाहरण के लिए, आप किसी विशिष्ट कार्य को करने वाली स्क्रिप्ट चला सकते हैं और मुख्य प्रोग्राम को स्क्रिप्ट के पूरा होने की प्रतीक्षा किए बिना समाप्त कर सकते हैं। यह मॉनिटरिंग, लॉगिंग और डेटा कलेक्शन के लिए उपयोगी है।

नॉन-Python इंटरप्रेटर से स्क्रिप्ट्स चलाना

subprocess मॉड्यूल आपको अन्य भाषाओं, जैसे Perl, Ruby, और Bash में लिखी स्क्रिप्ट्स चलाने में मदद कर सकता है। उदाहरण के लिए, आप किसी विशिष्ट कार्य को करने वाली Perl स्क्रिप्ट चला सकते हैं और फिर उसके आउटपुट का उपयोग अपने कोड में कर सकते हैं। यह डेटा प्रोसेसिंग, टेक्स्ट मैनिपुलेशन और सिस्टम एडमिनिस्ट्रेशन के लिए उपयोगी है।

समानांतर प्रोसेसिंग

subprocess मॉड्यूल का उपयोग एक साथ कई प्रोसेस चलाने के लिए किया जा सकता है, जो इमेज प्रोसेसिंग, डेटा विश्लेषण और मशीन लर्निंग जैसे कार्यों में उपयोगी है। उदाहरण के लिए, आप एक ही स्क्रिप्ट के कई इंस्टेंस चला सकते हैं, जिनमें से प्रत्येक डेटा के अलग-अलग हिस्से को प्रोसेस करे, और फिर परिणामों को संयोजित कर लें।

Python Subprocess के उदाहरण 

अब कुछ Python subprocess उदाहरण देखते हैं।

python subprocess run

subprocess.run() मेथड एक सबप्रोसेस चलाने और उसके पूरा होने तक प्रतीक्षा करने का सुविधाजनक तरीका है। इसमें आप कौन-सा कमांड चलाना है चुन सकते हैं और आर्ग्यूमेंट्स, एनवायरनमेंट वैरिएबल्स, और इनपुट/आउटपुट रीडायरेक्शन जैसे विकल्प जोड़ सकते हैं। सबप्रोसेस शुरू होने के बाद, run() मेथड तब तक ब्लॉक रहता है जब तक सबप्रोसेस पूरा न हो जाए और फिर एक CompletedProcess ऑब्जेक्ट लौटाता है, जिसमें सबप्रोसेस का रिटर्न कोड और आउटपुट होता है।

subprocess.run() मेथड कई आर्ग्यूमेंट्स लेता है, जिनमें से कुछ हैं:

• args: चलाने वाला कमांड और उसके आर्ग्यूमेंट्स, स्ट्रिंग्स की लिस्ट के रूप में।

• capture_output: True होने पर, स्टैंडर्ड आउटपुट और स्टैंडर्ड एरर को कैप्चर करेगा।

• text: True होने पर stdout और stderr स्ट्रिंग के रूप में लौटेंगे, अन्यथा बाइट्स में।

• check: एक बूलियन मान जो दर्शाता है कि सबप्रोसेस के रिटर्न कोड की जांच की जाए या नहीं; यदि check True है और रिटर्न कोड नॉन-ज़ीरो है, तो CalledProcessError उठेगा।

• timeout: सेकंड में वह समय, जिसके बाद सबप्रोसेस पूरा न होने पर टाइमआउट हो जाएगा।

• shell: एक बूलियन मान जो दर्शाता है कि कमांड को शेल में चलाया जाए या नहीं। इसका मतलब है कि कमांड स्ट्रिंग के रूप में पास किया जाता है और शेल-विशिष्ट फीचर्स—जैसे वाइल्डकार्ड एक्सपैंशन और वैरिएबल सब्स्टीट्यूशन—का उपयोग किया जा सकता है।

subprocess.run() मेथड एक CompletedProcess ऑब्जेक्ट भी लौटाता है, जिसमें ये एट्रीब्यूट्स होते हैं:

• args: चलाए गए कमांड और उसके आर्ग्यूमेंट्स।

• returncode: सबप्रोसेस का रिटर्न कोड।

• stdout: सबप्रोसेस का स्टैंडर्ड आउटपुट (यदि text=True तो स्ट्रिंग, अन्यथा बाइट्स)।

• stderr: सबप्रोसेस का स्टैंडर्ड एरर (यदि text=True तो स्ट्रिंग, अन्यथा बाइट्स)।

उदाहरण 1: शेल कमांड चलाना:

import subprocess

result = subprocess.run("dir", shell=True, capture_output=True, text=True)

print(result.stdout)
संचालित द्वारा

आउटपुट: 

Volume in drive C has no label.

Volume Serial Number is E414-A41C

 Directory of C:\Users\owner

01/25/2023  10:56 AM    <DIR>          .

01/25/2023  10:56 AM    <DIR>          ..

07/19/2021  01:19 PM    <DIR>          .anaconda

07/19/2021  01:19 PM    <DIR>          .astropy

07/19/2021  01:19 PM    <DIR>          .aws

09/12/2022  08:48 AM               496 .bash_history

03/27/2022  03:08 PM    <DIR>          .cache

09/26/2021  06:58 AM    <DIR>          .conda

09/26/2021  06:59 AM                25 .condarc

…
संचालित द्वारा

Linux/macOS पर उपयोग करें: result = subprocess.run(["ls", "-la"], capture_output=True, text=True) (shell आर्ग्यूमेंट की ज़रूरत नहीं)।

उदाहरण 2: Python स्क्रिप्ट्स चलाना:

आप subprocess.run() मेथड का उपयोग करके Python स्क्रिप्ट भी चला सकते हैं। पहले .py फाइल में एक साधारण Python स्क्रिप्ट बनाते हैं

print(“This is the output from subprocess module”)
संचालित द्वारा

इस फाइल को file_donot_exist.py नाम से सेव करें। अब, आप subprocess मॉड्यूल का उपयोग करके इस फाइल को चला सकते हैं:

import subprocess
import sys

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=False)

print(result.stdout)संचालित द्वारा

आउटपुट:

This is the output from subprocess module
संचालित द्वारा

उदाहरण 3: किसी फ़ंक्शन से सीधे Python कोड चलाना:

सरल उपयोग मामलों में, आप सीधे subprocess.run() फ़ंक्शन में Python कमांड पास कर सकते हैं। ऐसे करें:

result = subprocess.run([sys.executable, "-c", "print('This is directly from a subprocess.run() function')"], capture_output = True, text = True)

print(result.stdout)संचालित द्वारा

आउटपुट:

This is directly from a subprocess.run() function
संचालित द्वारा

args लिस्ट में, पहला एलिमेंट sys.executable मौजूदा Python इंटरप्रेटर का पाथ डायनामिक रूप से देता है। इससे चल रहे प्रोसेस के साथ संगति बनी रहती है और "C:/..." जैसे हार्डकोडेड पाथ से बचा जा सकता है। दूसरा एलिमेंट "-c" है, जो स्क्रिप्ट के बजाय अगली स्ट्रिंग को Python कोड की तरह चलाता है। sys.executable का उपयोग करने के लिए हमेशा import sys शामिल करें।

उदाहरण 4: check आर्ग्यूमेंट का उपयोग

check आर्ग्यूमेंट Python के subprocess मॉड्यूल में subprocess.run() फ़ंक्शन का एक वैकल्पिक आर्ग्यूमेंट है। यह एक बूलियन मान है जो नियंत्रित करता है कि चलाए जा रहे कमांड के रिटर्न कोड की जांच की जाए या नहीं।

जब check को True पर सेट किया जाता है, तो फ़ंक्शन कमांड के रिटर्न कोड की जाँच करता है और यदि रिटर्न कोड नॉन-ज़ीरो है तो CalledProcessError एक्सेप्शन उठाता है। इस एक्सेप्शन में रिटर्न कोड, stdout, stderr और कमांड एट्रीब्यूट्स के रूप में उपलब्ध होते हैं।

जब check को False (डिफ़ॉल्ट) पर सेट किया जाता है, तो फ़ंक्शन कमांड असफल होने पर भी एक्सेप्शन नहीं उठाता — इसके बजाय, आपको स्वयं रिटर्न कोड की जाँच करनी होगी।

import subprocess

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

print(result.stdout)

print(result.stderr)
संचालित द्वारा

आउटपुट:

---------------------------------------------------------------------------

CalledProcessError                        Traceback (most recent call last)

<ipython-input-81-503b60184db8> in <module>

      1 import subprocess

----> 2 result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

      3 print(result.stdout)

      4 print(result.stderr)

~\anaconda3\lib\subprocess.py in run(input, capture_output, timeout, check, *popenargs, **kwargs)

    514         retcode = process.poll()

    515         if check and retcode:

--> 516             raise CalledProcessError(retcode, process.args,

    517                                      output=stdout, stderr=stderr)

    518     return CompletedProcess(process.args, retcode, stdout, stderr)

CalledProcessError: Command '['python', 'file_donot_exist.py']' returned non-zero exit status 2.संचालित द्वारा

ध्यान दें कि कमांड असफल हुआ क्योंकि my_python_file2.py मौजूद नहीं है, और क्योंकि check=True पास किया गया था, एक CalledProcessError उठी। यदि आप check=False सेट करें (या इसे बिल्कुल न दें), तो आपका प्रोसेस एक्सेप्शन नहीं उठाएगा; इसके बजाय, आपको stderr में एरर संदेश दिखेगा और आप स्वयं तय कर सकते हैं कि उसे कैसे संभालना है।

import subprocess

result = subprocess.run(["python", "my_python_file2.py"], capture_output=True, text=True, check=False)

print(result.stdout)

print(result.stderr)
संचालित द्वारा

आउटपुट:

python: can't open file 'my_python_file2.py': [Errno 2] No such file or directory
संचालित द्वारा

python subprocess Popen

subprocess.Popen() सबप्रोसेस चलाने के लिए लो-लेवल इंटरफेस है, जबकि subprocess.run Popen के ऊपर एक हाई-लेवल रैपर है, जिसे अधिक सुविधाजनक उपयोग के लिए बनाया गया है।

Popen आपको एक नया प्रोसेस शुरू करने और उसके स्टैंडर्ड इनपुट, आउटपुट और एरर स्ट्रीम्स के साथ इंटरैक्ट करने देता है। यह चल रहे प्रोसेस का एक हैंडल लौटाता है, जिसका उपयोग आप प्रोसेस के पूरा होने की प्रतीक्षा करने, उसका रिटर्न कोड जांचने या उसे समाप्त करने के लिए कर सकते हैं।

run() एक अधिक सुविधाजनक फ़ंक्शन है जो आपको एक ही कॉल में कमांड चलाने और उसका आउटपुट कैप्चर करने देता है, बिना Popen ऑब्जेक्ट बनाने और स्ट्रीम्स को स्वयं मैनेज किए। यह यह भी निर्धारित करने के विकल्प देता है कि यदि कमांड असफल हो तो एक्सेप्शन उठाया जाए या नहीं।

सामान्यतः, यदि आपको सिर्फ कमांड चलाकर आउटपुट कैप्चर करना है तो run() का उपयोग करें, और यदि आपको प्रोसेस पर अधिक नियंत्रण चाहिए—जैसे उसकी इनपुट/आउटपुट स्ट्रीम्स से इंटरैक्ट करना—तो Popen का।

Popen क्लास run() के समान आर्ग्यूमेंट्स लेती है, जिनमें चलाए जाने वाले कमांड को निर्दिष्ट करने वाले args और stdin, stdout, stderr, shell, cwd, और env जैसे अन्य वैकल्पिक आर्ग्यूमेंट्स शामिल हैं। साथ ही, Popen क्लास में कई मेथड्स होते हैं, जैसे communicate(), poll(), wait(), terminate(), और kill(), जिनसे आप प्रोसेस के साथ इंटरैक्ट कर सकते हैं।

import subprocess

p = subprocess.Popen(["python", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

output, errors = p.communicate()

print(output)
संचालित द्वारा

आउटपुट:

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-b     : issue warnings about str(bytes_instance), str(bytearray_instance)

         and comparing bytes/bytearray with str. (-bb: issue errors)

-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser; also PYTHONDEBUG=x

-E     : ignore PYTHON* environment variables (such as PYTHONPATH)

…संचालित द्वारा

यह python –help कमांड चलाएगा और एक नया Popen ऑब्जेक्ट बनाएगा, जिसे वैरिएबल p में रखा गया है। कमांड के स्टैंडर्ड आउटपुट और एरर को communicate() मेथड से कैप्चर किया जाता है और क्रमशः output और errors वैरिएबल्स में रखा जाता है।

subprocess.Popen उपयोगी है जब आप प्रोसेस पर अधिक नियंत्रण चाहते हैं—जैसे उसे इनपुट भेजना, उससे आउटपुट प्राप्त करना, या उसके पूरा होने तक प्रतीक्षा करना।

python subprocess call

subprocess.call() Python के subprocess मॉड्यूल का एक फ़ंक्शन है जिसका उपयोग किसी कमांड को अलग प्रोसेस में चलाने और उसके पूरा होने तक प्रतीक्षा करने के लिए किया जाता है। यह कमांड का रिटर्न कोड लौटाता है—कमांड सफल होने पर शून्य और असफल होने पर नॉन-ज़ीरो।

call() फ़ंक्शन run() के समान आर्ग्यूमेंट्स लेता है, जिनमें चलाए जाने वाले कमांड को निर्दिष्ट करने वाले args और stdin, stdout, stderr, shell, cwd, और env जैसे अन्य वैकल्पिक आर्ग्यूमेंट्स शामिल हैं।

कमांड का स्टैंडर्ड आउटपुट और एरर पैरेंट प्रोसेस के समान stdout और stderr पर भेजे जाते हैं, जब तक कि आप उन्हें stdout और stderr आर्ग्यूमेंट्स के जरिए रीडायरेक्ट न कर दें।

import sys
import subprocess

return_code = subprocess.call([sys.executable, "--version"])

if return_code == 0:
    print("Command executed successfully.")
else:
    print("Command failed with return code", return_code)संचालित द्वारा

आउटपुट:

Command executed successfully.
संचालित द्वारा

यह python -–version कमांड को एक अलग प्रोसेस में चलाएगा और उसके पूरा होने तक प्रतीक्षा करेगा। कमांड का रिटर्न कोड return_code वैरिएबल में स्टोर होगा—कमांड सफल होने पर शून्य और असफल होने पर नॉन-ज़ीरो।

subprocess.call() तब उपयोगी है जब आपको सिर्फ कमांड चलाकर रिटर्न कोड जांचना हो, आउटपुट कैप्चर करने की आवश्यकता न हो।

python subprocess check_output

check_output subprocess मॉड्यूल का एक फ़ंक्शन है जो run() जैसा है, लेकिन यह केवल कमांड का स्टैंडर्ड आउटपुट लौटाता है और रिटर्न कोड नॉन-ज़ीरो होने पर CalledProcessError एक्सेप्शन उठाता है।

फ़ंक्शन check_output() वही आर्ग्यूमेंट्स लेता है जो run() लेता है—जैसे args (चलाने वाला कमांड) और stdin, stderr, shell, cwd, और env जैसे वैकल्पिक आर्ग्यूमेंट्स। यह कमांड का स्टैंडर्ड आउटपुट बाइट्स ऑब्जेक्ट या स्ट्रिंग (यदि text=True) के रूप में लौटाता है। कमांड असफल होने (नॉन-ज़ीरो एग्ज़िट स्टेटस) पर CalledProcessError उठाता है।

नोट: डिफ़ॉल्ट रूप से, check_output() केवल stdout को कैप्चर करता है। यदि आप आउटपुट में stderr भी शामिल करना चाहते हैं, तो इसे स्पष्ट रूप से stderr=subprocess.STDOUT के जरिए रीडायरेक्ट करें।

import subprocess
import sys

try:

    output = subprocess.check_output([sys.executable, "--version"], text=True)

    print(output)

except subprocess.CalledProcessError as e:

    print(f"Command failed with return code {e.returncode}")
संचालित द्वारा

आउटपुट:

Python 3.8.8संचालित द्वारा

Python Subprocess Pipe

Python का subprocess मॉड्यूल चाइल्ड प्रोसेस बनाने और उनसे इंटरैक्ट करने का तरीका देता है, जिसका उपयोग अन्य प्रोग्राम या कमांड चलाने के लिए किया जा सकता है। subprocess मॉड्यूल की विशेषताओं में से एक पाइप्स बनाना है, जो पैरेंट और चाइल्ड प्रोसेस के बीच संचार की सुविधा देता है।

पाइप एक एक-तरफा संचार चैनल है जो एक प्रोसेस के स्टैंडर्ड आउटपुट को दूसरे के स्टैंडर्ड इनपुट से जोड़ता है। पाइप एक कमांड के आउटपुट को दूसरे कमांड के इनपुट से जोड़ सकता है, जिससे पहले कमांड का आउटपुट दूसरे कमांड के इनपुट के रूप में उपयोग हो सके।

पाइप्स को subprocess मॉड्यूल में Popen क्लास का उपयोग करके बनाया जा सकता है—इसके लिए stdout या stdin आर्ग्यूमेंट को subprocess.PIPE के रूप में निर्दिष्ट करें।

उदाहरण के लिए, निम्न कोड एक पाइप बनाता है जो ls कमांड के आउटपुट को grep कमांड के इनपुट से जोड़ता है, जो आउटपुट को फ़िल्टर करके केवल वे लाइनें दिखाता है जिनमें "file" शब्द शामिल है:

import subprocess


ls_process = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)
grep_process = subprocess.Popen(
    ["grep", "sample"],
    stdin=ls_process.stdout,
    stdout=subprocess.PIPE,
    text=True
)
ls_process.stdout.close()  # POSIX-only: prevents deadlocks by closing the pipe
output, error = grep_process.communicate()


print(output)
print(error)
संचालित द्वारा

आउटपुट:

sample_dataसंचालित द्वारा

इस उदाहरण में, Popen क्लास का उपयोग करके दो चाइल्ड प्रोसेस बनाए जाते हैं—एक ls कमांड के लिए और एक grep कमांड के लिए। ls कमांड के stdout को subprocess.PIPE के जरिए grep कमांड के stdin से जोड़ा जाता है, जो दोनों प्रोसेस के बीच एक पाइप बनाता है। communicate() मेथड का उपयोग ls कमांड के आउटपुट को grep कमांड को भेजने और फ़िल्टर्ड आउटपुट प्राप्त करने के लिए किया जाता है।

निष्कर्ष

Python का subprocess मॉड्यूल चाइल्ड प्रोसेस बनाने और उनसे इंटरैक्ट करने का एक शक्तिशाली और लचीला तरीका प्रदान करता है, जिससे आप अपने Python स्क्रिप्ट के भीतर से अन्य प्रोग्राम चला सकते हैं या कमांड जारी कर सकते हैं। साधारण subprocess.call() जैसे कमांड से लेकर पाइप्स, इनपुट/आउटपुट रीडायरेक्शन और एनवायरनमेंट वैरिएबल्स पास करने जैसी उन्नत विशेषताओं तक—subprocess मॉड्यूल लगभग हर उपयोग मामले के लिए कुछ न कुछ प्रदान करता है। यह दोहराए जाने वाले कार्यों को स्वचालित करने, सिस्टम कमांड चलाने और अन्य प्रोग्रामिंग भाषाओं व प्लेटफ़ॉर्म्स के साथ इंटरैक्ट करने का एक बढ़िया तरीका है।

subprocess मॉड्यूल के साथ काम करते समय यह याद रखना महत्वपूर्ण है कि बाहरी कमांड चलाना सुरक्षा जोखिम पैदा कर सकता है, खासकर जब आप shell=True पैरामीटर का उपयोग करते हैं या बिना सैनिटाइज़ किए इनपुट पास करते हैं। बेहतर अभ्यास यह है कि आप subprocess.run() फ़ंक्शन का उपयोग करें, जो यह निर्धारित करने के लिए विभिन्न विकल्प देता है कि कमांड कैसे चलाया जाए—जैसे कमांड असफल होने पर एक्सेप्शन उठाया जाए या नहीं। 

यदि आप Python के माध्यम से कमांड लाइन ऑटोमेशन की असीम संभावनाओं में गहराई से जाना चाहते हैं, तो हमारा Command Line Automation in Python कोर्स देखें। इस कोर्स में, आप ऐसा ऑटोमेशन कोड लिखना सीखेंगे जो फाइल सिस्टम ब्राउज़ करे, किसी पैटर्न का अनुसरण करने वाली फाइलें ढूंढे, और अनेक परिस्थितियों में यह निर्धारित करे कि कौन-सी फाइलें डुप्लिकेट हैं। कोर्स पूरा करने के बाद, आप Unix प्रोसेस मैनेज कर पाएंगे और विभिन्न रूटीन फाइल सिस्टम गतिविधियों को ऑटोमेट कर पाएंगे। 

DataCamp for Business के साथ अपनी टीम की Python स्किल्स बढ़ाएँ

यदि आप या आपकी टीम Python और कमांड लाइन ऑटोमेशन में अपनी स्किल्स बढ़ाना चाहते हैं, तो DataCamp for Business को एक्सप्लोर करें। DataCamp सभी आकार की टीमों के लिए अनुकूलित लर्निंग समाधान प्रदान करता है, जिससे व्यवसाय तेजी से बदलते टेक परिदृश्य में आगे रह सकें। DataCamp for Business के साथ, आप अपनी टीम को Python, ऑटोमेशन, और अन्य आवश्यक डेटा साइंस टूल्स में विशेषज्ञता बनाने के लिए कोर्सेज और कस्टम लर्निंग ट्रैक्स से अपस्किल कर सकते हैं। चाहे आप स्टार्टअप हों या एंटरप्राइज़, DataCamp for Business आपकी टीम के लर्निंग लक्ष्यों को प्राप्त करने के लिए संसाधन और लचीलापन प्रदान करता है। आज ही डेमो का अनुरोध करें और अधिक जानें.