Простой пример классификации текста на python sklearn

Классификация текста — классическая задача в области обработки естественного языка. Лет 10-15 назад тема классификации бурлила в научных журналах, однако со временем бум утих. Это связоно с тем, что подход на основе TF-IDF показал точность близкую к 95%-99.9%. При такой точности на качество классификации больше уже влияют методы предобработки и особенности текста, чем непосредственно выбор самого алгоритма. Появление ембеддингов в 2013 году сильно повлияло на методы в обработке текстов, открыв новую эпоху. Сейчас практически все «production» решения основываются на ембеддингах, но! Тут надо сделать оговорку — ембеддинги чрезвычайно хороши для анализа коротких текстов, которыми сейчас полон интернет, а вот для средних и больших текстов — TF-IDF по прежнему на высоте!

Ниже я приведу базовый подход классификации на основе библиотеки sklearn в python. Код максимально короткий и понятный

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline


texts = ['текст номер один', 'текст номер два', 'комьютеры в лингвистике', 'компьютеры и обработка текстов']
texts_labels = [1, 1, 0, 0]

text_clf = Pipeline([
                     ('tfidf', TfidfVectorizer()),
                     ('clf', RandomForestClassifier())
                     ])

text_clf.fit(texts, texts_labels)

res = text_clf.predict(['текст номер три'])
print(res)  # [1]

На входе у нас список из текстов и список размеченных классов, далее делаем Pipeline, который включает в себя векторизацию слов на основе TfIdf и классификатор RandomForest . Далее обучаем «пайплайн-классификатор» и пытаемся предсказать новый текст. Как видим классификацию тексто на python сделать очень просто.

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

1. предобработка текста. Попробуйте нормализовать слова, тогда одно смысловое слово в разных склонениях/спряжениях будет интерпретироваться программой одинаково и возможно поднимет качество.
2. У TfIdf есть много разных параметров, наиболее существенные это
2.1 добавить список стоп слов: параметр stop_words
2.2 добавить n-gramm ы слов : параметр ngram_range, например ngram_range=(1,2)
2.3 ограничить список фич, взяв только самые важные и отрезав менее важные: параметр max_features
3. попробовать другой классификатор, например from sklearn.linear_model import SGDClassifier или SVM , XGB итд. соответсвенно подбирая в каждом из них свои гиперпараметры

С помощью перечисленных шагов, Вы достаточно быстро подберёте оптимальный вариант для классификации и получите точность более 90% (основываясь на моём опыте). Если не так, то возможно надо посмотреть внимательнее корректность входных данных.

Примеры curl запросов из командной строки

Для быстрого тестирования запросов к web сервисам очень удобно использовать curl запросы из командной строки. Простой GET запрос легко ввести прямиком в браузере, но вот с POST уже будет сложнее. Разумеется есть множество программ с удобным интерфейсом, но часто бывает что они не всегда под рукой, не установлены или надо написать универсальную инструкцию. В таком случае гораздо быстрее открыть терминал, ввести команду и сразу получить результат. Для установки curl на linux достаточно выполнить команду

sudo apt-get update && sudo apt-get install curl

Здесь я приведу несколько наиболее типичных примеров CURL запросов.

Пример CURL POST запроса и CURL GET запроса
curl -X POST http://127.0.0.1/page
curl -X GET http://127.0.0.1/page

Пример отправки данных постом
вариант 1: curl -X POST -d «data1=1&data2=2″ http://127.0.0.1/page
вариант 2: curl -X POST -d ‘{«data1″: «1″, «data2″: «2″}’ http://127.0.0.1/page
О том как программно загружать файлы с помощью curl смотрите в статье о загрузке файлов курлом

Пример отправки файла
curl -i -X POST —form datafile=@/path/to/file.pdf http://127.0.0.1/page
Обратите внимание на параметр -i, определяющий получение от сервера только заголовка. Параметр не обязательный, но ведь обычно достаточно только знать загрузился файл или нет.

Пример CURL запроса с авторизацией
curl -u username:password http://127.0.0.1/page -XPOST -d «id=123″ -v
О полезном параметре -v ниже.

