പൈത്തണിൽ ബാഹ്യ കമാൻഡുകൾ നടപ്പിലാക്കുന്നു

പൈത്തണിൻ്റെ കമാൻഡ് എക്‌സിക്യൂഷൻ കഴിവുകളെക്കുറിച്ചുള്ള ഒരു പ്രൈമർ

പൈത്തൺ, അതിൻ്റെ ലാളിത്യത്തിനും ശക്തിക്കും പേരുകേട്ട, സിസ്റ്റത്തിൻ്റെ അന്തർലീനമായ ഷെൽ എൻവയോൺമെൻ്റുമായി സംവദിക്കാൻ വിവിധ രീതികൾ വാഗ്ദാനം ചെയ്യുന്നു, ഒരു പൈത്തൺ സ്ക്രിപ്റ്റിൽ നിന്ന് നേരിട്ട് പ്രോഗ്രാമുകളോ സിസ്റ്റം കമാൻഡുകളോ നടപ്പിലാക്കുന്നത് സാധ്യമാക്കുന്നു. ഈ കഴിവ് പൈത്തണിൻ്റെ യൂട്ടിലിറ്റിയെ ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു, ഇത് ഒറ്റപ്പെട്ട ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിനുള്ള ഒരു ഉപകരണമായി മാത്രമല്ല, സിസ്റ്റത്തിൻ്റെ ഷെൽ കമാൻഡുകളുടെയും സ്ക്രിപ്റ്റുകളുടെയും മുഴുവൻ സാധ്യതകളും പ്രയോജനപ്പെടുത്തുന്നതിനുള്ള ഒരു പാലമായും പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു. സാധാരണ ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനോ സിസ്റ്റം റിസോഴ്‌സുകൾ കൈകാര്യം ചെയ്യുന്നതിനോ മറ്റ് സോഫ്‌റ്റ്‌വെയർ ഘടകങ്ങളുമായി പൈത്തൺ ആപ്ലിക്കേഷനുകൾ സമന്വയിപ്പിക്കുന്നതിനോ വേണ്ടിയാണെങ്കിലും, ബാഹ്യ കമാൻഡുകൾ എങ്ങനെ എക്‌സിക്യൂട്ട് ചെയ്യാമെന്ന് മനസിലാക്കുന്നത് ഡെവലപ്പർമാർക്ക് ഒരു അടിസ്ഥാന വൈദഗ്ധ്യമാണ്.

ഈ പ്രക്രിയയിൽ നിരവധി ബിൽറ്റ്-ഇൻ മൊഡ്യൂളുകളും ഫംഗ്ഷനുകളും ഉൾപ്പെടുന്നു, ഓരോന്നിനും അതിൻ്റേതായ ഉപയോഗ കേസുകളും സൂക്ഷ്മതകളും ഉണ്ട്. ഉദാഹരണത്തിന്, `os.system` പോലെയുള്ള പഴയ മൊഡ്യൂളുകൾ മാറ്റിസ്ഥാപിക്കുന്നതിനായി അവതരിപ്പിച്ച `സബ്പ്രോസസ്` മൊഡ്യൂൾ, പുതിയ പ്രോസസുകൾ സൃഷ്ടിക്കുന്നതിനും അവയുടെ ഇൻപുട്ട്/ഔട്ട്പുട്ട്/എറർ പൈപ്പുകളിലേക്ക് കണക്ട് ചെയ്യുന്നതിനും അവയുടെ റിട്ടേൺ കോഡുകൾ നേടുന്നതിനും കൂടുതൽ ശക്തമായ മാർഗങ്ങൾ നൽകുന്നു. `os`, `shutil` മൊഡ്യൂളുകൾ പോലെയുള്ള മറ്റ് രീതികൾ, സിസ്റ്റം നാവിഗേഷനും ഫയൽ പ്രവർത്തനങ്ങൾക്കും യഥാക്രമം അധിക യൂട്ടിലിറ്റികൾ വാഗ്ദാനം ചെയ്യുന്നു. ഈ ആമുഖം സിസ്റ്റം കമാൻഡുകളും ബാഹ്യ പ്രോഗ്രാമുകളും നടപ്പിലാക്കുന്നതിനുള്ള അവശ്യ ടെക്നിക്കുകളിലൂടെ നിങ്ങളെ നയിക്കും, കൂടുതൽ വിപുലമായ സിസ്റ്റം ഇൻ്റഗ്രേഷൻ ടാസ്ക്കുകൾക്ക് അടിത്തറയിടുന്നു.

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

