Tutorial Python - Instrucţiuni de Control Flow

Instrucţiunea if

Instrucţiunea if execută o anumită porţiune de cod numai dacă este îndeplinită o condiţie. Condiţia este o expresie booleeană.

>>> x = 0
>>> if x < 0:
 print('Negativ')
elif x == 0:
 print('Neutru')
elif x == 1:
 print('Unitate')
else:
 print('Pozitiv mai mare ca 1')

 
Neutru

Python foloseşte indentarea (alineatul) pentru a delimita blocurile de cod.
Instrucţiunile din blocul if se scriu cu 4 spaţii mai interior. În exemple nu apare aşa deoarece Python inserează TAB-uri în loc de spaţii, iar Blogspot se pare că are o problemă cu aceste TAB-uri.
În exemplu am o singură instrucţiune sub if, print('Negativ'). Nu trebuie să număraţi spaţiile deoarece Python indentează automat când apăsaţi ENTER după cele două puncte (:).
Instrucţiunea elif este o prescurtare de la else if.
Instrucţiunile elif şi else sunt opţionale. else apare întotdeauna ultima.
Semnificaţia este următoarea: Dacă condiţia de la if este adevărată se execută instrucţiunile din blocul if, altfel se trece la ramura următoare, else sau elif, şi se reia procesul.
După ce aţi terminat de scris o instrucţiune if în IDLE, apăsaţi de două ori ENTER ca s-o executaţi.

Instrucţiunile for şi while

Instrucţiunea for este folosită pentru a parcurge o secvenţă de numere (progresie aritmetică) sau pentru a parcurge elementele unei colecţii (liste, stringuri, seturi, etc.).

>>> txt = 'tutorialeplusplus'
>>> for ch in txt:
 print(ch, end=' ')

 
t u t o r i a l e p l u s p l u s 

end=' ' înseamnă că fiecare afişare este despărţită de spaţiu (implicit este end='\n').
Iată un exemplu cu for şi if.

>>> for ch in txt:
 if ord(ch) > ord('e'):
  print(ch, end=' ')
 else:
  print(ch.upper(), end=' ')

  
t u t o r i A l E p l u s p l u s 

Un exemplu cu o progresie aritmetică generată de funcţia range.

>>> for i in range(5):
 print(i)

 
0
1
2
3
4

Funcţia (de fapt este o clasă...dar voi ajunge şi acolo) range ia trei parametri (ultimul fiind opţional): start, stop, step (step [pas] semnifică raţia progresiei) SAU ia un singur parametru (ca-n exemplu) stop (start=0 şi step=1).

>>> for nr in range(10, 0, -1):
 print(nr, end=' ')

 
10 9 8 7 6 5 4 3 2 1 

Parcurgerea progresiilor aritmetice cu range este mult mai eficientă decât echivalentul în while.

>>> mylist = ['a', 1, True, 'b', 0]
>>> ln = len(mylist)
>>> for i in range(ln):
 print(mylist[i])

 
a
1
True
b
0

Instrucţiunea while repetă o porţiune de cod cât timp condiţia este adevărată.

>>> q = 1
>>> while q < 10:
 print(q)
 q += 1 # q = q + 1

 
1
2
3
4
5
6
7
8
9

Şi un alt exemplu, în care creez o listă pornind de la un string şi afişez acel string invers:

>>> st = list('stiva')
>>> while len(st) > 0:
 print(st.pop(), end='')

 
avits

Nu uitaţi că funcţia pop returnează şi apoi elimină elementul de la sfârşitul listei.

Instrucţiunile break, continue şi else pentru loopuri

Un loop (buclă) reprezintă o structură repetitivă (for sau while).
Instrucţiunea break întrerupe execuţia unui loop.

>>> for i in range(10):
 if i == 5:
  break
 print(i)

 
0
1
2
3
4

Instrucţiunea continue ignoră restul codului din loop şi continuă cu următoarea iteraţie.

>>> for i in range(10):
 if i == 3 or i == 5 or i == 7:
  continue
 print(i)

 
0
1
2
4
6
8
9

Instrucţiunile loop (repetitive) pot avea o ramură else care se execută atunci când loop-ul este epuizat, fie pentru că a parcurs toate elementele unei colecţii, fie condiţia a devenit falsă.
Pe scurt: Loopul NU este întrerupt cu break.

>>> for i in range(2, 10):
 for x in range(2, i):
  if i % x == 0:
   print(i, ' nu este numar prim')
   break
 else:
  # Dupa epuizarea forului se executa else
  print(i, ' este numar prim')

  
2  este numar prim
3  este numar prim
4  nu este numar prim
5  este numar prim
6  nu este numar prim
7  este numar prim
8  nu este numar prim
9  nu este numar prim

Atenţie! Acest else este asociat cu un for nu cu if.
Priviţi ce s-ar fi afişat fără else.

>>> for i in range(2, 10):
 for x in range(2, i):
  if i % x == 0:
   print(i, ' nu este numar prim')
   break
 # Aceasta instructiune se va executa de fiecare data
 print(i, ' este numar prim')

 
2  este numar prim
3  este numar prim
4  nu este numar prim
4  este numar prim
5  este numar prim
6  nu este numar prim
6  este numar prim
7  este numar prim
8  nu este numar prim
8  este numar prim
9  nu este numar prim
9  este numar prim

Deci, pentru structurile repetitive, else se execută numai când loopul se termină normal, fără întrerupere cu break.