Пример CURL JSON запроса
curl -X POST http://127.0.0.1/page -d ‘{«id»: «123″}’ -H «Content-Type:application/json»
Некоторые сервисы бракуют запросы без указания content-type, поэтому в случае json запроса — лучше всегда отправлять хэдер json.

Из полезных параметров стоит рассмотреть команду -v (verbose) чтобы получить максимум информации по запросу.
О том как работать с curl запросом через прокси смотрите в данной статье.

Приведённых примеров должно хватить для использования в 95% , если понадобятся более тонкие запросы, то используйте

curl --help

DataFrame pandas базовые манипуляции с данными

Pandas — очень мощный инструмент для работы и манипуляций над данными с помощью python. Можно сказать, что pandas предоставляет возможности SQL базы данных, дополненные мощью python. Однако, работа с данной библиотекой иногда вызывает некоторые трудности, так как работать приходится по сути с матричными данными и объектами pandas да numpy, а переход к стандартным python типам и циклам неминуемо грозит кратной потерей функциональности. Поэтому для себя создал шпаргалку по работе с дата-фреймами:

Работа начинается с загрузки данных в DataFrame, поэтому для начала считаем данные:

df = pd.read_csv('some.csv')
# если Вам заранее известны типы, то чрезвычайно полезно задать типы колонок сразу - это сэкономит оперативную память.
# также можно использоть лишь несколько колонок, а не все колонки в файле
df = pd.read_csv('some.csv', usecols=["user_id", "id3"], dtype={"user_id": np.int64, "id3": np.uint16})

Возможно и самостоятельно создать DataFrame и добавить строки

# пример создания объекта дата-фрейм
pd.DataFrame(columns=['A', 'B'])
# пример добавления строки в дата-фрейм
df.append({'A':1, 'B':2}, ignore_index=True)

После создания или загрузки DF полезно посмотреть чтоже там за данные, для этого можно воспользоваться следующими операциями:

df.head()       # первые строки
df.tail()       # последние строки
df.sample(5)    # случайно выбранное кол-ва строк, полезно использовать для уменьшения матрицы для прогонки тестов
df.shape        # по аналогии с numpy - размерность матрицы
df.describe()   # математические данные
df.info()       # использование памяти

Возможно далее вам захочется получить точечное значение по координатам из дата фрема, тогда используйте ix

some_value = df.ix[2, 'som_col']  # похожие функции loc и iloc

Для фильтрации по колонкам пандас использует булевую логику, проще показать на примере:

filtered_data = df[df.some_col == 'apple']
filtered_data = df[(df.price > 10.0) & (df.some_col == 'apple')]

Далее приведём несколько примеров манипуляции с данными:

# пример удаления колонки:
df = df.drop("A", axis=1)
# удалит дубликаты
df = df.drop_duplicates()
# Создание новой колонки со значением по умолчанию
df['new_col'] = 1
# а вот так можно добавлять колонку с условием
df['new_col2'] = np.where(df['score']>=10.0, True, False)

Применение произвольной функции ко всей колонке

def get_score(s):
    return s * 0.21

df['score'] = df.some_col.apply(get_score)

Переименование колонки, сортировка

# переименовываем колонку A на колонку C
df = df.rename(columns={'A': 'C'})
# сортировка по одной колонке
df = df.sort_values('price', axis=0, ascending=False)
# сортировка сразу по нескольким колонкам
df = df.sort_values(['price', 'score'], ascending=[1, 0])

пример на соединение или конкатенацию дата-фреймов

df = pd.concat([df1, df2], ignore_index=True, axis=0)

группировка в дата-фрейме без мультииндекса

df.groupby(['A'], as_index=False).agg({'B': lambda series: series.iloc[0]})

После всех манипуляций, вас скорее всего надо будет данные куда-то выгрузить в другом формате или сохранить до следующего раза новый фрагмент таблицы дата-фрейма:

# в numpy массив
df.values
# в numpy массив, но сразу всю матрицу
df.as_matrix
# сохранить в файл
df.to_csv('submission.csv', index=False)

Примеры использования Random Forest из scikit-learn для классификации