ഒരു പൈത്തൺ സ്ക്രിപ്റ്റിൽ നിന്ന് ഒരു പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുക അല്ലെങ്കിൽ ഒരു സിസ്റ്റം കമാൻഡ് വിളിക്കുക എന്നത് പല ഡവലപ്പർമാരുടെയും ഒരു സാധാരണ ആവശ്യകതയാണ്. സിസ്റ്റം ടാസ്‌ക്കുകൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതോ ബാഹ്യ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നതോ സെർവർ പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതോ ആകട്ടെ, ഈ ആവശ്യങ്ങൾ തടസ്സമില്ലാതെ കൈകാര്യം ചെയ്യാൻ പൈത്തൺ ശക്തമായ ലൈബ്രറികൾ നൽകുന്നു. ദി ഉപപ്രക്രിയ ഉദാഹരണത്തിന്, മൊഡ്യൂൾ, പുതിയ പ്രക്രിയകൾ സൃഷ്ടിക്കുന്നതിനും അവയുടെ ഇൻപുട്ട് / ഔട്ട്പുട്ട് / പിശക് പൈപ്പുകളുമായി ബന്ധിപ്പിക്കുന്നതിനും അവയുടെ റിട്ടേൺ കോഡുകൾ നേടുന്നതിനുമുള്ള ശക്തമായ ഒരു ഉപകരണമാണ്. ഈ മൊഡ്യൂൾ പഴയതിനേക്കാൾ മുൻഗണന നൽകുന്നു os.system() രീതി കാരണം ഇത് കമാൻഡ് എക്‌സിക്യൂഷനിൽ കൂടുതൽ വഴക്കവും നിയന്ത്രണവും നൽകുന്നു. ഉദാഹരണത്തിന്, subprocess.run() പൈത്തണിൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു നേരായ മാർഗമാണ്, ഔട്ട്പുട്ടും പിശകുകളും ക്യാപ്ചർ ചെയ്യാൻ അനുവദിക്കുന്നു, ഇത് ഡീബഗ്ഗിംഗിനും ലോഗിംഗിനും നിർണായകമാണ്.

മറുവശത്ത്, os.system() ഔട്ട്‌പുട്ടുകൾ ക്യാപ്‌ചർ ചെയ്യാതെ തന്നെ വേഗത്തിലുള്ളതും ലളിതവുമായ കമാൻഡ് എക്‌സിക്യൂഷൻ ആവശ്യമായ സാഹചര്യങ്ങളിൽ ഇപ്പോഴും അതിൻ്റെ ഉപയോഗം കണ്ടെത്തുന്നു. ഇത് ഒരു സബ്‌ഷെല്ലിൽ കമാൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നു, അതിനർത്ഥം ഇത് സുരക്ഷിതമല്ലാത്തതും എക്‌സിക്യൂഷനിൽ കുറച്ച് നിയന്ത്രണം വാഗ്ദാനം ചെയ്യുന്നതുമാണ്. നോൺ-ബ്ലോക്ക് എക്‌സിക്യൂഷൻ അല്ലെങ്കിൽ സമാന്തരമായി പ്രവർത്തിപ്പിക്കുന്ന കമാൻഡുകൾ പോലെയുള്ള വിപുലമായ ഉപയോഗ സാഹചര്യങ്ങൾ subprocess.Popen(). നിങ്ങൾ തത്സമയം ഔട്ട്‌പുട്ട് പ്രോസസ്സ് ചെയ്യേണ്ടതോ മറ്റ് ജോലികൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കുന്നത് തുടരുന്നതോ ആയ ദീർഘകാല കമാൻഡുകൾക്ക് ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. പൈത്തണിലെ ഫലപ്രദമായ സ്ക്രിപ്റ്റിംഗിനും ഓട്ടോമേഷനും ഈ രീതികൾ തമ്മിലുള്ള വ്യത്യാസങ്ങളും ഓരോന്നും എപ്പോൾ ഉപയോഗിക്കണം എന്നത് വളരെ പ്രധാനമാണ്.

പൈത്തണിൽ സിസ്റ്റം കമാൻഡുകൾ നടപ്പിലാക്കുന്നു

പൈത്തൺ പ്രോഗ്രാമിംഗ്

import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)

കമാൻഡ് എക്സിക്യൂഷനുവേണ്ടി os.system ഉപയോഗിക്കുന്നു

പൈത്തൺ കോഡ് സ്നിപ്പെറ്റ്

import os
os.system('echo Hello World!')

