Максим Припадчев

Ошибка детская, она вот в этом: "Есть 2 таблицы, в которых одинаковые поля".
Очень часто новички, которые не понимают, как работает база данных, делают подобное.
И всегда потом приходится переделывать, даже если очень не хочется.
Потому что в БД не должно быть таблиц с одинаковыми полями. Собственно, сообразительные новички уже на этом вопросе, "как выбрать из двух таблиц" начинают понимать, что у них что-то пошло не так.

Так что надо просто сделать одну таблицу, записать в неё данные из всех таблиц с одинаковыми полями, и выбирать из неё обычным способом.

Имя таблицы, кстати, тоже очень странное. Наверняка там внутри тоже треш и угар и вот её-то как раз и надо разделить, только не горизонтально, а вертикально. Судя по составу полей, нужна одна таблица city и одна таблица people, в которой указывается только city id

Это значит, что переменная block пустая. Т.е. ваш soup.find ничего не нашел.

сложно себя заставить начать или читать продолжительное время

Воля развивается только тренировкой.

Была хорошая рекомендация включать хорошо знакомый сериал в новом окне/на втором мониторе параллельно с обучением.

Это плохая рекомендация. Вы снизите концентрацию и либо станет ещё сложнее изучать, либо сформируется иллюзия компетентности.

Алгоритм называется "обход в глубину на графе". Работает за линию, все очень быстро. Правда, его придется применить несколько раз.

Все неравенства "==" замените на пару "<=" и ">=".
Добавьте неравенства 1 < 2, 3 < 4 и т.д. для каждой пары соседних на числовой прямой чисел во входных данных

Постройте граф: Каждой переменной и уникальному числу во входных данных сопоставьте одну вершину. Проведите для каждого неравнества ребро от меньшей вершины к большей, раскрашенное в 2 цвета: черный, если неравнество нестрогое (<=), белый - иначе.

Теперь, если в этом графе нет циклов, содержащих белые ребра (строгие неравенства) - то противоречий нет: Все циклы целиком из черных ребер означают, что все вершины имеют одинаковое значение. Можно эти вершины все объединить в одну новую. Раз белые ребра (<) циклов не образуют, то получившийся граф будет ациклическим и можно назначить всем вершинам какие-то числовые значения, удовлетворяющие условиям. Проблема может еще быть, что нет целых решений вроде 1== a < b < c == 2, но это можно потом проверить в топологической сортировке жадно назначая всем вершинам числа. Или противоречия вида 2==3. Тоже решается после получения компонент связности.

Итак, алгоритм: найдите в этом графе компоненты сильной связности. Потом проверьте все ребра. Если белое ребро (строгое неравнество) имеет оба конца в одной и той же компоненте - вы нашли противоречие.

Теперь надо постараться назначить кадой компоненте числовое значение так, чтобы не было противоречий. Это можно делать жадно, назначая каждой компоненте минимально возможное значение.

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

В конце вы получите для каждой компоненты ее численное значение без каких-либо противоречий.

2147483647 = 2³¹ - 1
Это максимальное 32-битное целое число со знаком.
Если вам нужно что-то большее, то используйте не число, а строку.

create temp table import_data (...);
copy import_data from '/path/to/file' (format csv, ...);
insert into tablename (...) select .. from import_data where not exists (select from tablename where tablename.phone = import_data.phone) on conflict do nothing;

Потому что переменная цикла может быть не определена за пределами цикла. Либо используйте её в пределах тела цикла, либо определяйте за его пределами.

Это называется "доступ по API".
Вместо прямого соединения с БД, "скрипт" отправляет запросы на удаленный веб-сервер, причем не SQL запрос, а какой-нибудь JSON. А уже приложение на веб-сервере соединяется с БД и отправляет запрошенные данные назад.
Это приложение будет и ключ проверять, и права доступа - какому пользователю какие данные можно отдавать.
Именно по такой схеме например работают мобильные приложения в вашем телефоне.

Случай, когда у вас динамически добавляются новые строки, но все они фиксированной длины - редок. Да и в этом случае можно завести vector из array'ов. Ничего городить нового, тем более в стандартах, не надо.

Если же добавляются и строки и столбцы, то такая структура будет не оптимальна, ведь на каждый чих надо перетасовывать все данные в памяти. Вектор векторов тут будет быстрее при изменении размера.

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

sorted(sizes, key=["M", "L", "XL", "XXL"].index)

Если не делать except, который проглатывает исключения, то можно в бэктрейсе увидеть причину.

Это объясняется тем, что в базовом питоне потоки не вполне честные - они конкурируют за global interpreter lock, так что код выполняется всё равно поочерёдно. Так что многопоточность в питоне полезна с точки зрения распараллеливания, но не ускорения. ЕМНИП, есть реализации питона, в которых нет этой GIL problem.
Но нужно иметь ввиду, что этот GIL блокирует только элементарные операции (как в твоём примере), тогда как явное использование lock может накрывать целые блоки кода, состоящие из нескольких операций с защищаемым ресурсом.

Вот тебе пример:

import threading
import time

class Data:
    def __init__(self):
        self.x: int = 0
        self.y: int = 0


do_sleep = False
run = True


def reader(d: Data):
    while run:
        x, y = d.x, d.y
        # по идее это условие не должно выполниться никогда
        if (x != 0) != (y != 0):  
            print(f'Got x={x} and y={y}')
        else:
            print(f'OK {x}', end='\x08\x08\x08\x08')


def writer(d: Data):
    while run:
        if d.x == 0:
            d.x = 1
            if do_sleep: pass
            d.y = 1
        else:
            d.x = 0
            if do_sleep: pass
            d.y = 0


do_sleep = False
instance = Data()
reader_thread = threading.Thread(target=reader, args=(instance,), daemon=True)
writer_thread = threading.Thread(target=writer, args=(instance,), daemon=True)
reader_thread.start()
writer_thread.start()
try:
    input()
finally:
    run = False
    reader_thread.join()
    writer_thread.join()

На моей машине, если if do_sleep: pass закомментировать, то в консоли высвечивается только OK - иными словами, присваивание двух полей выполняется достаточно быстро, чтобы поток не успел переключиться в промежутке. Как следствие, reader() всегда видит либо x=0 y=0, либо x=1 y=1.
Но если if do_sleep: pass оставить, то выполнение тела цикла замедляется достаточно, чтобы поток успел переключиться - и, как следствие, reader() начинает видеть структуру данных Data в неконсистентном состоянии, когда x=0 y=1 или когда x=1 y=0.
И вот чтобы не гадать "успеет - не успеет", нужно в таких случаях защищать связные серии обращений к структуре с помощью мьютекса, ну или в питоновских терминах - Lock.

Измените self.root.image = PhotoImage('font.jpg') на self.root.image = PhotoImage(file='font.jpg')