Один из классических алгоритмов классификации является, алгоритм использования ансамбля решающих деревьев Random Forest (далее просто RF). Его выбирают по следующим причинам:

  • Random Forest хорош для не нормализованных данных, многие алгоритмы машинного обучения (ML) дают плохие результаты и данные предварительно надо обрабатывать. Для RF этот шаг можно попробовать опустить и быстро получить работающей прототип
  • Быстрота обучения классификатора, поэтому для обучения можно использовать большое количество данных не беспокоясь в времени (в отличии от SVM). Распараллеливание алгоритма.
  • Можно получить важность / веса параметров из пространства признаков а также вероятность предсказания

Из некоторых минусув можно выделить то, что обучившись на одних и тех-же данных несколько раз — подход будет предсказывать немного разные значения с разными вероятностями. Т.е. детерминированности вы не получите. От этого не уйдешь, т.к. выборка ансамбля решающих деревьев происходит случайным образом. Для заморозки случайности используйте random_seed.

Первый пример c RF: обучаем модель и предсказываем один элемент

from sklearn.ensemble import RandomForestClassifier

x_train = [
    [1, 2],
    [3, 4],
    [-1, 2],
    [-3, 4]
]
y_train = [1, 1, 0, 0]
clf_rf = RandomForestClassifier()
clf_rf.fit(x_train, y_train)

print(clf_rf.predict([[2, 2]]))  # [1] это предсказанный класс
print(clf_rf.predict_proba([[2, 2]]))  # [[0.2 0.8]] вероятности по классам

Пример второй: кросс-валидация или разбиение оценка точности с помощью разбиения на выборки для теста и для тренировки модели RF

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import train_test_split


x_train = [
    [1, 2], [5, 6],
    [3, 4], [7, 8],
    [-1, 2], [-5, 6],
    [-3, 4], [-7, 8], [0, 0]
]
y_train = [1, 1, 1, 1, 0, 0, 0, 0, 1]
clf_rf = RandomForestClassifier()

# разбиваем на два подмножества / фолда, параметр cv и получаем точность для каждого
scores = cross_val_score(clf_rf, x_train, y_train, cv=2)
print(scores)  # [0.8  0.75]

# кстати рабить на обучающую выборку и тестовую можно функцией
X_train, X_test, Y_train, Y_test = train_test_split(x_train, y_train, test_size=0.2)
print(X_test, Y_test)  # [[5, 6], [-3, 4]] [1, 0]

Возможно вы уже задались вопросом, какие параметры подкрутить, чтобы как-то влиять на точность и адаптировать алгоритм для входных данных и для железа.
n_estimators — параметр, напрямую влияющий на качество, при увеличении пространства признаков, следует рассмотреть увеличение этого параметра
max_depth — поможет если модель получилась сильно переобученной
criterion — entropy или gini . Можно с ними поиграться)
n_jobs — когда можно использовать несколько ядер
Пример третий: использование параметров для настройки RF
Здесь показано как с помощью GridSearchCV найти оптимальные параметры для классификатора.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV


x_train = [
    [1, 2], [5, 6],
    [3, 4], [7, 8],
    [-1, 2], [-5, 6],
    [-3, 4], [-7, 8], [0, 0]
]
y_train = [1, 1, 1, 1, 0, 0, 0, 0, 1]

parameter_grid = {
            'criterion': ['entropy', 'gini'],
            'max_depth': [10, 20, 100],
            'n_estimators': [10, 20, 100]
        }
clf = RandomForestClassifier()
grid_searcher = GridSearchCV(clf, parameter_grid, verbose=2)
grid_searcher.fit(x_train, y_train)
clf_best = grid_searcher.best_estimator_

print('Best params = ', clf_best.get_params())

Пример четвертый — сохранение и распаковка обученной модели:

from sklearn.externals import joblib
# предполагаем что clf - обучен выше
joblib.dump(clf, path_to_pkl, compress=1)
clf = joblib.load(self.path_to_pkl)

Здесь параметр compress — влияет на то на сколько сильно будет сжат файл классификатора, чем больше тем сильнее, однако не советую увлекаться, т.к. это обратнопропорционально вляет на время распаковки.

Пример пятый — рисуем график важности параметров. Вполне может пригодиться для презентации результатов.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
import matplotlib.pyplot as plt
import numpy as np



