Python proqramlaşdırma dilində verilənlər tipindən biri də lüğət (dict) tipidir. Lüğətlər – nizamlanmamış və açar ilə müraciət edilə bilən ixtiyari obyektlər yığımıdır. Bəzən lüğətləri assosiativ massivlər və ya heş-cədvəllər də adlandırırlar. Lüğətlərin elementləri açar: qiymət cütlərindən ibarət olub vergüllə ayrılırlar. Lüğətin özü isə fiqurli mötərizə {} daxilində göstərilir. Qeyd etmək lazımdır ki, açarlar dəyişməyən tipdə (sətir, ədəd və ya kortej kimi) və unikal olmalıdırlar, qiymətlər isə istənilən tipdə olub təkrarlana bilər.
Lüğətlər müxtəlif üsullarla konstruksiya edilə bilər.

Literal vasitəsilə:

>>> d = {'bir': 1, 'on': 10, 'yüz': 100, 'min': 1000}
>>> d
{'yüz': 100, 'min': 1000, 'on': 10, 'bir': 1}
>>> e = {}
>>> e
{}
>>

dict() konstruktoru vasitəsilə:

>>> a = dict(short = 'dict', long = 'dictionary')
>>> a
{'short': 'dict', 'long': 'dictionary'}
>>> b = dict([(1, 1), (2, 4)])
>>> b
{1: 1, 2: 4}
>>> c = dict({'üç': 3, 'bir': 1, 'iki': 2})
>>> c
{'bir': 1, 'üç': 3, 'iki': 2}
>>>

fromkeys() metodu vasitəsilə:

>>> d = dict.fromkeys(['a', 'b'])
>>> d
{'a': None, 'b': None}
>>> d = dict.fromkeys(['a', 'b'], 100)
>>> d
{'a': 100, 'b': 100}
>>>

Burada None qiyməti NoneType tipinin yeganə qiymətidir. Ondan default (susmaya görə) arqumentlərin funksiyaya ötürülmədiyi zaman qiymətin yoxluğunu ifadə etmək üçün istifadə olunur.

Lüğət generatoru vasitəsilə