Instrucţiunea pass

Instrucţiunea pass nu face nimic. Este instrucţiunea vidă.
Se foloseşte acolo unde se cere o instrucţiune din punct de vedere sintactic, dar nu este nevoie de una.
Exemplu, while infinit.

>>> while True:
 pass # Apasati Ctrl+C ca sa opriti executia

Mai multe informaţii:

>>> help('for')
>>> help('while')

Acum ar trebui să fiţi în stare să scrieţi programe (scripturi) simple.
Scrieţi în Python Shell un program care calculează suma primilor 20 de termeni ai şirului lui Fibonacci.
Primii doi termeni sunt 1, iar umătorii se calculează conform formulei

fib_n = fib_n-1 + fib_n-2

Vezi rezultatul.
Vezi soluţia.

>>> fib, ssm = [1, 1], 2 # ssm - suma
>>> for i in range(18):
 fib.append(fib[-1] + fib[-2])
 ssm += fib[-1]

Tutorial Python - Stringuri (Şiruri de caractere)

Stringurile sunt şiruri de caractere Unicode (Python 3). Sunt immutable (imuabile; nu pot fi alterate).
Avantajul oferit de Unicode este că fiecare caracter, din orice limbă, şi fiecare simbol are asociat un număr de ordine (ordinal).
Înainte de Unicode existau doar 256 de ordinali cu care puteai să reprezinţi caracterele. Unicode a rezolvat această problemă.
Putem afla numărul de ordine (pentru caracterele uzuale acesta este codul ASCII) al unui caracter cu funcţia ord(ch) şi putem afla caracterul corespunzător unui ordinal cu funcţia chr(nr).

>>> ord('ă')
259
>>> ord('ف')
1601
>>> ord('∫')
8747
>>> ord('0')
48
>>> ord('A')
65
>>> chr(9001)
'〈'
>>> chr(8752)
'∰'
>>> chr(97)
'a'
>>> chr(1608)
'و'
>>> chr(25384)
'挨'