x_train = [
    [1, 2], [5, 6],
    [3, 4], [7, 8],
    [-1, 2], [-5, 6],
    [-3, 4], [-7, 8], [0, 0]
]
y_train = [1, 1, 1, 1, 0, 0, 0, 0, 1]

parameter_grid = {
            'criterion': ['entropy', 'gini'],
            'max_depth': [10, 20, 100],
            'n_estimators': [10, 20, 100]
        }
clf_rf = RandomForestClassifier()
clf_rf.fit(x_train, y_train)

importances = clf_rf.feature_importances_
print(importances)
std = np.std([tree.feature_importances_ for tree in clf_rf.estimators_], axis=0)

indices = np.argsort(importances)[::-1]
names_indices = ['x_coor', 'y_coor']

# Plot the feature importances of the forest
plt.figure()
plt.title("Feature importances")

plt.bar(range(len(importances)), importances[indices], color="r")
plt.xticks(range(len(importances)), names_indices, rotation=90)

plt.tight_layout()
plt.xlim([-1, len(importances)])
plt.show()

Как видно из нарисованного графика, первая координа является более ключевой, что действительно так по выборке. важность параметров в random forest

Как скопировать жесткий диск с OS linux

Бывает необходимо иметь резервную копию диска, на случай поломки или выхода из строя. Также возможна ситуация, когда Вы просто хотите перейти на диск большего размера. Как раз у меня возникла такая ситуация и на диск ssd диск 128 гигабайт перестал влезать необходимый софт. Для этого был прикуплен ssd на 250Gb. Установленная операционная система — Ubuntu 16.04 .
Немного порывшись в интернете решил, что самым простым способом будет исользовать специально предназначенную для этого программу clonezilla. Таким образом алгоритм перехода на новый диск будет таким

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

2. Делаем образ clonezilla live. Для этого можно воспользоваться специальной утилитой tuxboot.
2.1 устанавливаем Tuxboot , на официальном сайте tuxboot написано как это сделать. Я выбрал
установку через ppa.
2.2 Запускаем просто набрав в командной строке tuxboot. Вас спросят пароль администратора.
2.3 Интерфейс будет достаточно понятным, выбираем образ и флешку, и далее ОК

3. Загружаемся с загрузочной флешки (В биосе надо нажать кнопку прерывания для выбора приоритета загрузки, на плате B350M PRO-VDH это F11)
3.1 Далее идут простые вопросы, выбираем с диска на диск и в самом простом случае выбираем все дефолтные настройки. Опять же особенности каждой опции можно узнать на официальном сайте clonezilla .

Готово, теперь у Вас есть копия диска. На этом можно закончить, но добавлю пункт 4 со звёздочкой

4*. Редактирование разбиения диска или партиций. Как было замечено, мне необходимо было перейти на диск большего объёма, бывают случаи что надо например сделать резервную копию на диск меньшего объёма. В таком случае в clonezilla надо выбрать режим «expert mode». И тогда в одном из окон вас спросят про разделы. Выбираем чтобы разделы создавались пропорционально.

Таким образом за 4 шага мне удалось перейти на новый, более быстрый и объёмистый диск на линуксе.

Простой пример нейронной сети на keras и tensorflow с тремя слоями

В данном посте будет показано, как инициализировать нейроннуй сеть на python, задать слои, обучить и получить предсказанные результаты. Пример сделан на python3, а в прослойке между tensorflow установлена библиотека Keras. Чтобы было понятнее — все входные параметры будут подписаны.
И так, нейронные сети очень мощный и не тривиальный инструмент в руках дата-инженера. Однако большинство продвижений в области машинного обучения в последние годы связано именно с нейронными сетями.
Установка:
keras и tensorflow ставится через pip: pip3 install keras и pip3 install —upgrade tensorflow
Отмечу, что здесь мы установили tensorflow для CPU, использование GPU даёт существенный прирост скорости, но и поставить посложнее.

Общий путь
1) Создание модели
2) Компилирование модели
3) Загрузка/подготовка данных
4) Обучение нейронной сети
5) Предсказание

Импорт библиотек:
import numpy as np
# Для создания простых моделей используют Sequential,
# При использовании Sequential достаточно добавить несколько своих слоев.
# Для более сложных моделей уже надо будет использовать Functional API
from keras.models import Sequential
from keras.layers import Dense # Dense — один из типов слоёв в Keras для создания слоя нейронов