>>> d = {a: a**2 for a in range(6)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
>>>

Yuxarıdakı proqram kodu (lüğət generatoru) daha yığcamdır. Halbuki biz aşağıdakı variantdan da istifadə edə bilərdik:

>>> d = {}
>>> for a in range(6):
	 d[a] = a**2
	
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
>>>

Burada bir məqamı da göstərmək lazımdır ki, lüğət generatorundan istifadə etdiyimiz zaman istəyə uyğun olaraq, if operatorunu da işlədə bilərik:

>>> d = {a: a**2 for a in range(10) if a % 2 == 1}
>>> d
{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
>>> 

Lüğətlər nizamlanmamış elementlər toplusu olduğundan ardıcıllıq tiplərindəki indeksləmə, dilimləmə və s. kimi əməliyyatlar onlar üçün keçərli deyil.
Lüğətlərin uzunluğunu len() funksiyası ilə müəyyən etmək mümkündür. Verilmiş açarın lüğətə daxil olub-olmadığını isə üzvlük operatorları (in və not in) vasitəsilə yoxlamaq olar. Unutmayın ki, üzvlük yoxlaması qiymətlər üçün deyil, yalnız açarlar üçün tətbiq edilə bilər. Lüğətlərdən isə for sayğaclı dövründə qiymətlər çoxluğu kimi istifadə oluna bilər.

Aşağıdakı cədvəldə lüğət tipi ilə bağlı bir sıra metodlar verilmişdir:

Lüğətin elementlərinə açarlar vasitəsilə müraciət etmək mümkündür. Bunun üçün açarı ya [] daxilində, ya da get() funksiyası ilə vermək lazımdır:

>>> az_north = {'Xızı': '29', 'Siyəzən': '53', 'Şabran': '97', 'Xaçmaz': '27', 'Quba': '40'}
>>> az_north['Quba']
'40'
>>> az_north.get('Xaçmaz')
'27'
>>> az_north.get('Bakı')
>>> az_north.get('Bakı', 'Şimal bölgəsi deyil.')
'Şimal bölgəsi deyil.'
>>>

Lüğətin elementlərini dəyişmək və eləcə də yenilərini əlavə etmək mümkündür. Göstərilən açar lüğətdə mövcuddursa, onun qiyməti yenilənmiş olacaq. Əks halda, lüğətə yeni element (açar və qiyməti) əlavə olunacaq:

>>> az_north = {'Xızı': '29', 'Siyəzən': '53', 'Şabran': '97', 'Xaçmaz': '27', 'Quba': '40'}
>>> az_north['Şabran'] = '17'
>>> az_north['Qusar'] = '38'
>>> az_north	
{'Qusar': '38', 'Xaçmaz': '27', 'Siyəzən': '53', 'Şabran': '17', 'Xızı': '29', 'Quba': '40'}
>>> 

fromkeys() metodu ilə yeni bir lüğətin düzəldilməsi:

>>> d = dict.fromkeys(['Azərbaycan', 'Türkiyə'])
>>> d
{'Azərbaycan': None, 'Türkiyə': None}
>>> d = dict.fromkeys(['Azərbaycan', 'Türkiyə'],'Respublika')
>>> d
{'Azərbaycan': 'Respublika', 'Türkiyə': 'Respublika'}
>>>

items(), keys() və values() metodlarının qaytardıqları obyektlər görünüş obyektləri adlanır. Onlar lüğət yazılarını dinamik şəkildə təqdim edir. Başqa sözlə, lüğət dəyişdiyi zaman görünüş obyektləri də bu dəyişiklikləri əks etdirir.

>>> bayraq = {'yaşıl': 'islamiyyət', 'qırmızı': 'çağdaşlıq', 'mavi': 'türkçülük'}
>>> bayraq.items()
dict_items([('mavi', 'türkçülük'), ('yaşıl', 'islamiyyət'), ('qırmızı', 'çağdaşlıq')])
>>> bayraq.keys()
dict_keys(['mavi', 'yaşıl', 'qırmızı'])
>>> bayraq.values()
dict_values(['türkçülük', 'islamiyyət', 'çağdaşlıq'])
>>>

Lüğətin elementlərinin xaric olunması və bütövlükdə silinməsi ilə bağlı aşağıdakı misalları nəzərdən keçirin:

>>> d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
>>> d.pop('e', 0)
5
>>> d.pop('f', 0)
0
>>> d
{'c': 3, 'b': 2, 'a': 1, 'd': 4}
>>> d.pop('e')
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    d.pop('e')
KeyError: 'e'
>>>

>>> e = {'a': 1, 'b': 2, 'c': 3}
>>> f = {}
>>> e.popitem()
('c', 3)
>>> e
{'b': 2, 'a': 1}
>>> f.popitem()
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    f.popitem()
KeyError: 'popitem(): dictionary is empty'
>>>

>>> e = {'a': 1, 'b': 2, 'c': 3}
>>> e.clear()
>>> e
{}
>>>

Lüğətin başqa lüğət və ya digər açar/qiymət cütlərinin iterasiyası hesabına yenilənməsi:

>>> x = {'a': 1, 'b': 2, 'c': 3}
>>> y = {'a':10, 'b':20, 'c':30, 'd': 40, 'e':50}
>>> x.update(y)
>>> x.update(f=60, g=70)
>>> x.update([('h', 80),('i', 90),('j', 100)])
>>> x
{'f': 60, 'g': 70, 'b': 20, 'a': 10, 'h': 80, 'c': 30, 'i': 90, 'j': 100, 'd': 40, 'e': 50}
>>>

Lüğətin nüsxəsinin alınması aşağıdakı misalda göstərilmişdir:

>>> x = {'a':1, 'b':2, 'c':3}
>>> y = x.copy()
>>> y
{'a': 1, 'b': 2, 'c': 3}
>>> 

Aşağıdakı misallarda isə setdefault() metodunun istifadəsi göstərilir:

>>> x = {'a': 1, 'b': 2, 'c': 3}
>>> x.setdefault('b')
2
>>> x.setdefault('d', 4)
4
>>> x.setdefault('e')
>>> x
{'a': 1, 'e': None, 'c': 3, 'b': 2, 'd': 4}
>>>  

Çoxluq – nizamlanmamış təkrarlanmayan elementlər toplusudur. Python dilində iki növ çoxluq tipi var: set və frozenset. Bunların arasındakı yeganə fərq ondan ibarətdir ki, set dəyişən, frozenset isə dəyişməyən tipdir. Daha dəqiq desək, set tipindəki elementlər toplusunu dəyişmək (yeni element əlavə etmək və çıxarmaq) mümkündür, frozenset tipində isə bu mümkün deyil.
Çoxluqlar aşağıdakı üsullarla konstruksiya edilə bilər:

>>> {7, 4.44, 'z', "Turan", False}
{False, 'z', 'Turan', 4.44, 7}
>>> st1 = {2, 4, 8, 16}
>>> st2 = set('abcde')
>>> st3 = set({3,6,9})
>>> st4 = set()
>>> fs1 = frozenset('fghij')
>>> fs2 = frozenset({2,4,6,8})
>>> fs3 = frozenset()
>>> type(st1)
<class 'set'>
>>> type(fs1)
<class 'frozenset'>
>>>

Bir-birindən vergüllə (,) ayrılan çoxluğun elementləri müxtəlif tipdə qiymətlərdən ibarət ola bilər. Lakin təcrübədə, adətən, eynitipli elementlərdən istifadə edirlər. Çoxluğun özü isə fiqurlu mötərizə daxilində göstərilir. Çoxluqlar həmçinin set və frozenset konstruksiyaları ilə də verilə və boş da ola bilər. Yuxarıdakı proqramda st4 = set() və fs3 = frozenset() konstruksiyalarıdanboş çoxluqları düzəltmək üçün istifadə olundu. Çalışın ki, boş çoxluğu göstərmək üçün {} konstruksiyasından istifadə etməyəsiniz. Çünki interpretator bu yazılışı çoxluq kimi qəbul etməyəcək.
Çoxluqlar nizamlanmamış elementlər toplusu olduqlarına görə ardıcıllıq tiplərində olan indeksləmə, dilimləmə və s. kimi əməliyyatlar onlar üçün keçərli deyil.
Çoxluqların uzunluğunu len() funksiyası ilə müəyyən etmək mümkündür. Verilmiş qiymətin çoxluğa daxil olub-olmadığını isə üzvlük operatorları (in və not in) vasitəsilə yoxlamaq olar. Çoxluqlardan da for sayğaclı dövründə qiymətlər çoxluğu kimi istifadə oluna bilər.
Aşağıdakı cədvəldə set tipi ilə bağlı bir sıra metodlar verilmişdir:

Aşağıdakı misalları nəzərdən keçirək:

>>> a = {1, 2, 3, 4}
>>> a.add(5)
>>> a
{1, 2, 3, 4, 5}
>>> a.remove(5)
>>> a
{1, 2, 3, 4}
>>> 
>>> a.remove(5)
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    a.remove(5)
KeyError: 5
>>> a.discard(5)
>>> a.pop()
1
>>> a
{2, 3, 4}
>>> a.clear()
>>> a
set()
>>>
>>> a = {1, 2, 3}
>>> b = a.copy()
>>> b
{1, 2, 3}
>>> c = {4, 5}
>>> b.update(c)
>>> b
{1, 2, 3, 4, 5}
>>> d = {4, 5, 6, 7}
>>> e = b.union(d)
>>> e
{1, 2, 3, 4, 5, 6, 7}
>>> f = e.difference(d)
>>> f
{1, 2, 3}
>>> e.difference_update(f)
>>> e
{4, 5, 6, 7}
>>>

>>> a = {1, 2, 3, 4, 5}
>>> b = {4, 5, 6, 7, 8}
>>> a.symmetric_difference(b)
{1, 2, 3, 6, 7, 8}
>>> a.symmetric_difference_update(b)
>>> a
{1, 2, 3, 6, 7, 8}
>>>
>>> a = {1, 2, 3, 4, 5}
>>> b = {4, 5, 6, 7, 8}
>>> a.intersection(b)
{4, 5}
>>> a.intersection_update(b)
>>> a
{4, 5}
>>> c = {1, 2, 3}
>>> a.isdisjoint(c)
True
>>> d = {1, 2}
>>> d.issubset(c)
True
>>> e = {1, 2, 3, 4, 5}
>>> e.issuperset(c)
True
>>>

Yuxarıda sadalanan metodlardan, çoxluqlarda dəyişikliyə gətirib çıxaranlardan başqa, digərləri frozenset tipinə də tətbiq edilə bilər.