Напишите функцию to_dict(lst), которая принимает аргумент в виде списка и возвращает словарь, в котором каждый элемент списка является и ключом и значением. Предполагается, что элементы списка будут соответствовать правилам задания ключей в словарях. 

def to_dict(lst):
    return {element: element for element in lst}

# Тесты
print(to_dict([1, 2, 3, 4]))
print(to_dict(['grey', (2, 17), 3.11, -4]))

{1: 1, 2: 2, 3: 3, 4: 4}
{'grey': 'grey', (2, 17): (2, 17), 3.11: 3.11, -4: -4}

Иван решил создать самый большой словарь в мире. Для этого он придумал функцию biggest_dict(**kwargs), которая принимает неограниченное количество параметров «ключ: значение» и обновляет созданный им словарь my_dict, состоящий всего из одного элемента «first_one» со значением «we can do it». Воссоздайте эту функцию. 

my_dict = {'first_one': 'we can do it'}


def biggest_dict(**kwargs):
    my_dict.update(**kwargs)


biggest_dict(k1=22, k2=31, k3=11, k4=91)
biggest_dict(name='Елена', age=31, weight=61, eyes_color='grey')
print(my_dict)

{'first_one': 'we can do it', 'k1': 22, 'k2': 31, 'k3': 11, 'k4': 91, 'name': 'Елена', 'age': 31, 'weight': 61, 'eyes_color': 'grey'}

Дана строка в виде случайной последовательности чисел от 0 до 9. 

Требуется создать словарь, который в качестве ключей будет принимать данные числа (т. е. ключи будут типом int), а в качестве значений – количество этих чисел в имеющейся последовательности. Для построения словаря создайте функцию count_it(sequence), принимающую строку из цифр. Функция должна возвратить словарь из 3-х самых часто встречаемых чисел.

def count_it(sequence):
    # При помощи генератора создаем словарь, где ключом выступает уникальный элемент строки, а значением - его частота (вычисляется методом count()) 	
    num_frequency = {int(item): sequence.count(item) for item in sequence}

    # Сортируем словарь по значениям в порядке возрастания. Для этого методом items() формируем пары “(ключ, значение)” в виде кортежей по всем элементам словаря. Т. к. нужно сортировать по значениям, берем второй элемент кортежей. В результате получим список из кортежей “(ключ, значение)”
    sorted_num_frequency = sorted(num_frequency.items(), key=lambda element: element[1])

    # Возвращаем последние 3 элемента списка, т. е. кортежи с самыми большими значениями второй компоненты, которые преобразовываем в словарь 
    return dict(sorted_num_frequency[-3:])

# Тесты
print(count_it('1111111111222'))
print(count_it('123456789012133288776655353535353441111'))
print(count_it('007767757744331166554444'))

{1: 10, 2: 3}
{3: 8, 1: 7, 5: 7}
{7: 6, 4: 6, 6: 3}

from collections import Counter


def count_it(sequence):
    return dict(Counter([int(num) for num in sequence]).most_common(3))

# Тесты
print(count_it('1111111111222'))
print(count_it('123456789012133288776655353535353441111'))
print(count_it('007767757744331166554444'))

{1: 10, 2: 3}
{3: 8, 1: 7, 5: 7}
{7: 6, 4: 6, 6: 3}

Создайте словарь с количеством элементов не менее 5-ти. Поменяйте местами первый и последний элемент объекта. Удалите второй элемент. Добавьте в конец ключ «new_key» со значением «new_value». Выведите на печать итоговый словарь. Важно, чтобы словарь остался тем же (имел тот же адрес в памяти).

>>> from collections import OrderedDict
>>> dct = OrderedDict({1: 1, 2: 2, 3: 3, 4: 4, 5: 5})

# Меняем местами первый и последний элементы
>>> first = list(dct.items())[0]
>>> last = list(dct.items())[-1]
>>> dct.move_to_end(key=first[0])
>>> dct.move_to_end(key=last[0], last=False)

# Удаляем второй элемент
>>> second = list(dct.items())[1]
>>> del dct[second[0]]

