Drill

Вы можете создать класс, который будет хранить состояние ресурсов и предоставлять к нему доступ через свойства или методы. Вам может потребоваться реализовать синглтон-паттерн, чтобы обеспечить, что экземпляр этого класса существует только в одном экземпляре на всем протяжении существования приложения. Также вам может потребоваться защитить состояние ресурсов от неправильного использования, реализовав некоторые методы для доступа к ресурсам.

В качестве примера:

from threading import Lock

class ResourceContainer:
    _instance = None
    _lock = Lock()

    def __new__(cls):
        with cls._lock:
            if cls._instance is None:
                cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        self._db_connection = None
        self._message_broker_connection = None
        self._config = {}

    def get_db_connection(self):
        return self._db_connection

    def set_db_connection(self, connection):
        self._db_connection = connection

    def get_message_broker_connection(self):
        return self._message_broker_connection

    def set_message_broker_connection(self, connection):
        self._message_broker_connection = connection

    def get_config(self):
        return self._config

    def set_config(self, config):
        self._config = config

В этом примере создается класс ResourceContainer, который реализует синглтон-паттерн с помощью метода __new__ и мьютекса _lock. Он хранит состояние ресурсов (подключение к БД, подключение к брокеру сообщений, конфигурация) и предоставляет к ним доступ через методы get_* и set_*.

Другие модули или функции могут получить доступ к экземпляру ResourceContainer так:

def foo():
    container = ResourceContainer()
    db_conn = container.get_db_connection()
    # use db_conn

def bar():
    container = ResourceContainer()
    config = container.get_config()
    # use config

Обратите внимание, что каждый раз при вызове ResourceContainer() будет возвращаться один и тот же экземпляр, таким образом состояние ресурсов будет сохраняться на всем протяжении существования приложения.

Вывести в консоль?
Ну я бы подходил к этому так.
1. Преобразовать все выводимые данные в строки и разбить их по переносам строки.
2. Определить наибольшую ширину каждого столбца с учётом переносов строки. Для каждой ячейки вычисляем наибольшую ширину строки, потом ищем максимум по столбцу. Можно добавить 1-2 символа как "поля", если надо.
3. При выводе строки, выводим строки ячеек вместе, используя itertools.zip_longest(). Т.е. сначала первую строку в каждой ячейке, потом вторую, и т.д. Если получили вместо одной из строк None, значит в этой ячейке строки уже закончились - выводим пробелы.
Ширину вывода каждой ячейки мы знаем из пункта 2, выровнять значение пробелами - тривиально.

# -*- coding: utf-8 -*-
import typing as t
import itertools

def print_table(headers: t.Dict[str, str], data: t.Iterable[t.Dict[str, str]]) -> None:
    keys: t.List[str] = list(headers.keys()) #список ключей в таблице - чтобы сохранять порядок столбцов
    split_data: t.List[t.Dict[str, t.List[str]]] = [] #ячейки, разбитые на строки
    max_widths: t.Dict[str, int] = { key:len(value) for key,value in headers.items() } #ширина каждого столбца в таблице
    for line in data:
        #разбиваем ячейки строки на текстовые строки по \n
        split_line: t.Dict[str, t.List[str]] = { key:value.splitlines() for key,value in line.items() }
        #обновляем ширину столбцов, если надо
        for key in keys:
            new_width = max(map(len, split_line.get(key, [''])))
            if new_width > max_widths[key]:
                max_widths[key] = new_width
        split_data.append(split_line)
    #выводим заголовки
    for key in keys:
        print(f'{{0:<{max_widths[key]}}}'.format(headers[key]), end='|') #можно вместо | поставить пробел
    print()
    print( '+'.join('-'*v for v in max_widths.values()) + '|') #разделитель заголовка и тела таблицы
    #выводим строки таблицы
    for row in split_data:
        for parts in itertools.zip_longest(*(row[key] for key in keys)):
            #parts - кортеж, где каждый элемент либо строка в очередной ячейке, либо None
            for key,part in zip(keys, parts):
                #None означает, что в этой ячейке строки текста уже кончились
                print(f'{{0:<{max_widths[key]}}}'.format(part if part is not None else ''), end='|')
            print()
        print( '+'.join('-'*v for v in max_widths.values())  + '|') #разделитель строк, если надо

data = [
    {'ip':'192.168.0.2', 'model':'DES-3200-26', 'uptime': '3d 12:03:05', 'uplink state': '25: up\n26:up', 'uplink err': '0\n11', 'uplink mcast': '24560\n113'},
    {'ip':'192.168.0.2', 'model':'DES-3200-52', 'uptime': '1d 04:00:15', 'uplink state': '49: up\n50:up\n51:down\n52:down', 'uplink err': '10\n1133\n0\n0', 'uplink mcast': '5497812\n3145\n0\n0'},
]
headers = {'ip': 'IP address', 'model': 'Model', 'uptime': 'Uptime', 'uplink state': 'Uplink state', 'uplink err': 'Uplink errors', 'uplink mcast': 'Uplink M-cast'}
print_table(headers, data)