În Python caracterele nu au un tip propriu. Pur şi simplu sunt stringuri de lungime 1.
Stringurile se declară fie cu ghilimele fie cu apostrofuri. Eu, de regulă, folosesc apostrofuri.
Dacă le declaraţi cu apostrofuri puteţi folosi ghilimele în string. Dacă le declaraţi cu ghilimele puteţi folosi apostrofuri în string.
Sau puteţi folosi secvenţe escape (\' şi \").

>>> txt = 'Vi \'imbecillia\' asseverent to ostenditur "objectioni" argumentis.'
>>> txt
'Vi \'imbecillia\' asseverent to ostenditur "objectioni" argumentis.'
>>> alttxt = "Videmur vim quo seorsim' petebat."
>>> alttxt
"Videmur vim quo seorsim' petebat."

Interpretorul afişează stringurile aşa cum le-am introdus. Dacă vrem să fie afişate corespunzător folosim funcţia print.

>>> print(txt)
Vi 'imbecillia' asseverent to ostenditur "objectioni" argumentis.
>>> print(alttxt)
Videmur vim quo seorsim' petebat.

Puteţi folosi secvenţa escape \n pentru a insera un rând nou în string şi puteţi folosi \ pentru a indica interpretorului că stringul continuă pe rândul următor (altfel dacă apăsaţi ENTER interpretorul va evalua expresia).

>>> txt = 'Vul student quaeque brachia nos divelli.\
Ha ex alterius locusque\n\
ins idias\n  formalis ii mutuatur judiciis.'
>>> print(txt)
Vul student quaeque brachia nos divelli.Ha ex alterius locusque
ins idias
  formalis ii mutuatur judiciis.
>>> txt
'Vul student quaeque brachia nos divelli.Ha ex alterius locusque\nins idias\n  formalis ii mutuatur judiciis.'

Observaţi că acel backslash nu apare în string.
O alternativă la \n este folosirea a trei ghilimele sau a trei apostrofuri.
În acest caz rândurile noi din interpretor se traduc în \n în string.
În exemplu, folosesc un backslash la început (şi la sfârşit) ca să previn inserarea unui nou rând în string.
Puteam de asemenea să încep imediat după apostrofuri şi să nu mai pun acel backslash.

>>> txt = '''\
Essentiae infinitae ad imaginata vi videretur to tantaeque obversari.
Debiliora in ab opinantem priusquam perfectae.
Desumptas apparebat effecerit dubitandi objective id ex du profundum.\
'''
>>> print(txt)
Essentiae infinitae ad imaginata vi videretur to tantaeque obversari.
Debiliora in ab opinantem priusquam perfectae.
Desumptas apparebat effecerit dubitandi objective id ex du profundum.

Puteţi afişa un string aşa cum îl introduceţi dacă adăugaţi un r în faţa acestuia (raw string).

>>> rw = r'This \n is a\' raw "string"'
>>> print(rw)
This \n is a\' raw "string"

Putem accesa caractere individuale aşa cum accesam elementele listelor şi, de asemenea, putem folosi notaţia slice pentru a "extrage" substringuri (vezi liste).

>>> txt = 'Corpus omne perseverare in statu suo quiescendi vel movendi uniformiter in directum, nisi quatenus a viribus impressis cogitur statum illum mutare.'
>>> len(txt) # Lungimea stringului
147
>>> txt[0]
'C'
>>> txt[-1]
'.'
>>> txt[-2]
'e'
>>> txt[7:23]
'omne perseverare'
>>> txt[:6]
'Corpus'
>>> txt[-7:-1]
'mutare'

Stringurile nu pot fi modificate!

>>> txt[0] = 'T'
Traceback (most recent call last):
  File "<pyshell#66>", line 1, in <module>
    txt[0] = 'T'
TypeError: 'str' object does not support item assignment

Operatorul + concatenează două stringuri, iar operatorul * repetă un string. Ambii operatori returnează un string nou.

>>> law = 'Lex'
>>> word = law + ' I'
>>> print(word)
Lex I
>>> print(law * 7)
LexLexLexLexLexLexLex

Tipul str (string) conţine numeroase metode (funcţii) ce implementează operaţiile comune cu stringuri.
Acest exemplu vă prezintă câteva din aceste metode.

>>> lex3 = 'Actioni contrariam semper et æqualem esse reactionem: sive corporum duorum actiones in se mutuo semper esse æquales et in partes contrarias dirigi.'
>>> sub = lex3[8:36]
>>> sub
'contrariam semper et æqualem'
>>> # Returneaza un string cu primul caracter capitalizat si restul lowercase
>>> sub.capitalize()
'Contrariam semper et æqualem'
>>> # Returneaza numarul de aparitii al unui string
>>> lex3.count('semper')
2
>>> # Returneaza indicele unui substring
>>> lex3.index(sub)
8
>>> # Returneaza true daca toate caracterele sunt lowercase
>>> sub.islower()
True
>>> # Elimina spatiile initiale si finale
>>> '   fara spatii    '.strip()
'fara spatii'
>>> # Returneaza true daca caracterul este cifra
>>> '1'.isdigit()
True

Mai multe informaţii pe siteul Python.
În Python până şi constantele string sunt obiecte! ('1'.isdigit())
Puteţi testa dacă un string se află într-un alt string cu operatorul in.

>>> 'et' in lex3
True
>>> 'A' in lex3
True
>>> sub in lex3
True

Stringurile pot fi formatate cu funcţia format.

>>> username = 'Newton'
>>> password = 'inertia'
>>> 'Parola lui {0} este "{1}"'.format(username, password)
'Parola lui Newton este "inertia"'

Câmpurile {0} şi {1} ţin locul (în ordine) parametrilor funcţiei format.
Mai multe detalii despre aceste câmpuri găsiţi pe siteul Python.
Şi nu uitaţi de:

>>> help('str')

Tutorial Python - Seturi şi Dicţionare

Seturi (Mulţimi)

Un set (mulţime) este o colecţie neordonată de iteme de orice tip immutable.
Elementele apar într-un singur exemplar (nu există duplicate) şi nu apar în ordine.
Set-urile suportă operaţiile standard de reuniune, intersecţie, diferenţă, şi diferenţă simetrică.
Un set se defineşte ca şi o listă, dar cu acolade în loc de paranteze pătrate.

>>> A = {4}
>>> vid = set()
>>> A
{4}
>>> vid
set()

Setul vid (mulţimea vidă) se defineşte folosind funcţia set(). Sintaxa {} defineşte un dicţionar vid.
Tot cu această funcţie puteţi crea un set pornind de la o listă set(lst) unde lst este o listă.
Putem crea un set pornind de la un string.

>>> litere = set('tutorialeplusplus')
>>> litere
{'u', 't', 's', 'r', 'p', 'e', 'a', 'o', 'l', 'i'}

Observaţi că elementele sunt unice, iar ordinea nu se păstrează.
Putem adăuga elemente noi la un set. Dacă valoarea adăugată există deja, nu se întâmplă nimic: no-op (no operation).

>>> a = {1}
>>> a.add(2)
>>> a
{1, 2}
>>> a.add(3)
>>> a
{1, 2, 3}
>>> a.add(2)
>>> a
{1, 2, 3}

Putem folosi funcţia update să adăugăm mai multe elemente (fie de la alte seturi, fie de la liste).

>>> a.update({4,7,9})
>>> a
{1, 2, 3, 4, 7, 9}
>>> a.update({1, 10}, {13, 11})
>>> a
{1, 2, 3, 4, 7, 9, 10, 11, 13}
>>> a.update([40, 42, 50])
>>> a
{1, 2, 3, 4, 7, 9, 10, 11, 13, 40, 42, 50}

Această funcţie acceptă orice număr de parametri (seturi, liste, tuple, etc.).
Eliminăm elemente cu funcţiile discard şi remove.
Atunci când remove încearcă să elimine un element inexistent va lansa excepţia (eroarea) KeyError, în timp ce discard nu face nimic (no-op).

>>> a.discard(11)
>>> a
{1, 2, 3, 4, 7, 9, 10, 13, 40, 42, 50}
>>> a.discard(11)
>>> a
{1, 2, 3, 4, 7, 9, 10, 13, 40, 42, 50}
>>> a.remove(13)
>>> a
{1, 2, 3, 4, 7, 9, 10, 40, 42, 50}
>>> a.remove(13)
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    a.remove(13)
KeyError: 13

Cu funcţia clear() putem şterge toate elementele setului.
Operaţiile standard mulţimilor le suportă şi tipul set.

>>> a = {1, 2, 3, 4}
>>> b = {3, 4, 5, 6}
>>> a.union(b) # Reuniune
{1, 2, 3, 4, 5, 6}
>>> a | b
{1, 2, 3, 4, 5, 6}
>>> a.intersection(b) # Intersectie
{3, 4}
>>> a & b
{3, 4}
>>> a.difference(b) # Diferenta
{1, 2}
>>> a - b
{1, 2}
>>> a.symmetric_difference(b) # Diferenta simetrica
{1, 2, 5, 6}
>>> a ^ b
{1, 2, 5, 6}

Observaţi că am pus şi operatorii specifici fiecărei operaţii. Atât funcţiile cât şi operatorii returnează seturi noi.
Puteţi testa dacă un element se află într-un set cu operatorul in (vezi liste).
De asemenea, există şi funcţiile issubset şi issuperset care testează dacă un set este un subset sau un superset al unui alt set.

>>> a = {1,  2}
>>> b = {1, 2, 3, 4}
>>> a.issubset(b)
True
>>> b.issuperset(a)
True
>>> a.add(7)
>>> a.issubset(b)
False
>>> b.issuperset(a)
False

În contextele booleene seturile vide sunt False, iar cele nevide sunt True.
Mai multe informaţii:

>>> help('set')

Dictionaries (Dicţionare)

Dicţionarul este un tip de dată compus. Este o mulţime neordonată de perechi key - value (cheie - valoare).
Dicţionarele sunt optimizate pentru extragerea valorilor atunci când se cunosc cheile. Aceste chei pot fi obiecte de tip immutable (stringuri, numere, tuple care conţin numai elemente immutable).
Listele nu pot fi chei deoarece pot fi modificate. Dicţionarele se definesc cu acolade. Cheile şi valorile asociate se precizează folosind sintaxa key:value.
Perechea {} defineşte un dicţionar vid.

>>> bob = {'a': 1, 'b': 2, 'c':3}
>>> vid = {}
>>> bob
{'a': 1, 'c': 3, 'b': 2}
>>> vid
{}

Apoi putem folosi notaţia de la liste (numai că de data aceasta în loc de indici numerici avem chei) ca să extragem valorile din dicţionar. Dacă o cheie nu există va fi lansată o eroare.

>>> bob['b']
2
>>> bob['a']
1
>>> bob[2]
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    bob[2]
KeyError: 2

Puteţi adăuga elemente noi folosind sinxtaxa dictionar[key] = value.
Puteţi modifica elemente existente folosind aceeaşi sintaxă. Cu del se pot şterge elemente.

>>> bob[2] = 'doi'
>>> bob
{2: 'doi', 'a': 1, 'c': 3, 'b': 2}
>>> bob['c'] = 5
>>> bob
{2: 'doi', 'a': 1, 'c': 5, 'b': 2}
>>> del bob[2]
>>> bob
{'a': 1, 'c': 5, 'b': 2}

Dintr-un dicţionar se pot extrage cheile, valorile şi itemele în liste.

>>> list(bob.keys())
['a', 'c', 'b']
>>> list(bob.items())
[('a', 1), ('c', 5), ('b', 2)]
>>> list(bob.values())
[1, 5, 2]

Folosiţi operatorul in pentru a testa dacă o cheie (nu o valoare!) se află în dicţionar.

>>> 'a' in bob
True
>>> 1 in bob
False

În contextele booleene dicţionarele vide sunt False, iar cele nevide sunt True.
Informaţii suplimentare:

>>> help('dict')

Tutorial Python - Liste şi Tuple

Liste

• Lista este un tip de dată compus.
• Este o colecţie de iteme.
• Itemele (elementele) pot fi de orice tip.
• Este un tip de dată mutable - poate fi modificat

Itemele listelor se pun intre paranteze pătrate. Listele se declară în felul următor:

>>> mylist = [1, 'a', '%', 2.57, 9+3j]
>>> mylist
[1, 'a', '%', 2.57, (9+3j)]

Stringurile (şirurile de caractere) în Python se declară cu ghilimele sau cu apostrofuri.
Obiectele listei sunt numerotate de la zero, deci primul element este mylist[0].
Lista păstrează ordinea elementelor. Un element poate apărea de mai multe ori într-o listă.
De asemenea, Python permite indici negativi cu semnificaţia

mylist[-n] == mylist[len(mylist) - n]

>>> mylist[0] # Primul item al listei
1
>>> mylist[-1] # Ultimul item al listei
(9+3j)
>>> mylist[4]  # Ultimul item al listei
(9+3j)
>>> mylist[5]
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    mylist[5]
IndexError: list index out of range

Dacă depăşiţi dimensiunea listei, Python va lansa eroarea IndexError.
Funcţia len(ob) returnează mărimea / dimensiunea obiectului ob (trebuie să fie o colecţie).

>>> len(mylist)
5

Putem tăia o listă, adică putem să extragem părţi dintr-o listă folosind sintaxa slice:

>>> mylist[1:3]
['a', '%']
>>> mylist[0:3]
[1, 'a', '%']
>>> mylist[:3]
[1, 'a', '%']
>>> mylist[3:]
[2.57, (9+3j)]
>>> mylist[:]
[1, 'a', '%', 2.57, (9+3j)]

Operatorul slice (:) returnează întotdeauna o listă nouă.
Sintaxa mylist[start:end] are semnificaţia: Returnează itemele din intervalul [start, end). Fără mylist[end].
Atunci când start lipseşte, Python ia în considerare valoarea implicită zero.
Iar când end lipseşte se ia considerare valoarea len(mylist).
În exemplu, mylist[:3] returnează toate itemele începând de la primul (0) până la al patrulea (3), dar fără acest element, iar mylist[3:] returnează toate elementele începând cu al patrulea (3) până la sfârşit.
Dacă ambele valori lipsesc, operatorul slice returnează o copie a listei.
Listele pot fi modificate. Putem adăuga elemente noi la listă cu operatorul de concatenare +.

>>> mylist = [3]
>>> mylist = mylist + ['1', 6.7]
>>> mylist
[3, '1', 6.7]

Operatorul + creează o nouă listă în memorie formată din concatenarea celor două liste, apoi atribuie noua listă variabilei mylist.
Dacă memoria este limitată atunci nu folosiţi această sintaxă. Folosiţi funcţiile append şi extend.

>>> mylist.append(True)
>>> mylist
[3, '1', 6.7, True]
>>> mylist.extend(['^', 7.0])
>>> mylist
[3, '1', 6.7, True, '^', 7.0]

Atenţie! Funcţia extend adaugă elementele argumentului (iterabil; are sau poate genera o secvenţă de iteme) la listă, în timp ce funcţia append adaugă argumentul la listă (chiar dacă este iterabil). Exemplu:

>>> mylist = [1, 2, 3, 4, 5]
>>> len(mylist)
5
>>> mylist.append(['one', 'two'])
>>> mylist
[1, 2, 3, 4, 5, ['one', 'two']]

Listele pot avea ca elemente alte liste, după cum vedeţi. Elementele acestor liste se accesează uşor:

>>> mylist[-1]
['one', 'two']
>>> mylist[-1][0]
'one'
>>> mylist[-1][1]
'two'

Elementele listei pot fi modificate.

>>> mylist = ['a', 'b', 5, 7]
>>> mylist[0] = False
>>> mylist
[False, 'b', 5, 7]

Putem verifica dacă un element se află în listă folosind operatorul in.

>>> 'b' in mylist
True
>>> 'a' in mylist
False

Putem afla de câte ori un element se află în listă.

>>> mylist = ['c', 'b', 's', 'ab', 'b', 'c']
>>> mylist.count('c')
2

Şi putem să aflăm index-ul unui item.

>>> mylist.index('ab')
3
>>> mylist.index('b')
1
>>> mylist.index('b', 2)
4
>>> mylist.index('abc')
Traceback (most recent call last):
  File "<pyshell#44>", line 1, in <module>
    mylist.index('abc')
ValueError: 'abc' is not in list

Funcţia index ia trei parametri: valoarea căutată, [start, [stop]] reprezentând capetele intervalului pe care se face căutarea: [start, stop).
Am pus parametrii între paranteze pătrate (aşa veţi întâlni şi-n documentaţiile Python) ca să subliniez faptul că sunt opţionali.
Când stop lipseşte se caută de la start până la sfârşit.
Dacă elementul nu există în listă, funcţia va genera eroarea ValueError.
Un alt mod de inserare a valorilor într-o listă este prin funcţia insert.

>>> mylist = [1, 2, 'a']
>>> mylist.insert(0, 'E')
>>> mylist
['E', 1, 2, 'a']
>>> mylist.insert(2, 'two')
>>> mylist
['E', 1, 'two', 2, 'a']

Aceasta ia doi parametri: primul reprezintă indexul unde va fi inserat elementul, iar al doilea reprezintă elementul inserat.
Funcţia insert inserează în faţă, elementele listei fiind deplasate la dreapta pentru a face loc itemului adăugat.
Ca să ştergem un element dintr-o listă putem folosi operatorul del.

>>> mylist = [-1, -2, ':)', ':(']
>>> mylist
[-1, -2, ':)', ':(']
>>> del mylist[-1]
>>> mylist
[-1, -2, ':)']
>>> del mylist[0]
>>> mylist
[-2, ':)']

Atunci când un element este eliminat dintr-o listă, celelalte elemente sunt mutate astfel încât să acopere "gaura" creată. Ordinea itemelor se păstrează.

>>> mylist[0]
-2
>>> mylist[-1]
':)'

Dacă nu cunoaşteţi poziţia unui item în listă, puteţi folosi funcţia remove.

>>> mylist = ['t', 'r', 4.5, True]
>>> mylist.remove('t')
>>> mylist
['r', 4.5, True]
>>> mylist.remove('t')
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    mylist.remove('t')
ValueError: list.remove(x): x not in list

Pe lângă remove mai există şi funcţia pop. Aceasta returnează elementul înainte de a-l elimina.

>>> mylist = ['a', 'b', 'patru', 'last']
>>> mylist.pop()
'last'
>>> mylist
['a', 'b', 'patru']
>>> mylist.pop(0)
'a'
>>> mylist
['b', 'patru']

Fără argument, pop returnează şi elimină ultimul element.
Se pot elimina iteme de pe alte poziţii dacă transmitem indicele corespunzător. Şi aici elementele vor fi mutate pentru a acoperi "gaura" creată.
Ca să eliminăm toate elementele dintr-o listă avem două opţiuni:

>>> mylist[:] = [] # [] este lista vida (fara elemente)

Sau cu funcţia clear.

>>> mylist.clear()
>>> mylist
[]

În contextele booleene listele nevide sunt True, iar cele vide sunt False.

>>> if []:
 print(True)
else:
 print(False)

 
False
>>> if [1]:
 print(True)
else:
 print(False)

 
True

În final nu uitaţi de >>> help('list'). Poate fi de mare ajutor atunci când uitaţi ceva.

Tuple

Un tuple (n-am găsit o traducere mai bună) este o listă immutable (imuabilă, care nu poate fi modificată). Se definesc ca listele numai că se folosesc paranteze rotunde.

>>> tupy = ('^_^', '©', 8, 9, 6)
>>> tupy
('^_^', '©', 8, 9, 6)
>>> tupy[0]
'^_^'
>>> tupy[-1]
6

Puteţi folosi operatorul slice, puteţi concatena (aceste operaţii creează tuple noi), puteţi verifica dacă un element se află într-un tuple, dar nu-l puteţi modifica.
Aşadar funcţiile append, extend, remove, pop, insert nu există într-un tuple.
Un tuple este mai rapid decât o listă atunci când aveţi o secvenţă şi vreţi doar să iteraţi prin ea.
Un tuple poate fi folosit la dicţionare pe post de key (asta dacă elementele pe care le conţine sunt immutable: stringuri, numere, tuple, etc.).
Ca să creaţi un tuple cu un singur element puneţi virgulă după acel element (altfel Python va crede că sunt doar două paranteze şi le va ignora).

>>> tupy = ('one',)
>>> tupy
('one',)  # Avem tuple :)
>>> tupy = ('one')
>>> tupy
'one'     # Oops! String!

La fel ca listele, un tuple vid este False, iar un tuple nevid este True (în contexte booleene).
Puteţi transforma un tuple într-o listă folosind funcţia list(ob) sau puteţi transforma o listă într-un tuple folosind funcţia tuple(ob).
Pentru mai multe detalii aveţi >>> help('tuple').

Tutorial Python - Calculatorul Python - Variabile

Python ca şi calculator

Aşa cum v-am spus, Python poate fi folosit ca şi calculator. Deschideţi Shellul (IDLE) şi calculaţi ceva, să zicem:

>>> 3 * 2 + 1
7

Regulile sunt ca la matematică. Puteţi folosi paranteze ca să alteraţi ordinea evaluării.

>>> 3 * (2 + 1)
9

Spaţiile albe nu sunt obligatorii. Eu le introduc pentru claritate.
Operatorii aritmetici sunt: +, -, / , *, % , //, **
Operatorul modulo % calculează restul împărţirii a două numere.

>>> 5 % 2
1

Operatorul împărţire întreagă // returnează partea întreagă a împărţirii a două numere.

>>> 9 // 2
4
>>> 9 // -2
-5

Operatorul / realizează împărţirea normală şi returnează un float.

>>> 5 / 2
2.5

Iar ultimul operator ** ridică la putere.

>>> 2 ** 3
8
>>> 4 ** (1/2) # Radical din 4
2.0

Comentariile în Python se introduc cu simbolul #. Comentariile sunt ignorate de interpretor, rolul lor este de a clarifica porţiuni de cod, deşi fiecare foloseşte comentariile cum vrea.
Python permite folosirea notaţiei ştiinţifice:

>>> 2e3 # 2 * 10**3
2000.0
>>> 4E-3 # 4 * 10**-3
0.004
>>> 1.23e9 # 1.23 * 10**9
1230000000.0
>>> 1e2 # 10**2
100.0

e sau E înseamnă, în notaţia ştiinţifică, 10 la puterea.
Variabila built-in _ (prezentă în modul interactiv) reţine ultima valoare calculată. Este utilă atunci când folosiţi Python pe post de calculator.
Nu atribuiţi nicio valoare acestei variabile deoarece veţi crea una nouă, locală, care o va masca pe cea originală şi nu veţi mai obţine efectele dorite (decât dacă restartaţi Shellul).

>>> 2 + 4
6
>>> 8 * _
48
>>> _
48

Ca să putem folosi funcţiile matematice (sin, cos, log, etc.) trebuie să importăm modulul (built-in) math folosind această instrucţiune import math.
Apoi puteţi folosi instrucţiunea help('math') ca să aflaţi mai multe informaţii despre acest modul.

>>> import math
>>> math.sin(math.pi/2)  # Argumentul trebuie sa fie in radiani
1.0
>>> math.log(math.e)  # Logaritm natural (in baza e)
1.0
>>> math.hypot(3, 5)  # Calculeaza ipotenuza conform Teoremei lui Pitagora
5.8309518948453

Observaţi că trebuie să scrieţi de fiecare dată numele modului atunci când folosiţi obiecte definite în acesta. Dacă vă este lene staţi liniştiţi deoarece există o soluţie.
Puteţi folosi instrucţiunea from modul import nume unde modul este numele modului din care importaţi, iar nume este numele pe care-l importaţi.
Ca să importaţi toate numele dintr-un modul folosiţi from modul import *.
Nu recomand acest lucru deoarece pot apărea conflicte între numele din modulul respectiv şi numele din modulul vostru (să zicem că aveţi funcţia sin definită de voi şi funcţia sin definită în math. Conflict!).
Există o soluţie şi pentru această problemă: Alias-urile.

>>> from math import sin as sn
>>> from math import pi as PI
>>> sn(PI/2)
1.0

Python caută modulele în toate folderele ce apar în sys.path. Ca să vedeţi conţinutul sys.path, importaţi modulul sys.

>>> import sys
>>> sys.path
['', 'C:\\Python33\\Lib\\idlelib', 'C:\\Windows\\system32\\python33.zip', 'C:\\Python33\\DLLs', 'C:\\Python33\\lib', 'C:\\Python33', 'C:\\Python33\\lib\\site-packages']

Python este case-sensitive. Literele mari diferă de cele mici.

Variabile

Variabilele în Python sunt simplu de definit. Trebuie doar să atribuiţi o valoare unui nume.

>>> pret = 300
>>> pret
300

Nu puteţi folosi un nume (variabilă) înainte de a-l defini. Acest lucru va genera eroarea NameError.

>>> a
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in 
    a
NameError: name 'a' is not defined

Variabilele pot fi formate din cifre, litere, underscore. Nu pot începe cu cifre.
Puteţi atribui simultan o valoare mai multor variabile.

>>> a = b = c = 4
>>> b
4

Puteţi atribui valoarea unei expresii.

>>> x = 4 + 7 * 3
>>> x
25

Şi puteţi folosi variabilele în expresii, împreună cu funcţii şi alte obiecte.
Python determină tipul de dată al variabilei pe baza informaţiei memorată în acea variabilă şi reţine intern tipul de dată al fiecărei variabile.
Puteţi iniţializa mai multe variabile pe acelaşi rând folosind sintaxa:

>>> a, b, c = 7, 2, 4
>>> b
2
>>> a
7
>>> c
4

Dacă vreţi să atribuiţi o progresie de numere unor variabile puteţi folosi funcţia range.

>>> a, b, c, d = range(4)
>>> a
0
>>> b
1
>>> c
2
>>> d
3

Puteţi distruge o variabilă folosind operatorul del:

>>> del a # Obs: Nu puteti sterge o variabila nedefinita
>>> a
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    a
NameError: name 'a' is not defined

Tutorial Python - Numere şi Booleeni

În Python fiecare valoare are un tip de dată, dar atunci când definiţi o variabilă nu trebuie să precizaţi tipul deoarece Python îşi dă singur seama de acest lucru pe baza valorii atribuite variabilei.
Orice lucru din Python este un obiect. Obiectul este un concept abstract (va fi definit mai bine când voi ajunge la OOP), dar... ce trebuie să ştiţi este că obiectele au atribute şi metode (funcţii).
Atributele şi metodele se accesează folosind operatorul punct (.) (Ex: math.pi). Obiectele pot fi atribuite variabilelor şi pot fi transmise ca argumente funcţiilor.
Pe lângă tipurile pe care le veţi întâlni în acest tutorial, trebuie să ştiţi că mai există şi altele, cum ar fi tipul clasă, tipul modul, tipul funcţie, tipul fişier, tipul cod compilat (până şi codul compilat are tip), etc.
Aceste lucruri sunt posibile deoarece - REŢINEŢI - în Python există numai obiecte.

Numere

Aţi văzut deja exemple. Numerele în Python sunt:

• Întregi: -4, 1, 68, 78964, -45
• Float (Numere Reale): 2.234, -234.4, 1.0
• Fracţii (Numere Raţionale): 1/2, 4/5, 2/3
• Numere Complexe: 1+4j, 2-3j, 5j

>>> import fractions
>>> x = fractions.Fraction(4, 5) # Defineste o fractie
>>> x
Fraction(4, 5) # 4 / 5
>>> 2 * x
Fraction(8, 5)
>>> y = fractions.Fraction(1, 2)
>>> x + y
Fraction(13, 10)
>>> fractions.Fraction(1, 0)
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    fractions.Fraction(1, 0)
  File "C:\Python33\lib\fractions.py", line 167, in __new__
    raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
ZeroDivisionError: Fraction(1, 0)

Ca să puteţi folosi fracţiile trebuie să importaţi modulul fractions.
Fracţiile suportă şi ele aceleaşi operaţii matematice ca şi celelalte numere. Python nu permite împărţirea prin zero.
Fracţiile vor fi aduse automat la forma ireductibilă de către obiectul Fractions.
Numerele complexe sunt definite în Python. Numerele imaginare au sufixul j sau J.
Nu este necesar să importaţi vreun modul ca să le puteţi folosi.

>>> z = 3 + 4j
>>> q = 9 - 7j
>>> z + q
(12-3j)
>>> z - q
(-6+11j)
>>> z * q
(55+15j)
>>> z / q
(-0.007692307692307695+0.4384615384615385j)
>>> q.conjugate() # Conjugatul lui q
(9+7j)
>>> z.real # Partea reala
3.0 
>>> z.imag # Partea imaginara
4.0
>>> x = complex(1, 2) # Un alt mod de a crea un nr complex
>>> x
(1+2j)

Nu există limită pentru lungimea întregilor. Pot fi oricât de lungi vreţi (trebuie doar să aveţi destulă memorie).

>>> wow = 239502357286547637657436598234983928647836745836473856738402390417309720953498564836502479104739846537845619823675498734572039470943579034578634578353785387583457384583745873458345810123131091928301297394730291093
>>> wow
239502357286547637657436598234983928647836745836473856738402390417309720953498564836502479104739846537845619823675498734572039470943579034578634578353785387583457384583745873458345810123131091928301297394730291093

Numerele float au o precizie de 15 zecimale, dar aveţi grijă deoarece operaţiile cu float nu sunt întotdeauna precise. De exemplu:

>>> import math
>>> math.tan(math.pi / 4)
0.9999999999999999 # Ar fi trebuit sa fie 1.0

Puteţi folosi funcţia abs ca să aflaţi valoarea absolută a unui număr şi funcţia round ca să rotunjiţi un float.

>>> z = 2+2j
>>> abs(z)
2.8284271247461903
>>> p = -3
>>> abs(p)
3
>>> i = 9j
>>> abs(i)
9.0
>>> x = 2.678
>>> round(x)
3
>>> round(x, 1)
2.7
>>> round(x, 2)
2.68
>>> round(x, 3)
2.678

Al doilea parametru al funcţiei round reprezintă precizia rotunjirii (la câte zecimale să fie rotunjit numărul).

Booleeni

Valorile booleene apar în instrucţiunile decizionale, în loop-urile while, for, practic în orice context boolean (expresiile de la care Python aşteaptă o valoare booleană).
O valoare booleană poate fi True sau False.
Valorile nenule sunt considerate True, iar cele nule sunt considerate False.
Din acest motiv, practic orice expresie poate fi folosită într-un context boolean.
Operatorii care returnează valori booleene sunt: >, <, ==, >=, <=, not

>>> 1 < 2
True
>>> 1 > 5
False
>>> 2 == 2 # echivalent 
True
>>> 9 <= 10 # mai mic sau egal
True
>>> 11 >= 11 # mai mare sau egal
True
>>> 1.0 == 1
>>> (1/2) / (1/2) == 1
True
not 1 < 2
False

Operatorul not inversează valoarea de adevăr a expresiei.
Nu confundaţi operatorul de atribuire = cu operatorul de egalitate == !
Operatorii logici în Python sunt and şi or.

>>> True and True
True
>>> False and True
False
>>> True or False
True
>>> False or False
False

AND returnează TRUE dacă ambii operanzi sunt TRUE.
OR returnează TRUE dacă unul dintre operanzi este TRUE.
Vom folosi aceşti operatori la structurile de control.

Tutorial Python - Introducere

Ce este Python?

Python este un limbaj de nivel înalt, uşor de învăţat, cu o sintaxă elegantă. Este un limbaj multi-paradigmă cu  structuri de date de nivel înalt (high level) predefinite.
Este ideal pentru scripting şi dezvoltarea rapidă de aplicaţii. Este un limbaj interpretat ceea ce înseamnă că programele pot fi dezvoltate mai rapid deoarece nu se mai pierde timp cu compilarea şi linkeditarea. Interpretorul Python poate fi extins cu noi funcţii şi structuri de date built-in, implementate în C/C++. Implementarea de bază a acestuia, CPython, este scrisă în C. Python este folosit de companii şi organizaţii ca Google, NASA, Yahoo, etc., şi este utilizat ca limbaj de scriere în multe aplicaţii. Este un limbaj dinamic, caracterizat prin tipizare dinamică (tipul variabilelor este determinat dinamic de interpretor în funcţie de conţinutul acestora) şi are management de memorie automatizat (garbage collection).

Instalare

• Intraţi pe siteul http://www.python.org/download/ 
• Descărcaţi pachetul Python 3.x (cea mai nouă versiune) potrivit OS-ului vostru.
• După ce l-aţi instalat (Pe Windows se instalează în C:\Python33) deschideţi IDLE (Python GUI). Intraţi în All Programs -> Python şi găsiţi acolo shortcut-ul.
• Scrieţi print('Hello Python') şi apăsaţi ENTER.

IDLE

Cu acest IDLE puteţi scrie programe Python rapid, puteţi testa programe Python, vă puteţi documenta (scrieţi help) sau puteţi folosi Python ca şi calculator.
Cele trei paranteze unghiulare >>> reprezintă promptul Python, adică Python aşteaptă comenzi de la utilizator. Comanda este executată de îndată ce apăsaţi Enter. Acesta este modul interactiv.
De asemenea, este posibil să scrieţi întâi programele şi apoi să le daţi interpretorului să le execute, şi este posibil să scrieţi instrucţiuni pe mai multe rânduri - în modul interactiv - fără să fie executate imediat.
Ca să întrerupteţi execuţia unei comenzi în IDLE apăsaţi Control-C sau DEL. Dacă întrerupeţi execuţia unei comenzi, Python va lansa excepţia KeyboardInterrupt care poate fi tratată cu instrucţiunea try.
Încercaţi următorul exemplu:

>>> 1+1
2

Atenţie! Voi nu trebuie să introduceţi >>> !
Pe linia promptului (>>>) se află instrucţiunea, iar pe cealaltă linie se află rezultatul. Încercaţi şi voi în IDLE. Scrieţi 1 + 1 şi apăsaţi ENTER.
Dacă se întâmplă să uitaţi o comandă sau vreţi mai multe informaţii despre obiectele din Python, puteţi folosi comanda

>>> help
Type help() for interactive help, or help(object) for help about object.

Ca să intraţi în modul help interactiv scrieţi help(). Ca să ieşiţi din acest mod folosiţi quit.
Să zicem că vrem informaţii despre instrucţiunea if. Vom scrie help('if') urmat de ENTER. Sau vrem informaţii despre funcţia print. Atunci vom scrie help('print')
Pentru obiectele built-in (print, str, int, help, etc.) puteţi omite apostrofurile.
Incercaţi IDLE-ul, jucaţi-vă prin el, obişnuiţi-vă cu el, iar dacă greşiţi ceva, cel mai rău lucru care se poate întâmpla este un mesaj cu o eroare.