അസിൻക്രണസ് കമാൻഡ് എക്സിക്യൂഷൻ

പൈത്തൺ അസിൻക്രണസ് എക്സിക്യൂഷൻ

import subprocess
process = subprocess.Popen(['ping', '-c 4', 'example.com'], stdout=subprocess.PIPE)
output, error = process.communicate()
print(output.decode())

പൈത്തണിൽ സിസ്റ്റം കമാൻഡ് എക്‌സിക്യൂഷൻ പര്യവേക്ഷണം ചെയ്യുന്നു

ടാസ്‌ക്കുകൾ ഓട്ടോമേറ്റ് ചെയ്യാനോ സിസ്റ്റം റിസോഴ്‌സുകൾ കൈകാര്യം ചെയ്യാനോ മറ്റ് പ്രോഗ്രാമുകളുമായി സംയോജിപ്പിക്കാനോ ശ്രമിക്കുന്ന ഡെവലപ്പർമാർക്ക് പൈത്തൺ സ്‌ക്രിപ്‌റ്റുകൾ വഴി സിസ്റ്റം കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുന്നത് അത്യന്താപേക്ഷിതമാണ്. പൈത്തണിൻ്റെ ബിൽറ്റ്-ഇൻ ലൈബ്രറികൾ ഉപപ്രക്രിയ ഒപ്പം os, ഈ പ്രവർത്തനങ്ങൾക്ക് സമഗ്രമായ പിന്തുണ നൽകുക. ദി ഉപപ്രക്രിയ മൊഡ്യൂൾ, പ്രത്യേകിച്ച്, ഉയർന്ന തലത്തിലുള്ള നിയന്ത്രണവും വഴക്കവും വാഗ്ദാനം ചെയ്യുന്നു, ബാഹ്യ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനും അവയുടെ ഔട്ട്പുട്ട് ക്യാപ്ചർ ചെയ്യാനും പിശകുകൾ കൈകാര്യം ചെയ്യാനും ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു. പോലുള്ള പഴയ ഫംഗ്‌ഷനുകൾ മാറ്റിസ്ഥാപിക്കുന്നതിനാണ് ഇത് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് os.system(), കമാൻഡുകൾക്ക് അകത്തും പുറത്തും ഡാറ്റ പൈപ്പ് ചെയ്യൽ, കമാൻഡുകൾ പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കൽ, അവയുടെ റിട്ടേൺ കോഡുകൾ ആക്സസ് ചെയ്യൽ എന്നിവ പോലുള്ള കൂടുതൽ സുരക്ഷയും പ്രവർത്തനവും വാഗ്ദാനം ചെയ്യുന്നു.

അതേസമയം ഉപപ്രക്രിയ ശക്തമാണ്, ഇത് ഉപയോഗിക്കുന്നതിനേക്കാൾ സങ്കീർണ്ണവുമാണ് os.system(), ഒരു സബ്‌ഷെല്ലിൽ ഒരു കമാൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നതും നേരായ ജോലികൾക്കായി ഉപയോഗിക്കാൻ എളുപ്പവുമാണ്. എന്നിരുന്നാലും, ഇത് നിർവ്വഹണത്തിൽ കുറച്ച് നിയന്ത്രണം നൽകുന്നു, മാത്രമല്ല ഇത് സുരക്ഷിതമല്ലാത്തതായി കണക്കാക്കുകയും ചെയ്യുന്നു. ഈ രീതികൾക്കിടയിൽ തിരഞ്ഞെടുക്കുന്നത് നിങ്ങളുടെ പൈത്തൺ കോഡിലെ കമാൻഡിൻ്റെ ഔട്ട്പുട്ട് പ്രോസസ്സ് ചെയ്യേണ്ടതുണ്ടോ എന്നതുപോലുള്ള ടാസ്ക്കിൻ്റെ പ്രത്യേക ആവശ്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു. കൂടാതെ, ഈ ലൈബ്രറികൾ എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കാമെന്ന് മനസിലാക്കുന്നത്, അവരുടെ വർക്ക്ഫ്ലോ ഓട്ടോമേറ്റ് ചെയ്യാനും കാര്യക്ഷമമാക്കാനുമുള്ള ഒരു പൈത്തൺ ഡെവലപ്പറുടെ കഴിവ് ഗണ്യമായി വർദ്ധിപ്പിക്കും, ഇത് സോഫ്റ്റ്വെയർ വികസന മേഖലയിലെ വൈദഗ്ധ്യത്തിൻ്റെ നിർണായക മേഖലയാക്കുന്നു.

