Александр

Чтобы проверять RSS вам вообще не нужен какой-то сторонний сервис.

Отправляете запрос на адрес, получаете xml, парсите, сравниваете с тем, что пришло в прошлый раз.
Ну или можно поискать модули, которые это автоматизируют.

Вроде есть какой-то pythonhosted.org/feedparser , но я с ним не работал, ничего про него сказать не могу.

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

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

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

1. Консоли бывают разные даже в рамках одной операционной системы. И у каждой могут быть свои настройки. Общего ответа не существует.
2. В любом случае изменение прозрачности - это манипулирование самой консолью. С питон-кодом это никак не связано.

[print(country['title']) for country in countries]

Прежде чем пробовать что-то делать на питоне, прочитайте хотя бы базовые вещи про него. Иначе так и будете под каждую конкретную задачу подбирать правильное "заклинание", не понимая, как и почему оно работает.

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

Исключения тут ни при чём.
Просто в питоне отрицательный индекс обозначает элемент, отсчитываемый с конца списка. Например, lst[-1] - последний элемент списка, lst[-2] -предпоследний, и так далее.

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

Все четыре варианта допустимы. Я обычно принимаю решение, отталкиваясь от окружающего кода.

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

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

Оба варианты допустимы. Выбирайте тот, который обеспечит большую читабельность и ясность кода.

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

Это популярная ошибка. Никогда не меняйте ту последовательность, по которой итерируетесь.

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

Решить проблему можно, если итерироваться по копии последовательности, а удалять - из оригинальной.

data = [1,2,3,4,5]
for a in data.copy():
    if data.count(a) == 1:
        data.remove(a)
print(data)

Во-первых, так делать не надо, это чревато проблемами.
Гораздо проще и правильнее создать словарь и все динамически создаваемые объекты заносить туда. Тогда введённое пользователем имя можно будет использовать как ключ. Это убережёт от конфликтов с именами других переменных. И можно создать по отдельному словарю на разные типы динамически создаваемых объектов.

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

name = input()
globals()[name] = 5
print(abc)

Здесь если пользователь ввёл имя "abc", то скрипт напечатает 5. Если пользователь ввёл другое имя - получите ошибку.

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

Когда вы инстанцируете новый экземпляр объект, то это происходит в таком порядке
1. Новый экземпляр создаётся
2. Созданный экземпляр инициализируется в соответствии с __init__

Таким образом, __init__ сработает только после того, как экземпляр уже создан со всеми его методами. Соответственно, и метод __setattr__ (если он объявлен в классе), у этого экземпляра уже есть.

Поэтому, когда в __init__ вы пишете self._defs = defaults интерпретатор уже не будет делать это стандартным способом, а полезет в метод __setattr__.
Там он идёт по ветке else, выполняет pass и на этом успокаивается. В итоге атрибут _defs так и не был записан.

А после этого, когда вы вызываете __getattr__, интерпретатор видит, что он должен обратиться к _defs, пытается найти его, не находит, и опять вызывает __getattr__, чтобы понять, как ему поступить в этом случае. И там он опять видит, что нужно обратиться к _defs. И получается бесконечная рекурсия.

А если __setattr__ не определён, то в __init__ нормально создаётся _defs, и ничего такого не происходит.

Решение:
замените строчку в __init__ на
self.__dict__['_defs'] = defaults

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

А дальше всё стандартно - есть набор входных параметров, есть результат (является ли предложение первым предложением абзаца, и является ли оно последним). На выходе у вас будет модель, которая для каждого предложения определяет вероятность того, что оно является "головой" абзаца и вероятность того, что это предложение является "хвостом".

А дальше вы просто ставите абзац после тех предложений с высокой вероятность "хвоста", за которым идёт предложение с высокой вероятностью "головы".

Здесь
while i < n:
Должно быть
while f <= n:

А после цикла проверяйте только n==0, а второй проверки не нужно, во всех остальных случаях возвращайте -1.

Режешь текст по пробелам, используя split.
А потом с помощью join из этих кусочков опять собираешь одну строку, но чередуя их со словами, которые с помощью random.sample() выбираются из списка слов.