30.2-dars: subprocess bilan boshqa dasturlarni chaqirish
30-QISM — PYTHON VA BOSHQA TILLAR · 2-dars
1. Kirish va motivatsiya
Ba'zan Python'dan boshqa dasturni ishga tushirish kerak: buyruq qatori vositasi (git, ffmpeg, ImageMagick), boshqa tildagi skript (Node.js, bash), tizim buyrug'i. Bu dasturlar allaqachon mavjud, sinalgan, kuchli — ularni Python'da qayta yozish behuda. Masalan videoni kodlash uchun ffmpeg bor (mukammal, tez) — uni qayta yozish o'rniga Python'dan chaqirish oson. subprocess bu imkonni beradi: Python'dan boshqa dasturni ishga tushiradi, unga argument beradi, natijasini (chiqish, xato, kod) oladi. Bu tillarni birlashtirishning eng oddiy usuli 30.1-bob — mustaqil dasturni chaqirish.
subprocess — Python'dan boshqa dasturlarni ishga tushirish moduli: subprocess.run (dasturni ishga tushirish, tugashini kutish), argumentlar (ro'yxat sifatida — ["git", "status"]), stdout/stderr (chiqish va xato — capture_output=True), return code (chiqish kodi — 0 muvaffaqiyat, boshqa xato), stdin (kirish berish), shell=False (xavfsizlik — buyruq in'ektsiyasidan). Foydalanish: CLI vositalar (git, ffmpeg), boshqa til skriptlari, avtomatlashtirish. Bu FFI/kengaytmadan (30.3+) farqli — alohida jarayon (ajratilgan, matn/fayl orqali aloqa). Bu 26.1 (skript), 30.1 (birlashtirish) bilan bog'liq. subprocess — boshqa dasturni chaqirish. Mustaqil dastur — ishga tushirish.
Real vaziyat. Bir Python dastur foydalanuvchi yuklagan videolarni qayta ishlashi kerak edi (o'lcham o'zgartirish, format). Video kodlashni Python'da yozish — koshmar (murakkab, sekin). Yechim: ffmpeg (tayyor, kuchli vosita) subprocess bilan chaqirildi (subprocess.run(["ffmpeg", "-i", ...])) — Python argumentlarni tayyorladi, ffmpeg ishladi, Python natijani (muvaffaqiyat/xato) oldi. Video qayta ishlash mukammal ishladi (mavjud vosita). subprocess — kuchli vositani ishlatdi.
Bu darsda subprocess ni o'rganamiz.
Bu darsda:
- subprocess nima
- subprocess.run (asosiy)
- Argumentlar va return code
- stdout/stderr (chiqish, xato)
- stdin (kirish berish)
- Xavfsizlik (shell=False, in'ektsiya)
- subprocess amaliyoti
- Amaliy: subprocess modeli
ℹ Misollarda Python subprocess bilan Python interpretatorini chaqiradi (deterministik).
2. Nazariya — chuqur tushuntirish
2.1. subprocess nima
Boshqa dasturni ishga tushirish:
import subprocess
# boshqa dasturni ishga tushirish (git, ffmpeg, ...)
natija = subprocess.run(["git", "status"], capture_output=True, text=True)
print(natija.stdout) # dastur chiqishi
print(natija.returncode) # 0 (muvaffaqiyat) yoki xato subprocess — Python'dan boshqa dasturni ishga tushirish moduli: mustaqil dastur (CLI vosita — git, ffmpeg; boshqa til skript; tizim buyrug'i) chaqiriladi, argument beriladi, natijasi (chiqish, xato, kod) olinadi. Sabab: ko'p kuchli dastur mavjud (sinalgan, tez) — ularni Python'da qayta yozish behuda; subprocess ularni chaqiradi (qayta yozmasdan). Bu tillarni birlashtirishning eng oddiy usuli 30.1-bob — alohida jarayon (Python emas, boshqa dastur; matn/fayl orqali aloqa). subprocess — boshqa dasturni ishga tushirish. Mavjud vosita — chaqirish.
2.2. subprocess.run (asosiy)
Dasturni ishga tushirish:
natija = subprocess.run(
["python", "-c", "print(2+2)"], # buyruq (ro'yxat)
capture_output=True, # chiqishni ushlash
text=True, # matn (bayt emas)
)
# natija: stdout, stderr, returncode subprocess.run — dasturni ishga tushirish va tugashini kutish: buyruq (ro'yxat — ["python", "-c", "..."], argumentlar alohida), capture_output=True (chiqishni ushlash — stdout, stderr), text=True (matn sifatida — baytlar emas), check=True (xato kodda istisno). Natija (CompletedProcess): stdout (chiqish), stderr (xato), returncode (kod). run — bloklaydi (tugashini kutadi); Popen — asinxron (fon, kuzatuv). Ko'p holatda run yetadi (oddiy chaqiruv). subprocess.run — dasturni ishga tushirish (kutish bilan). run — asosiy chaqiruv.
2.3. Argumentlar va return code
# ARGUMENTLAR — ro'yxat (alohida elementlar)
subprocess.run(["git", "commit", "-m", "xabar"]) # to'g'ri
# NOTO'G'RI: "git commit -m xabar" (bir satr — shell)
# RETURN CODE — natija holati
natija = subprocess.run([...])
if natija.returncode == 0: # 0 = muvaffaqiyat
print("OK")
else: # boshqa = xato
print("xato") Argumentlar va return code: Argumentlar — dasturga ro'yxat sifatida (["git", "commit", "-m", "xabar"] — har argument alohida element); bir satr emas ("git commit ..." — shell bilan, xavfli 30.2.6). Return code (chiqish kodi) — dastur natija holati: 0 (muvaffaqiyat — konvensiya), boshqa (xato — nol emas, turli kod turli xato). Sabab: return code — dastur muvaffaqiyat/xatoni bildiradi (Python tekshiradi — 09-qism xato boshqarish); argument ro'yxati — aniq, xavfsiz (shell parse emas). Argumentlar — ro'yxat, return code — holat. 0 — muvaffaqiyat.
2.4. stdout/stderr (chiqish, xato)
Ikki oqim:
natija = subprocess.run([...], capture_output=True, text=True)
natija.stdout # standart chiqish (natija)
natija.stderr # standart xato (xato xabari)
# dasturlar ikki oqimga yozadi:
# stdout — normal natija · stderr — xato/ogohlantirish stdout va stderr — dasturlar ikki oqimga yozadi: stdout (standart chiqish — normal natija, print), stderr (standart xato — xato/ogohlantirish xabarlari). capture_output=True ikkalasini ushlaydi (natija.stdout, natija.stderr). Sabab: natija va xatoni ajratish (26-qism logging kabi) — natija stdout'dan (qayta ishlanadi), xato stderr'dan (log, ko'rsatish). Masalan ffmpeg progressni stderr'ga, natijani stdout'ga. Python ikkalasini alohida oladi. stdout/stderr — natija va xato oqimlari. Ajratilgan — aniq.
2.5. stdin (kirish berish)
Dasturga ma'lumot berish:
# dasturga kirish (stdin) berish
natija = subprocess.run(
["python", "-c", "print(input().upper())"],
input="salom", # stdin ga beriladi
capture_output=True,
text=True,
)
# natija.stdout: "SALOM" stdin (standart kirish) — dasturga ma'lumot berish: input="..." (matn stdin'ga uzatiladi — dastur uni o'qiydi). Sabab: ko'p dastur kirishni stdin'dan oladi (fayl o'rniga — pipe, oqim); Python ma'lumotni beradi (fayl yozmasdan). Masalan grep matnni stdin'dan o'qiydi, sort saralaydi. Bu pipe (quvur — 26-qism, bir dastur chiqishi boshqasiga kirish). stdin — dasturga kirish (input). Kirish berish — pipe. Ma'lumot uzatish — stdin orqali.
2.6. Xavfsizlik (shell=False, in'ektsiya)
Buyruq in'ektsiyasidan himoya:
# XAVFLI: shell=True + foydalanuvchi kiritishi
fayl = foydalanuvchi_kiritdi # "; rm -rf /"
subprocess.run(f"cat {fayl}", shell=True) # IN'EKTSIYA!
# XAVFSIZ: shell=False (standart) + ro'yxat
subprocess.run(["cat", fayl]) # fayl — argument (parse yo'q) Xavfsizlik — subprocess buyruq in'ektsiyasi (command injection) xavfini keltiradi: shell=True + foydalanuvchi kiritishi — xavfli (foydalanuvchi ; rm -rf / kiritsa — shell buni bajaradi!). Yechim: shell=False (standart) + argument ro'yxati (["cat", fayl] — fayl argument, shell parse qilmaydi — in'ektsiya yo'q). Sabab: shell=True buyruqni shell orqali (parse — ;, |, $ maxsus); ro'yxat to'g'ridan (parse yo'q — xavfsiz). Qoida: hech qachon shell=True foydalanuvchi ma'lumoti bilan; ro'yxat ishlat (CLAUDE.md — sirlar, in'ektsiya). Xavfsizlik — shell=False, ro'yxat. In'ektsiya — shell=True xavfi.
2.7. subprocess amaliyoti
subprocess amaliyotlari: argument ro'yxati (shell emas — xavfsizlik, 30.2.6); shell=False (standart — in'ektsiyadan); return code tekshirish (check=True yoki returncode — 09-qism xato); timeout (timeout=N — osilib qolmaslik, 27.12); text=True (matn — baytlar emas); capture_output (chiqishni ushlash); xato boshqarish (CalledProcessError, TimeoutExpired); katta chiqish (Popen + oqim — xotira). Tuzoqlar: shell=True foydalanuvchi bilan (in'ektsiya), return code tekshirmaslik (jim xato), timeout yo'q (osilib qolish), bir satr buyruq (parse). Yaxshi subprocess — ro'yxat, shell=False, return code, timeout. Amaliyot — xavfsiz, ishonchli. Ro'yxat + tekshiruv — xavfsiz.
2.8. subprocess — mustaqil dasturlarni birlashtirish
subprocess asosiy g'oyasi — mustaqil dasturlarni birlashtirish: Python boshqa dasturlarni (CLI vosita, boshqa til, tizim buyruq) chaqiradi — mavjud kuchni ishlatish (qayta yozmasdan). Bu tillarni birlashtirishning eng oddiy usuli (30.1 — alohida jarayon, matn/fayl aloqa; FFI/kengaytma — bir jarayon, tez, yaqin — 30.3+). Farq: subprocess ajratilgan (mustaqil dastur — sekinroq, lekin oddiy, xavfsiz — jarayon izolyatsiyasi), FFI yaqin (bir jarayon — tez, lekin murakkab). Bu Unix falsafasi ("kichik dasturlar, birga ishlaydi" — pipe), avtomatlashtirish (26-qism) bilan bog'liq. subprocess — dasturlar ni orkestrlash. Mustaqil dastur — oddiy birlashtirish.
3. Tez ma'lumotnoma
import subprocess
# ASOSIY (run — kutish bilan):
natija = subprocess.run(
["python", "-c", "print(2+2)"], # buyruq ro'yxati
capture_output=True, # stdout/stderr ushlash
text=True, # matn (bayt emas)
timeout=10, # osilib qolmaslik
check=True, # xato kodda istisno
)
natija.stdout # chiqish · natija.stderr — xato
natija.returncode # 0 (OK) / boshqa (xato)
# STDIN (kirish berish):
subprocess.run([...], input="ma'lumot", text=True)
# XAVFSIZLIK:
# XAVFLI: subprocess.run(f"cat {fayl}", shell=True)
# XAVFSIZ: subprocess.run(["cat", fayl]) # ro'yxat, shell=False
# Popen — asinxron (fon jarayon, oqim):
# p = subprocess.Popen([...], stdout=subprocess.PIPE)
# XATO: CalledProcessError, TimeoutExpired
# QOIDA: ro'yxat, shell=False, return code, timeoutsubprocess xulosasi
subprocess — Python'dan boshqa dasturni ishga tushirish
run (kutish) · argument ro'yxati · return code (0 = OK)
stdout (natija) / stderr (xato) · stdin (kirish — input)
Xavfsizlik: shell=False + ro'yxat (in'ektsiyadan)
Alohida jarayon (ajratilgan) — eng oddiy birlashtirish4. Batafsil misollar
Misollarda Python subprocess bilan Python interpretatorini chaqiradi (deterministik).
Misol 1 — subprocess.run (asosiy)
"""subprocess.run: boshqa dasturni (Python) ishga tushirish, natijani olish."""
import subprocess
import sys
def main() -> None:
print("=== 1. Python interpretatorini chaqirish ===")
natija = subprocess.run(
[sys.executable, "-c", "print(2 + 2)"],
capture_output=True,
text=True,
)
print(f" chiqish: {natija.stdout.strip()}")
print("\n=== 2. Return code ===")
print(f" returncode: {natija.returncode} (0 = muvaffaqiyat)")
print("\n=== 3. Boshqa buyruq ===")
natija = subprocess.run(
[sys.executable, "-c", "print('salom', 'dunyo')"],
capture_output=True,
text=True,
)
print(f" chiqish: {natija.stdout.strip()}")
print("\n=== 4. Natija tuzilishi ===")
print(" CompletedProcess: stdout, stderr, returncode")
print(" run — dasturni ishga tushirib, tugashini kutadi")
print(" ⭐ subprocess.run — boshqa dasturni chaqirish")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Python interpretatorini chaqirish ===
chiqish: 4
=== 2. Return code ===
returncode: 0 (0 = muvaffaqiyat)
=== 3. Boshqa buyruq ===
chiqish: salom dunyo
=== 4. Natija tuzilishi ===
CompletedProcess: stdout, stderr, returncode
run — dasturni ishga tushirib, tugashini kutadi
⭐ subprocess.run — boshqa dasturni chaqirishNima ko'rsatdi: 2.1, 2.2-bo'limlar.
Misol 2 — Return code (muvaffaqiyat/xato)
"""Return code: dastur muvaffaqiyat (0) yoki xato (boshqa) holatini bildiradi."""
import subprocess
import sys
def main() -> None:
print("=== 1. Muvaffaqiyatli buyruq (returncode 0) ===")
natija = subprocess.run(
[sys.executable, "-c", "print('OK')"],
capture_output=True,
text=True,
)
print(f" returncode: {natija.returncode}")
print(f" muvaffaqiyat: {natija.returncode == 0}")
print("\n=== 2. Xato beruvchi buyruq (returncode != 0) ===")
natija = subprocess.run(
[sys.executable, "-c", "import sys; sys.exit(1)"],
capture_output=True,
text=True,
)
print(f" returncode: {natija.returncode}")
print(f" xato: {natija.returncode != 0}")
print("\n=== 3. Return code tekshirish ===")
natija = subprocess.run(
[sys.executable, "-c", "import sys; sys.exit(3)"],
capture_output=True,
text=True,
)
holat = "muvaffaqiyat" if natija.returncode == 0 else f"xato (kod {natija.returncode})"
print(f" holat: {holat}")
print("\n=== 4. Konvensiya ===")
print(" 0 — muvaffaqiyat, boshqa — xato")
print(" Python tekshiradi (09-qism xato boshqarish)")
print(" ⭐ Return code — dastur holati")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Muvaffaqiyatli buyruq (returncode 0) ===
returncode: 0
muvaffaqiyat: True
=== 2. Xato beruvchi buyruq (returncode != 0) ===
returncode: 1
xato: True
=== 3. Return code tekshirish ===
holat: xato (kod 3)
=== 4. Konvensiya ===
0 — muvaffaqiyat, boshqa — xato
Python tekshiradi (09-qism xato boshqarish)
⭐ Return code — dastur holatiNima ko'rsatdi: 2.3-bo'lim.
Misol 3 — stdout va stderr (ajratish)
"""stdout/stderr: normal natija va xato ikki alohida oqimga yoziladi."""
import subprocess
import sys
def main() -> None:
print("=== 1. stdout (normal chiqish) ===")
natija = subprocess.run(
[sys.executable, "-c", "print('natija')"],
capture_output=True,
text=True,
)
print(f" stdout: {natija.stdout.strip()!r}")
print(f" stderr: {natija.stderr.strip()!r}")
print("\n=== 2. stderr (xato oqimi) ===")
natija = subprocess.run(
[sys.executable, "-c", "import sys; sys.stderr.write('ogohlantirish')"],
capture_output=True,
text=True,
)
print(f" stdout: {natija.stdout.strip()!r}")
print(f" stderr: {natija.stderr.strip()!r}")
print("\n=== 3. Ikkalasi ===")
natija = subprocess.run(
[sys.executable, "-c", "import sys; print('natija'); sys.stderr.write('xato')"],
capture_output=True,
text=True,
)
print(f" stdout: {natija.stdout.strip()!r}")
print(f" stderr: {natija.stderr.strip()!r}")
print("\n=== 4. Nega ajratilgan ===")
print(" stdout — natija (qayta ishlanadi)")
print(" stderr — xato/ogohlantirish (log)")
print(" ⭐ stdout/stderr — natija va xato oqimlari")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. stdout (normal chiqish) ===
stdout: 'natija'
stderr: ''
=== 2. stderr (xato oqimi) ===
stdout: ''
stderr: 'ogohlantirish'
=== 3. Ikkalasi ===
stdout: 'natija'
stderr: 'xato'
=== 4. Nega ajratilgan ===
stdout — natija (qayta ishlanadi)
stderr — xato/ogohlantirish (log)
⭐ stdout/stderr — natija va xato oqimlariNima ko'rsatdi: 2.4-bo'lim.
Misol 4 — stdin (kirish berish)
"""stdin: dasturga kirish berish (input orqali — pipe kabi)."""
import subprocess
import sys
def main() -> None:
print("=== 1. stdin ga ma'lumot berish ===")
natija = subprocess.run(
[sys.executable, "-c", "print(input().upper())"],
input="salom",
capture_output=True,
text=True,
)
print(f" kirish: 'salom' → chiqish: {natija.stdout.strip()}")
print("\n=== 2. Boshqa kirish ===")
natija = subprocess.run(
[sys.executable, "-c", "n = int(input()); print(n * 2)"],
input="21",
capture_output=True,
text=True,
)
print(f" kirish: '21' → chiqish: {natija.stdout.strip()}")
print("\n=== 3. Ko'p qatorli kirish ===")
natija = subprocess.run(
[sys.executable, "-c", "import sys; print(sum(int(x) for x in sys.stdin))"],
input="10\n20\n30",
capture_output=True,
text=True,
)
print(f" kirish: '10,20,30' → yig'indi: {natija.stdout.strip()}")
print("\n=== 4. Pipe g'oyasi ===")
print(" Python ma'lumot beradi (stdin), dastur o'qiydi")
print(" fayl yozmasdan (oqim — pipe)")
print(" ⭐ stdin — dasturga kirish (input)")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. stdin ga ma'lumot berish ===
kirish: 'salom' → chiqish: SALOM
=== 2. Boshqa kirish ===
kirish: '21' → chiqish: 42
=== 3. Ko'p qatorli kirish ===
kirish: '10,20,30' → yig'indi: 60
=== 4. Pipe g'oyasi ===
Python ma'lumot beradi (stdin), dastur o'qiydi
fayl yozmasdan (oqim — pipe)
⭐ stdin — dasturga kirish (input)Nima ko'rsatdi: 2.5-bo'lim.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "Dasturni qayta yoz" | subprocess (mavjudni chaqir) |
| "Buyruq bir satr" | Argument ro'yxati |
| "shell=True qulay" | Xavfli (in'ektsiya) |
| "Return code keraksiz" | Muvaffaqiyat/xato holati |
| "stdout = stderr" | Natija vs xato (ajratilgan) |
| "Timeout keraksiz" | Osilib qolish (timeout) |
| "subprocess = FFI" | Alohida jarayon (ajratilgan) |
| "Xato tekshirmasa mayli" | Return code (jim xato) |
6. Keng tarqalgan xatolar va yechimlari
1. shell=True foydalanuvchi bilan (in'ektsiya)
subprocess.run(f"cat {fayl}", shell=True) # xavfli # ⚠️
subprocess.run(["cat", fayl]) # ro'yxat, xavfsiz # ✅2. Buyruq bir satr (ro'yxat emas)
subprocess.run("git commit -m xabar") # xato # ⚠️
subprocess.run(["git", "commit", "-m", "xabar"]) # ✅3. Return code tekshirmaslik
subprocess.run([...]) # xato jim o'tadi # ⚠️
subprocess.run([...], check=True) # yoki returncode # ✅4. Timeout yo'q (osilib qolish)
subprocess.run([...]) # cheksiz kutish # ⚠️
subprocess.run([...], timeout=30) # ✅5. text=True unutish (baytlar)
natija.stdout # b'...' (baytlar — noqulay) # ⚠️
subprocess.run([...], text=True) # matn # ✅6. Katta chiqish (xotira)
subprocess.run([...], capture_output=True) # katta # ⚠️
# Popen + oqim (qator-qator — 29.9) # ✅7. Xatoni e'tiborsiz (stderr)
# faqat stdout (stderr'dagi xato ko'rinmaydi) # ⚠️
# stderr ni ham tekshir (xato/ogohlantirish) # ✅7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 30.1-dars (o'tilgan): Tillar birlashtirish — subprocess
- 26.1-dars (o'tilgan): Skript — avtomatlashtirish
- 30.3-4-dars: ctypes, cffi — FFI (bir jarayon)
- 09-dars (o'tilgan): Xatolar — return code
- 27.12-dars (o'tilgan): Chidamlilik — timeout
8. Eng yaxshi amaliyotlar
Argument ro'yxati (bir satr emas).
shell=False(standart — in'ektsiyadan).Return code tekshir (
check=True).Timeout (osilib qolmaslik).
text=True(matn — baytlar emas).stderr ni ham tekshir (xato).
Katta chiqish — oqim (
Popen).Foydalanuvchi ma'lumoti — hech qachon
shell=True.
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
1. # subprocess nima?
2. # subprocess.run nima?
3. # argumentlar qanday?
4. # return code nima?
5. # 0 nima?
6. # stdout nima?
7. # stderr nima?
8. # stdout vs stderr?
9. # stdin nima?
10. # shell=True xavfi?
11. # in'ektsiya nima?
12. # subprocess vs FFI?Javoblar
- Boshqa dasturni ishga tushirish moduli
- Dasturni ishga tushirib, tugashini kutish
- Ro'yxat (har argument alohida)
- Dastur natija holati (kod)
- Muvaffaqiyat (konvensiya)
- Standart chiqish (normal natija)
- Standart xato (xato/ogohlantirish)
- stdout natija, stderr xato (ajratilgan)
- Standart kirish (dasturga ma'lumot)
- Buyruq in'ektsiyasi (xavfli)
- Foydalanuvchi zararli buyruq kiritishi
- subprocess alohida jarayon, FFI bir jarayon
Vazifa 2: Xatolarni tuzating
1. subprocess.run(f"cat {fayl}", shell=True)
2. subprocess.run("git commit -m xabar")
3. subprocess.run([...]) # tekshirmaslik
4. subprocess.run([...]) # timeout yo'q
5. natija.stdout # baytlarJavoblar
1. subprocess.run(["cat", fayl])
2. subprocess.run(["git", "commit", "-m", "xabar"])
3. subprocess.run([...], check=True)
4. subprocess.run([...], timeout=30)
5. subprocess.run([...], text=True)Vazifa 3: run
Yozing:
- Buyruq ro'yxati
- capture_output
- text
- Natija
Vazifa 4: Return code
Modellang:
- Muvaffaqiyat (0)
- Xato
- Tekshirish
- Holat
Vazifa 5: stdout/stderr
Modellang:
- stdout
- stderr
- Ajratish
- Ikkalasi
Vazifa 6: stdin
Modellang:
- input
- Dastur o'qiydi
- Pipe
- Natija
Vazifa 7: O'ylash
subprocess mavjud dasturlarni (ffmpeg, git) qayta yozmasdan chaqiradi — "g'ildirakni qayta ixtiro qilma". Nima uchun "mavjud vositani ishlatish" (qayta yozish o'rniga) muhandislikda kuchli tamoyil, va nega shell=True bilan buyruq in'ektsiyasi shunchalik jiddiy xavfsizlik xatosi — foydalanuvchi ma'lumoti buyruqqa aralashsa nima bo'ladi?
Javob
Qisqa javob: "Mavjud vositani ishlatish" kuchli tamoyil, chunki: mavjud dastur (ffmpeg, git, ImageMagick) yillar davomida ishlab chiqilgan (minglab dasturchi, million foydalanuvchi — sinalgan, tuzatilgan, optimallashtirilgan, hujjatlangan); uni qayta yozish — o'sha ishni takrorlash (behuda — vaqt, xato: video kodlash mukammal qilish yillar oladi). "G'ildirakni qayta ixtiro qilma" (don't reinvent the wheel): mavjud yechim bor bo'lsa — ishlat (qayta yozma), o'z kuchingni yangi muammoga sarfla (mavjudni takrorlashga emas). subprocess buni osonlashtiradi (mavjud dasturni chaqirish — bir necha qator). Bu 30.1 (til birlashtirish — mavjud kutubxona), 27.3 (naqshlar — sinalgan yechim) bilan bir. Lekin shell=True bilan buyruq in'ektsiyasi jiddiy xavf, chunki: shell=True buyruqni shell orqali bajaradi (bash/cmd) — shell maxsus belgilarni talqin qiladi (; — buyruqni ajratadi, | — pipe, $() — buyruq bajarish, && — zanjir). Agar foydalanuvchi ma'lumoti buyruqqa aralashsa (f"cat {fayl}" — fayl foydalanuvchidan) va foydalanuvchi fayl = "; rm -rf /" kiritsa — buyruq cat ; rm -rf / bo'ladi → shell ikki buyruq bajaradi (cat va rm -rf / — hamma faylni o'chirish!). Ya'ni foydalanuvchi o'z buyrug'ini sizning tizimingizda bajaradi (remote code execution — eng jiddiy xavfsizlik xatosi). Bu 28.9 (sirlar), SQL in'ektsiya (kod va ma'lumot aralashishi) bilan bir sinf: ma'lumot kodga aylanadi (foydalanuvchi ma'lumoti buyruq sifatida bajariladi). Yechim: ma'lumot va kodni ajratish — argument ro'yxati (["cat", fayl] — fayl argument, shell parse qilmaydi, ; oddiy belgi, buyruq emas). Qoida: foydalanuvchi ma'lumoti hech qachon to'g'ridan buyruqqa (ro'yxat, shell=False). Muhandislik saboqlari: mavjud vositani ishlat (qayta ixtiro qilma — sinalgan, arzon); in'ektsiya — ma'lumot kodga aralashishi (foydalanuvchi buyrug'i bajariladi); ma'lumot va kodni ajrat (ro'yxat, parametrlangan — SQL kabi); foydalanuvchi ma'lumoti — ishonchsiz (hech qachon kodga).
1. Nega mavjud vosita kuchli
Yillar rivojlanish (sinalgan, optimal, hujjatli). Qayta yozish — takrorlash (behuda, xato). "G'ildirakni qayta ixtiro qilma".
2. Nega in'ektsiya jiddiy
shell=True — shell maxsus belgilarni talqin qiladi (;, |, $()). Foydalanuvchi ; rm -rf / kiritsa → shell buni buyruq deb bajaradi.
3. Ma'lumot kodga aylanadi
| Kirish | Buyruq | Natija |
|---|---|---|
fayl.txt |
cat fayl.txt |
Normal |
; rm -rf / |
cat ; rm -rf / |
Falokat (o'chirish) |
Foydalanuvchi o'z buyrug'ini bajaradi (RCE).
4. Yechim (ajratish)
Argument ro'yxati (["cat", fayl]) — fayl argument, shell parse qilmaydi. Ma'lumot va kod ajratilgan (SQL parametrlashtirish kabi).
5. Muhandislik saboqlari
- Mavjud vositani ishlat (qayta ixtiro qilma)
- In'ektsiya — ma'lumot kodga aralashishi
- Ma'lumot va kodni ajrat (ro'yxat)
- Foydalanuvchi ma'lumoti — ishonchsiz
6. Xulosa
- Mavjud vosita — sinalgan (subprocess chaqiradi)
- shell=True — ma'lumot kodga (in'ektsiya)
- Falokat (foydalanuvchi buyrug'i bajariladi)
- Ro'yxat, shell=False (ajratish)
Nimani mustahkamlaydi: 2.6, 2.8-bo'limlar.
Xulosa
Bu darsda subprocess ni o'rgandik.
Eng muhim uch fikr:
subprocess va run.
subprocess— Python'dan boshqa dasturni ishga tushirish moduli: mustaqil dastur (CLI vosita —git,ffmpeg; boshqa til; tizim buyrug'i) chaqiriladi, argument beriladi, natijasi olinadi; mavjud kuchni ishlatish (qayta yozmasdan).subprocess.run— dasturni ishga tushirib tugashini kutish: buyruq (ro'yxat —["python", "-c", "..."]),capture_output=True(stdout/stderr ushlash),text=True(matn),check=True(xato kodda istisno); natijaCompletedProcess(stdout, stderr, returncode).runbloklaydi,Popenasinxron.Return code, stdout/stderr, stdin. Argumentlar — ro'yxat (
["git", "commit", "-m", "xabar"]— har argument alohida, bir satr emas). Return code — dastur holati: 0 (muvaffaqiyat), boshqa (xato) — Python tekshiradi. stdout va stderr — dasturlar ikki oqimga yozadi: stdout (normal natija), stderr (xato/ogohlantirish) —capture_outputikkalasini ushlaydi (ajratilgan — natija qayta ishlanadi, xato log). stdin — dasturga kirish berish (input="..."— matn stdin'ga, dastur o'qiydi — pipe kabi).Xavfsizlik va birlashtirish. Xavfsizlik — subprocess buyruq in'ektsiyasi xavfini keltiradi:
shell=True+ foydalanuvchi kiritishi xavfli (; rm -rf /— shell bajaradi!); yechim:shell=False(standart) + argument ro'yxati (fayl argument, shell parse qilmaydi — in'ektsiya yo'q); hech qachonshell=Truefoydalanuvchi ma'lumoti bilan. Amaliyot: ro'yxat, shell=False, return code (check=True), timeout (osilib qolmaslik — 27.12),text=True, stderr tekshirish, katta chiqish oqim (Popen). subprocess — mustaqil dasturlarni birlashtirish (eng oddiy usul — 30.1, alohida jarayon; FFI/kengaytma — bir jarayon, tez); Unix falsafasi (kichik dasturlar, pipe), avtomatlashtirish (26-qism). In'ektsiya — ma'lumot kodga aralashishi (foydalanuvchi buyrug'i bajariladi — ma'lumot va kodni ajratish, SQL in'ektsiya sinfi).
Keyingi darsda ctypes — C kutubxonasini chaqirishni o'rganamiz: Python'dan to'g'ridan-to'g'ri C kutubxonalari (.so, .dll) funksiyalarini chaqirish — FFI (Foreign Function Interface), tur muvofiqligi va bir jarayonda til birlashtirish.
Izohlar · 0
Izoh yozish uchun kiring.