Introducere în programare

Containere
 Tablouri (Arrays)
https://docs.python.org/3/library/array.html?highlight=arrays
>>> import array
>>> a=array.array('i', [0,0,0,0,0])
>>> a
array('i', [0, 0, 0, 0, 0])
>>> a[2]
0
>>> a[2]=12
>>> a[2]
12
>>> a[22]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: array index out of range
>>> a.insert(3,111)
>>> a[3]
111
>>> a
array('i', [0, 0, 12, 111, 0, 0])
 Containere
Containerele Python se disting prin modul de acces al
datelor și prin faptul că pot fi modificate sau nu

Datele pot fi modificate: Date fixe

"Mutables" "Immutables"

Acces prin indice: Liste Tuple

“Secvențe" String
Bytes
Acces prin nume: Dicționare Named tuple
"Mapping"

Acces prin verificarea Mulțimi Frozen set

existenței:
“Mulțimi"
 Secvențe
Avantajul este că valorile sunt dispuse secvențial, se pot și ordona.
Lungimea unei secvențe:
len(sequence_name)
a = len(seq)
Accesul la date se face cu indicele de poziție:
name[i] # i este întreg.
print(seq[2]) #

Indicii încep de la zero până la len(sequence_name) - 1

i = 0 i = 1 i = 2 i = 3 … i = len(x) - 1
 Secvențe

Tuple: secvențe imutabile de obiecte.

Liste: secvențe mutabile de obiecte.

Atât tuplele cât și listele pot conține alte secvențe ca și

componente; componentele pot fi de tipuri diferite.
 Tuple
Constructorul pentru tuple este operatorul “virgulă” ,:
>>> a = 2,3,4
>>> a
(2, 3, 4)
Utilizarea parantezelor este obligatorie pentru tupla vida:
>>> n = ()
>>> n
()
Tupla cu un singur element (singleton):
a = 2,
Se poate folosi și funcția constructor din altă secvență:
a = tuple(some_other_container)

>>> a = tuple([1,2,3,4])
>>> a
(1, 2, 3, 4)
 Tuple
Tuplele pot fi adunate și multiplicate:
>>> a = 1,2,3
>>> a = a + (4,) # sau a += 4,
>>> a
(1, 2, 3, 4)

>>> a = 1,2,3
>>> a = a*2 # sau a *= 2
>>> a
(1,2,3,1,2,3)
 Indici
Accesul la componente:
a[0] # Primul element
a[len(a) - 1] # Ultimul element

Indici negativi - acces de la sfârșit la început :

a[-1] # Ultimul element
a[-len(a)] # Primul element

a[-i] înseamnă a[len()-i]

>>> a = (1,2,3),0,(),7
>>> a[0]
(1, 2, 3)
>>> a[0][1]
2
>>> a[2]
()
 Împachetare