Использовать будем бинарную классификацию, т.е. по набору фич надо определить принадлежит ли объект классу или нет.
Данные можете взять свои или например из этого файла data.txt. В нём есть 8 фич, а последний столбец показывает принадлежность классу

from keras.models import Sequential
from keras.layers import Dense
import numpy as np

# загружаем данные с фичами
dataset = np.loadtxt("data.txt", delimiter=",")
# Первые 8 столбцов в примере отвечают за фичи, последний же за класс, разбиваем 
X = dataset[:,0:8]
Y = dataset[:,8]

# Создаём модель!
model = Sequential()
# Добавляем первый слой Dense, первое число 12 - это количество нейронов, 
# input_dim - количество фич на вход
# activation -  функция активации, полулинейная функция max(x, 0) 
# именно полулинейные функции позволяют получать нелинейные результаты с минимальными затратами
model.add(Dense(12, input_dim=8, activation='relu'))
# добавляем второй слой с 8ю нейронами
model.add(Dense(8, activation='relu'))
# на выходе при бинарной классификации, функцию активации чаще всего используют sigmoid , реже softmax
# Компилирование модели. binary_crossentropy - опять же не случайно, а т.к. у нас два класса.
# Метрика accuracy используется практически для всех задач классификации
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Наконец дошли до обучения модели, X и Y - понятно, 
# epoch - максимальное количество эпох до остановки
# batch_size - сколько объектов будет загружаться за итерацию
model.fit(X, Y, epochs=15, batch_size=10,  verbose=2)
# Предсказание
predictions = model.predict(X)

Создание высокоточной нейронной сети - непростое задание. Порой хорошо работающие сетки получают случайно, и сложно объснить почему именно они хорошо работают. Поэтому дальше можете поиграть с разными параметрами. Заглядывая наперед - один из способов подбора гиперпараметров нейронной сети - использование библиотеки hyperopt, которая пытается сделать предсказать результирующую функцию, вместо перебора всех параметров, т.к. перебор параметров может быть уж сильно долгим.
Таким образом на выходе мы получаем обученную нейронную сеть на keras . Для использования этой сети в будущем, проще всего использовать model.save(filepath) . Обращу внимание, что picke не рекомендуется. А для загрузки сохраненной ранее модели: keras.models.load_model(filepath).

Определение языка текста на python с помощью langdetect

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

$ pip install langdetect

Заметим, что код портирован на питон из гугловской библиотеки language-detection, поэтому качество распознавания языка находится на уровне, во всяком случае у меня пока особых претензий не было.
Далее, всё весьма стандартно, импортируем библиотеку и вызываем функцию «детектирования языка», пример:

from langdetect import detect
detect("здесь произвольный фрагмент текста на вход")
# результат: ru

По умолчанию поддерживается 55 языков, двухбуквенные коды взяты из стандарта кодов языков, и если быть подробнее, то они такие: af, ar, bg, bn, ca, cs, cy, da, de, el, en, es, et, fa, fi, fr, gu, he, hi, hr, hu, id, it, ja, kn, ko, lt, lv, mk, ml, mr, ne, nl, no, pa, pl, pt, ro, ru, sk, sl, so, sq, sv, sw, ta, te, th, tl, tr, uk, ur, vi, zh-cn, zh-tw

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

from langdetect import detect, detect_langs
from langdetect import DetectorFactory
DetectorFactory.seed = 0

detect_langs("Otec matka syn.") 
# результат [sk:0.572770823327, pl:0.292872522702, cs:0.134356653968]

Как видим, detect_langs определил не только языки, использованные в тексте, но ещё и их вероятности. Также возможно у Вас возник вопрос, зачем я использовал DetectorFactory? Дело в том, что алгоритм не является детерминированным, т.е. при разных запусках он может выдавать разные результаты. Если Вы хотите избежать разнозначности при разных запусках, то советую использовать DetectorFactory.seed = 0, если же такой необходимости нет, то лучше сэкономить пару строк.

Далее подметим, что detect_langs вернул не просто языки, а лист объектов Language, и возникает вопрос, как же получить языки и вероятности из этого листа? Смотрите пример:

