Pythoni programmeerimise maailm

Pythonis käsurea argumentide kasutamine: algajast edasijõudnuni

Välised teegid, API-d ja side
目次

1. Pythonis käsurea argumentide põhikasutus

Mis on käsurea argumendid?

Käsurea argumendid on lisainformatsioon, mida edastatakse koos käsuga, kui Python programm käivitatakse. See võimaldab programmil paindlikult oma käitumist muuta või andmeid väljastpoolt edastada. Näiteks faili nime või seadistuse väärtuse edastamine argumendina võimaldab programmi dünaamiliselt kohandada.

Käsurea argumentide hankimine sys.argv abil

Pythonis saab käsurea argumente hankida standardteegi sys mooduli kaudu. sys.argv on muutuja, mis salvestab käsurea argumendid loendina. Loendi esimene element (sys.argv[0]) on käivitatud skripti nimi, ning alates teisest elemendist on väärtused, mis anti edasi argumentidena.

Näide: Lihtne arvutusprogramm

import sys

def main():
    if len(sys.argv) < 3:
        print("Viga: vaja on kahte argumenti")
        return

    num1 = float(sys.argv[1])
    num2 = float(sys.argv[2])
    print(f"Summa: {num1 + num2}")

if __name__ == "__main__":
    main()
Ülaltoodud programm võtab käsurealt kaks numbrit ja kuvab nende summa. Käivitamise näide:
$ python script.py 3 5
Summa: 8.0
 

2. Täpsem argumentide töötlemine argparse mooduli abil

argparse põhitõed

sys.argv võimaldab lihtsat argumentide hankimist, kuid kui argumente on palju või vaja on kasutada valikulisi argumente ja lippe (nt --verbose), siis on kasulik kasutada standardteeki argparse. See moodul muudab argumentide parsimise ja veateadete genereerimise lihtsaks.

Argumentide parsimine ja parseri loomine

argparse kasutamiseks tuleb kõigepealt luua parser, mis analüüsib argumendid. Seejärel seadistatakse parserile argumendid ja lõpuks töödeldakse käsurealt saadud väärtused.

Näide: Põhiline argparse kasutus

import argparse

def main():
    parser = argparse.ArgumentParser(description='Näidisprogramm')
    parser.add_argument('arg1', help='Esimene argument')
    parser.add_argument('arg2', type=float, help='Teine arvuline argument')
    args = parser.parse_args()

    print(f"arg1 = {args.arg1}")
    print(f"arg2 = {args.arg2}")

if __name__ == "__main__":
    main()
See programm võtab kaks argumenti. arg1 käsitletakse stringina ja arg2 arvuna, mis kuvatakse peale parsimist.
$ python script.py test 5.5
arg1 = test
arg2 = 5.5

Valikulised argumendid ja lipud

argparse üks võimsamaid omadusi on valikuliste argumentide ja lippude tugi. Sellega saab määrata koodi, mis käivitub ainult siis, kui argument on määratud, või pakkuda detailsemat väljundit (nt --verbose lipp).

Näide: Valikuliste argumentide ja lippude kasutamine

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--verbose', action='store_true', help='Näita detailset väljundit')
    parser.add_argument('numbers', nargs='+', type=float, help='Nimekiri arvudest')
    args = parser.parse_args()

    total = sum(args.numbers)
    if args.verbose:
        print(f"Detailne arvutus: {args.numbers} summa on {total}")
    else:
        print(f"Summa: {total}")

if __name__ == "__main__":
    main()
Selles programmis, kui on määratud --verbose, siis kuvatakse detailne väljund. Kui mitte, kuvatakse lihtne tulemus.
$ python script.py 1 2 3 --verbose
Detailne arvutus: [1.0, 2.0, 3.0] summa on 6.0
 
年収訴求

3. Vigade käsitlemine ja argumentide valideerimine

Argumentide arvu ja tüübi kontroll

Käsurea argumentidega töötades on oluline vältida vigast sisendit. Kui kasutaja ei anna õigeid argumente, tuleb kuvada veateade ja vältida programmi valesti töötamist. Kontrollides argumentide arvu ja tüüpi saab tagada stabiilsuse.

Näide: Argumentide arvu ja tüübi kontroll

import sys

def main():
    if len(sys.argv) != 3:
        print("Viga: vaja on kahte argumenti")
        return

    try:
        num1 = float(sys.argv[1])
        num2 = float(sys.argv[2])
    except ValueError:
        print("Viga: argumendid peavad olema arvud")
        return

    print(f"Summa: {num1 + num2}")

if __name__ == "__main__":
    main()
See programm kuvab veateate, kui argumentide arv pole kolm (skripti nimi + 2 arvu) või kui argumendid ei ole arvulised.

4. Praktilised kasutusjuhud

Näide käsurea tööriista loomisest

Üks praktiline näide käsurea argumentide kasutamisest on tööriista loomine, mis teostab failide töötlemist või andmete analüüsi.

Näide: Faili sisu lugemise tööriist

import argparse

def main():
    parser = argparse.ArgumentParser(description='Tööriist failis olevate ridade loendamiseks')
    parser.add_argument('filename', help='Faili nimi, mida loendada')
    args = parser.parse_args()

    try:
        with open(args.filename, 'r') as file:
            lines = file.readlines()
            print(f"Faili {args.filename} ridade arv: {len(lines)}")
    except FileNotFoundError:
        print(f"Viga: faili {args.filename} ei leitud")

if __name__ == "__main__":
    main()
See tööriist loendab etteantud faili ridade arvu ja kuvab selle.
$ python count_lines.py example.txt
Faili example.txt ridade arv: 100
年収訴求

5. Kokkuvõte

Õppides Pythonis käsurea argumentide kasutamist, saad muuta oma programmid paindlikumaks. sys.argv sobib lihtsateks juhtudeks, samas kui argparse võimaldab keerukamat töötlemist. Vigade käsitlemine ja argumentide valideerimine aitab sul luua töökindlamaid programme.
年収訴求