പൈത്തണിൽ സിസ്റ്റം കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള പതിവുചോദ്യങ്ങൾ

1. ചോദ്യം: പൈത്തണിൽ ഉപയോഗിക്കുന്ന സബ്പ്രോസസ് മൊഡ്യൂൾ എന്താണ്?
2. ഉത്തരം: പുതിയ പ്രക്രിയകൾ സൃഷ്ടിക്കുന്നതിനും അവയുടെ ഇൻപുട്ട്/ഔട്ട്പുട്ട്/പിശക് പൈപ്പുകളുമായി ബന്ധിപ്പിക്കുന്നതിനും അവയുടെ റിട്ടേൺ കോഡുകൾ നേടുന്നതിനും സബ്പ്രോസസ് മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു.
3. ചോദ്യം: subprocess.run() ഒരു കമാൻഡിൻ്റെ ഔട്ട്‌പുട്ട് ക്യാപ്‌ചർ ചെയ്യാൻ കഴിയുമോ?
4. ഉത്തരം: അതെ, subprocess.run() സജ്ജീകരിച്ച് ഒരു കമാൻഡിൻ്റെ ഔട്ട്‌പുട്ട് ക്യാപ്‌ചർ ചെയ്യാൻ കഴിയും ക്യാപ്‌ചർ_ഔട്ട്‌പുട്ട് ശരിയിലേക്കുള്ള വാദം.
5. ചോദ്യം: സിസ്റ്റം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് os.system() സുരക്ഷിതമാണോ?
6. ഉത്തരം: os.system() ഒരു സബ്‌ഷെല്ലിലെ കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിനാൽ സുരക്ഷിതമല്ലാത്തതായി കണക്കാക്കുന്നു, ഇത് ഷെൽ ഇൻജക്ഷൻ ആക്രമണത്തിന് ഇരയാകാം.
7. ചോദ്യം: ഒരു കമാൻഡ് പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാതെ എനിക്ക് എങ്ങനെ അത് എക്സിക്യൂട്ട് ചെയ്യാം?
8. ഉത്തരം: ബ്ലോക്ക് ചെയ്യാതെ ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ നിങ്ങൾക്ക് subprocess.Popen() ഉപയോഗിക്കാം, നിങ്ങളുടെ സ്ക്രിപ്റ്റിൻ്റെ ബാക്കിയുള്ളവ പ്രവർത്തിക്കുന്നത് തുടരാൻ അനുവദിക്കുന്നു.
9. ചോദ്യം: പൈത്തൺ ഉപയോഗിച്ച് എനിക്ക് ഒന്നിലധികം കമാൻഡുകൾ സമാന്തരമായി പ്രവർത്തിപ്പിക്കാൻ കഴിയുമോ?
10. ഉത്തരം: അതെ, ഓരോ കമാൻഡിനും subprocess.Popen() ഉപയോഗിച്ച് നിങ്ങൾക്ക് സമാന്തരമായി ഒന്നിലധികം കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനും നിങ്ങളുടെ സ്ക്രിപ്റ്റിൽ അവ കൈകാര്യം ചെയ്യാനും കഴിയും.
11. ചോദ്യം: ഒരു സബ്പ്രോസസ് കമാൻഡിലെ പിശകുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യാം?
12. ഉത്തരം: കമാൻഡിൻ്റെ റിട്ടേൺ കോഡ് പരിശോധിച്ചോ അല്ലെങ്കിൽ സ്റ്റാൻഡേർഡ് എറർ ഔട്ട്പുട്ട് ക്യാപ്ചർ ചെയ്തോ നിങ്ങൾക്ക് പിശകുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും stderr subprocess.run() ലെ വാദം
13. ചോദ്യം: subprocess.run() ഉം subprocess.Popen() ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?
14. ഉത്തരം: subprocess.run() എന്നത് നിങ്ങൾ ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്ത് പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കേണ്ട ലളിതമായ സന്ദർഭങ്ങൾക്കായി ഉദ്ദേശിച്ചുള്ളതാണ്, അതേസമയം subprocess.Popen() നിർവ്വഹണം തടയാത്തതോ സ്ട്രീമിംഗ് ഔട്ട്പുട്ട് ക്യാപ്ചർ ചെയ്യുന്നതോ പോലുള്ള സങ്കീർണ്ണമായ സാഹചര്യങ്ങൾക്ക് കൂടുതൽ നിയന്ത്രണം നൽകുന്നു.
15. ചോദ്യം: എൻ്റെ പൈത്തൺ സ്ക്രിപ്റ്റ് ഒരു ഉപപ്രോസസ്സ് പൂർത്തിയാകുന്നതിന് കാത്തിരിക്കുന്നുവെന്ന് എനിക്ക് എങ്ങനെ ഉറപ്പാക്കാനാകും?
16. ഉത്തരം: നിങ്ങൾക്ക് ഒരു പോപ്പൻ ഒബ്‌ജക്റ്റിൻ്റെ വെയിറ്റ് () രീതി ഉപയോഗിക്കാം അല്ലെങ്കിൽ സ്ഥിരസ്ഥിതിയായി കാത്തിരിപ്പ് പെരുമാറ്റം ഉപയോഗിച്ച് subprocess.run() ഉപയോഗിക്കാം.
17. ചോദ്യം: സബ്പ്രോസസ് അല്ലെങ്കിൽ OS മൊഡ്യൂളുകൾ ഉപയോഗിക്കാതെ പൈത്തണിൽ നിന്ന് ഷെൽ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുമോ?
18. ഉത്തരം: ഷെൽ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള സ്റ്റാൻഡേർഡും ശുപാർശ ചെയ്യപ്പെടുന്നതുമായ മാർഗ്ഗങ്ങളാണ് സബ്പ്രോസസും ഓസും ആണെങ്കിലും, തേർഡ്-പാർട്ടി ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് പോലെയുള്ള ഇതര രീതികൾ നിലവിലുണ്ടെങ്കിലും പൊതുവെ സുരക്ഷിതത്വം കുറവായതിനാൽ ശുപാർശ ചെയ്യുന്നില്ല.

