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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
### 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}.
|