from langdetect import detect_langs

list_of_languages = detect_langs("Здесь некий текст") 
for l in list_of_languages:
    # используем атрибуты lang и prod
    print(l.lang, l.prob)
    # результат: ru , 0.99

Определение языка может быть полезно при реализации поиска (для выдачи более релевантных результатов), а также для запуска языко-зависимых программ. Как видите с помощью langdetect определить язык можно всего в 2 строки!

Пример использования CountVectorizer в sklearn

Одна из первых концепций обрабтки естественных языков Bag-of-Words — это статистический анализ, анализирующий количественное вхождение слов в документах. Не смотря на то, что подход сформирован весьма давно, он отлично подходит для первичной обработки текстов и быстрого прототипирования.

Модуль CountVectorizer в sklearn как раз подзволяет сконвертировать набор текстов в матрицу токенов, находящихся в тексте. Также имеется много полезных настроек, например можно задать минимальное количество необходимое для появления токена в матрице и даже получить статистику по n-граммам. Следует учитывать, что CountVectorizer по умолчанию сам производит токенизацию и выкидывает слова с длиной меньшей чем два.

Пример:

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np

# инициализируем
vectorizer = CountVectorizer()
# составляем корпус документов
corpus = [
  'слово1 слово2 слово3',
  'слово2 слово3',
  'слово1 слово2 слово1',
  'слово4'
]
# подсчитываем
X = vectorizer.fit_transform(corpus)

# таким образом будет подсчитана следующая структура:
#        | слово1 | слово2 | слово3 | слово4
# текст1 |   1    |    1   |   1    |   0
# текст2 |   0    |    1   |   1    |   0
# текст3 |   2    |    1   |   0    |   0
# текст4 |   0    |    0   |   0    |   1

# чтобы получить сгенерированный словарь, из приведенной структуры CountVectorizer, стоит отметить что порядок совпадает с матрицей
vectorizer.get_feature_names()  # ['слово1', 'слово2', 'слово3', 'слово4']

# чтобы узнать индекс токена в словаре
vectorizer.vocabulary_.get('слово3') # вернет 2

# показать матрицу
X.toarray()

# теперь можно быстро подсчитать вектор для нового документа
vectorizer.transform(["слово1 слово4 слово4"])  # результат [[1 0 0 2]]

# чтобы узнать количественное вхождение каждого слова:
matrix_freq = np.asarray(X.sum(axis=0)).ravel()
final_matrix = np.array([np.array(vectorizer.get_feature_names()), matrix_freq])

Один из минусов, что добавлять новые слова в словарь не получится, необходимо сразу указать все документы.
Второй из минусов, отчасти идущий от первого — плохая масштабируемость на большой набор текстов. Есть вероятность натолкнуться на MemoryError уже при десятке тысяч документов. Поэтому либо надо ограничивать количество фич/токенов для попадания в словарь с помощью настройки max_features или же использовать другую библиотеку. Однако для нескольких тысяч можно весьма быстро получить результат и далее использовать фичи например для классификации или кластеризации документов.

Постинг в канал telegram с помощью python или бот telegram в 3 строчки

Предположим надо написать телеграмм бота, который при появлении свежей новости на сайте пишет в канал. Практическое применение для меня было в том, что на одном сайте изредка появляется важная информация, которую пропускать не хотелось, но и постоянно мониторить сайт тоже. В итоге захотелось написать максимально простой и минималистичный python скрипт, выполнющий задачу постинга в канал telegram и не использующий даже базу данных. Такая простота достигается следующим образом: по крону раз в сутки запускается программа, которая вытягивает все новости за вчерашний день. Непосредственно отправление сообщения в канал занимает 3 строчки, подробнее об этом конце, а сейчас разделим задачу на несколько логических последовательных подзадач:

  1. Отслеживание появления новости

    • 1.1 Запрос html страницы (использование бибиотеки requests)
    • 1.2 Парсинг html страницы (здесь будем использовать питон библиотеку BeautifulSoup)
    • 1.3 разбивка списка новостей на старые и новые публикации
  2. Отправка сообщения в телеграм канал

    • 2.1 Создание канала а также бота с помощью BotFather и добавление бота в администраторы канала
    • 2.2 Выбор библиотеки и её инициализация с помощью токена telegram, полученного от все того же BotFather (в нашем случае это библиотека python-telegram-bot )
    • 2.3 Отправка сообщения.
  3. Настройка обработчика cron

    • раз в сутки: «1 12 * * * /path/to/bot.py >/dev/null 2>&1″