പൈത്തൺ ഉപയോഗിച്ച് സിസ്റ്റം കമാൻഡ് എക്‌സിക്യൂഷൻ പൊതിയുന്നു

പൈത്തണിലെ മാസ്റ്ററിംഗ് സിസ്റ്റം കമാൻഡ് എക്‌സിക്യൂഷൻ, ടാസ്‌ക്കുകൾ ഓട്ടോമേറ്റ് ചെയ്യാനും ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായി ഇടപഴകാനും ബാഹ്യ പ്രോഗ്രാമുകൾ കാര്യക്ഷമമായി പ്രവർത്തിപ്പിക്കാനുമുള്ള ശക്തി ഡെവലപ്പർമാരെ സജ്ജമാക്കുന്നു. ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് സ്ട്രീമുകൾ, പിശക് കൈകാര്യം ചെയ്യൽ, പ്രോസസ്സ് പൈപ്പ്ലൈനുകൾ എന്നിവയിൽ നിയന്ത്രണം വാഗ്ദാനം ചെയ്യുന്ന അത്തരം പ്രവർത്തനങ്ങൾക്കുള്ള ഏറ്റവും വൈവിധ്യമാർന്ന ഉപകരണമായി സബ്പ്രോസസ് മൊഡ്യൂൾ വേറിട്ടുനിൽക്കുന്നു. os.system() നേരായ ജോലികൾക്കുള്ള ഒരു ലളിതമായ ബദലായി പ്രവർത്തിക്കുമ്പോൾ, കൂടുതൽ സങ്കീർണ്ണമായ ആവശ്യകതകൾക്ക് ആവശ്യമായ കൃത്യത ഉപപ്രോസസ് നൽകുന്നു. സ്ക്രിപ്റ്റിംഗ് ഓട്ടോമേഷൻ, ഡാറ്റ പ്രോസസ്സിംഗ്, അല്ലെങ്കിൽ മറ്റ് സിസ്റ്റം ഘടകങ്ങളുമായി പൈത്തൺ ആപ്ലിക്കേഷനുകൾ സമന്വയിപ്പിക്കൽ എന്നിവയ്ക്ക് വേണ്ടിയാണെങ്കിലും, ഈ കമാൻഡ് എക്സിക്യൂഷൻ രീതികൾ മനസ്സിലാക്കുന്നത് വിലമതിക്കാനാവാത്തതാണ്. അവ സുരക്ഷിതമായും കാര്യക്ഷമമായും ഉപയോഗിക്കാൻ ഓർമ്മിക്കുന്നത് നിങ്ങളുടെ പ്രോഗ്രാമിംഗ് പ്രോജക്റ്റുകളും സിസ്റ്റം മാനേജുമെൻ്റ് ജോലികളും വളരെയധികം മെച്ചപ്പെടുത്തും.