Inteligenta Artificiala

Argumentele programului

Uneori dorim sa apelam programul cu anumite argumente. In acest caz scriem in linia de comanda ceva de genul: python programel.py arg1 arg2 arg3 ......

Pentru a accesa argumentele trebuie sa importam modulul sys: import sys si apoi iteram prin lista sys.argv. Atentie, primul argument este numele programului.

Consideram exemplul de mai jos: import sys
print("\nAfisaj executie program\n")
for i in range(len(sys.argv)):
    print ("Argumentul {} are valoarea {} si tipul de date {}".format(i, sys.argv[i], type(sys.argv[i]))) Observam executia programului:

Observam si ca tipul de date al tuturor argumentelor este str, deci daca vrem sa folosim o valoare numerica data ca parametru, trebuie sa o convertim la numar.

Timeout in python

Uneori dureaza foarte mult executia unei functii, si am vrea daca depaseste un anumit interval de timp, sa o oprim (consideram ca peste acel interval de timp, rezultatul nu mai este relevant sau este oricum prea costisitor de obtinut).

Putem pune un timeout pe executia unei functii folosind modulul stopit.

Se instaleaza in mod obisnuit cu pip: pip install stopit

Pentru a folosi stopit, "decoram" functia (scriem pe randul imediat de deasupra definirii ei) cu: @stopit.threading_timeoutable(default="valoare returnata de functie cand intra in timeout") Valoarea data parametrului default este, asa cum scrie si mai sus, cea returnata de functie in caz de timeout (in felul asta ii putem da o valoare speciala ca sa verificam daca a intrat in timeout sau nu).

De asemenea, functia se va apela cu un parametru suplimentar, numit timeout in care se va specifica numarul de secunde dupa care sa intrerupa functia, in cazul in care nu si-a terminat singura executia. Parametru timeout nu trebuie precizat in definirea functiei. De exemplu, daca functia e definita: def f(a,b,c):
... si are deocratia @stopit.threading_timeoutable, se va apela cu 4 parametri (primele 3 valori fiind asociate cu a, b si c, iar a 4 fiind timeout-ul de care se ocupa "decoratia" functiei): f(10,20,30, timeout=10):
... In acest exemplu, executia functiei va fi intrerupta fortat dupa 10 secunde, daca functia nu s-a terminat inca.

De exemplu, avem codul: import stopit


@stopit.threading_timeoutable(default="intrat in timeout")
def functie(n):
    j=0;
    for i in range(n):
        print(i, end=" ")
    return "functie finalizata"
        
        
print("#"*10)
rez=functie(1000,timeout=1)
print("\nRezultat functie: {}".format(rez))
print("#"*10)
rez=functie(10,timeout=1)
print("\nRezultat functie: {}".format(rez)) Cu outputul: ##########
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
Rezultat functie: intrat in timeout
##########
0 1 2 3 4 5 6 7 8 9
Rezultat functie: functie finalizata

Se observa ca la primul apel, functia a intrat in timeout (a durat mai mult de o secunda, cat am precizat) si a fost intrerupta dupa ce a trecut acel timp. Din aceasta cauza functia a returnat valoarea din parametrul default. In al doilea caz, functia a returnat valoarea efectiva din return-ul ei (fiindca nu a mai intrat in timeout).

Este posibil cand rulati programul sa nu va dea timeout in primul caz, daca aveti un calculator foarte rapid. Pentru a vedea efectul, cresteti numarul de iteratii, de exemplu puneti 100000.