Dacă rezultatul unui calcul este format din mai multe valori, acestea sunt
“împachetate” într-o tuplă.
Exemplu: Funcția divmod() returnează o tuplă (a // b, a % b)

>>> c = divmod (9,2)

>>> type(c)
<class 'tuple'> # c este de tipul tuplă
>>> c[0] # prima componentă
4 # 9//2
>>> c[1] # a doua componentă
1 # 9%2
 Despachetare
Despachetarea unei tuple înseamnă transferul componentelor unei variabile:

>>> a = (1,2)
>>> b, c = a
>>> b
1
>>> c
2

>>> x = ('a', 'b','c')

>>> a,b,c = x
>>> b
'b'
>>> a+b+c
'abc'
 Împachetare/Despachetare
Asignarea multiplă:
a, b = 1, 2
a, b = divmod(9,2)

Dacă în partea stângă a asignării sunt mai multe variabile despărțite prin
virgulă, în partea dreaptă este o secvență despachetată.

>>> c = divmod(99,8)
>>> type(c)
<class 'tuple'>
>>> type(divmod(99,8))
<class 'tuple'>
 Exemplu

>>> # Seria Fibonacci

>>> # Suma a două elemente = elementul următor
>>> a, b = 0, 1
>>> while b < 10:
... print(b)
... a, b = b, a+b
 Funcții
< , <=, >, >=, ==, !=
len(tuple) #Gives the total length of the tuple
max(tuple) #Returns item from the tuple with max value.
min(tuple) #Returns item from the tuple with min value.
tuple(seq) #Converts a list into tuple.

>>> max((2,4,3,5,4,3))
5
>>> max(2,4,3,5,4,3)
5
>>> (3,4)>(1,2,3)
True
>>> (3,4)!=(1,2,3)
True
>>> tuple([2,3,2,'oo'])
(2, 3, 2, 'oo')
>>> list1= ['maths', 'che', 'phy', 'bio']
>>> tuple1=tuple(list1)
>>> tuple1
('maths', 'che', 'phy', 'bio')
 Ranges (Șiruri, Serii..)
Un tip special de secvență read-only (imutabilă).
range(start, stop, step) # Elements in italics optional
start; stop; step trebuie să fie intregi.

Default pentru start = 0

Default pentru step = 1
Sunt generate numere până la stop (exclusiv stop).

range(4) se generează 0,1,2,3

range(2,8,2) se generează 2,4,6

range(0,-5,-1) se generează 0,-1,-2,-3,-4
 Constructortorul tuple
a = tuple(x) # x este un container sau range()

Exemplu:
>>> a = tuple(range(5))
>>> a
(0,1,2,3,4)

>>> a = range(5)
>>> b = tuple(a)
>>> a
range(0, 5)
>>> b
(0, 1, 2, 3, 4)
>>> type(a)
<class 'range'>
 Compararea secvențelor
a = (1,2,3,4)
b = (1,2,3)
4 in a # True
5 not in a # True
b in a # False
a == b # False

a > b # True

a = (2,2,2,2,2,2)
b = (6,6)
b > a # True
 Funcții pe secvențe

min(a) Cel mai mic element din a.

max(a) Cel mai mare element din a.
a.index(x,i,j) Indexul primei apariții a lui x în a
(opțional, începând cu i înaintea lui j).
a.count(x) Numărul elementelor x în a.
any(a) a este o secvență de valori Booleene (sau
numere), se testează dacă este măcar unul
True (sau !=0)
 Funcții pe secvențe
>>> a = (6,3,5,8,2,9,2,3,5)
>>> min(a)
2
>>> max(a)
9
>>> a.index(2)
4
>>> a.index(2,5)
6
>>> a.count(5)
2
>>> any(a)
True
>>> x=(0,0,0)
>>> any(x)
False
 Liste
Listele sunt secvențe mutabile și sunt reprezentate cu ajutorul parantezelor
pătrate []. Se construiesc prin:
Asignare:
>>> a = [1,2,3]

Constructorul de liste:
a = list(some_other_container)

Indexarea la fel ca la tuple, de la zero până la lungimea listei mai puțin 1:

>>> a[0]
1
>>> a[len(a) - 1]
3
 Componentele se pot schimba

a = (1,2,3)
a[0] = 10 # Modificare imposibilă!

a = [1,2,3]
a[0] = 10 # OK!

a = [10,20,30] # Asignare cu o nouă listă,

# cea veche rămâne nealterată.
 Liste cu etichete multiple
>>> a = [10] # Lista ce cobține 10.
>>> b = a. # Lista [10] are două etichete(nume) a și b
>>> b[0]
10
>>> b[0] = 20
>>> a[0] # Schimbând b se schimbă și a: etichetează aceeași listă
20
>>> b = [30] # b este atașat altei liste.
>>> a[0]
10
>>> b[0]
30
 Felii: indexare extinsă
Prin indexare extinsă pot fi accesate mai multe valori într-o secvență.
Aceste valori se numesc felii (slices).

a[i:j] returnează toate elementele de la a[i] până la a[j-1]

a[i:j:k] la fel dar cu pasul k.

a[:] (slice everything) înseamnă a[0], a[1],…, a[n-1], n = lungimea listei

Dacă j > len(a), se folosește ultima poziție.
Dacă i este None sau lipsește, se folosește zero.
Dacă i > j, felia este vidă.

a[:2] # primele 2 valori.

a[-2:] # ultimele 2 valori.
a[4:2] # felia vidă
 Asignare cu felii

>>> a = [0,1,2,3,4]
>>> b = [10,20,30]
>>> a[1:3] = b
>>> a
[0,10,20,30,3,4] # Atenție: 2 valori sunt înlocuite cu 3 valori.

>>> a = [0,1,2,3,4]
>>> b = [10,20]
>>> a[1:5] = b
>>> a
[0,10,20] # Se înlocuiesc 4 valori cu 2.
 Copiere
Asignare fără copiere (a și b etichetează aceeași listă):
>>> a = [1,2,3,4,5,6]
>>> b = a

Asignare cu copiere: b etichetează o copie a listei inițiale

>>> a = [1,2,3,4,5,6]
>>> b = a[:] # se poate folosi a.copy()
>>> b[0] = 10
>>> a
[1,2,3,4,5,6]
>>> b
[10,2,3,4,5,6]
 Funcții relative la liste
Se pot folosi toate funcțiile de la secvențe imutabile (min, max, index, count, any).
În plus, funții ”in place"(i.e. funcții ce schimbă originalul, fără a returna o copie):
del(a[i:j:k]) Ștergere felie.
a.clear() Sterge lista.

>>> a
[0, 10, 20, 30, 2, 3, 4]
>>> del(a[3:5])
>>> a
[0, 10, 20, 3, 4]
>>> a.clear()
>>> a
[]

a.extend(b) Extinde a cu b (i.e. a += b)

a.insert(i, x) Inserează x în a la poziția i.
a.pop(i) Returnează valoarea de la i și o elimină din a.
a.remove(x) Elimină din a primul element ce este egal cu x
a.reverse() Inversează elementele lui a.
 Funcții relative la liste
<, <=, >, >=, == Compares elements of both lists.
len(list) Gives the total length of the list.
list(seq) Converts a tuple into list

>>> [8,5,4,6,3,4,5,6]<=[8,5,4,9]
True
>>> [8,5,4,6,3,4,5,6]==[8,5,4,9]
False

>>> len(list(range(4,19,2)))
8
>>> len([8,5,4,6,3,4,5,6])
8

>>> list((4,3,5,2,8,7))
[4, 3, 5, 2, 8, 7]
 Funcții relative la liste
list.append(obj) #Appends object obj to list
list.count(obj) #Returns count of how many times
obj occurs in list
list.extend(seq) #Appends the contents of seq to list

list1 = ['C++', 'Java', 'Python']

list1.append('C#')
[‘C++', 'Java', 'Python', ‘C#']

>>> list1 = ['physics', 'chemistry', 'maths']

>>> list2=list(range(5))
>>> list1.extend(list2)
>>> list1
['physics', 'chemistry', 'maths', 0, 1, 2, 3, 4]
 Funcții relative la liste
list.index(obj) #Returns the lowest index in list that obj appears
list.insert(index, obj) #Inserts object obj into list at offset index
list.pop(obj=list[-1]) #Removes and returns last object or obj from list

>>> list1.index('chemistry’) 1
>>> list1.index('C#’)
ValueError: 'C#' is not in list

>>> list1.insert(1, 'Biology')

>>> list1
['physics', 'Biology', 'chemistry', 'maths’]

>>> list1.pop()
'maths'
>>> list1.pop(1)
‘Biology'
 Funcții relative la liste
list.remove(obj) #Removes object obj from list
list.reverse() #Reverses objects of list in place
list.sort([func]) #Sorts objects of list, use compare func if given

>>> list1 = ['physics', 'Biology', 'chemistry', 'maths']

>>> list1.remove('Biology')
>>> list1.remove('maths')
>>> list1
['physics', 'chemistry']

>>> list1.reverse()
>>> list1
['maths', 'chemistry', 'Biology', 'physics']

>>> list1.sort()
>>> list1
[‘Biology', 'chemistry', 'maths', 'physics']
 Exemple
>>> a = [1,2,3,4]
>>> b = [11,22,33]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 11, 22, 33]
>>> a.insert(3,99)
>>> a.pop(4)
4
>>> a.pop(5)
22
>>> a
[1, 2, 3, 99, 11, 33]
>>> a.insert(5,99)
>>> a.remove(99)
>>> a
[1, 2, 3, 11, 99, 33]
>>> a.reverse()
>>> a
[33, 99, 11, 3, 2, 1]
 Liste 2D
O listă poate conține ca elemente alte liste care pot fi de aceeași
dimensiune sau nu.
>>> a = [[1,2,3],[10,20,30],[100,200,300]]
>>> a[1]
[10, 20, 30]
>>> a[0][2]
3
>>> a[2][0]
100

>>> b = [3, [0,1,2,3], ['a','b','c'], [True, True, False], []]

>>> b[4]
[]
>>> b[2][2]
'c'
>>> b[3][2]
False
 Secvențe 2D

>>> a = ([1,2],[10,20])
>>> a[0][0] = 100
>>> a
([100,2],[10,20])

>>> a[0] = [1000,2000]

TypeError: 'tuple' object does not support item
assignment
 Secvențe 2D - zip
Două liste sau două tuple pot fi combinate într-o listă de tuple folosind
funcția zip():

>>> a = [1,2,3,4,5]
>>> b = [10,20,30,40,50]
>>> c = zip(a,b)
>>> c
<zip object at 0x106b68388>
>>> d = list(c)
>>> d
[(1,10),(2,20),(3,30),(4,40),(5,50)]
 Temă
• Construiti o lista formată din perechi (nume, varsta) De exemplu [(‘Ion’, 45), (‘Dana’, 32), …]
• Folosiți funcțiile referitoare la listă
• Listati sub forma unui tabel:
Nume Varsta
Ion 45

• Construiti o lista de liste cu elemente de forma [tara, continent, suprafata, populatie]:

tari = [[‘Romania’, ‘Europa’, 250000, 19500000],…]

• Creati un tabel
Tara Continent Nr. Locuitori
==============================
 Strings
Pe lângă secvențele imutabile tuple și range, Python mai
implementează două secvențe imutabile:
Bytes : 8 biți de 0 și 1 - adică un întreg între 0 = 00000000 și 255 =
11111111). Versiunea mutabilă este tabloul de biți.

Strings: șir de caractere = text

Python nu are tipul caracter (ca alte limbaje); un caracter este un șir
de lungime 1.
 Strings
Dacă un string se schimbă, cel vechi se distruge și se construiește unul nou.
Nu pot fi modificate componentele unui string (este imutabil):
>>> a = "hello world"
>>> a
'hello world'
>>> a = "hello globe"
>>> a
'hello globe'
>>> a[6]
'g'
>>> a = str(2345)
>>> a[1]
'3'
>>> a[0] = 'm'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
 Strings
Caracterele unui string sunt cuprinse între:
Apostrof 'content'
Ghilimele "content"
în cazul când sunt scrise pe un singur rând, sau:
Trei apostroafe: '''content'''
Trei ghilimele: """content"""
dacă sunt scrise pe mai multe rânduri

>>> print('''Facultatea
... de
... Geografie''')
Facultatea
de
Geografie
>>> print(“Facultatea " +
... 'de '+
... "Geografie")
Facultatea de Geografie
 Concatenare
Concatenarea șirurilor se realizează cu operatorul +:

>>> a = "hello" + "world"

>>> a = "hello" "world" # "+" este optional doar pentru literali
>>> a
'helloworld'

Adăugare de spații:
>>> a = "hello " + "world"
>>> a = "hello" + " " + “world"

Pentru variabile este obligatoriu "+"

>>> h= "hello"
>>> a = h + "world"
 Divizare (Split)
Stringurile pot fi divizate cu funcția split (rezultatul este o listă):
a = str.split(string, delimiter)
a = some_string.split(delimiter)
Exemple:
>>> a = "Facultatea de Geografie, Master Geomatica"
>>> b = str.split(a) # delimitatorul este implicit spațiu
>>> b
['Facultatea', 'de', 'Geografie,', 'Master', 'Geomatica']
>>> x = "ala bala portocala"
>>> y = str.split(x, 'a')
>>> y
['', 'l', ' b', 'l', ' portoc', 'l', '']
>>> z = str.split(x, "bala")
>>> z
['ala ', ' portocala’]
>>> u = x.split()
>>> u
['ala', 'bala', 'portocala']
 Căutare și Înlocuire
str.startswith(strA, start, end) Se verifică dacă un string începe/se termină cu strA.
str.endswith(suffix, start, end) start și end opționale (implicit 0 și lungimea șirului).

str.find(strA, start, end) Indexul poziției lui strA în string, -1 dacă nu este găsit.
str.index(strA, start, end) Același lucru cu mesaj de eroare în loc de -1.
rfind și rindex Același lucru de la sfârșit la început

Dacă strA este găsit poate fi utilizat:

strB = strA[index1:index2]

lstrip(str)/rstrip(str) Elimină spațiile goale de la stânga/dreapta

strip([chars]) Elimină spațiile goale de la stânga și dreapta
str.replace(substringA, substringB, int) Înlocuiește substringul A cu B.
int este opțional - numărul de înlocuiri.

https://docs.python.org/3/library/stdtypes.html#string-methods
 Exemple
>>> a = "Facultatea de Geografie, Master Geomatica”
>>> a.startswith('F')
True
>>> a.startswith('F', 0, 10)
True
>>> a.startswith('G', 0, 20)
False
>>> a = "Facultatea de Geografie"
>>> a.startswith("Fac")
True
>>> a.startswith("Fac", 6, 20)
False
>>> a.startswith("cult", 2)
True
>>> a.endswith("cult", 2)
False
>>> a.endswith("cult", 0, 5 )
False
>>> a.endswith("afie")
True
>>> a.endswith("tea", 0,9)
False
>>> a.endswith("tea", 0,8)
False
>>> a.endswith("tea", 0,10)
True
 Exemple
>>> a.find('a')
1
>>> a.find('a',6,20)
6
>>> a.index('a',6,20)
6
>>> a.find('+',6,20)
-1
>>> a.index('+',6,20)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> x = ' Master Geomatica '
>>> x.lstrip()
'Master Geomatica '
>>> x.rstrip()
' Master Geomatica'
>>> x.strip()
'Master Geomatica'
>>> x
' Master Geomatica '
>>> x.strip('matica')
' Master Geomatica '
>>> x.strip('Geomatica')
' Master Geomatica '
>>> y = x.strip()
>>> y
'Master Geomatica'
>>> y.lstrip('Mas')
'ter Geomatica'
>>> y.rstrip('Geomatica')
'Master '
 Caractere “escape”
>>> a = "Cifrele în baza 2 sunt "zero" și "unu""
File "<stdin>", line 1
a = "Cifrele în baza 2 sunt "zero" și "unu""
^
SyntaxError: invalid syntax
>>> a = "Cifrele în baza 2 sunt \"zero\" și \"unu\""
>>> a
'Cifrele în baza 2 sunt "zero" și “unu"'

>>> b = ''Dan', 'Dana', 'Ion', 'Ioana''

File "<stdin>", line 1
b = ''Dan', 'Dana', 'Ion', 'Ioana''
^
SyntaxError: invalid syntax
>>> b = '\'Dan\', \'Dana\', \'Ion\', \'Ioana\''
>>> b
"'Dan', 'Dana', 'Ion', 'Ioana'"
 Escape characters
\newline Backslash and newline ignored
\\ Backslash (\)
\' Single quote (')
\" Double quote (")
\b ASCII Backspace (BS)
\f ASCII Formfeed (FF)
\n ASCII Linefeed (LF)
\r ASCII Carriage Return (CR)
\t ASCII Horizontal Tab (TAB)
\ooo Character with octal value ooo
\xhh Character with hex value hh
\N{name} Character named name in the Unicode database
\uxxxx Character with 16-bit hex value xxxx
\Uxxxxxxxx Character with 32-bit hex value xxxxxxxx
 Print
Comanda print inserează spații atunci când argumentele sunt despărțite prin virgulă:
>>> print ("a","b","c")
a b c
>>> print(10,20,30)
10 20 30
>>>

Implicit print se termină cu newline (se trece la o linie nouă). Pentru altceva se folosește end
=…

>>> print ("a", end=",")

a,>>>

În scripturi:
print ("a", end=",")
print ("b", end=",")
print ("c")

a,b,c
 Print cu format
Pentru formatare există mai multe variante:
https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting

>>> a='Bob'
>>> b=75
>>> print( "{0} are: {1:10.2f} kilograme”.format(a,b)) # 0 = a 1 = b
Bob are: 75.00 kilograme

>>> # se substituie 0,1,.. cu %(a), %(b) și caracterele de conversie

>>> print('%(a)s are %(b)10.2f kilograme. '%{'a':"Bob", 'b':75.89})
Bob are 75.89 kilograme.
 Templeturi de formatare

Se construiește un template de formatare în care sunt substituite

variabilele:

>>> from string import Template

>>> t = Template('${a} are: $b Kilograme.')
>>> t.substitute(a='Bob', b=75.504)
'Bob are: 75.504 Kilograme.'

https://docs.python.org/3/tutorial/stdlib2.html#templating
 Șiruri de formatare
>>> a='Bob'
>>> b=75.45378
>>> f"{a} are: {b:8.3} Kilograme."
'Bob are: 75.5 Kilograme.'
>>> f"{a} are: {b:10.3} Kilograme."
'Bob are: 75.5 Kilograme.'
>>> b
75.45378
>>> b=4.6489
>>> f"{a} are: {b:10.3} Kilograme."
'Bob are: 4.65 Kilograme.’

https://docs.python.org/3/reference/lexical_analysis.html#f-strings
 str.format
https://docs.python.org/3/reference/lexical_analysis.html#f-strings
>>> a = "Bob"
>>> b = 4.6489
>>> print( "{0} are: {1:10.2f} Kilograme".format(a,b) )
Bob are: 4.65 Kilograme

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')

'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
 str.format
Accesarea argumentelor prin nume:
>>> 'Coordonate: {lat}, {long}'.format(lat='37.24N', long='-115.81W')
'Coordonate: 37.24N, -115.81W’

>>> coord = {'lat': '37.24N', 'long': '-115.81W'}

>>> 'Coordonate: {lat}, {long}'.format(**coord)
'Coordonate: 37.24N, -115.81W'

Accesarea argumentelor prin atribute:

>>> c = 3-5j
>>> ('Numărul complex 3-5j {0} este format din partea reală {0.real} '
... 'și partea imaginară {0.imag}.').format(c)
'Numărul complex (3-5j) este format din partea reală 3.0 și partea
imaginară -5.0.’
 str.format
Alinierea textului relativ la o dimensiune dată:
>>> '{:<30}'.format('left aligned')
'left aligned '
>>> '{:>30}'.format('right aligned’)
' right aligned'
>>> '{:^30}'.format('centered')
' centered '
>>> '{:*^30}'.format('centered') # use '*' as a fill char
'***********centered***********'

Accesarea componentelor unei tuple:

>>> coord = (3, 5)
>>> 'X: {0[0]}; Y: {0[1]}'.format(coord)
'X: 3; Y: 5'
 Exemplu
for i in range(1,11):
for j in range(1,11):
k=i*j
print (k, end=' ')
print()

1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
 Exemplu
for i in range(1,11):
for j in range(1,11):
k=i*j
print ("{0:4d}".format(k), end=' ')
print()

1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
 Mulțimi (Sets)
Mulțimea este o colecție neordonată de obiecte unice.
Tipul set este mutabil dar există și o variantă imutabilă, frozenset:
https://docs.python.org/3/library/stdtypes.html#frozenset

Constructorul:
a = {"red", "green", "blue"}
a = set(some_other_container)

>>> a = set((1,2,3,4))
>>> a
{1, 2, 3, 4}
>>> b = set(range(0,100,20))
>>> b
{0, 40, 80, 20, 60}
>>> z=set({'a','b','c'})
>>> z
{'c', 'a', 'b'}
>>> u = {'a','b','c'}
>>> u
{'c', 'a', 'b'}
 Add/Remove
>>> a = {1,2,3,4}
>>> a.add(8)
>>> a >>> a.discard(10)
{1, 2, 3, 4, 8}
>>> print(a.remove(3)) >>> a.pop()
None 1
>>> a
>>> a
{1, 2, 4, 8}
>>> a.remove(10) {2, 4, 8}
Traceback (most recent call >>> a.clear()
last):
File "<stdin>", line 1, >>> a
in <module> set()
KeyError: 10
 Operatori și Funcții
| or a.union(b) # Reuniune.
& or a.intersection(b) # Intersecție.
- or a.difference(b) # Diferență (elementele lui a ce nu sunt în b).
^ or a.symmetric_difference(b) # Diferența simetrică (Inversa intersecției).
x in a # x este în a ?
x not in a # x nu se află în a?
a <= b or a.issubset(b) # a este submulțime în b?
a < b # a este submulțime proprie în b?
a >= b or a.issuperset(b) # b este submulțime în a?
a > b # b este submulțime proprie în a?
len(a) # numărul de elemente
a.isdisjoint(b) # intersecție vidă?
a.copy() #se crează o copie a lui a

Pentru alte funcții vezi: https://docs.python.org/3/library/stdtypes.html#set

 Mapare
Maparea unei mulțimi de date cu altă mulțime de date astfel încât,
cererea către una din ele o are ca rezultat pe cealaltă.

Clasa corespunzătoare în Python este dict (dicționar; în alte limbaje

este vorba de tablouri asociative sau hashtables)

Dicționarele sunt compuse dintr-o tabelă de chei și valori. Dacă

interoghezi o cheie obții valoarea corespunzătoare.

Exemplu: Cheia = Numele unei persoane, Valoarea = Adresa sa.

Cheile într-un dicționar trebuie să fie unice, obiecte imutabile.

Dicționarele nu sunt ordonate (nu sunt secvențe).
 Dicționare
a = {1:"Person One", 2:"Person Two", 3:"Person 3"}

a = {"one"="Person One", "two"="Person Two"}

a = {} # Empty dictionary.

keys = (1,2,3)
values = ("Person One", "Person Two", "Person 3")
a = dict(zip(keys, values))

a[key] = value # Set a new key and value.

print(a[key]) # Gets a value given a key.
 Funcții
del a[key] # Eliminarea unei chei și valori.
a.clear() # Ștergere.
a.get(key, default) # Obține valoarea, dacă nu există, obțin default.

a.keys() a.values() # Chei, Valori.

a.items() # Perechi (Cheie, Valoare)
list(a.items()) list(a.keys()) list(a.values())

Lista completă a funcțiilor:

https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
 Dicționare
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> a.get('two')
2
>>> a.keys()
dict_keys(['one', 'two', 'three'])
>>> a.values()
dict_values([1, 2, 3])
>>> a.get(‘five’,100)
100
 Funcții
len(dict)
str(dict)
type(variable)

d = {'Name': 'Manni', 'Age': 7, 'Class': 'First'}

>>> len(d)
3
>>> str(d)
"{'Name': 'Manni', 'Age': 7, 'Class': 'First'}”
>>> x=8
>>> type(x)
<class 'int'>
>>> type(d)
<class 'dict'>
 Funcții
dict.clear() Removes all elements of dictionary dict
dict.copy() Returns a shallow copy of dictionary dict
dict.fromkeys() Create a new dictionary with keys from seq and values set to value.

dict.get(key, default=None)
dict.has_key(key)
dict.items()
dict.keys()
dict.update(dict2)
dict.values()
For key key, returns value or default if key not in
dictionary
Returns true if key in dictionary dict, false otherwise
Returns a list of dict's (key, value) tuple pairs
Returns list of dictionary dict's keys
Adds dictionary dict2's key-values pairs to dict
Returns list of dictionary dict’s values
 Temă
Construiți o agendă telefonică folosind:
O listă
Un dicționar

Adăugați/ștergeți intrări din agendă

Listați agenda sub formă de tabel (nume nr.telefon)
Verificați dacă un anumit nume există in agenda
Gasiți numărul de telefon pentru o anumită persoană sub formă de dialog:
Dați numele persoanei:….
Se introduce numele
Se obține numărul de telefon sau mesajul că persoana nu este în agendă