# Вставляем новый элемент
>>> dct['new_key'] = 'new_value'
>>> my_dict
{5: 5, 3: 3, 4: 4, 1: 1, 'new_key': 'new_value'}
>>> id(my_dict)
17128656
>>> start_dict_id
17128656

Имеется ряд словарей с пересекающимися ключами (значения - положительные числа). Напишите 2 функции, которые делают с массивом словарей следующие операции:
1-ая функция max_dct(*dicts) формирует новый словарь по правилу:

Если в исходных словарях есть повторяющиеся ключи, выбираем среди их значений максимальное и присваиваем этому ключу (например, в словаре_1 есть ключ “а” со значением 5, и в словаре_2 есть ключ “а”, но со значением 9. Выбираем максимальное значение, т. е. 9, и присваиваем ключу “а” в уже новом словаре).  

Если ключ не повторяется, то он просто переносится со своим значением в новый словарь (например, ключ “с” встретился только у одного словаря, а у других его нет. Следовательно, переносим в новый словарь этот ключ вместе с его значением). Сформированный словарь возвращаем.

2-ая функция sum_dct(*dicts) суммирует значения повторяющихся ключей. Значения остальных ключей остаются исходными. (Проводятся операции по аналогу первой функции, но берутся не максимумы, а суммы значений одноименных ключей). Функция возвращает сформированный словарь.

from collections import Counter
from functools import reduce
dict_1 = {1: 12, 2: 33, 3: 10, 4: 10, 5: 2, 6: 90}
dict_2 = {1: 12, 3: 7, 4: 1, 5: 2, 7: 112}
dict_3 = {2: 3, 3: 3, 4: 60, 6: 8, 7: 25, 8: 71}
dict_4 = {3: 1, 4: 13, 5: 31, 9: 9, 10: 556}


def sum_dct(*dicts):
    return dict(reduce(lambda a, b: Counter(a) + Counter(b), dicts))

def max_dct(*dicts):
    return dict(reduce(lambda a, b: Counter(a) | Counter(b), dicts))

# Тесты
print(max_dct(dict_1, dict_2))
print(sum_dct(dict_1, dict_4, dict_3))
print(max_dct(dict_1, dict_2, dict_3, dict_4))
print(sum_dct(dict_1, dict_2, dict_3, dict_4))

{1: 12, 2: 33, 3: 10, 4: 10, 5: 2, 6: 90, 7: 112}
{1: 12, 2: 36, 3: 14, 4: 83, 5: 33, 6: 98, 9: 9, 10: 556, 7: 25, 8: 71}
{1: 12, 2: 33, 3: 10, 4: 60, 5: 31, 6: 90, 7: 112, 8: 71, 9: 9, 10: 556}
{1: 24, 2: 36, 3: 21, 4: 84, 5: 35, 6: 98, 7: 137, 8: 71, 9: 9, 10: 556}

from collections import Counter
from functools import reduce
from operator import or_, add

def sum_dct(*dicts):
    return dict_transformer(*dicts)

def max_dct(*dicts):
    return dict_transformer(*dicts, op=or_)

def dict_transformer(*dicts, op=add):
    return dict(reduce(lambda a, b: op(Counter(a), Counter(b)), dicts))


# Тесты
print(max_dct(dict_1, dict_2))  # Ищем максимум
print(sum_dct(dict_1, dict_4, dict_3))  # Складываем 
print(max_dct(dict_1, dict_2, dict_3, dict_4))  # Ищем максимум
print(sum_dct(dict_1, dict_2, dict_3, dict_4))  # Складываем

{1: 12, 2: 33, 3: 10, 4: 60, 5: 2, 6: 90, 7: 25, 8: 71}
{1: 12, 2: 36, 3: 14, 4: 83, 5: 33, 6: 98, 9: 9, 10: 556, 7: 25, 8: 71}
{1: 12, 2: 33, 3: 10, 4: 60, 5: 31, 6: 90, 7: 112, 8: 71, 9: 9, 10: 556}
{1: 24, 2: 36, 3: 21, 4: 84, 5: 35, 6: 98, 7: 137, 8: 71, 9: 9, 10: 556}