Создайте словарь из списка ключей и значений в Python
В этом посте мы обсудим, как создать словарь из списка ключей и значений в Python.
Например, keys = [‘A’, ‘B’, ‘C’] а также values = [1, 2, 3] должен привести к словарю .
1. Использование zip() с dict() функция
Самый простой и элегантный способ построить словарь из списка ключей и значений — использовать метод zip() функция с конструктором словаря.
if __name__ == ‘__main__’ :
keys = [ ‘A’ , ‘B’ , ‘C’ ]
values = [ 1 , 2 , 3 ]
dictionary = dict ( zip ( keys , values ) )
print ( dictionary ) #
2. Использование словарного понимания
Другой подход заключается в использовании zip() с пониманием словаря. Это часто полезно, когда вам нужны пары ключ-значение вместо пар ключ-значение или вы применяете некоторую функцию сопоставления к каждому ключу или значению. Это может быть реализовано как:
if __name__ == ‘__main__’ :
keys = [ ‘A’ , ‘B’ , ‘C’ ]
values = [ 1 , 2 , 3 ]
dictionary = < k : v for k , v in zip ( keys , values ) >
print ( dictionary ) #
Вот как выглядел бы код без zip() :
if __name__ == ‘__main__’ :
keys = [ ‘A’ , ‘B’ , ‘C’ ]
values = [ 1 , 2 , 3 ]
dictionary = < keys [ i ] : values [ i ] for i in range ( len ( keys ) ) >
print ( dictionary ) #
Если вам нужно создать новый словарь с ключами из iterable с тем же значением, вы можете сделать следующее.
if __name__ == ‘__main__’ :
keys = [ ‘A’ , ‘B’ , ‘C’ ]
dictionary = < key : value for key in keys >
print ( dictionary ) #
В качестве альтернативы вы можете использовать fromkeys() функция класса:
if __name__ == ‘__main__’ :
keys = [ ‘A’ , ‘B’ , ‘C’ ]
dictionary = dict . fromkeys ( keys , value )
print ( dictionary ) #
Это все о создании словаря из списка ключей и значений в Python.
Оценить этот пост
Средний рейтинг 4.96 /5. Подсчет голосов: 25
Голосов пока нет! Будьте первым, кто оценит этот пост.
Сожалеем, что этот пост не оказался для вас полезным!
Расскажите, как мы можем улучшить этот пост?
Спасибо за чтение.
Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.
Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂
Подписывайся
0 Комментарии
Встроенные отзывы
Просмотреть все комментарии
Загрузить больше комментариев
Просматривать
Подпишитесь на новые публикации
- Все проблемы
- Практика DSA
- 100 самых популярных задач
- 50 лучших классических задач
- Лучшие алгоритмы
- Компилятор С/С++
- Компилятор Java
- Компилятор Python
- Компилятор JavaScript
- компилятор PHP
- Компилятор C#
- Свяжитесь с нами
- Политика конфиденциальности
- условия обслуживания
- Подпишитесь на новые публикации
Techie Delight © 2023 Все права защищены.
Этот веб-сайт использует файлы cookie. Используя этот сайт, вы соглашаетесь с использованием файлов cookie, нашей политикой, условиями авторского права и другими условиями. Читайте наши Политика конфиденциальности. Понятно
Списки, словари и множества в Python
У разработчиков типа данных list Python было много вариантов каким сделать его во время реализации. Каждый выбор повлиял на то, как быстро список мог выполнять операции. Одно из решений было сделать список оптимальным для частых операций.
Индексирование и присваивание
Две частые операции — индексирование и присваивание на позицию индекса. В списках Python значения присваиваются и извлекаются из определенных известных мест памяти. Независимо от того, насколько велик список, индексный поиск и присвоение занимают постоянное количество времени и, таким образом их трудоемкость O(1).
Pop, Shift, Delete
Извлечение элемента(pop) из списка Python по умолчанию выполняется с конца, но, передавая индекс, вы можете получить элемент из определенной позиции. Когда pop вызывается с конца, операция имеет сложность O(1) , а вызов pop из любого места — O(n). Откуда такая разница?
Когда элемент берется из середины списка Python, все остальные элементы в списке сдвигаются на одну позицию ближе к началу. Это суровая плата за возможность брать индекс за O(1), что является более частой операцией.
По тем же причинам вставка в индекс — O(N); каждый последующий элемент должен быть сдвинут на одну позицию ближе к концу, чтобы разместить новый элемент. Неудивительно, что удаление ведет себя таким же образом.
Итерирование
Итерирование выполняется за O(N), потому что для итерации по N элементам требуется N шагов. Это также объясняет, почему оператор in, max, min в Python является O(N): чтобы определить, находится ли элемент в списке, мы должны перебирать каждый элемент.
Срезы
Чтобы получить доступ к фрагменту [a: b] списка, мы должны перебрать каждый элемент между индексами a и b. Таким образом, доступ к срезу — O(k), где k — размер среза. Удаление среза O(N) по той же причине, что удаление одного элемента — O(N): N последующих элементов должны быть смещены в сторону начала списка.
Умножение на int
Чтобы понять умножение списка на целое k, вспомним, что конкатенация выполняется за O(M), где M — длина добавленного списка. Из этого следует, что умножение списка равно O(N k), так как умножение k-размера списка N раз потребует времени k (N-1).
Разворот списка
Разворот списка — это O(N), так как мы должны переместить каждый элемент.
2. Множества
Множество (set)
Множество в языке Python — это структура данных, эквивалентная множествам в математике. Элементы могут быть различных типов. Порядок элементов не определён.
Действия, которые можно выполнять с множеством:
- добавлять и удалять элементы,
- проверять принадлежность элемента множеству,
- перебирать его элементы,
- выполнять операции над множествами (объединение, пересечение, разность).
Операция “проверить принадлежность элемента” выполняется в множестве намного быстрее, чем в списке.
Элементами множества может быть любой неизменяемый тип данных: числа, строки, кортежи.
Изменяемые типы данных не могут быть элементами множества, в частности, нельзя сделать элементом множества список (вместо этого используйте неизменяемый кортеж) или другое множество. Требование неизменяемости элементов множества накладывается особенностями представления множества в памяти компьютера.
Задание множеств
Множество задается перечислением в фигурных скобках. Например:
Исключением явлеется пустое множество:
A = set() # A -- множество D = <> # D -- не пустое множество, а пустой словарь!
Если функции set передать в качестве параметра список, строку или кортеж, то она вернет множество, составленное из элементов списка, строки, кортежа. Например:
>>> A = set('qwerty') >>> print(A) .
Каждый элемент может входить в множество только один раз.
>>> A = >>> B = >>> print(A == B) # A и B — равные множества. True >>> set(‘Hello’)
Работа с элементами множеств
| Операция | Значение | Трудоемкость |
|---|---|---|
| x in A | принадлежит ли элемент x множеству A (возвращают значение типа bool ) | O(1) |
| x not in A | то же, что not x in A | O(1) |
| A.add(x) | добавить элемент x в множество A | O(1) |
| A.discard(x) | удалить элемент x из множества A | O(1) |
| A.remove(x) | удалить элемент x из множества A | O(1) |
| A.pop() | удаляет из множества один случайный элемент и возвращает его | O(1) |
Как мы видим, по времени стандартные оперцаии с одним элементом множества выполняются за O(1).
Поведение discard и remove различается тогда, когда удаляемый элемент отсутствует в множестве: discard не делает ничего, а метод remove генерирует исключение KeyError . Метод pop также генерирует исключение KeyError , если множество пусто.
При помощи цикла for можно перебрать все элементы множества:
Primes = for num im Primes: print(num)
Из множества можно сделать список при помощи функции list :
>>> A = >>> B = list(A) [1, 2, 3, 4, 5]
Упражнение №2
Вывести на экран все элементы множества A, которых нет в множестве B.
A = set('bqlpzlkwehrlulsdhfliuywemrlkjhsdlfjhlzxcovt') B = set('zmxcvnboaiyerjhbziuxdytvasenbriutsdvinjhgik') for x in A: .
Операции с множествами, обычные для математики
| Операция | Значение | Трудоемкость |
| A | B A.union(B) |
Возвращает множество, являющееся объединением множеств A и B . | O(len(A)+len(B)) |
| A | = B A.update(B) |
Записывает в A объединение множеств A и B . | O(len(A)+len(B)) |
| A & B A.intersection(B) |
Возвращает множество, являющееся пересечением множеств A и B . | O(min(len(A), len(B)) |
| A &= B A.intersection_update(B) |
Записывает в A пересечение множеств A и B . | O(min(len(A), len(B)) |
| A — B A.difference(B) |
Возвращает разность множеств A и B (элементы, входящие в A, но не входящие в B). | O(len(A)+len(B)) |
| A -= B A.difference_update(B) |
Записывает в A разность множеств A и B . | O(len(A)+len(B)) |
| A ^ B A.symmetric_difference(B) |
Возвращает симметрическую разность множеств A и B (элементы, входящие в A или в B, но не в оба из них одновременно). | O(len(A)+len(B)) |
| A ^= B A.symmetric_difference_update(B) |
Записывает в A симметрическую разность множеств A и B . | O(len(A)+len(B)) |
| A A.issubset(B) | Возвращает True, если A является подмножеством B. | O(len(A)) |
| A >= B A.issuperset(B) |
Возвращает True, если B является подмножеством A. | O(len(B)) |
| A < B | Эквивалентно A | O(len(A)) |
| A > B | Эквивалентно A >= B and A != B | O(len(B)) |
В случае, если нужно провести процедуру, затрагивающую все элементы множества, то его трудоемкость будет O(N).
3. Словари
Словарь (ассоциативный массив, dict)
В массиве или в списке индекс — это целое число. Традиционной является следующая ситуация:
>>> Days = ['Sunday', 'Monday', 'Tuesday', 'Wednessday', 'Thursday', 'Friday', 'Saturday'] >>> Days[0] 'Sunday' >>> Days[1] 'Monday'
А как реализовать обратное соответствие?
>>> Days['Sunday'] 0 >>> Days['Monday'] 1
При помощи списка или массива это сделать невозможно, нужно использовать ассоциативный массив или словарь.
В словаре индекс может быть любого неизменяемого типа! Индексы, как и сами хранимые значения, задаются явно:
Days = < 'Sunday': 0, 'Monday': 1, 'Tuesday': 2, 'Wednessday': 3, 'Thursday': 4, 'Friday': 5, 'Saturday': 6 >>>> Days['Sunday'] 0 >>> Days['Monday'] 1 >>> Days['Yesterday'] Traceback (most recent call last): File "", line 1, in KeyError: 'Yesterday'
При попытке обратиться к несуществующему элементу ассоциативного массива мы получаем исключение KeyError .
Особенностью ассоциативного массива является его динамичность: в него можно добавлять новые элементы с произвольными ключами и удалять уже существующие элементы.
>>> Days['Yesterday'] = -1 >>> print(Days['Yesterday']) -1
При этом размер используемой памяти пропорционален размеру ассоциативного массива. Доступ к элементам ассоциативного массива выполняется хоть и медленнее, чем к обычным массивам, но в целом довольно быстро.
Значения ключей уникальны , двух одинаковых ключей в словаре быть не может. А вот значения могут быть одинаковыми.
>>> Days['Tomorrow'] = -1 >>> Days['Yesterday'] == Days['Tomorrow'] True
Ключом может быть произвольный неизменяемый тип данных: целые и действительные числа, строки, кортежи. Ключом в словаре не может быть множество, но может быть элемент типа frozenset: специальный тип данных, являющийся аналогом типа set, который нельзя изменять после создания. Значением элемента словаря может быть любой тип данных, в том числе и изменяемый.
Создание словаря
Пустой словарь можно создать при помощи функции dict() или пустой пары фигурных скобок <> (вот почему фигурные скобки нельзя использовать для создания пустого множества).
Для создания словаря с некоторым набором начальных значений можно использовать следующие конструкции:
Capitals = Capitals = dict(Russia = 'Moscow', Ukraine = 'Kiev', USA = 'Washington') Capitals = dict([("Russia", "Moscow"), ("Ukraine", "Kiev"), ("USA", "Washington")]) Capitals = dict(zip(["Russia", "Ukraine", "USA"], ["Moscow", "Kiev", "Washington"]))
Также можно использовать генерацию словаря через Dict comprehensions:
Cities = [«Moscow», «Kiev», «Washington»] States = [«Russia», «Ukraine», «USA»] CapitalsOfState =
Это особенно полезно, когда нужно «вывернуть» словарь наизнанку:
StateByCapital =
Операции с элементами словарей
| Операция | Значение | Трудоемкость |
| value = A[key] | Получение элемента по ключу. Если элемента с заданным ключом в словаре нет, то возникает исключение KeyError. | O(1) |
| value = A.get(key) | Получение элемента по ключу. Если элемента в словаре нет, то get возвращает None. | O(1) |
| value = A.get(key, default_value) | То же, но вместо None метод get возвращает default_value. | O(1) |
| key in A | Проверить принадлежность ключа словарю. | O(1) |
| key not in A | То же, что not key in A. | O(1) |
| A[key] = value | Добавление нового элемента в словарь. | O(1) |
| del A[key] | Удаление пары ключ-значение с ключом key. Возбуждает исключение KeyError, если такого ключа нет. | O(1) |
| if key in A: del A[key] | Удаление пары ключ-значение с предварительной проверкой наличия ключа. | O(1) |
| try: del A[key] except KeyError: pass | Удаление пары ключ-значение с перехватыванием и обработкой исключения. | O(1) |
| value = A.pop(key) | Удаление пары ключ-значение с ключом key и возврат значения удаляемого элемента.Если такого ключа нет, то возбуждается KeyError. | O(1) |
| value = A.pop(key, default_value) | То же, но вместо генерации исключения возвращается default_value. | O(1) |
| A.pop(key, None) | Это позволяет проще всего организовать безопасное удаление элемента из словаря. | O(1) |
| len(A) | Возвращает количество пар ключ-значение, хранящихся в словаре. | O(1) |
Перебор элементов словаря по ключу
for key in A: print(key, A[key])
Представления элементов словаря
Представления во многом похожи на списки, но они остаются связанными со своим исходным словарём и изменяются, если менять значения элементов словаря.
- Метод keys возвращает представление ключей всех элементов.
- Метод values возвращает представление всех значений.
- Метод items возвращает представление всех пар (кортежей) из ключей и значений.
>>> A = dict(a='a', b='b', c='c') >>> k = A.keys() >>> v = A.values() >>> k, v (dict_keys(['c', 'b', 'a']), dict_values(['c', 'b', 'a'])) >>> A['d'] = 'a' >>> k, v (dict_keys(['d', 'c', 'b', 'a']), dict_values(['a', 'c', 'b', 'a']))
Учтите что итерироваться по представлениям изменяя словарь нельзя
>>> for key in A.keys(): . del A[key] . Traceback (most recent call last): File "", line 1, in RuntimeError: dictionary changed size during iteration
Можно, если в начале скопировать представление в список
>>> for key in list(A.keys()): . del A[key] . >>> A <>
Пример использования словаря
# Создадим пустой словать Capitals Capitals = dict() # Заполним его несколькими значениями Capitals['Russia'] = 'Moscow' Capitals['Ukraine'] = 'Kiev' Capitals['USA'] = 'Washington' # Считаем название страны print('В какой стране вы живете?') country = input() # Проверим, есть ли такая страна в словаре Capitals if country in Capitals: # Если есть - выведем ее столицу print('Столица вашей страны', Capitals[country]) else: # Запросим название столицы и добавим его в словарь print('Как называется столица вашей страны?') city = input() Capitals[country] = city
Трудоемкость стандартных операций
Второй основной тип данных Python — это словарь. Как вы помните, словарь отличается от списка возможностью доступа к элементам по ключу, а не позиции. На данный момент наиболее важной характеристикой является то, что получение и присваивание элемента в словаре являются операциями за O(1).
Мы не будем пытаться пока дать интуитивное объяснение этому, но будьте уверены, что позже мы обсудим реализации словарей. Пока просто помните, что словари были созданы специально для того, чтобы как можно быстрее получить и установить значения по ключу.
Другая важная операция словаря — проверка наличия ключа в словаре. Операция contains также работает за O(1) (в случае со списками это занимало O(N)), потому что проверка для данного ключа подразумевает простое получение элемента по ключу, которое делается за O(1).
Когда нужно использовать словари
Словари нужно использовать в следующих случаях:
- Подсчет числа каких-то объектов. В этом случае нужно завести словарь, в котором ключами являются объекты, а значениями — их количество.
- Хранение каких-либо данных, связанных с объектом. Ключи — объекты, значения — связанные с ними данные. Например, если нужно по названию месяца определить его порядковый номер, то это можно сделать при помощи словаря Num[‘January’] = 1; Num[‘February’] = 2; .
- Установка соответствия между объектами (например, “родитель—потомок”). Ключ — объект, значение — соответствующий ему объект.
- Если нужен обычный массив, но при этом масимальное значение индекса элемента очень велико, но при этом будут использоваться не все возможные индексы (так называемый “разреженный массив”), то можно использовать ассоциативный массив для экономии памяти.
4. Задача №3768. Контрольная по ударениям
Вариант 1. Используем множество
Вариант 2. Используем словарь
Словари (dict) и работа с ними. Методы словарей
Сегодня я расскажу о таком типе данных, как словари, о работе со словарями, операциях над ними, методах, о генераторах словарей.
Словари в Python — неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.
Чтобы работать со словарём, его нужно создать. Сделать это можно несколькими способами. Во-первых, с помощью литерала:
Во-вторых, с помощью функции dict:
В-третьих, с помощью метода fromkeys:
В-четвертых, с помощью генераторов словарей, которые очень похожи на генераторы списков.
Теперь попробуем добавить записей в словарь и извлечь значения ключей:
: Как видно из примера, присвоение по новому ключу расширяет словарь, присвоение по существующему ключу перезаписывает его, а попытка извлечения несуществующего ключа порождает исключение. Для избежания исключения есть специальный метод (см. ниже), или можно перехватывать исключение.
Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: встроенные функции, ключевые слова (например, циклы for и while), а также специальные методы словарей.
Методы словарей
dict.clear() — очищает словарь.
dict.copy() — возвращает копию словаря.
classmethod dict.fromkeys(seq[, value]) — создает словарь с ключами из seq и значением value (по умолчанию None).
dict.get(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).
dict.items() — возвращает пары (ключ, значение).
dict.keys() — возвращает ключи в словаре.
dict.pop(key[, default]) — удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).
dict.popitem() — удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.
dict.setdefault(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ со значением default (по умолчанию None).
dict.update([other]) — обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).
dict.values() — возвращает значения в словаре.
Для вставки кода на Python в комментарий заключайте его в теги
Словари и методы в Python. Добавление списка в словарь
Словарь в Python — неупорядоченная структура данных, позволяющая хранить пары «ключ-значение». В этой статье вы узнаете, как выглядит словарь, какие используются методы при работе с ним, а также о том, как преобразовать список в словарь.
Словарь (dictionary) в Python используется наряду с кортежами и списками, похожие структуры есть и в других языках программирования (ассоциативный массив в PHP, словарь в C#).
Словарь, как и список, хранит коллекцию элементов. И каждый элемент в словаре, как было уже упомянуто, имеет уникальный ключ — с ним ассоциировано какое-либо значение.
Вот синтаксис словаря в Python:
dictionary =
А вот ещё пример словаря:
dictionary =
Вышописанный словарь использует в качестве ключей строки. Но ключом может быть и другой неизменяемый тип данных, а значением конкретного ключа — что угодно. Давайте посмотрим на словарь, где ключи — это числа, а значения — это строки:
gender_dict =
Примечание: если будете применять в качестве ключа изменяемый тип данных (правильнее сказать, нехэшируемый, хотя обычно это одно и то же), то на выходе будет ошибка:
dictionary =
Получаем данные из словаря
Чтобы получить значения конкретного ключа используют квадратные скобки [] . Представим, что у нас в словаре присутствует пара «марафон»: 26.
# берём значение с ключом «марафон» dictionary['марафон']Но если вы захотите получить значение, используя не существующий ключ, будет ошибка. Чтобы избежать ошибок, применяют методы.
Как добавлять и обновлять ключи
Добавление в словарь новых пар выполняется просто:
# Добавляем ключ «туфля» со значением «род обуви, который закрывает ногу не выше щиколотки» dictionary['туфля'] = 'род обуви, который закрывает ногу не выше щиколотки'Для обновления делаем то же самое:
# Обновляем ключ "туфля" и присваиваем ему значение "хорошая туфля" dictionary['туфля'] = 'хорошая туфля'Как удалять ключи
Чтобы удалить ключ и соответствующее значение из словаря, используем del:
# Удаляем значение с ключом "противостоять" из словаря del dictionary['противостоять']Методы
Cловари имеют много полезных методов, помогающих в работе. Рассмотрим наиболее популярные.
Update
Метод update() нужен при объявлении нескольких пар одновременно. В качестве аргумента метод принимает другой словарь:
# Добавляем две пары в словарь dictionary, используя метод update dictionary.update() >>> dictionary
Возможно, вы спросите, почему в словаре данные расположены в другом порядке, а не в том, в котором были в него внесены. Ответ прост — словари не упорядочены.
Get
# Представьте, что у нас есть словарь story_count story_count =
get() возвратит значение по указанному ключу. А если его нет, то метод вернёт нам None .
# Ключ "двенадцать" существует и метод get в данном случае вернёт 12 story_count.get('двенадцать')Способ используют при проверке, а есть ли ключи в словаре:
>>> story_count.get('два') NoneКроме того, вы можете указать значение по умолчанию — оно вернётся вместо None , если ключа не будет в словаре:
# Метод вернёт 0 в случае, если данного ключа не существует story_count.get('два', 0)Pop
Метод pop() служит для удаления ключа и возвращения соответствующего ему значения.
>>> story_count.pop('девяносто') 90 >>> story_count
Keys
Метод keys() необходим, чтобы возвратить коллекцию ключей в словаре:
>>> story_count.keys() ['сто', 'пять', 'двенадцать']Values
Возвратит коллекцию значений в словаре.
>>> story_count.values() [100, 12, 5]Items
Если нужно вернуть пары «ключ — значение», используют items() :
>>> dictionary.items() [('персона', 'человек'), ('бежать', 'двигаться со скоростью'), ('туфля', 'род обуви, закрывающей ногу не выше щиколотки'), ('бежал', 'бежать в прошедшем времени'), ('марафон', 'гонка бегунов длиной около 26 миль'), ('туфли', 'туфля во множественном числе')]Итерация через словарь
В «Питоне» есть возможность выполнить итерацию в словаре по каждому ключу:
for key in story_count: print(key)Кстати, вместо story_count можно применять story_count.keys() .
Внимательно посмотрите на участок кода ниже: в нём цикл for использует метод items() , чтобы получить пары «ключ — значение» на каждую итерацию:
>>> for key, value in dictionary.items(): print(key, value) ('персона', 'человек') ('бежать', 'двигаться со скоростью') ('туфля', 'род обуви, закрывающей ногу не выше щиколотки') ('бежал', 'бежать в прошедшем времени') ('марафон', 'гонка бегунов длиной около 26 миль') ('туфли', 'туфля во множественном числе')Словарь и список: выполнение преобразования из списка в словарь
Словарь (dictionary) и список (list) — типы, непохожие по своей структуре. Однако для отдельных видов списка есть возможность преобразования списка в словарь. Для этого используют встроенную функцию dict() . Необходимо, чтобы список хранил набор вложенных списков. Также нужно, чтобы каждый вложенный список состоял из 2-х элементов. В результате во время конвертации списка в словарь 1-й элемент превратится в ключ, 2-й — в значение:
users_list = [ ["+111123455", "Tom"], ["+384767557", "Bob"], ["+958758767", "Alice"] ] users_dict = dict(users_list) print(users_dict) #
Таким же образом возможно преобразование в словарь не только списка, но и двухмерных кортежей:
users_tuple = ( ("+111123455", "Tom"), ("+384767557", "Bob"), ("+958758767", "Alice") ) users_dict = dict(users_tuple) print(users_dict)
Материал подготовлен специально для OTUS на основании статьи «Python Dictionary and Dictionary Methods».
