Python kursi30.2-dars: subprocess bilan boshqa dasturlarni chaqirish
Python kursi · Python va boshqa tillar

30.2-dars: subprocess bilan boshqa dasturlarni chaqirish

17 daqiqa2/16-dars

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:

python
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:

python
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

python
# 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:

python
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:

python
# 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:

python
# 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

python
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, timeout

subprocess 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 birlashtirish

4. Batafsil misollar

Misollarda Python subprocess bilan Python interpretatorini chaqiradi (deterministik).

Misol 1 — subprocess.run (asosiy)

python
"""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:

text
=== 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 chaqirish

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Return code (muvaffaqiyat/xato)

python
"""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:

text
=== 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 holati

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — stdout va stderr (ajratish)

python
"""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:

text
=== 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 oqimlari

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — stdin (kirish berish)

python
"""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:

text
=== 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)

python
subprocess.run(f"cat {fayl}", shell=True)   # xavfli   # ⚠️
subprocess.run(["cat", fayl])   # ro'yxat, xavfsiz     # ✅

2. Buyruq bir satr (ro'yxat emas)

python
subprocess.run("git commit -m xabar")   # xato         # ⚠️
subprocess.run(["git", "commit", "-m", "xabar"])       # ✅

3. Return code tekshirmaslik

python
subprocess.run([...])   # xato jim o'tadi              # ⚠️
subprocess.run([...], check=True)   # yoki returncode   # ✅

4. Timeout yo'q (osilib qolish)

python
subprocess.run([...])   # cheksiz kutish               # ⚠️
subprocess.run([...], timeout=30)                       # ✅

5. text=True unutish (baytlar)

python
natija.stdout   # b'...' (baytlar — noqulay)           # ⚠️
subprocess.run([...], text=True)   # matn               # ✅

6. Katta chiqish (xotira)

python
subprocess.run([...], capture_output=True)   # katta   # ⚠️
# Popen + oqim (qator-qator — 29.9)                     # ✅

7. Xatoni e'tiborsiz (stderr)

python
# 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

  1. Argument ro'yxati (bir satr emas).

  2. shell=False (standart — in'ektsiyadan).

  3. Return code tekshir (check=True).

  4. Timeout (osilib qolmaslik).

  5. text=True (matn — baytlar emas).

  6. stderr ni ham tekshir (xato).

  7. Katta chiqish — oqim (Popen).

  8. Foydalanuvchi ma'lumoti — hech qachon shell=True.


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
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
  1. Boshqa dasturni ishga tushirish moduli
  2. Dasturni ishga tushirib, tugashini kutish
  3. Ro'yxat (har argument alohida)
  4. Dastur natija holati (kod)
  5. Muvaffaqiyat (konvensiya)
  6. Standart chiqish (normal natija)
  7. Standart xato (xato/ogohlantirish)
  8. stdout natija, stderr xato (ajratilgan)
  9. Standart kirish (dasturga ma'lumot)
  10. Buyruq in'ektsiyasi (xavfli)
  11. Foydalanuvchi zararli buyruq kiritishi
  12. subprocess alohida jarayon, FFI bir jarayon

Vazifa 2: Xatolarni tuzating

python
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   # baytlar
Javoblar
python
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:

  1. Buyruq ro'yxati
  2. capture_output
  3. text
  4. Natija

Vazifa 4: Return code

Modellang:

  1. Muvaffaqiyat (0)
  2. Xato
  3. Tekshirish
  4. Holat

Vazifa 5: stdout/stderr

Modellang:

  1. stdout
  2. stderr
  3. Ajratish
  4. Ikkalasi

Vazifa 6: stdin

Modellang:

  1. input
  2. Dastur o'qiydi
  3. Pipe
  4. 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

  1. Mavjud vositani ishlat (qayta ixtiro qilma)
  2. In'ektsiya — ma'lumot kodga aralashishi
  3. Ma'lumot va kodni ajrat (ro'yxat)
  4. Foydalanuvchi ma'lumoti — ishonchsiz

6. Xulosa

  1. Mavjud vosita — sinalgan (subprocess chaqiradi)
  2. shell=True — ma'lumot kodga (in'ektsiya)
  3. Falokat (foydalanuvchi buyrug'i bajariladi)
  4. Ro'yxat, shell=False (ajratish)

Nimani mustahkamlaydi: 2.6, 2.8-bo'limlar.


Xulosa

Bu darsda subprocess ni o'rgandik.

Eng muhim uch fikr:

  1. 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); natija CompletedProcess (stdout, stderr, returncode). run bloklaydi, Popen asinxron.

  2. 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_output ikkalasini ushlaydi (ajratilgan — natija qayta ishlanadi, xato log). stdin — dasturga kirish berish (input="..." — matn stdin'ga, dastur o'qiydi — pipe kabi).

  3. 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 qachon shell=True foydalanuvchi 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.

Python va boshqa tillar · 2-dars yakunlandi

30.2-dars: subprocess bilan boshqa dasturlarni chaqirish

17 daqvaqt
0belgi
Keyingi dars: 30.3-dars: ctypes — C kutubxonasini chaqirish
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0