### SET - набор неупорядоченная последовательность элементов
Может содержать ТОЛЬКО уникальные элементы !
По сути тот же список, но только с уникальными элементами !

```python
S = {'Moscow', 'Riga', ''Dolgoprudny', 'Piter'}

S.add('Rostov')

if 'Riga' in S :
	print('.......')

for el in S :
	print( el )
```

### DICT - словарь (набор элементов)
ключ : значение (нет уникальных индексов)

```python
D = { 
	'Moscow': 12547,
	'Dolgoprudny': 3562,
	'Piter': 15478 
	'Rostov': 333
}
print(D['Moscow'])
# 12547
 
D['Rostov'] = 756
print(D['Rostov'])
# 756


# с python 3.9 новый оператор слияния словарей
# создается новый словарь:
x = {1: 'qwe', 2: 'ggfd'}
y = {3: 'qwjhgv', 4: 'gfffgfd'}
z = {5: 'q234we', 6: 'gg45fd'}

d = x | y | z
print(d)
```
**Удаление дубликатов в словаре**

Стратегия заключается в преобразовании списка словарей в список кортежей, где кортежи содержат элементы словаря. 
Поскольку кортежи могут быть хешированы, вы можете удалить дубликаты с помощью set(используя здесь понимание множества , более старой альтернативой Python будет set(tuple(d.items()) for d in l)) и после этого заново создать словари из кортежей с помощью dict.
![[telegram-cloud-photo-size-2-5280728042542581828-y.jpg]]

** - можно распаковать словарь
### LIST - список (изменяемый)
Упорядоченная последовательность любых элементов. 
Может содержать ЛЮБЫЕ (даже повторяющиеся - НЕ уникальные) элементы.
Можно изменять, удалять, добавлять. 
```python
A = [1,2,3,4,5]
A = [(1,10),(2,20),(3,30), {'den': 345}]

# копирование списка (создание нового, еще одного):
B = A[:]
B = A.copy()
B = list(A)
```

### TUPLE - кортеж (не изменяемый)
последовательность элементов - ВАЖНА ! 
```python
T = (1, 2, 3, 4, 5)
a, b, *rest = T
*rest, a, b = T

print(T)
print(*T)
print(*T, sep=":", end=" !\n")


def hello_n(name: str, n: int):
     for i in range(n):
	     print('Привет ', name)

hello_n('Алеша', 5)
hello_n('Петя', 4)
vasya = 'Вася', 3
hello_n(*vasya)

########################################################

my_object = {
			 'x': 10,
			 'y': True
}

for item in my_object.items():
	key, value = item
	print(key, value)

for key, value in my_object.items():
	print(key, value)
```

### RANGE - упорядоченная НЕизменяемая последовательность элементов
Обычно используются в циклах. 
```python
my_range = range(20) # до
my_range = range(10, 20) # от : до
my_range = range(10, 20, 3) # от : до : шаг

print(my_range)
# range(10, 20, 3)

print(list(my_range))
# [10, 13, 16, 19]

for n in my_range:
	print(n)
# 10
# 13
# 16
# 19
```

![[Снимок экрана 2024-03-10 в 20.55.05.png]]

### ZIP - встроенная функция

```python
fruits = ['apple', 'banana', 'lime']
quantities = [100, 70, 50]
availabiliti = [True, False, False, True]

fruit_qtys_zip = zip(fruits, quantities, availabiliti)

print(fruit_qtys_zip)

print(type(fruit_qtys_zip))

fruit_qtys_list = list(fruit_qtys_zip)
print(fruit_qtys_list) # создается список кортежей

# fruit_qtys_list = tuple(fruit_qtys_zip)
# print(fruit_qtys_list) # создается список кортежей

# fruit_qtys_list = dict(fruit_qtys_zip)
# print(fruit_qtys_list) # создается список словарей
```

```python
from copy import deepcopy # глубокая копия


info = {
	'name': 'vlapa',
	'is_instructor': True,
	'reviews': []
}


info_deepcopy = info.copy() # deepcopy(info)
info_deepcopy['reviews'].append('Great_course')
info['reviews'].append('Super')

print('\n-1-')
print(info)

print('\n-2-')
print(info_deepcopy)
```

```python
# Фильтрация элементов по типу:
def filter_list(list_to_filter, value_type):
	filtered_list = []
	for element in list_to_filter:
		if type(element) == value_type:
			filtered_list.append(element)

		# Not recomended! Because bool is subclass of int !
		# if isinstance(element, value_type):
		# filtered_list.append(element)

	return filtered_list

  
print(filter_list([35, True, 'abc', 10], int))
print(filter_list([35, True, 'abc', 10], str))
print(filter_list([35, True, 'abc', 10], bool))

################################################
# Фильтрация элементов с помощью <filter>:

def filter_list(list_to_filter, value_type):
	def check_element_type(elem):
		return isinstance(elem, value_type)
	return list(filter(check_element_type, list_to_filter))

res = filter_list([1, 10, 'abc', 5.5], int)
print(res)

################################################
# Фильтрация элементов с помощью <filter> и <lambda>:

def filter_list(list_to_filter, value_type):
	return list(filter(lambda elem: type(elem) is value_type, list_to_filter))

res = filter_list([1, 10, 'abc', 5.5], int)
print(res)
```

**Соединение списка и множества в словарь**

![[telegram-cloud-photo-size-2-5249336126576118394-y.jpg]]

Для соединения списка и множества в словарь можно использовать встроенную функцию `zip()`. Эта функция объединяет элементы нескольких последовательностей (`списков`, множеств, кортежей и т.д.) в кортежи.

Для создания словаря из списков и множеств нужно сначала объединить элементы в кортежи при помощи функции zip(), а затем создать словарь из этих кортежей при помощи функции dict().

`fruit_prices 
будет содержать словарь
`{'apple': 1.20, 'banana': 0.80, 'orange': 1.50}.