# подключаем библиотеки
import requests
import random
from bs4 import BeautifulSoup
from datetime import date, timedelta
import telegram

# будем брать информацию за вчерашний день
yesterday = date.today() - timedelta(1)
yesterday_str = yesterday.strftime('%d.%m.%Y')

# На некоторых сайтах стоит минимальная защита и они не отдают контент без user-agent
headers = {'user-agent': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'}
# чтобы избежать кэширования на любом уровне, на всякий случай добавим случайно число
r = requests.get('http://здесь-название-сайта.ru/?r='+str(random.random()))

# парсинг заголовков и времени создания новости
soup = BeautifulSoup(r.text, 'html.parser')
h2s = soup.find_all('h2', class_='PostHeaderIcon-wrapper')
h2s = [x.text.strip() for x in h2s]
times = soup.find_all('div', class_='PostHeaderIcons metadata-icons')
times = [x.text.strip() for x in times]

for k, t in enumerate(times):
    if t.split()[0] == yesterday_str:  # если новость за вчера, то постим
        # Непосредственно здесь идет отправка. Инициализируем бота с помощью токена
        bot = telegram.Bot(token='123456789:AABBCCDDefgh_mnaviwuue_DP865Y')
        chat_id = '@here_some_channel_to_post'
        # тест новости
        chat_text = 'Новая новость на <a href="http://здесь-урл-сайта.ru">сайте</a>:\n {}'.format(h2s[k])
        # отправка поста в канал. Маленькая тонкость - используется HTML разметка
        bot.send_message(chat_id=chat_id, text=chat_text, parse_mode=telegram.ParseMode.HTML)

Таким вот несложным образом создан информационный telegram бот для канала. В канал можно приглашать других пользователей и они будут получать пуш-уведомления. Если сделать сухую выжимку из всего кода выше, то непосредственно отправка сообщения канал telegram займет 3 строчки:

import telegram
bot = telegram.Bot(token='123456789:AABBCCDDefgh_mnaviwuue_DP865Y')
bot.send_message(chat_id='@here_some_channel_to_post', text='some text to post')

					

Как создать requirements.txt файл для python программы

Требование наличия в корне файла requirements.txt — достаточно распространенное среди заказчиков. Это и не удивительно — ведь для того чтобы быстро установить все требуемые библиотеки python в новом окружении достаточно выполнить команду pip install -r requirements.txt .

Рассмотрим несколько вариантов.
Вариант первый — вручную. Минусы думаю объяснять не надо, мало того что вы можете ошибиться в названиях и версиях, но также легко и пропустить библиотеку.

Вариант второй — стандартом pip. Выполнив команду pip freeze > requirements.txt вы сразу получите файл в требуемом формате. Если есть уверенность, что у Вас не установлено никаких лишних библиотек — то это самый оптимальный способ. Недостаток этого способа один — в файле будут отображены абсолютно все библиотеки python, уже установленные ранее и никак не относящиеся к текущему проекту.

Вариант третий — использовать дополнительную библиотеку для генерации файла зависимостей. В данном случае надо сразу смотреть на кроссплатформенность, так как не все библиотеки могут работать с windows/unix . Самым распространненым вариантом на данный момент является библиотека pipreqs (установка «pip install pipreqs») . Чтобы сгенерировать файл requirements.txt надо в команде указать просто путь до папки с проектом, т.е. : pipreqs /path/to/project/folder . Если requirements.txt уже есть и необходимо его перезаписать, то используйте флаг —force . Если просто хотите посмотреть на используемые библиотеки без создания, флаг —print.
В конце приведу пример созданного файла:

PyMySQL==0.7.11
pandas==0.19.2
opencv_contrib_python==3.2.0.7
beautifulsoup4==4.6.0
scikit_learn==0.19.0
python_stdnum==1.6