IP address |Model      |Uptime     |Uplink state|Uplink errors|Uplink M-cast|
-----------+-----------+-----------+------------+-------------+-------------|
192.168.0.2|DES-3200-26|3d 12:03:05|25: up      |0            |24560        |
           |           |           |26:up       |11           |113          |
-----------+-----------+-----------+------------+-------------+-------------|
192.168.0.2|DES-3200-52|1d 04:00:15|49: up      |10           |5497812      |
           |           |           |50:up       |1133         |3145         |
           |           |           |51:down     |0            |0            |
           |           |           |52:down     |0            |0            |
-----------+-----------+-----------+------------+-------------+-------------|

Для того, чтобы вы задали себе этот вопрос и открыли для себя пользу учебников. Целая глава посвящена вопросу!

Либо человек способен учиться по учебникам, либо не способен быть программистом.

Перефразирую - нужно удалить из списка все элементы, для которых существует хотя бы один другой элемент с совпадающими N последними символами. Так?
Используй collections.Counter.

l1 = ['Ивановы', 'Петровы', 'Сидоровы', 'Груши', 'Яблоки', 'Стол', 'Машина', 'Лампа', '940345']
N = 2
suffixes = collections.Counter( item[-N:] for item in l1 )
l2 = list( filter( lambda item: suffixes[item[-N:]] <= 1, l1 ) )

легко и просто, в питоне есть как распаковка кортежей, что собственно и происходит
получается примерно так:

{}[()] = 0
word = 'what

также в питоне ключем в словаре может быть любой объект от которого можно взять hash, поэтому
сначала {} - создается словарь, потом в этот созданный словарь с ключом () - кортеж идет присваивание данных

но так писать не стоит

ну вообще, писавший этот код, вероятно не очень здоров
для начала предлагаю разобраться с деструктуризацией

если вы напишите
a,b = 2,3
то в переменной a окажется значение 2
а в переменной b -- значение 3

это же можно использовать в циклах:

words = [(0,'What'),(1,'the'),(2,'heck?')]
for key,word in words:
    print('key:', key)
    print('word:', word)
    print()

вывод:

key: 0
word: What

key: 1
word: the

key: 2
word: heck?

если же при разборе кортежа, какой-то элемент вам не нужет, то можно просто использовать нижнее подчёркивание

words = [(0,'What'),(1,'the'),(2,'heck?')]

for _,word in words:
    print(word)

Но автор вашего примера решил сделать нечто странное:
{} -- создание пустого dict
[()] -- присвоение в него по ключу "пустой кортеж" значения

учитывая, что исходный dict никуда не сохраняется, это можно считать отчисткой, только вот зачем?

a = {}
a[()] = 5
print(a)

{(): 5}

max_number = float('-inf')
[(max_number := i) for i in map(int, input().split(',')) if i > max_number]

count = {}

for n in sum([ m[::2] for m in arr ], []):
  count[n] = count.get(n, 0) + 1

def sum_items(arr):
  result = {}

  for item in arr:
    v, k = int(item[:-1]), item[-1]
    result[k] = result.get(k, 0) + v

  return [ str(v) + k for k, v in result.items() ]

Может, как-то так?

items = [
    ["item1", 30],
    ["item2", 20],
    ["item3", 50]
]
weights = [i[1] for i in items]
rand_items = random.choices(items, weights=weights, k=1)[0]
print(rand_items)

Проблема из-за условия проверки
if ord(text[i + j]) - ord(elems[-1][-1]) < 2
в условии последовательности требуется, чтобы последующая буква была не меньше предыдущей, не понятно, с чего Вы вдруг такое условие написали.

Вообще нет надобности сохранять куда-то сами последовательности, тем более, что требуется только первую из самых длинных. Как можно это сделать:
Проходим по символам последовательности и проверяем, стал ли ord() текущего символа меньше предыдущего. Если стал, то последовательность закончилась. Проверяем, не стала ли эта последовательность больше предыдущей. Если да, обновляем данные максимальной последовательности (стартовую позицию и длину).
В противном случае переходим к следующему.
Примерно так:

itertools.compress

d3 = list(compress(d2, d1))

Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many try and except statements. The technique contrasts with the LBYL style common to many other languages such as C.

https://docs.python.org/3/glossary.html

def generate(sequence, group_by=5, func=sum):
    for group in zip(*[iter(sequence)]*group_by):
        yield from group
        yield func(group)
        
print(*generate(a))