Парсинг групп: 10 парсеров пользователей из групп ВКонтакте — лучшие сервисы

Содержание

как использовать парсинг «ВКонтакте» — Маркетинг на vc.ru

Команда Tesla Target составила гайд, который поможет вам выбрать сервис для парсинга и научиться использовать его результаты для таргетированной рекламы «ВКонтакте».

6052 просмотров

Бывают ситуации, когда типичных настроек рекламного кабинет ВКонтакте не хватает, а сливать рекламный бюджет на слишком широкие аудитории не хочется. Что же делать? Использовать парсинг!

Что такое парсинг, чем он может быть полезен бизнесу

Парсер — это программа/скрипт, которая по заданному алгоритму собирает нужную информацию на сайте. Инструмент, помогающий специалистам по рекламе и владельцам бизнеса находить и анализировать свою целевую аудиторию. С помощью парсеров можно быстро искать данные и загружать их в рекламный кабинет.

Парсинг — это автоматический сбор информации с какого-либо источника с целью его дальнейшего использования.

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

Использование парсеров ВКонтакте полностью легализовано – программа обращается напрямую к API (открытому коду). Поэтому никаких проблем с администрацией сайта использование парсеров не принесёт.

Основные сервисы для парсинга

Составили список самых популярных парсеров, которые помогут вам в сборе информации.

Стоимость: от 490 р. в месяц

Тестовый период: 3 дня бесплатно

Стоимость: от 18 р. в день на тарифе Стандартный

Тестовый период: бесплатный тариф с ограниченным функционалом

Стоимость: от 399 р. в месяц

Тестовый период: 7 дней бесплатно

Стоимость: 1 225 р. в месяц или 750 р. в день базовая версия

Тестовый период: нет

Стоимость: 1999 р. в месяц

Тестовый период: есть бесплатный тариф с ограниченным функционалом

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

Target Hunter

Нет, это не реклама, по крайней мере, нам ничего не заплатили( Исторически сложилось, что мы перешли на этот парсер и его функционал нам понравился.

У сервиса множество инструментов для поиска целевой аудитории. Парсинг групп ВКонтакте по ключевым словам, сбор людей вступивших в сообщество конкурентов, очистка от ботов – вот лишь несколько функций.

Существует 3 тарифных плана, включая бесплатный. Он позволяет пользоваться 24 инструментами и запускать 1 поток задач в стандартной скорости парсинга. Также вы можете отдельно докупить потоки для задач и кейсов, сообщества на отслеживание и опцию управления ставками в рекламном кабинете.

Также в Target Hunter вы можете подключить свое сообщество для исследования статистики и отправки уведомлений. В модуле рассылок вы сможете создавать цепочки сообщений, формировать группы рассылки и пр. Биржа баз позволяет купить в сервисе готовые базы пользователей, собранные другими специалистами. Некоторые из баз доступны бесплатно.

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

Топ настроек

Ниже рассказываем про настройки, которые мы чаще всего используем в работе. Сбор таких аудиторий может закрыть много вопросов при ведении трафика.

Успех таргетированной кампании также зависит и от заголовков объявлений. В статье в своем блоге рассказываем о 12 вариантах, которые мы часто используем в своих объявлениях, чтобы пробить «рекламную слепоту».

— Состоят в нескольких группах

Как правило, если люди интересуются тем или иным продуктом в социальных сетях, они вступают в соответствующие группы. Но бывает такое, что пользователи случайно или давно вступают в сообщества и уже не интересуются темой, которую мы рекламируем. Что же делать?

Один из способов – это собрать тех, кто состоит в нескольких сообществах по определенной теме.

Шаг 1 — вкладка «Участники»

Шаг 2 — вносим ссылки на группы или спарсенные базы и собираем пользователей

— Новые вступления

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

Шаг 1 — вкладка «Недавно вступившие»

Шаг 2 — выбор периода вступления

— Анализ целевых сообществ

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

— Топ участники

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

Рассмотрим парсинг на примере

Скажем, к вам обратился магазин детских деревянных игрушек. Целевая аудитория — мамочки.

Чтобы найти таких женщин Вконтакте мы можем попробовать настроить рекламу на участников «мамских» групп. Но что, если пользователь состоит в группе давно и ребенок уже вырос?

Тут нам может помочь ретаргетинг! Попробуем собрать вступивших в такие группы за последний месяц — скорее всего такие женщины нам подходят.

Для начала соберем все такие сообщества

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

Готово! Осталось загрузить данные и собирать заявки. Ну и покреативить над объявлениями)

Как теперь добавить полученные базы в рекламный кабинет ВКонтакте

После того, как мы собрали данные, необходимо их как-то использовать.

Для этого нужно скачать текстовый файл с ID пользователей «ВКонтакте».

Далее, загружаем базу в рекламный кабинет, в раздел «Ретаргетинг».

При создании рекламных кампаний вы можете дополнительно отфильтровать аудиторию по полу, возрасту, географии и другим таргетингам рекламного кабинета.

Надеемся, что теперь вы знаете о парсинге чуть больше. Информации в этой статье хватит для удачного старта, а дальше – только тестировать новые гипотезы и разбираться с другими функциями парсеров. Удачи!

Парсинг групп и аудитории Вконтакте

Парсер Вконтакте — незаменимый инструмент для любого владельца группы или бизнеса, спамера, арбитражника, маркетолога, smm специалиста, продавца или любого новичка, который только постигает заработок Вконтакте. Точная выборка целевой аудитории является первоочередной задачей для подготовки рекламной рассылки. Чем лояльнее собранные пользователи, тем выше конверсия и меньше жалоб на спам. Заинтересованные люди — это большое количество переходов по ссылкам, а значит и количество новых партнеров, покупателей и клиентов. Данный сервис по парсингу Вконтакте умеет собирать и фильтровать целевые группы и пользователей по самым разнообразным критериям, которые удовлетворят ваши самые изысканные запросы. Рассмотрим основные функциональные возможности данного парсера Вк.

Ниже приведены основные возможности парсера Вконтакте, всего на сайте их около 130 видов. (параметры фильтрации расписаны внизу этой страницы)

Парсер всех участников группы Вконтакте

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

Парсер контактов пользователей Вк

Почты, телефоны, чаты, инстаграм (с возможностью преобразовать логины в id), facebook и скайп аккаунты. Обратите внимание, что вся собираемая информация находится в свободном доступе в самом Вк, например на стенах или личных страницах. Никаких персональных и конфиденциальных данных сервис не собирает и собрать не может.

Отслеживание вступивших в группы конкурентов

«Ловите» новых подписчиков ваших конкурентов и переманивайте их к себе или делайте им выгодные предложения. До 120 групп для отслеживания. Никто не пройдет незамеченным. Эффективный способ для набора только целевых подписчиков в свою группу.

Парсер активных пользователей в группе за определенный период

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

Парсер групп и пользователей из всего Вк

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

Парсер пользователей, состоящих в нескольких группах Вк

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

Парсер полной информации о группах Вконтакте, которую можно выгрузить в Excel

(название, описание, ссылка на группу, город, короткий адрес, фотография и тематика сообщества, контактная информация, сайт, товары, количество видео, фото, обсуждений, число участников, права участников в группе: можно ли делать посты, оставлять комментарии, загружать фотографии и т.д)

Парсер фото и видео групп и пользователей Вк

Занимайтесь сбором фотографий и видеозаписей групп или пользователей для наполнения своих сообществ или фейков как в Вк, так и других социальных сетях.

Поиск похожих групп

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

Парсер групп пользователей Вконтакте

Указывайте id людей или ссылки, а парсер Вк соберет все группы, в которых они состоят или паблики, на которые подписаны. Хороший способ для анализа интересов для рекламной рассылки.

Парсер друзей и подписчиков пользователей Вк

Эффективно работает, если это рекламная страница вашего конкурента. Но вы можете найти и свое применение данной возможности.

Парсер популярных постов в группах Вк

Узнавайте, что больше всего любит аудитория групп-конкурентов и делайте похожие посты, чтобы собирать максимальное количество лайков и репостов, тем самым продвигая свою группу

Парсер рекламных постов в группах Вк

Смотрите, какая реклама лучше заходит в схожих по тематике сообществах. Данная функция подойдет и рекламодателям, и админам похожих групп.

Анализ ваших постов в новостных лентах подписчиков

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

Парсер по новостям и хэштегам Вк, сбор постов в группе и у пользователей

Выборку пользователей по каждой опции парсинга Вконтакте можно отфильтровать по следующим параметрам:

— день рождения

— город и страна

— имя и фамилия

— девичья фамилия

— семейное положение

— наличие аватарки

— указаны ли дети, родители, братья и сестры

— по ключевым словам в статусе и интересам

— по школе, вузу, работе и должности

— родному городу

— количеству друзей, подписчиков и подписок

— дате захода в Вк и типу устройства

— только тех, кто онлайн

— открытому профилю, личным сообщениям, стене и комментариям

— наличию верификации

— присутствию сайта в профиле

— будет ли такой человек получать уведомление при заявке в друзья.

— Список стоп или белых слов. При наличии одного стоп слова в любых данных пользователь исключается из выборки, даже если подходит по остальным параметрам. Соответственно, при наличии белого слова, остается в выборке, даже если по другим критериям не подходит.

Как можно заметить, парсер Вконтакте имеет около 30 опций для фильтрации аудитории, что сделает результат парсинга Вк максимально точным.

Выборку групп тоже можно отфильтровать:

— по типу сообщества и его доступу (открытое, закрытое)

— количеству участников

— открытой стене, комментариям, обсуждениям и личным сообщениям

— дате последнего поста на стене

— наличию товаров, аватарки, обложки, верификации, закрепленному посту, wiki страницы

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

— список стоп или белых слов. При наличии одного стоп слова в любых данных группа исключается из выборки, даже если подходит по остальным параметрам. Соответственно, при наличии белого слова, остается в выборке, даже если по другим критериям не подходит.

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

Парсинг в ВК: сбор групп, аудитории, телефонов и фото

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

О том, как собирать целевую аудиторию для рекламы ВКонтакте, а также парсить данные по этой аудитории и сообществам, мы расскажем в этой статьей.

Что такое парсер и парсинг в ВК

Парсер — это сервис, программа или скрипт, которая по заданному алгоритму собирает нужную информацию в соцсети.

Если говорить конкретно о ВКонтакте, то парсер ВК — это скрипт, обращающийся к API ВК и получающий от него информацию о пользователях, сообществах и контенте. 

Парсинг — процесс поиска, анализа и систематизации данных по заданному алгоритму и выдача его в удобном для сохранения и использования формате (Exel, csv, txt). 

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

Статья в тему: Как парсить ЦА в Инстаграм

Зачем нужен парсить аудиторию в ВК

  • Ретаргетинг. При помощи парсера можно собирать аудитории пользователей ВКонтакте, по определённым, нужным нам параметрам. Затем загружать эти аудитории в свой рекламный кабинет и показывать им свои рекламные объявления.
    Также можно собирать базы ретаргетинга на заказ или для последующей перепродажи.
  • Реклама в Инсте и ФБ. Обратите внимание, что парсинг аудитории с последующей загрузкой в рекламный кабинет возможен только ВКонтакте. В Инстаграм и Фейсбуке так сделать нельзя, но для них можно собрать данные для создания look-a-like аудитории. Для этого, достаточно номеров телефонов.
  • Сбор аудитории для рассылки приглашений, масслайкинга и прочее.
  • Номера телефонов — для настройка лук-э-лайк аудитории на любой рекламной площадке, для рассылки в мессенджерах и прочее.
  • Инстаграм-аккаунты из профилей в ВК для запуска масслукинга или другой активности. 

Видео по сбору, парсингу аудитории и групп Вконтакте

Как собрать аудиторию ВКонтакте

Запускаем программу SocialKit. Для сбора аудитории требуется добавить в программу технический аккаунт. 

Технический аккаунт — это фейковый аккаунт, с которого происходят запросы и сбор аудитории, и который не страшно потерять в случае блокировки. Если вы хотите, чтобы данные собирались быстрее, то добавьте несколько технических аккаунтов.

Переходим на вкладку ВКонтакте и кликаем «Добавить аккаунт».

Вводим логин (почта или телефон) и пароль для входа.

Парсинг групп

Этот тип парсинга позволит собрать список сообществ по заданным параметрам.

Шаг 1. Нажимаем «Сбор и анализ аудитории» и выбираем «Сбор и анализ сообществ ВКонтакте».

Шаг 2. Ставим отметку в поле «Сообщества из глобальной базы ВКонтакте» и жмём «Критерии фильтрации сообществ».

Шаг 3. Вводим ключевые слова для поиска групп, регион и тип собираемых сообществ.

Шаг 4. Ставим галочку в поле «Сохранять текстовую информацию из групп в файлы» и выбираем, что будем сохранять.

Также, указываем файл, в который нужно записать данные. В блоке ниже задаём правила формирования файла. В завершении кликаем «Применить» и запускаем парсинг.

Готово!

Сбор аудитории и данных (телефоны, Инстаграм)

Шаг 1. Возвращаемся в главное окно программы. Жмём «Сбор и анализ аудитории» и выбираем «Сбор и анализ профилей ВКонтакте».

Шаг 2. Далее есть 2 основных варианта парсинга: сбор аудитории из глобальной базы ВК или подписчиков из групп ВКонтакте.

(а) Сбор аудитории из базы ВК. Ставим отметку в поле «Пользователи из глобальной базы ВКонтакте» и жмём «Критерии фильтрации пользователей».

Затем указываем критерии сбора аудитории:

  • Можно добавить ссылку на поиск по ВК;
  • Имя;
  • Страна и город;
  • Возраст;
  • Пол;
  • Семейное положение;
  • Находится ли пользователь онлайн и есть ли у него фото профиля;
  • Год, месяц и день рождения.

(б) Пользователи из сообществ (поиск на лету). Отмечаем соответствующий пункт и жмём кнопку «Критерии поиска сообществ». Как вариант можно загрузить файл со списком сообществ, которые мы сформировали заранее.

Задаём критерии подбора сообществ, с которых требуется спарсить аудиторию.

Шаг 4. Ставим галочку в поле «Сохранять текстовую информацию из профилей в файлы» и выбираем, что сохраняем, куда и в каком виде. Например, можно сохранить не просто список id, а номера телефонов и другую информацию на выбор.

Шаг 5. Кликаем «Запуск» и получаем готовую базу пользователей ВК для дальнейшей работы!

Статья в тему: Как собрать базу Инстаграм-аккаунтов из ВК

Парсинг фото

Также вы можете собрать и скачать фотографии отобранных пользователей или групп. Для этого заходим во вкладку «Сохранение медиа-контента».

И выбираем что нужно сохранять. У пользователей можно сохранить:

  • альбомы;
  • фотографии из профиля;
  • фотографии со стены;
  • сохранённые изображения.

Например, можно скачать всю инфу по каждому профилю в папку. А через автопостинг в Инстаграм всё это заливать, на каждый новый аккаунт из своей папки. На выходе получаются уникальные заполненные страницы.

Из групп можно спарсить:

  • альбомы сообществ;
  • аватары;
  • фотографии со стены.

Заключение

Парсинг — полезный инструмент, который поможет найти и загрузить данные в рекламный кабинет ВК или другие сервисы. Парсер SocialKit позволяет быстро собрать базу людей (или отдельные данные), сообществ и контента, которые можно использовать для дальнейшей работы. 

Ключевое преимущество SocialKit — безлимитный и многопоточный парсинг, без доплат и каких-либо ограничений.



Парсинг групп

Функция «Парсинг групп» позволяет собрать id групп по заданным параметрам.

Для ее использования необходимо на экране выбора функций для ВК активировать пункт «Парсинг групп».

Внимание! При использовании кнопки функции в верхнем меню, функция будет использована на всех аккаунтах ВК в вашей программе.

Чтобы выбрать определенные аккаунты, для которых будет выполнена заданная функция, необходимо выделить нужные аккаунты в списке аккаунтов. Нажать правую кнопку мыши и затем в контекстном меню выбрать «Функции»

После того как мы попали в окно настроек самой функции. Мы можем настроить поиск нужных нам групп.

В поле «Страна» вы можете вбить страну, по которой будет происходить поиск групп.

В поле «Город» вы можете указать город, по которому будет производится поиск групп.

В поле «Параметры поиска» вы можете выбрать один из 3-х вариантов сортировки поиска групп.

В поле «Тип страницы» вы можете выбрать один из 3-х типов страниц, ID которых вы планируете собрать.

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

Слова и фразы для поиска групп вы можете ввести в поле «Слова для поиска групп» каждое слово (фраза) с новой строки.

Так же в настройках мы можем активировать опции: «Только открытые страницы» — группы, в которые возможно вступить без дополнительных запросов. «Открытые комментарии» — группы, в которых разрешено комментирование постов на стенах. «Открытая стена» — группы, в которых разрешено размещать посты. «Открытые видео» — группы, в которых разрешено размещать видео.

Результат будет сохранен в папку «results» внутри папки с программой. Чем больше аккаунтов будет выполнять функцию, тем быстрее будет собрано необходимое число id групп.

После настройки нажмите кнопку «Продолжить». Начнется выполнение функции для заданных аккаунтов. За выполнением вы можете следить на вкладке Лог.

Парсинг групп Вконтакте — цены на профессиональные услуги по парсингу групп (сообществ) в ВК

Если вам нужна быстрая и эффективная раскрутка своего паблика на страницах, сходных по тематике со сферой ваших интересов, вам понадобится профессиональная помощь. Конечно, можно попытаться сделать все самостоятельно вручную, отслеживая страницы «Вконтакте», однако намного успешней работа будет проведена с помощью качественного парсинга – сбора данных по заданным вами критериям и отсев ненужной информации. Заказать такие услуги по самым выгодным расценкам можно на сервисе YouDo. Простой и понятный интерфейс, большое количество предложений, отзывы реальных пользователей о работе исполнителей, приемлемая стоимость услуг – все это позволит сделать выбор в пользу лучшего специалиста.

Преимущества автоматического парсинга групп «Вконтакте»

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

  • сферу деятельности;
  • город или страну;
  • активность пользователей в каждой группе и т.д.

Написанный скрипт сможет:

  • обработать не менее 1000 сообществ vkпо заданным ключевым словам;
  • работа проводится только со страницами с открытой стеной (чтобы в будущем вы смогли там разместить собственный контент) – это несколько замедляет работу программы, но повышает результативность в конечном итоге;
  • сделать выборку «Вконтакте» по нужным вам городам, странам;
  • отсортировать полученные данные в наиболее удобном для вас варианте.

Скорость и качество автоматического парсинга группы «Вконтакте» позволит в короткие сроки получить великолепно систематизированную таблицу с активными открытыми страницами в ВК, которые вы сможете использовать для продвижения. Парсить страницы можно неоднократно, постоянно обновляя базу.

Как делается парсинг групп vkontakte

Автоматизация всего процесса предполагает выполнение трех последовательных действий:

  • поиск и получение кода страницы ВК;
  • извлечение необходимого контента по ключевым словам;
  • генерация базы данных групп в указанном вами формате.

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

Когда нужны услуги парсинга

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

Pepper Ninja — обзор парсера групп ВКонтакте, Одноклассниках

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

И, несмотря на широкий функционал настроек в рекламных кабинетах (как в Фейсбук, так и во ВКонтакте), без стороннего сервиса по сбору целевой аудитории, осуществить настройку рекламы сложнее.

Конечно же, в ТОП известных русскоязычных парсеров, входит Pepper Ninja.

Прежде всего, поражает огромный функционал и возможности парсера. Удобно, что есть тестовый период. Всего лишь за вступление в официальную группу в ВК, вам предоставят месяц бесплатного пользования с ограниченным функционалом. Также сразу после регистрации, у вас есть 3 дня бесплатного пользования, чтобы вдоволь изучить сервис.

С чем работает парсер?

  • ВКонтакте
  • Instagram
  • Одноклассники
  • Facebook (можно собирать СНГ аудиторию из групп и публичных страниц, находится от 10 до 80% аудитории (почты и телефоны, которые можно загружать в рекламный кабинет фейсбука)

Функционал

Pepper Ninja имеет широкий… Нет! Широчайший спектр возможностей. Остановлюсь на некоторых из них:

Для ВКонтакте

  1. Самая простая функция, с которой я рекомендую начинать всем новичкам – «Кто мой клиент».

Идеально подходит для сообщества, в котором уже собрана пусть небольшая, но целевая аудитория. Т.e., если вы заведомо ранее получали подписчиков путем накрутки, эта функция не подойдет.

Суть, в том, что вы просто вводите ссылку на свое сообщество, а Pepper Ninja анализирует аудиторию, собирает похожую (по типу Look-a-like аудиторий в Facebook), отбирает сообщества, где состоит ваша аудитория и даже предоставляет подробную аналитику.

  1. Мониторинг сообществ

Позволяет отслеживать не просто количество вступивших в группу, но и сразу же парсить этих пользователей в свою базу.

  1. Поиск сообществ

Можно искать сообщества по ключевым словам, по степени вовлеченности участников в контент сообщества, по гео и типу сообщества. В 2018 г. поиск сообществ улучшили, теперь можно искать и по параметрам аудитории, например, найти группы, в которых состоит больше 70% женщин или сообщества, в которых менее 2% людей до 18 лет, также есть поиск по интересам аудитории и ее гео (именно аудитории, раньше было только гео групп) ну и еще появилась статистика групп и другие фильтры.

  1. Парсинг людей из сообщества

Здесь очень удобно, что собирать можно не всех подряд, а только активных. И даже можно указывать, в чем именно для вас заключается активность. Также в 2018 г. появилась кнопка «Быстрый парсинг» туда можно вставить любую ссылку (на группу, пост, человека и т.д.) и парсер сам покажет какую аудиторию можно по ней найти, можно искать посты, хештеги, выгружать аудиторию по гео (работает с ВК).

  1. Поиск целевой аудитории по пересечениям

Pepper Ninja показывает в каких еще группах в ВК пересекается ваша целевая аудитория, кроме той, что указали вы.

  1. Аудитория в 2 и более

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

  1. Родители

Нужно собрать только тех, у кого есть дети? Запросто. У Pepper Ninja даже отдельная вкладка для этого есть.

  1. Сканер виджетов на сайтах

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

  1. Популярные посты

Нужен вирусный контент? Используйте эту опцию. Аналог сервиса FeedSpy.

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

И еще (!!) по каждой готовой базе в кабинете отображается статистика, где можно посмотреть следующие характеристики участников:

  • Пол
  • Возраст
  • Гео
  • Профессию
  • Университеты
  • Сообщества, в которых состоят пользователи

P.S. В октябре 2018 г. ребята выкатили еще Парсинг по аудио или как искать меломанов.

Instagram

  1. Поиск по городам.

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

  1. Родственники и поиск родителей.

Все то же, что и для ВКонтакте.

  1. Конвертер.

Еще одна удобная функция – возможность конвертировать пользователей с Instagram профилей в аккаунты ВКонтакте и обратно.

Одноклассники

Здесь функционал ограничен. Вы можете или собирать аудиторию поста или аудиторию сообществ (причем, вторая функция сейчас в BETA версии).

Facebook

Нужна аналитика сообществ? В этом вопросе Pepper Ninja прекрасно справится. Просто введите нужную ссылку и вперед.

Метрика для ВКонтакте

Аналитика – ключ к успеху в любом интернет-бизнесе. Данная функция позволяет собрать группы в ВКонтакте, в которых состоят посетившие ваш сайт пользователи. Настоящая фантастика, не так ли?

Последние обновления сервиса также смотрите в вебинаре:

Преимущества сервиса:
  • удобный и интуитивно понятный интерфейс. Даже если вы – владелец бизнеса, и хотите запускать рекламные кампании самостоятельно, у вас все легко получится;
  • развернутый функционал и возможность фильтровать пользователей до идеального портрета целевой аудитории;
  • возможность настраивать периодические задания. То есть, вы можете заранее на таймер поставить задания, которые должны выполняться несколько раз в месяц;
  • наглядный раздел «Помощь» с видео инструкциями;
  • наличие блога с интересными статьями и кейсами;
  • удаленная работа сервиса. Вам просто нужно настроить задачи и можно смело выключать ПК;
  • не менее прекрасные партнеры сервиса: Popsters и Socialhammer.
Недостатки сервиса:

Единственным недостатком у сервиса можно назвать ограниченный функционал для социальных сетей Facebook и Одноклассники. С Instagram дела обстоят получше.

В целом, сервисом осталась очень довольна, и с уверенностью могу его рекомендовать, как новичкам в SMM, так и профи.

Автор: Валерия Головко

Источник: https://vlada-rykova.com/?p=6289


Данный материал является частной записью члена сообщества Club.CNews.
Редакция CNews не несет ответственности за его содержание.

Одноклассники Парсинг Групп, Вступление Zennoposter Шаблон

Ok.ru Парсинг, Вступление в Группы.

 

Парсит, вступает в группы.
Возможно задать критерий поиска групп.

 

Состоит из двух частей:
1.OD Groups Parser.xmlz – Парсинг
2.OD Groups Joiner.xmlz – Вступление

 

1. OD Groups Parser
Порядок Запуска:
Количество выполнений: -1 (или по числу запросов)
Максимальное число потоков: Неограниченно, но не больше чем кол-во аккаунтов в файле

 

Входные Данные:
Все входные данные для этого шаблона должны располагатся в папке data (файлы «profile.txt» и «key.txt»), которая должна находится в директории шаблона.

 

Profile.txt
Установите пароль и логин для входа в виде — login;password;proxy или просто в вид login;password
Строчки берутся из файла с удалением и записываются в конец файла.
Таким образом, профиля используются по кругу.

 

Key.txt
Ключевые фразы для парсинга групп.
Берётся случайная строка с удалением.
По умолчанию ищет ключевые слова в названии сообщества. В случае, если установить галочку в поле входных настроек «Поиск по тегам», ключевое слово будет искаться в тегах сообщества.
В случае, если данный файл пустой, ключевое слово введено не будет, а шаблон выдаст сообщение «Отсутствует ключевое слово»

 

Выходные Данные:
Выходные данные записываются в разные файлы в папку result.

Имя файла с результатами будет составлено из Ключевого слова, Страны, Города и будет содержать в себе ссылки на группы.
Пример Юмор.Россия.Москва.txt


2. OD Groups Joiner
Порядок Запуска:
Количество выполнений: -1
Максимальное число потоков: Неограниченно, но не больше чем кол-во аккаунтов в файле

 

Входные Данные:
Файл «profile.txt» должен располагаться в папкe data, которая должна находится в директории шаблона.

Profile.txt
Установите пароль и логин для входа в виде — login;password;proxy или просто в вид login;password
Строчки берутся из файла с удалением и записываются в конец файла.
Таким образом, профиля используются по кругу.

 

Файл, с ссылками на группы.
Если путь к файлу не указан во входных настройках, шаблон берет ссылки на группы из случайного файла из папки result. Т.е. из файлов, которые собрал первый шаблон OD  Groups Parser
Ссылки на группы в которые нужно вступить.
Сыылки берутся построчно с удалением или с записью в конец списка(согласно настройкам шаблона).

 

Выходные данные:
Если включена опция «Чекать группы на открытость стены», шаблон создаст файл open wall.txt в папке data и будет туда записывать ссылки на группы, в которых открыатя стена для постинга.

Также шаблон создает файл «black list.txt» в папке data (черный список групп) и папку zpprofile (в ней содержатся куки используемых аккаунтов)

 

В случае, если работа шаблона прекращается по ошибке (вследствие неверно заполненных данных или же  изменений на сайте), он автоматически создаёт отчётные файлы в папке error. Для того, чтобы вернуться к работе в кратчайшие сроки, вам нужно предпринять следующие шаги:
Если вы сталкиваетесь с проблемой впервые, запустите шаблон в один поток без прокси, и посмотрите, на каком месте происходит сбой. Опишите этот момент своими словами, и  пришлите описание на [email protected] вместе с архивом папки файлом «error».
Если вы ранее уже обращались в техподдержку, то перед тем, как запускать шаблон, удалите все файлы в папке «error». Выполнение перечисленных пунктов значительно ускорит решение вашей проблемы!

argparse — синтаксический анализатор параметров, аргументов и подкоманд командной строки — документация Python 3.9.5

Модуль argparse упрощает написание удобной для пользователя командной строки интерфейсы. Программа определяет, какие аргументы ей требуются, и argparse выяснит, как разобрать те из sys.argv . argparse модуль также автоматически генерирует справочные сообщения и сообщения об использовании и выдает ошибки когда пользователи предоставляют программе неверные аргументы.

Пример

Следующий код представляет собой программу Python, которая принимает список целых чисел и производит либо сумму, либо максимум:

 импорт argparse

parser = argparse.ArgumentParser (description = 'Обработать некоторые целые числа.')
parser.add_argument ('целые числа', metavar = 'N', type = int, nargs = '+',
                    help = 'целое число для аккумулятора')
parser.add_argument ('- сумма', dest = 'накопить', действие = 'store_const',
                    const = сумма, по умолчанию = макс,
                    help = 'суммировать целые числа (по умолчанию: найти максимум)')

args = парсер.parse_args ()
печать (args.accumulate (args.integers))
 

Предполагая, что приведенный выше код Python сохранен в файл с именем prog.py , он может запускается из командной строки и предоставляет полезные справочные сообщения:

 $ python prog.py -h
использование: prog.py [-h] [--sum] N [N ...]

Обработать несколько целых чисел.

позиционные аргументы:
 N целое число для аккумулятора

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --sum суммировать целые числа (по умолчанию: найти максимум)
 

При запуске с соответствующими аргументами выводит либо сумму, либо макс. целые числа командной строки:

 $ питон прог.ру 1 2 3 4
4

$ python prog.py 1 2 3 4 - сумма
10
 

Если переданы недопустимые аргументы, будет выдана ошибка:

 $ python prog.py а б в
использование: prog.py [-h] [--sum] N [N ...]
prog.py: ошибка: аргумент N: недопустимое значение int: 'a'
 

В следующих разделах представлен этот пример.

Создание парсера

Первым шагом в использовании argparse является создание ArgumentParser объект:

 >>> парсер = argparse.ArgumentParser (description = 'Обработать некоторые целые числа.')
 

Объект ArgumentParser будет содержать всю информацию, необходимую для проанализировать командную строку на типы данных Python.

Добавление аргументов

Заполнение ArgumentParser информацией об аргументах программы выполняется путем вызова метода add_argument () . Как правило, эти вызовы сообщают ArgumentParser , как принимать строки в командной строке и превратить их в объекты.Эта информация хранится и используется при вызове parse_args () . Например:

 >>> parser.add_argument ('целые числа', metavar = 'N', type = int, nargs = '+',
... help = 'целое число для аккумулятора')
>>> parser.add_argument ('- сумма', dest = 'накапливать', action = 'store_const',
... const = сумма, по умолчанию = max,
... help = 'суммировать целые числа (по умолчанию: найти максимум)')
 

Позже вызов parse_args () вернет объект с два атрибута, целых чисел и составляют .Атрибут целых чисел будет списком из одного или нескольких целых чисел, а атрибут накопить будет либо функция sum () , если в командной строке было указано --sum , или функция max () , если это не так.

Аргументы синтаксического анализа

ArgumentParser анализирует аргументы через parse_args () метод. Это проверит командную строку, преобразовать каждый аргумент в соответствующий тип и затем вызвать соответствующее действие.В большинстве случаев это означает, что простой объект Namespace будет создан из атрибуты, извлеченные из командной строки:

 >>> parser.parse_args (['- сумма', '7', '-1', '42'])
Пространство имен (накопление = <сумма встроенной функции>, целые числа = [7, -1, 42])
 

В сценарии parse_args () обычно вызывается без аргументы, а ArgumentParser автоматически определит аргументы командной строки из sys.argv .

Объекты ArgumentParser

класс argparse. ArgumentParser ( prog = None , usage = None , description = None , epilog = None , parent = [] , formatter_class = argparse. , fromfile_prefix_chars = Нет , argument_default = Нет , конфликт_handler = ‘error’ , add_help = True , allow_abbrev = True , exit_on_error = True6 )

Создайте новый объект ArgumentParser .Все параметры должны быть переданы как аргументы ключевого слова. Каждый параметр имеет свое более подробное описание. ниже, но вкратце они:

  • prog — Имя программы (по умолчанию: sys.argv [0] )

  • usage — Строка, описывающая использование программы (по умолчанию: генерируется из аргументы добавлены в парсер)

  • описание — текст, отображаемый перед справкой по аргументу (по умолчанию: нет)

  • эпилог — текст, отображаемый после справки по аргументу (по умолчанию: нет)

  • родителей — список из объектов ArgumentParser , аргументы которых должны также должны быть включены

  • formatter_class — Класс для настройки вывода справки

  • prefix_chars — Набор символов, предшествующих необязательным аргументам. (по умолчанию: ‘-‘)

  • fromfile_prefix_chars — Набор символов, префикс файлов из какие дополнительные аргументы следует читать (по умолчанию: Нет )

  • argument_default — Глобальное значение по умолчанию для аргументов (по умолчанию: Нет )

  • dancing_handler — Стратегия разрешения конфликтующих опций. (обычно не требуется)

  • add_help — Добавить параметр -h / - help в парсер (по умолчанию: True )

  • allow_abbrev — Позволяет сокращать длинные параметры, если аббревиатура однозначна.(по умолчанию: True )

  • exit_on_error — Определяет, завершается ли ArgumentParser с информация об ошибке при возникновении ошибки. (по умолчанию: True )

Изменено в версии 3.5: добавлен параметр allow_abbrev .

Изменено в версии 3.8: В предыдущих версиях allow_abbrev также отключал группировку коротких такие флаги, как -vv , означают -v -v .

Изменено в версии 3.9: exit_on_error Добавлен параметр .

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

прогр

По умолчанию объекты ArgumentParser используют sys.argv [0] для определения как отображать название программы в справочных сообщениях. Это значение по умолчанию почти всегда желательно, потому что это заставит справочные сообщения соответствовать тому, как была программа вызывается из командной строки. Например, рассмотрим файл с именем myprogram.py со следующим кодом:

 импорт argparse
parser = argparse.ArgumentParser ()
parser.add_argument ('- foo', help = 'foo help')
args = parser.parse_args ()
 

Справка для этой программы будет отображать myprogram.py как имя программы. (независимо от того, откуда была вызвана программа):

 $ python myprogram.py --help
использование: myprogram.py [-h] [--foo FOO]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo FOO foo help
$ cd..
Подкаталог $ python / myprogram.py --help
использование: myprogram.py [-h] [--foo FOO]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo FOO foo help
 

Чтобы изменить это поведение по умолчанию, можно указать другое значение с помощью prog = аргумент для ArgumentParser :

 >>> parser = argparse.ArgumentParser (prog = 'myprogram')
>>> parser.print_help ()
использование: myprogram [-h]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 

Обратите внимание, что имя программы, определенное ли из sys.argv [0] или из prog = аргумент, доступен для справочных сообщений в формате % (prog) s спецификатор.

 >>> parser = argparse.ArgumentParser (prog = 'myprogram')
>>> parser.add_argument ('- foo', help = 'foo программы% (prog) s')
>>> parser.print_help ()
использование: myprogram [-h] [--foo FOO]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo FOO foo программы myprogram
 

использование

По умолчанию ArgumentParser вычисляет сообщение об использовании из аргументов:

 >>> парсер = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- foo', nargs = '?', help = 'foo help')
>>> parser.add_argument ('bar', nargs = '+', help = 'bar help')
>>> parser.print_help ()
использование: PROG [-h] [--foo [FOO]] bar [bar ...]

позиционные аргументы:
 бар бар справка

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo [FOO] foo справка
 

Сообщение по умолчанию можно переопределить с помощью аргумента ключевого слова usage = :

 >>> парсер = argparse.ArgumentParser (prog = 'PROG', usage = '% (prog) s [options]')
>>> parser.add_argument ('- foo', nargs = '?', help = 'foo help')
>>> parser.add_argument ('bar', nargs = '+', help = 'bar help')
>>> parser.print_help ()
использование: PROG [параметры]

позиционные аргументы:
 бар бар справка

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo [FOO] foo справка
 

Описатель формата % (prog) s доступен для ввода имени программы в сообщения об использовании.

описание

Большинство вызовов конструктора ArgumentParser будут использовать description = аргумент ключевого слова. Этот аргумент дает краткое описание что делает программа и как она работает. В справочных сообщениях есть описание отображается между строкой использования командной строки и справочными сообщениями для различные аргументы:

 >>> parser = argparse.ArgumentParser (description = 'Фу, что мешает')
>>> parser.print_help ()
использование: argparse.ру [-h]

Фу, что бары

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 

По умолчанию описание переносится по строкам, чтобы оно соответствовало данное пространство. Чтобы изменить это поведение, см. Аргумент formatter_class.

эпилог

Некоторые программы любят отображать дополнительное описание программы после описание аргументов. Такой текст можно указать с помощью эпилога = . аргумент для ArgumentParser :

 >>> парсер = argparse.ArgumentParser (
... description = 'Фу, что барабанит',
... epilog = "Вот так и получился бы бар")
>>> parser.print_help ()
использование: argparse.py [-h]

Фу, что бары

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти

И вот как вы попали в бар
 

Как и в случае с аргументом описания, текст эпилога = по умолчанию обернутый строкой, но это поведение можно настроить с помощью formatter_class аргумент ArgumentParser .

родители

Иногда несколько синтаксических анализаторов имеют общий набор аргументов.Скорее, чем повторяя определения этих аргументов, единый парсер со всеми общие аргументы и переданы родителям = аргумента ArgumentParser может быть использован. Аргумент родителей = принимает список из ArgumentParser объекты, собирает из них все позиционные и необязательные действия и добавляет эти действия с создаваемым объектом ArgumentParser :

 >>> parent_parser = argparse.ArgumentParser (add_help = False)
>>> parent_parser.add_argument ('- родительский', type = int)

>>> foo_parser = argparse.ArgumentParser (родители = [parent_parser])
>>> foo_parser.add_argument ('фу')
>>> foo_parser.parse_args (['- родитель', '2', 'XXX'])
Пространство имен (foo = 'XXX', parent = 2)

>>> bar_parser = argparse.ArgumentParser (родители = [parent_parser])
>>> bar_parser.add_argument ('- бар')
>>> bar_parser.parse_args (['- bar', 'YYY'])
Пространство имен (bar = 'YYY', parent = None)
 

Обратите внимание, что большинство родительских парсеров будут указывать add_help = False .В противном случае ArgumentParser увидит два параметра -h / - help (один в родительском и один в дочернем) и вызывают ошибку.

Примечание

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

formatter_class

Объекты ArgumentParser позволяют настраивать форматирование справки с помощью указание альтернативного класса форматирования.В настоящее время существует четыре таких классов:

класс argparse. RawDescriptionHelpFormatter
класс argparse. RawTextHelpFormatter
класс argparse. ArgumentDefaultsHelpFormatter
класс argparse. MetavarTypeHelpFormatter

RawDescriptionHelpFormatter и RawTextHelpFormatter дают больше контроля над отображением текстовых описаний.По умолчанию объекты ArgumentParser переносят описание и тексты эпилога в справочных сообщениях командной строки:

 >>> parser = argparse.ArgumentParser (
... prog = 'PROG',
... description = '' 'это описание
... со странным отступом
... но это нормально '',
... эпилог = '' '
... аналогично этому эпилогу, в котором пробелы будут
... очиститься и чьи слова будут завернуты
... через пару строк '')
>>> парсер.print_help ()
использование: PROG [-h]

это описание было со странным отступом, но это нормально

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти

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

Передается RawDescriptionHelpFormatter как formatter_class = указывает, что описание и эпилог уже правильно отформатированы и не следует переносить по строкам:

 >>> парсер = argparse.ArgumentParser (
... prog = 'PROG',
... formatter_class = argparse.RawDescriptionHelpFormatter,
... description = textwrap.dedent ('' '\
... Пожалуйста, не перепутайте этот текст!
... --------------------------------
... Я сделал отступ
... именно так
...             Я хочу это
... '' '))
>>> parser.print_help ()
использование: PROG [-h]

Пожалуйста, не перепутайте этот текст!
--------------------------------
   Я сделал отступ
   именно так
   Я хочу это

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 

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

ArgumentDefaultsHelpFormatter автоматически добавляет информацию о значения по умолчанию для каждого из справочных сообщений аргумента:

 >>> parser = argparse.ArgumentParser (
... prog = 'PROG',
... formatter_class = argparse.ArgumentDefaultsHelpFormatter)
>>> parser.add_argument ('- foo', type = int, default = 42, help = 'FOO!')
>>> парсер.add_argument ('bar', nargs = '*', default = [1, 2, 3], help = 'BAR!')
>>> parser.print_help ()
использование: PROG [-h] [--foo FOO] [bar ...]

позиционные аргументы:
 бар БАР! (по умолчанию: [1, 2, 3])

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --фу-у-у-у! (по умолчанию: 42)
 

MetavarTypeHelpFormatter использует имя аргумента типа для каждого аргумент в качестве отображаемого имени для его значений (вместо использования dest как обычный форматтер):

 >>> парсер = argparse.ArgumentParser (
... prog = 'PROG',
... formatter_class = argparse.MetavarTypeHelpFormatter)
>>> parser.add_argument ('- foo', type = int)
>>> parser.add_argument ('bar', type = float)
>>> parser.print_help ()
использование: PROG [-h] [--foo int] float

позиционные аргументы:
  плавать

необязательные аргументы:
  -h, --help показать это справочное сообщение и выйти
  --foo int
 

prefix_chars

В большинстве параметров командной строки в качестве префикса используется , например -f / - foo .Парсеры, которые должны поддерживать другой или дополнительный префикс символы, например для вариантов например + f или / foo , можно указать их с помощью аргумента prefix_chars = в конструктор ArgumentParser:

 >>> parser = argparse.ArgumentParser (prog = 'PROG', prefix_chars = '- +')
>>> parser.add_argument ('+ f')
>>> parser.add_argument ('++ bar')
>>> parser.parse_args ('+ f X ++ bar Y'.split ())
Пространство имен (bar = 'Y', f = 'X')
 

Аргумент prefix_chars = по умолчанию равен '-' .Поставка комплекта символы, которые не включают - , приведут к тому, что параметры -f / - foo будут запрещено.

из файла_prefix_chars

Иногда, например, при работе с особенно длинными списками аргументов, может иметь смысл сохранить список аргументов в файле, а не печатать его в командной строке. Если аргумент fromfile_prefix_chars = передается ArgumentParser , затем аргументы, начинающиеся с любого из указанные символы будут рассматриваться как файлы и будут заменены символом аргументы они содержат.Например:

 >>> с open ('args.txt', 'w') как fp:
... fp.write ('- f \ nbar')
>>> parser = argparse.ArgumentParser (fromfile_prefix_chars = '@')
>>> parser.add_argument ('- f')
>>> parser.parse_args (['- f', 'foo', '@ args.txt'])
Пространство имен (f = 'bar')
 

Аргументы, считываемые из файла, по умолчанию должны быть по одному на строку (но см. Также convert_arg_line_to_args () ) и обрабатываются так, как если бы они были в том же месте, что и исходный аргумент ссылки на файл в команде линия.Итак, в приведенном выше примере выражение ['-f', 'foo', '@ args.txt'] считается эквивалентом выражения ['-f', 'foo', '-f', 'bar'] .

Аргумент fromfile_prefix_chars = по умолчанию равен Нет , что означает, что аргументы никогда не будут рассматриваться как ссылки на файлы.

аргумент_по умолчанию

Как правило, значения аргументов по умолчанию задаются либо путем передачи значения по умолчанию в add_argument () или позвонив в set_defaults () методов с определенным набором имя-значение пары.Однако иногда может быть полезно указать один для всего парсера по умолчанию для аргументов. Это можно сделать, передав argument_default = аргумент ключевого слова для ArgumentParser . Например, для глобального подавления создания атрибутов на parse_args () звонков, мы предоставляем argument_default = SUPPRESS :

 >>> parser = argparse.ArgumentParser (аргумент_default = argparse.SUPPRESS)
>>> parser.add_argument ('- foo')
>>> парсер.add_argument ('бар', nargs = '?')
>>> parser.parse_args (['- foo', '1', 'BAR'])
Пространство имен (bar = 'BAR', foo = '1')
>>> parser.parse_args ([])
Пространство имен ()
 

allow_abbrev

Обычно, когда вы передаете список аргументов в parse_args () метод ArgumentParser , он распознает сокращения длинных опций.

Эту функцию можно отключить, задав для allow_abbrev значение False :

 >>> парсер = argparse.ArgumentParser (prog = 'PROG', allow_abbrev = False)
>>> parser.add_argument ('- foobar', action = 'store_true')
>>> parser.add_argument ('- foonley', action = 'store_false')
>>> parser.parse_args (['- foon'])
использование: PROG [-h] [--foobar] [--foonley]
ПРОГ: ошибка: нераспознанные аргументы: --foon
 

конфликтующий обработчик

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

 >>> парсер = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- f', '--foo', help = 'old foo help')
>>> parser.add_argument ('- foo', help = 'new foo help')
Отслеживание (последний вызов последний):
 ..
ArgumentError: аргумент --foo: конфликтующая строка (строки) параметров: --foo
 

Иногда (например, при использовании родителей) может быть полезно просто переопределить любой более старые аргументы с той же строкой параметров. Чтобы получить такое поведение, значение «разрешение» может быть передано в аргумент конфликт_хандлер = ArgumentParser :

 >>> парсер = argparse.ArgumentParser (прог = 'ПРОГ', конфликт_хандлер = 'разрешить')
>>> parser.add_argument ('- f', '--foo', help = 'old foo help')
>>> parser.add_argument ('- foo', help = 'new foo help')
>>> parser.print_help ()
использование: PROG [-h] [-f FOO] [--foo FOO]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 -f FOO старый foo help
 --foo FOO новая справка foo
 

Обратите внимание, что объектов ArgumentParser удаляют действие, только если все его строки опций переопределяются.Итак, в приведенном выше примере старый -f / - foo действие сохраняется как действие -f , потому что только параметр --foo строка была переопределена.

add_help

По умолчанию объекты ArgumentParser добавляют параметр, который просто отображает справочное сообщение парсера. Например, рассмотрим файл с именем myprogram.py , содержащий следующий код:

 импорт argparse
parser = argparse.ArgumentParser ()
parser.add_argument ('- foo', help = 'foo help')
args = парсер.parse_args ()
 

Если в командной строке указано -h или --help , ArgumentParser будет напечатана справка:

 $ python myprogram.py --help
использование: myprogram.py [-h] [--foo FOO]

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo FOO foo help
 

Иногда бывает полезно отключить добавление этой опции справки. Этого можно добиться, передав False в качестве аргумента add_help = в ArgumentParser :

 >>> парсер = argparse.ArgumentParser (prog = 'PROG', add_help = False)
>>> parser.add_argument ('- foo', help = 'foo help')
>>> parser.print_help ()
использование: PROG [--foo FOO]

необязательные аргументы:
 --foo FOO foo help
 

Обычно используется опция справки -h / - help . Исключением является если указано prefix_chars = и не включает - , в в этом случае -h и --help не являются допустимыми параметрами. В в этом случае первый символ в prefix_chars используется для префикса варианты помощи:

 >>> парсер = argparse.ArgumentParser (prog = 'PROG', prefix_chars = '+ /')
>>> parser.print_help ()
использование: PROG [+ h]

необязательные аргументы:
  + h, ++ help показать это справочное сообщение и выйти
 

exit_on_error

Обычно, когда вы передаете недопустимый список аргументов в parse_args () метод ArgumentParser , он выйдет с информацией об ошибке.

Если пользователь хочет отлавливать ошибки вручную, эту функцию можно включить, установив exit_on_error Ложь :

 >>> парсер = argparse.ArgumentParser (exit_on_error = False)
>>> parser.add_argument ('- целые числа', type = int)
_StoreAction (option_strings = ['- integer'], dest = 'integer', nargs = None, const = None, default = None, type = , choices = None, help = None, metavar = None )
>>> попробуйте:
... parser.parse_args ('- целые числа a'.split ())
... кроме argparse.ArgumentError:
... print ('Обнаружена ошибка аргумента')
...
Перехват аргументаОшибка
 

Метод add_argument ()

ArgumentParser. add_argument ( имя или флаги … [, action ] [, nargs ] [, const ] [, default ] [, type ] [, choices ] [ , требуется ] [, help ] [, metavar ] [, dest ])

Определите, как следует анализировать один аргумент командной строки. Каждый параметр имеет собственное более подробное описание ниже, но вкратце они:

  • имя или флаги — Либо имя, либо список строк параметров, e.грамм. foo или -f, --foo .

  • действие — основной тип действия, выполняемого, когда этот аргумент встречается в командной строке.

  • nargs — количество аргументов командной строки, которые следует использовать.

  • const — Постоянное значение, требуемое для некоторых действий и выборок nargs.

  • по умолчанию — значение, полученное, если аргумент отсутствует в командная строка и если она отсутствует в объекте пространства имен.

  • type — Тип, в который должен быть преобразован аргумент командной строки.

  • вариантов — контейнер допустимых значений для аргумента.

  • требуется — можно ли опустить параметр командной строки (только опционально).

  • help — Краткое описание того, что делает аргумент.

  • metavar — Имя аргумента в сообщениях об использовании.

  • dest — Имя атрибута, добавляемого к объекту, возвращаемому parse_args () .

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

имя или флаги

Метод add_argument () должен знать, является ли необязательный аргумент, например -f или --foo , или позиционный аргумент, например список имена файлов, ожидается. Первые аргументы, переданные в add_argument () , следовательно, должно быть либо серией flags или простое имя аргумента. Например, необязательный аргумент может создаваться как:

 >>> парсер.add_argument ('- f', '--foo')
 

, в то время как позиционный аргумент может быть создан как:

 >>> parser.add_argument ('полоса')
 

При вызове parse_args () необязательные аргументы будут идентифицируется префиксом - , а остальные аргументы будут считаться равными быть позиционным:

 >>> parser = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- f', '--foo')
>>> parser.add_argument ('панель')
>>> парсер.parse_args (['BAR'])
Пространство имен (bar = 'BAR', foo = None)
>>> parser.parse_args (['BAR', '--foo', 'FOO'])
Пространство имен (bar = 'BAR', foo = 'FOO')
>>> parser.parse_args (['- foo', 'FOO'])
использование: PROG [-h] [-f FOO] bar
ПРОГ: ошибка: требуются следующие аргументы: бар
 

действие

Объекты ArgumentParser связывают аргументы командной строки с действиями. Эти действия могут делать что угодно с аргументами командной строки, связанными с их, хотя большинство действий просто добавляют атрибут к объекту, возвращаемому parse_args () .Аргумент ключевого слова action указывает как следует обрабатывать аргументы командной строки. Поставляемые акции:

  • «store» — просто сохраняет значение аргумента. Это по умолчанию действие. Например:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo')
    >>> parser.parse_args ('- foo 1'.split ())
    Пространство имен (foo = '1')
     
  • 'store_const' — Здесь хранится значение, указанное ключевым словом const аргумент.Действие 'store_const' чаще всего используется с необязательные аргументы, указывающие какой-то флаг. Например:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', action = 'store_const', const = 42)
    >>> parser.parse_args (['- foo'])
    Пространство имен (foo = 42)
     
  • 'store_true' и 'store_false' — это особые случаи 'store_const' используется для хранения значений True и False соответственно.Кроме того, они создают значения по умолчанию: , ложь, и Правда соответственно. Например:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', action = 'store_true')
    >>> parser.add_argument ('- bar', action = 'store_false')
    >>> parser.add_argument ('- baz', action = 'store_false')
    >>> parser.parse_args ('- foo --bar'.split ())
    Пространство имен (foo = True, bar = False, baz = True)
     
  • 'append' — сохраняет список и добавляет значение каждого аргумента в список.Это полезно для того, чтобы параметр можно было указывать несколько раз. Пример использования:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', action = 'append')
    >>> parser.parse_args ('- foo 1 --foo 2'.split ())
    Пространство имен (foo = ['1', '2'])
     
  • 'append_const' — Здесь хранится список и добавляется значение, указанное аргумент ключевого слова const для списка. (Обратите внимание, что ключевое слово const аргумент по умолчанию Нет .) Действие 'append_const' обычно полезно, когда несколько аргументов должны хранить константы в одном списке. Для пример:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- str', dest = 'types', action = 'append_const', const = str)
    >>> parser.add_argument ('- int', dest = 'types', action = 'append_const', const = int)
    >>> parser.parse_args ('- str --int'.split ())
    Пространство имен (types = [, ])
     
  • «count» — Подсчитывает, сколько раз встречается аргумент ключевого слова.Для Например, это полезно для увеличения уровня детализации:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- подробный', '-v', action = 'count', по умолчанию = 0)
    >>> parser.parse_args (['- vvv'])
    Пространство имен (подробное = 3)
     

    Обратите внимание, что по умолчанию будет Нет , если явно не установлено значение 0 .

  • 'help' — выводит полное справочное сообщение для всех параметров в текущий парсер, а затем завершает работу.По умолчанию действие справки автоматически добавлен в парсер. См. ArgumentParser для получения подробной информации о том, как вывод создан.

  • 'версия' — Ожидается, что версия = аргумент ключевого слова в add_argument () вызывает и выводит информацию о версии и выходит при вызове:

     >>> import argparse
    >>> parser = argparse.ArgumentParser (prog = 'PROG')
    >>> parser.add_argument ('- версия', действие = 'версия', версия = '% (prog) s 2.0 ')
    >>> parser.parse_args (['- версия'])
    ПРОГ 2.0
     
  • 'extend' — сохраняет список и расширяет значение каждого аргумента до список. Пример использования:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ("- foo", action = "extend", nargs = "+", type = str)
    >>> parser.parse_args (["- foo", "f1", "--foo", "f2", "f3", "f4"])
    Пространство имен (foo = ['f1', 'f2', 'f3', 'f4'])
     

Вы также можете указать произвольное действие, передав подкласс Action или другой объект, реализующий тот же интерфейс. BooleanOptionalAction доступен в argparse и добавляет поддержку логических действий, таких как --foo и --no-foo :

 >>> import argparse
>>> parser = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', действие = argparse.BooleanOptionalAction)
>>> parser.parse_args (['- no-foo'])
Пространство имен (foo = False)
 

Рекомендуемый способ создания настраиваемого действия — расширить Action , переопределение метода __call__ и опционально __init__ и format_usage метода.

Пример настраиваемого действия:

 >>> класс FooAction (argparse.Action):
... def __init __ (self, option_strings, dest, nargs = None, ** kwargs):
... если nargs не None:
... поднять ValueError ("наркотики запрещены")
... super () .__ init __ (option_strings, dest, ** kwargs)
... def __call __ (self, parser, namespace, values, option_string = None):
... print ('% r% r% r'% (пространство имен, значения, option_string))
... setattr (пространство имен, self.dest, values)
...
>>> parser = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', действие = FooAction)
>>> parser.add_argument ('бар', действие = FooAction)
>>> args = parser.parse_args ('1 --foo 2'.split ())
Пространство имен (bar = None, foo = None) '1' None
Пространство имен (bar = '1', foo = None) '2' '--foo'
>>> аргументы
Пространство имен (bar = '1', foo = '2')
 

Для получения дополнительной информации см. Действие .

нарг

Объекты ArgumentParser обычно связывают один аргумент командной строки с одно действие, которое необходимо предпринять.Аргумент ключевого слова nargs связывает различное количество аргументов командной строки с одним действием. Поддерживаемый значения:

  • N (целое число). N Будет собрано аргумента из командной строки вместе в список. Например:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', nargs = 2)
    >>> parser.add_argument ('bar', nargs = 1)
    >>> parser.parse_args ('c --foo a b'.расколоть())
    Пространство имен (bar = ['c'], foo = ['a', 'b'])
     

    Обратите внимание, что nargs = 1 дает список из одного элемента. Это отличается от значение по умолчанию, при котором элемент создается сам по себе.

  • '?' . Если возможно, из командной строки будет использован один аргумент, и выпускается как единое целое. Если аргумент командной строки отсутствует, значение из по умолчанию будет произведено. Обратите внимание, что для необязательных аргументов есть дополнительный случай — строка параметра присутствует, но не сопровождается аргумент командной строки.В этом случае будет получено значение из const. Некоторый примеры, чтобы проиллюстрировать это:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', nargs = '?', const = 'c', по умолчанию = 'd')
    >>> parser.add_argument ('bar', nargs = '?', по умолчанию = 'd')
    >>> parser.parse_args (['XX', '--foo', 'YY'])
    Пространство имен (bar = 'XX', foo = 'YY')
    >>> parser.parse_args (['XX', '--foo'])
    Пространство имен (bar = 'XX', foo = 'c')
    >>> parser.parse_args ([])
    Пространство имен (bar = 'd', foo = 'd')
     

    Одно из наиболее распространенных применений nargs = '?' — разрешить дополнительный ввод и выходные файлы:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('infile', nargs = '?', type = argparse.FileType ('r'),
    ... по умолчанию = sys.stdin)
    >>> parser.add_argument ('outfile', nargs = '?', type = argparse.FileType ('w'),
    ... по умолчанию = sys.stdout)
    >>> parser.parse_args (['input.txt', 'output.txt'])
    Пространство имен (infile = <_ io.TextIOWrapper name = 'input.txt' encoding = 'UTF-8'>,
              Outfile = <_ io.TextIOWrapper name = 'output.txt' encoding = 'UTF-8'>)
    >>> парсер.parse_args ([])
    Пространство имен (infile = <_ io.TextIOWrapper name = '' ​​encoding = 'UTF-8'>,
              Outfile = <_ io.TextIOWrapper name = '' encoding = 'UTF-8'>)
     
  • '*' . Все имеющиеся аргументы командной строки собраны в список. Обратите внимание, что обычно нет смысла использовать более одного позиционного аргумента с nargs = '*' , но несколько необязательных аргументов с nargs = '*' — это возможный. Например:

     >>> парсер = argparse.ArgumentParser ()
    >>> parser.add_argument ('- foo', nargs = '*')
    >>> parser.add_argument ('- бар', nargs = '*')
    >>> parser.add_argument ('baz', nargs = '*')
    >>> parser.parse_args ('a b --foo x y --bar 1 2'.split ())
    Пространство имен (bar = ['1', '2'], baz = ['a', 'b'], foo = ['x', 'y'])
     
  • '+' . Как и '*' , все присутствующие аргументы командной строки собраны в список. Кроме того, будет сгенерировано сообщение об ошибке, если не было присутствует хотя бы один аргумент командной строки.Например:

     >>> parser = argparse.ArgumentParser (prog = 'PROG')
    >>> parser.add_argument ('foo', nargs = '+')
    >>> parser.parse_args (['a', 'b'])
    Пространство имен (foo = ['a', 'b'])
    >>> parser.parse_args ([])
    использование: PROG [-h] foo [foo ...]
    PROG: error: необходимы следующие аргументы: foo
     

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

конст.

const аргумент add_argument () используется для хранения постоянные значения, которые не считываются из командной строки, но необходимы для различные действия ArgumentParser . Два наиболее распространенных его использования:

  • Когда add_argument () вызывается с action = 'store_const' или action = 'append_const' . Эти действия добавляют const значение одного из атрибутов объекта, возвращаемого parse_args () .Примеры см. В описании действия.

  • Когда add_argument () вызывается со строками параметров (например, -f или --foo ) и nargs = '?' . Это создает необязательный аргумент, за которым может следовать ноль или один аргумент командной строки. При разборе командной строки, если строка параметра встречается без аргумент командной строки, следующий за ним, вместо него будет принято значение const . Примеры см. В описании наргов.

С действиями 'store_const' и 'append_const' , const должен быть указан аргумент ключевого слова. Для других действий по умолчанию используется Нет .

по умолчанию

Все необязательные аргументы и некоторые позиционные аргументы могут быть опущены в командная строка. Аргумент ключевого слова по умолчанию для add_argument () , значение которого по умолчанию Нет , указывает, какое значение следует использовать, если аргумент командной строки отсутствует.Для необязательных аргументов используется значение по умолчанию , когда строка параметра не присутствовал в командной строке:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', по умолчанию = 42)
>>> parser.parse_args (['- foo', '2'])
Пространство имен (foo = '2')
>>> parser.parse_args ([])
Пространство имен (foo = 42)
 

Если в целевом пространстве имен уже установлен атрибут, действие по умолчанию не перепишу:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', по умолчанию = 42)
>>> parser.parse_args ([], пространство имен = argparse.Namespace (foo = 101))
Пространство имен (foo = 101)
 

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

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- length', по умолчанию = '10 ', type = int)
>>> parser.add_argument ('- width', по умолчанию = 10,5, type = int)
>>> parser.parse_args ()
Пространство имен (длина = 10, ширина = 10,5)
 

Для позиционных аргументов с nargs равным ? или * , значение по умолчанию используется при отсутствии аргумента командной строки:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('foo', nargs = '?', по умолчанию = 42)
>>> парсер.parse_args (['а'])
Пространство имен (foo = 'a')
>>> parser.parse_args ([])
Пространство имен (foo = 42)
 

Предоставление default = argparse.SUPPRESS не приводит к добавлению атрибутов, если аргумент командной строки отсутствовал:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', по умолчанию = argparse.SUPPRESS)
>>> parser.parse_args ([])
Пространство имен ()
>>> parser.parse_args (['- foo', '1'])
Пространство имен (foo = '1')
 

тип

По умолчанию синтаксический анализатор считывает аргументы командной строки как простую струны.Однако довольно часто строка командной строки должна быть интерпретируется как другой тип, например float или int . В тип ключевое слово для add_argument () разрешает любое необходимая проверка типов и преобразование типов, которые должны быть выполнены.

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

Аргументом типа может быть любой вызываемый объект, который принимает единственную строку.Если функция вызывает ArgumentTypeError , TypeError или ValueError , исключение перехвачено и красиво отформатированная ошибка отображается сообщение. Никакие другие типы исключений не обрабатываются.

Общие встроенные типы и функции могут использоваться как преобразователи типов:

 импорт argparse
импортировать pathlib

parser = argparse.ArgumentParser ()
parser.add_argument ('количество', тип = целое)
parser.add_argument ('расстояние', тип = float)
parser.add_argument ('улица', тип = ascii)
парсер.add_argument ('точка_кода', тип = ord)
parser.add_argument ('исходный_файл', тип = открытый)
parser.add_argument ('dest_file', type = argparse.FileType ('w', encoding = 'latin-1'))
parser.add_argument ('путь к данным', тип = pathlib.Path)
 

Также могут использоваться пользовательские функции:

 >>> def через дефис (строка):
... вернуть '-'. join ([word [: 4] вместо слова в string.casefold (). split ()])
...
>>> parser = argparse.ArgumentParser ()
>>> _ = parser.add_argument ('short_title', тип = с дефисом)
>>> парсер.parse_args (['"Повесть о двух городах"'])
Пространство имен (short_title = '"сказка о двух городах')
 

Функция bool () не рекомендуется в качестве преобразователя типов. Все это делает преобразует пустые строки в False , а непустые строки в True . Обычно это не то, что нужно.

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

Например, преобразования JSON или YAML имеют сложные случаи ошибок, требующие лучшая отчетность, чем может дать ключевое слово типа . An JSONDecodeError не будет хорошо отформатирован и FileNotFound исключение не обрабатывается вообще.

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

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

варианта

Некоторые аргументы командной строки следует выбирать из ограниченного набора значений.С ними можно справиться, передав объект-контейнер в качестве ключевого слова choices аргумент для add_argument () . Когда командная строка проанализированы, значения аргументов будут проверены, и будет отображено сообщение об ошибке если аргумент не был одним из допустимых значений:

 >>> parser = argparse.ArgumentParser (prog = 'game.py')
>>> parser.add_argument ('move', choices = ['камень', 'бумага', 'ножницы'])
>>> parser.parse_args (['камень'])
Пространство имен (move = 'rock')
>>> парсер.parse_args (['огонь'])
использование: game.py [-h] {камень, ножницы, бумага}
game.py: ошибка: перемещение аргумента: неверный выбор: 'огонь' (выберите из 'рок',
'бумага', 'ножницы')
 

Обратите внимание, что включение в контейнер choices проверяется после любого типа преобразования были выполнены, поэтому тип объектов в выборе контейнер должен соответствовать указанному типу:

 >>> parser = argparse.ArgumentParser (prog = 'doors.py')
>>> parser.add_argument ('дверь', type = int, choices = range (1, 4))
>>> print (parser.parse_args (['3']))
Пространство имен (door = 3)
>>> parser.parse_args (['4'])
использование: doors.py [-h] {1,2,3}
Door.py: ошибка: аргумент дверь: неверный выбор: 4 (выберите из 1, 2, 3)
 

Любой контейнер может быть передан как значение choices , поэтому перечисляет объекта, устанавливает объекта, и все настраиваемые контейнеры поддерживаются.

Использование перечисления enum.Enum не рекомендуется, поскольку его трудно контролировать его внешний вид в сообщениях об использовании, справке и ошибках.

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

требуется

В общем, модуль argparse предполагает, что такие флаги, как -f и --bar укажите необязательных аргумента , которые всегда можно опустить в командной строке.Чтобы сделать опцию обязательной, можно указать , True , если требуется = . аргумент ключевого слова для add_argument () :

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', обязательно = True)
>>> parser.parse_args (['- foo', 'BAR'])
Пространство имен (foo = 'BAR')
>>> parser.parse_args ([])
использование: [-h] --foo FOO
: error: необходимы следующие аргументы: --foo
 

Как показано в примере, если опция отмечена как , требуется , parse_args () сообщит об ошибке, если эта опция не указана. присутствует в командной строке.

Примечание

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

справка

Справка Значение — это строка, содержащая краткое описание аргумента. Когда пользователь запрашивает помощь (обычно с помощью -h или --help в командная строка), эти описания справки будут отображаться с каждым аргумент:

 >>> парсер = argparse.ArgumentParser (prog = 'frobble')
>>> parser.add_argument ('- foo', action = 'store_true',
... help = 'foo the bars before frobbling')
>>> parser.add_argument ('bar', nargs = '+',
... help = 'одна из полосок, которую нужно заморозить')
>>> parser.parse_args (['- h'])
использование: frobble [-h] [--foo] bar [bar ...]

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

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 --foo foo the bars перед замораживанием
 

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

 >>> parser = argparse.ArgumentParser (prog = 'frobble')
>>> parser.add_argument ('bar', nargs = '?', type = int, по умолчанию = 42,
... help = 'полоса до% (prog) s (по умолчанию:% (default) s)')
>>> parser.print_help ()
использование: frobble [-h] [bar]

позиционные аргументы:
 заблокировать полосу до замораживания (по умолчанию: 42)

необязательные аргументы:
 -h, --help показать это справочное сообщение и выйти
 

Поскольку строка справки поддерживает% -форматирование, если вы хотите, чтобы появился литерал % в строке справки вы должны экранировать его как %% .

argparse поддерживает отключение записи справки для определенных параметров с помощью установка значения help на argparse.SUPPRESS :

 >>> parser = argparse.ArgumentParser (prog = 'frobble')
>>> parser.add_argument ('- foo', help = argparse.SUPPRESS)
>>> parser.print_help ()
использование: frobble [-h]

необязательные аргументы:
  -h, --help показать это справочное сообщение и выйти
 

dest

Большинство действий ArgumentParser добавляют некоторое значение в качестве атрибута объект, возвращенный parse_args () .Название этого атрибут определяется аргументом ключевого слова dest add_argument () . Для позиционных аргументов действия dest обычно предоставляется в качестве первого аргумента для add_argument () :

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('панель')
>>> parser.parse_args (['XXX'])
Пространство имен (bar = 'XXX')
 

Для действий с дополнительным аргументом значение dest обычно выводится из строки параметров. ArgumentParser генерирует значение dest с помощью взяв первую длинную строку опционов и убрав начальные - нить. Если не были предоставлены длинные строки опций, dest будет производным от первая короткая строка параметра, удалив начальный символ . Любой внутренние - символа будут преобразованы в _ символа, чтобы убедиться, что строка является допустимым именем атрибута. Примеры ниже иллюстрируют это поведение:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- f', '--foo-bar', '--foo')
>>> parser.add_argument ('- x', '-y')
>>> parser.parse_args ('- f 1 -x 2'.split ())
Пространство имен (foo_bar = '1', x = '2')
>>> parser.parse_args ('- foo 1 -y 2'.split ())
Пространство имен (foo_bar = '1', x = '2')
 

dest позволяет указать имя настраиваемого атрибута:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo', dest = 'bar')
>>> парсер.parse_args ('- foo XXX'.split ())
Пространство имен (bar = 'XXX')
 

Классы действия

Классы действий реализуют API действий, вызываемый объект, который возвращает вызываемый объект. который обрабатывает аргументы из командной строки. Любой объект, следующий за этот API может быть передан как параметр действия в add_argument () .

класс argparse. Действие ( option_strings , dest , nargs = None , const = None , default = None , type = None , choices = None , required, required = required = required = false4 9010 help = Нет , metavar = Нет )

Объекты Action используются ArgumentParser для представления информации необходимо для синтаксического анализа одного аргумента из одной или нескольких строк из командная строка.Класс Action должен принимать два позиционных аргумента плюс любые аргументы ключевого слова, переданные в ArgumentParser.add_argument () кроме самого действия .

экземпляров действия (или возвращаемое значение любого вызываемого действия параметр) должен иметь атрибуты «dest», «option_strings», «default», «type», Определение «требуется», «помощь» и т. Д. Самый простой способ обеспечить эти атрибуты определены, это вызвать Action .__ init__ .

Экземпляры Action должны быть вызываемыми, поэтому подклассы должны переопределять __call__ метод, который должен принимать четыре параметра:

  • parser — Объект ArgumentParser, который содержит это действие.

  • namespace — Объект Namespace , который будет возвращен parse_args () . Большинство действий добавляют атрибут к этому объект с помощью setattr () .

  • значений — Связанные аргументы командной строки с любыми преобразованиями типов применяемый. Преобразования типов указываются с помощью аргумента ключевого слова типа в add_argument () .

  • option_string — Строка параметра, которая использовалась для вызова этого действия.Аргумент option_string является необязательным и будет отсутствовать, если действие связан с позиционным аргументом.

Метод __call__ может выполнять произвольные действия, но обычно устанавливает атрибуты в пространстве имен на основе dest и значений .

Подклассы

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

Метод parse_args ()

ArgumentParser. parse_args ( args = None , namespace = None )

Преобразовать строки аргументов в объекты и назначить их как атрибуты пространство имен. Верните заполненное пространство имен.

Предыдущие вызовы add_argument () точно определяют, какие объекты созданы и как они назначены.Документацию для add_argument () для подробностей.

  • args — Список строк для синтаксического анализа. По умолчанию берется из sys.argv .

  • пространство имен — объект, принимающий атрибуты. По умолчанию новый пустой Объект пространства имен .

Синтаксис значения опции

Метод parse_args () поддерживает несколько способов указание значения опции (если она нужна).В простейшем случае параметр и его значение передаются как два отдельных аргумента:

 >>> parser = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- x')
>>> parser.add_argument ('- foo')
>>> parser.parse_args (['- x', 'X'])
Пространство имен (foo = None, x = 'X')
>>> parser.parse_args (['- foo', 'FOO'])
Пространство имен (foo = 'FOO', x = None)
 

Для длинных опций (опций с именами длиннее одного символа) опция и значение также можно передать как один аргумент командной строки, используя = для разделить их:

 >>> парсер.parse_args (['- foo = FOO'])
Пространство имен (foo = 'FOO', x = None)
 

Для коротких опций (варианты длиной всего один символ), опция и ее значение можно объединить:

 >>> parser.parse_args (['- xX'])
Пространство имен (foo = None, x = 'X')
 

Несколько коротких вариантов можно объединить, используя только один префикс - , если только последний вариант (или ни один из них) не требует значения:

 >>> parser = argparse.ArgumentParser (prog = 'PROG')
>>> парсер.add_argument ('- x', действие = 'store_true')
>>> parser.add_argument ('- y', action = 'store_true')
>>> parser.add_argument ('- z')
>>> parser.parse_args (['- xyzZ'])
Пространство имен (x = True, y = True, z = 'Z')
 

Неверные аргументы

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

 >>> парсер = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- foo', type = int)
>>> parser.add_argument ('bar', nargs = '?')

>>> # недопустимый тип
>>> parser.parse_args (['- foo', 'spam'])
использование: PROG [-h] [--foo FOO] [bar]
ПРОГ: ошибка: аргумент --foo: недопустимое значение int: 'спам'

>>> # неверный вариант
>>> parser.parse_args (['- bar'])
использование: PROG [-h] [--foo FOO] [bar]
ПРОГ: ошибка: нет такой опции: --bar

>>> # неправильное количество аргументов
>>> парсер.parse_args (['спам', 'барсук])
использование: PROG [-h] [--foo FOO] [bar]
ПРОГ: ошибка: найдены лишние аргументы: барсук
 

Аргументы, содержащие

-

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

 >>> парсер = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- x')
>>> parser.add_argument ('foo', nargs = '?')

>>> # нет опций с отрицательными числами, поэтому -1 - позиционный аргумент
>>> parser.parse_args (['- x', '-1'])
Пространство имен (foo = None, x = '- 1')

>>> # нет опций с отрицательными числами, поэтому -1 и -5 являются позиционными аргументами
>>> parser.parse_args (['- x', '-1', '-5'])
Пространство имен (foo = '- 5', x = '- 1')

>>> parser = argparse.ArgumentParser (prog = 'PROG')
>>> парсер.add_argument ('- 1', dest = 'один')
>>> parser.add_argument ('foo', nargs = '?')

>>> # присутствуют отрицательные числа, поэтому -1 - это вариант
>>> parser.parse_args (['- 1', 'X'])
Пространство имен (foo = None, one = 'X')

>>> # присутствуют отрицательные числа, поэтому -2 - это вариант
>>> parser.parse_args (['- 2'])
использование: PROG [-h] [-1 ONE] [foo]
ПРОГ: ошибка: нет такой опции: -2

>>> # присутствуют варианты с отрицательными числами, поэтому оба значения -1 являются вариантами
>>> parser.parse_args (['- 1', '-1'])
использование: PROG [-h] [-1 ONE] [foo]
ПРОГ: ошибка: аргумент -1: ожидался один аргумент
 

Если у вас есть позиционные аргументы, которые должны начинаться с и не смотрите как и отрицательные числа, вы можете вставить псевдо-аргумент '-' , который сообщает parse_args () что все после этого является позиционным аргумент:

 >>> парсер.parse_args (['-', '-f'])
Пространство имен (foo = '- f', one = None)
 

Сокращения аргументов (сопоставление префиксов)

Метод parse_args () по умолчанию позволяет сокращать длинные параметры до префикса, если это сокращение однозначный (префикс соответствует уникальному варианту):

 >>> parser = argparse.ArgumentParser (prog = 'PROG')
>>> parser.add_argument ('- бекон')
>>> parser.add_argument ('- барсук')
>>> parser.parse_args ('- bac MMM'.расколоть())
Пространство имен (bacon = 'MMM', badger = None)
>>> parser.parse_args ('- плохой WOOD'.split ())
Пространство имен (бекон = Нет, барсук = 'ДЕРЕВО')
>>> parser.parse_args ('- ba BA'.split ())
использование: PROG [-h] [-bacon BACON] [-badger BADGER]
ПРОГ: ошибка: неоднозначный параметр: -ba может соответствовать -badger, -bacon
 

Ошибка возникает для аргументов, которые могут давать более одного варианта. Эту функцию можно отключить, установив для параметра allow_abbrev значение False .

Beyond

sys.argv

Иногда может быть полезно иметь аргументы синтаксического анализа ArgumentParser, отличные от из систем.argv . Это можно сделать, передав список строк в parse_args () . Это полезно для тестирования на интерактивная подсказка:

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument (
... 'целые числа', metavar = 'int', type = int, choices = range (10),
... nargs = '+', help = 'целое число в диапазоне 0..9')
>>> parser.add_argument (
... '--sum', dest = 'Накопить', action = 'store_const', const = sum,
... по умолчанию = max, help = 'суммировать целые числа (по умолчанию: найти максимум)')
>>> парсер.parse_args (['1', '2', '3', '4'])
Пространство имен (накопление = <встроенная функция max>, целые числа = [1, 2, 3, 4])
>>> parser.parse_args (['1', '2', '3', '4', '--sum'])
Пространство имен (накопление = <сумма встроенных функций>, целые числа = [1, 2, 3, 4])
 

Объект пространства имен

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

Простой класс, используемый по умолчанию parse_args () для создания объект, содержащий атрибуты, и вернуть его.

Этот класс намеренно прост, просто подкласс объекта с читаемое строковое представление. Если вы предпочитаете, чтобы атрибуты, вы можете использовать стандартную идиому Python, vars () :

 >>> парсер = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo')
>>> args = parser.parse_args (['- foo', 'BAR'])
>>> vars (аргументы)
{'foo': 'BAR'}
 

Также может быть полезно, чтобы ArgumentParser назначал атрибуты объекту уже существующий объект, а не новый объект Namespace .Это может достигается путем указания аргумента ключевого слова namespace = :

 >>> класс C:
...     проходить
...
>>> c = C ()
>>> parser = argparse.ArgumentParser ()
>>> parser.add_argument ('- foo')
>>> parser.parse_args (args = ['- foo', 'BAR'], namespace = c)
>>> c.foo
'БАР'
 

python — Разбор вложенных групп скобок / скобок

Я пытаюсь разобрать файлы, которые выглядят так:

  МСХ
[PD1]
[{ROL}]
[
  {ROL}
]
[
    {
        PR1
        [{ROL}]
    }
]
[
    {
        В 1
        [IN2]
        [{IN3}]
    }
]
[ACC]
  

Где:

  • 3 отдельных буквенно-цифровых символа представляют СЕГМЕНТ
  • [SEGMENT] представляет собой необязательный сегмент
  • {SEGMENT} представляет собой повторяющийся сегмент
  • [{SEGMENT}] представляет необязательный повторяющийся сегмент
  • Любой из вышеперечисленных профилей СЕГМЕНТА можно сгруппировать во вложении. Необязательные ([]) и / или повторяющиеся ({}) ГРУППЫ.
  • Примерами вложенных повторяющихся групп являются строки 4-19 в приведенном выше коде.

Идеальный результат будет примерно таким:

  {
  "MSH": {
    "name": "заполнитель",
    "opt": false,
    "rep": ложь,
    "description": "Обычный сегмент"
  },
  "PD1": {
    "name": "заполнитель",
    "opt": правда,
    "rep": ложь,
    "description": "Необязательный сегмент"
  },
  // здесь несколько сегментов
  "группа": {
    "opt": правда,
    "rep": ложь,
    "description": "Текст заполнителя необязательной группы",
    "segment0": {
      "ROL": {
        "name": "заполнитель",
        "opt": false,
        "rep": правда,
        "description": "Повторяющийся сегмент"
      }
    }
  }
}
  

Я прочитал большинство сообщений о pyparsing на SO и вики Pyparsing, включая fourFn.py примеры и regexinverter. Я считаю, что мне нужно использовать Infixnotation , но я не совсем понимаю, как его использовать.

Это то, что у меня есть:

  lbrack = pp.Literal ("[")
rbrack = pp.Literal ("]")
lbrace = pp.Literal ("{")
rbrace = pp.Literal ("}")
сегмент = стр. слово (стр. букв, точное = 3)
optsegment = lbrack + сегмент + rbrack
repsegment = lbrace + сегмент + rbrace
optrepsegment = lbrack + lbrace + сегмент + rbrace + rbrack


сегменты = (segment.setResultsName ("RawSegment") |
           optsegment.setResultsName («Необязательный сегмент») |
           repsegment.setResultsName («Повторяющийся сегмент») |
           optrepsegment.setResultsName ("OptionalRepeatingSegment"))

opt_group = pp.Group (lbrack + сегменты + rbrack)
rep_group = pp.Group (lbrace + сегменты + rbrace)

message = pp.Group (сегменты | opt_group | rep_group)

expr = pp.infixNotation (сообщение,
            [
            ('[', 2, стр. OpAssoc.LEFT),
            ('{', 2, стр. OpAssoc.LEFT),
            ('}', 1, стр. OpAssoc.RIGHT),
            (']', 1, стр.opAssoc.RIGHT),
            ])

msg = message.searchString (данные)

для элемента в сообщении:
    печать (элемент)
  

Я еще не придумал формат вывода, я просто пытаюсь правильно проанализировать вывод на этом этапе.

Анализируйте шаблоны переменных с помощью Regex

  1. Последнее обновление
  2. Сохранить как PDF
  1. Синтаксис
  2. Параметры
  3. Правила
  4. Примеры
    1. Разбор IP-адреса
    2. Указание условия ИЛИ для использования групп без захвата
    3. Parse multi
    4. Регулярное выражение синтаксического анализа без учета регистра
(также называемый оператором извлечения) позволяет пользователям, которые привыкли к синтаксису регулярных выражений, извлекать более сложные данные из строк журнала.Регулярное выражение синтаксического анализа можно использовать, например, для извлечения вложенных полей.

Поля, добавленные пользователем, такие как извлеченные или проанализированные поля, могут быть названы с использованием буквенно-цифровых символов, а также символов подчеркивания («_»). Они должны начинаться и заканчиваться буквенно-цифровым символом.

Дополнительную информацию о регулярных выражениях см. В документации Perl. Или попробуйте тестер регулярных выражений на regex101.com.

Синтаксис

  • | синтаксический анализ регулярного выражения "<начальное_выражение> (? ) "
  • | синтаксический анализ регулярного выражения "<начальное_выражение> (? ) " [nodrop]
  • | синтаксический анализ регулярного выражения [field = ] " (? ) "
  • Вы можете использовать альтернативный термин «экстракт».
    | extract "<начальное_выражение> (? ) "

Опции

  • field =

    Параметр field = fieldname позволяет указать поле для синтаксического анализа, отличное от сообщения по умолчанию. Дополнительные сведения см. В разделе «Поле синтаксического анализа».

  • нодроп

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

    .
  • мульти

    Параметр multi позволяет анализировать несколько значений в пределах в одном сообщении журнала. См. Parse multi.

Правила

  • Регулярное выражение должно быть действительным регулярным выражением JAVA или RE2, заключенным в кавычки.
  • При сопоставлении учитывается регистр. Если какой-либо из текстовых сегментов не может быть сопоставлен, то ни одна из переменных не будет назначена.
  • Если поле не указано, то используется весь текст входящих сообщений.
  • Несколько выражений синтаксического анализа обрабатываются в том порядке, в котором они указаны. Сопоставление каждого выражения всегда начинается с начала строки сообщения.
  • Несколько синтаксических выражений можно записать сокращенно, используя термины, разделенные запятыми.
  • Может использоваться с оператором привязки синтаксического анализа.
  • Вложение именованных групп захвата не поддерживается.
  • Оператор синтаксического анализа регулярных выражений поддерживает только регулярные выражения, содержащие хотя бы одну именованную группу захвата.Мы не поддерживаем регулярные выражения, которые либо не имеют групп захвата, либо содержат безымянную / пронумерованную группу захвата. Для получения дополнительной информации см. Именованные группы захвата.

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

    Заключите все в круглые скобки и добавьте «? », за которым следует имя группы захвата, заключенное в« <> ». Давайте посмотрим на пример ниже, выделенные части — это то, что было добавлено.

    Обычное регулярное выражение Регулярное выражение с именованной группой захвата
    \ d {3} - [\ w] * (? \ d {3} - [\ w] *)

    Если ваше регулярное выражение содержит группу захвата (часть регулярного выражения заключена в круглые скобки), у вас есть два варианта:

    1. Вы можете преобразовать его в группу без захвата.В этом случае мы не будем извлекать эту часть вашего регулярного выражения в поле Sumo. Вы можете легко преобразовать их, добавив «?: » к группе сразу после начальной скобки.

    Этот подход не будет работать, если в вашем регулярном выражении есть только группы, не требующие захвата. У вас должна быть хотя бы одна группа захвата в вашем регулярном выражении.
    Обычное регулярное выражение Регулярное выражение с незахватываемой группой
    (abc | \ d {3}) (?: Abc | \ d {3})
    1. Если вы хотите извлечь значение из пронумерованной группы захвата в именованную группу захвата в регулярном выражении, вы можете преобразовать его в именованную группу захвата.Сделайте это, добавив «? », заключив имя группы захвата в« <> ». Sumo сгенерирует поле с тем же именем, которое указано в названной группе захвата.

    Обычное регулярное выражение Регулярное выражение с именованной группой захвата
    (abc | \ d {3}) (? abc | \ d {3})

Примеры

Анализ IP-адреса

Извлечение IP-адресов из журналов осуществляется напрямую с помощью регулярного выражения синтаксического анализа, подобного:

... | синтаксический анализ регулярного выражения "(? \ d {1,3} \. \ d {1,3} \. \ d {1,3} \. \ d {1,3})" | ...

Анализ нескольких полей в одном запросе.

Регулярное выражение Parse поддерживает анализ нескольких полей в одном запросе. Например, предположим, что мы хотим проанализировать имя пользователя и информацию о хосте из журналов. Используйте запрос, похожий на:

... | синтаксический анализ регулярного выражения "user = (? . *?):"
| синтаксический анализ регулярного выражения "host = (? . *?):"
| ...

Указывает условие ИЛИ для использования групп без захвата

В ситуациях, когда вы хотите использовать условие ИЛИ, когда у вас есть несколько возможностей, которые могут соответствовать регулярному выражению, лучше всего использовать групп без захвата (?: Regex) .

Язык запросов Sumo Logic требует, чтобы группы, которые не захватываются псевдонимом, были явно помечены как группы без захвата.

Чтобы указать список альтернативных строк в регулярном выражении, используйте групповой синтаксис. Например, для следующих двух строк журнала:

11 октября 18:20:49 host123.example.com 16234563: 11 октября 18:20:49:% SEC-6-IPACCESSLOGP: список 101 запрещен tcp 10.1.2.3 (1234) -> 10.1.2.4 (5678), 1 пакет
11 октября 18:20:49 host123.example.com 16234564: 11 октября 18:20:49:% SEC-6-IPACCESSLOGP: список 101 принят tcp 10.1.2.5 (4321) -> 10.1.2.6 (8765), 1 пакет 

вы можете написать следующий запрос для извлечения «протокола»:

| анализировать регулярное выражение "список 101 (принято | отклонено) (? <протокол>. *?)"

Итак, вы на самом деле написали бы:

| анализировать регулярное выражение "список 101 (?: принято | отклонено) (? <протокол>. *?)"

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

| parse regex "список 101 (? <статус> принят | отклонен) (? <протокол>.*?) "

Разобрать мульти

В дополнение к синтаксическому анализу значения поля, опция multi (также называемая синтаксическим анализом multi) позволяет вам анализировать несколько значений в пределах одного сообщения журнала. Это означает, что ключевое слово multi указывает оператору синтаксического анализа регулярного выражения искать не только первое значение в сообщении журнала, но и все значения, даже в сообщениях с различным числом значений. В рамках этого процесса ключевое слово multi создает копии каждого сообщения, чтобы можно было подсчитать каждое отдельное значение в поле.

Например, в журналах потоков Amazon VPC вы можете идентифицировать сообщения с одинаковыми IP-адресами источника и назначения с помощью синтаксического анализа регулярных выражений multi.

_sourceCategory = aws / vpc
| синтаксический анализ регулярного выражения "(? \ d {1,3} \. \ d {1,3} \. \ d {1,3} \. \ d {1,3})" multi
| подсчитать по ip_address, _raw
| где _count> 1

Результат выглядит так:

Регулярное выражение синтаксического анализа без учета регистра

Вы можете указать синтаксическому анализатору использовать нечувствительность к регистру, указав параметр регулярного выражения (? I) .Например, предположим, что у нас есть следующие сообщения журнала:

Строка1: Сообщалось о следующем исключении: ошибка в журнале Строка2: Сообщалось о следующем исключении: Ошибка в журнале Строка3: Сообщалось о следующем исключении: ОШИБКА в журнале

Используйте следующее выражение регулярного выражения синтаксического анализа, чтобы сопоставить «ошибку» в журналах. (? I) указывает синтаксическому анализатору игнорировать регистр в завершающем выражении.

| parse regex "сообщил: \ s (? (? i) error) \ s"

Это приведет к следующим проанализированным полям

Исключение Сообщение
ОШИБКА Строка 3: Сообщение о следующем исключении: ОШИБКА в журнале
Ошибка Строка2: Было зарегистрировано следующее исключение: Ошибка в журнале
ошибка Строка1: Было зарегистрировано следующее исключение: ошибка в журнале

Также можно использовать операторы toLowerCase и toUpperCase.

Анализ групп Active Directory — AuditScripts.com

В предыдущем посте мы поделились сценарием PowerShell, который позволяет аудитору анализировать список групп и членов групп в системе Microsoft Windows в рамках процесса оценки безопасности или определения базовых значений. Однако возник вопрос — что, если кто-то захочет выполнить тот же процесс, но вместо этого проанализирует список групп Active Directory и их членов?

Оказывается, намного проще выполнить задачу с Active Directory, чем с локальной базой данных Microsoft Windows Local Security Accounts Manager (SAM).Похоже, что встроенные возможности командлетов PowerShell в Active Directory облегчат нам выполнение этой задачи.

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

Код, который мы использовали для анализа списка групп AD и их членов:

 Get-ADGroup -Filter * | ForEach-Object {
    $ GroupName = $ _.Имя
    $ Members = Get-ADGroupMember $ _. Samaccountname -Recursive | foreach {$ _. Name}
        Если ($ Members.count -ge 1) {
            $ Out = $ GroupName + "," + [String] :: Join (",", $ Members)
            $ out | Out-File -append ad_group_members.txt
        }
        Еще{
            $ Out = $ GroupName
            $ out | Out-File -append ad_group_members.txt
        }
    }
 

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

Network Rollup и группы сайтов | База знаний

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

Network Rollup дает вам общее представление о том, как сообщения, авторы, разделы, теги и источники трафика работают на каждом сайте в вашей сети.

Как работает сетевой накопительный пакет

  • После включения сетевого накопления вы сможете выбрать это представление в раскрывающемся списке сайта.
  • Пользователи смогут видеть сводное представление только тех сайтов, к которым у них есть доступ. Например, редактор Conde Nast, имеющий доступ к Wired и Vogue, сможет видеть все данные для обоих сайтов, но не для всей сети.

В то время как Network Rollup показывает все сайты в вашей сети, группы сайтов показывают данные только для выбранных вами сайтов.

Создать группу предприятий

Только сетевые администраторы могут создавать группы сайтов.

  1. Щелкните раскрывающийся список учетной записи.
  2. Щелкните Группы сайтов.
  3. Щелкните «Создать группу».

  1. Введите имя группы.
  2. Добавить сайты.
  3. Щелкните «Создать».

См. Данные для группы объектов

  1. Щелкните раскрывающийся список сайтов.
  2. Щелкните имя группы сайтов.

Как работают группы сайтов

  • Сетевой накопительный пакет должен быть включен для создания групп сайтов.
  • Только сетевые администраторы могут создавать группы сайтов.
  • Группы сайтов видны пользователям, имеющим доступ ко всем сайтам в этой группе. Например, если есть группа сайтов под названием Fashion, в которую входят Vanity Fair и Vogue, пользователь, имеющий доступ как к Vanity Fair, так и к Vogue, сможет увидеть эту группу. Пользователь, у которого есть доступ к Vanity Fair, но не к Vogue, не сможет увидеть группу сайтов Fashion.
  • Сайт может быть помещен в несколько групп сайтов, но вы не можете создавать свертки групп, только сайты. Таким образом, вы не могли, например, создать группы под названием Северная Каролина, Южная Каролина и Джорджия, а затем создать объединение под названием Юг этих групп. Но вы можете создать свертку под названием South и включить все сайты, входящие в каждую из трех групп.

Группы тегов: узнайте, как ваши теги работают вместе

Почему мы помечаем контент? По своей сути теги существуют для группировки и категоризации контента.Теги позволяют легко разместить контент под общим лейблом, чтобы мы могли сказать что-то вроде «Все эти статьи о Nintendo, глубоководной рыбалке или yerba mate», а затем сказать «Хорошо, работает ли этот тип контента? Как это может повлиять на нашу контент-стратегию? »

Когда наша команда пересмотрела, как мы отображаем теги в Parse.ly, стало ясно, что просмотр списка тегов не способствует пониманию того, какому тегу соответствуют теги контента. Контент «Nintendo» получил наибольшее количество просмотров страниц в прошлом месяце, но какие статьи попадают в эту группу? Более конкретно, что такое «поднарративы» (т.е. другие теги) внутри «Nintendo», например, взлом Animal Crossing или Switch?

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

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

Как использовать группы тегов

На странице «Теги» щелкните вкладку «Группы тегов», чтобы перейти из режима просмотра списка тегов. Сообщения автоматически группируются по общему тегу (или тегам), что позволяет легко увидеть, какие темы привлекают внимание вашей аудитории. Это позволит вам быстро понять, какой контент способствует трафику тега.

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

Щелкните один из этих тегов, чтобы просмотреть группы тегов, с которыми он делится контентом. Например, фильтрация по «науке-2» выявляет «подтемы», такие как физика, археология и химия, а также сообщения, которые попадают в эти категории. Если вы хотите вникнуть (каламбур) в популярные истории об археологии, они у вас под рукой.

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

Небольшое примечание: чем лучше настроена ваша таксономия тегов, тем более полезными будут группы тегов. Ознакомьтесь с этими рекомендациями по применению тегов темы.

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

Анализ текста с помощью PowerShell (1/3)

Это первая публикация из серии из трех частей.

  • Часть 1 :
    • Полезные методы класса String
    • Введение в регулярные выражения
    • Командлет Select-String
  • Часть 2:
    • Оператор -split
    • Оператор -матч
    • Оператор switch
    • Класс Regex
  • Часть 3:
    • Реальный мир, полный и немного больший, пример синтаксического анализатора на основе переключателей

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

Я всегда стремлюсь создать структуру как можно раньше в конвейере, чтобы позже я мог рассуждать о содержимом как о свойствах объектов, а не как о тексте с некоторым смещением в строке. Это также помогает при сортировке, поскольку свойства могут иметь правильный тип, поэтому числа, даты и т. Д. Сортируются как таковые, а не как текст.

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

Это не текст о том, как создать высокопроизводительный синтаксический анализатор для языка со структурированной грамматикой EBNF. Для этого доступны лучшие инструменты, например ANTLR.

.Net методы в строке

класс

Любая обработка синтаксического анализа строк в PowerShell была бы неполной, если бы в ней не упоминались методы класса string .Есть несколько методов, которые я использую при синтаксическом анализе строк чаще других:

Имя Описание
Подстрока (int startIndex) Извлекает подстроку из этого экземпляра. Подстрока начинается с указанной позиции символа и продолжается до конца строки.
Подстрока (int startIndex, int length) Извлекает подстроку из этого экземпляра.Подстрока начинается с указанной позиции символа и имеет указанную длину.
IndexOf (строковое значение) Сообщает отсчитываемый от нуля индекс первого вхождения указанной строки в этом экземпляре.
IndexOf (строковое значение, int startIndex) Сообщает отсчитываемый от нуля индекс первого вхождения указанной строки в этом экземпляре. Поиск начинается с указанной позиции символа.
LastIndexOf (строковое значение) Сообщает отсчитываемый от нуля индекс последнего вхождения указанной строки в этом экземпляре.Часто используется вместе с Substring .
LastIndexOf (строковое значение, int startIndex) Сообщает отсчитываемую от нуля позицию индекса последнего вхождения указанной строки в этом экземпляре. Поиск начинается с указанной позиции символа и продолжается в обратном направлении к началу строки.

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

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

 function parseThirdFromEnd ([строка] $ line) {
    $ i = $ line.LastIndexOf (",") # получить последний разделитель
    $ i = $ line.LastIndexOf (",", $ i - 1) # получаем предпоследний разделитель, а также конец интересующего нас столбца
    $ j = $ line.LastIndexOf (",", $ i - 1) # получаем разделитель перед нужным столбцом
    $ j ++ # дальше вперед за разделитель
    $ line.SubString ($ j, $ i- $ j) # получаем текст искомого столбца
} 

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

В редких случаях я пишу весь синтаксический анализатор на C #. Примером этого является модуль, оборачивающий систему управления версиями Perforce, где инструмент командной строки может выводить словари Python.Это двоичный формат, и вариант использования был достаточно сложным, поэтому мне было удобнее использовать язык реализации, проверенный компилятором.

Регулярные выражения

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

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

Это очень богатый язык, но вы можете пройти довольно долгий путь, изучив несколько ключевых частей. Я обнаружил, что regular-expressions.info является хорошим онлайн-ресурсом для получения дополнительной информации. Он не написан непосредственно для реализации регулярного выражения .net, но большая часть информации действительна для различных реализаций.

Регулярное выражение Описание
* Ноль или более предшествующих символов. a * соответствует пустой строке, a , aa и т. Д., Но не b .
+ Один или несколько предшествующих символов. a + соответствует a , aa и т. Д., Но не пустой строке или b .
. Соответствует любому символу
[ax1] Любой из a , x , 1
и др соответствует любому из a , b , c , d
\ w Метасимвол \ w используется для поиска символа слова.Словесный символ — это символ от a до z, от A до Z, 0-9, включая символ _ (подчеркивание). Он также соответствует вариантам символов, например ??? и ??? .
\ Вт Инверсия \ w . Соответствует любому символу, не являющемуся словом
\ с Метасимвол \ s используется для поиска пробелов
\ S Инверсия \ s .Соответствует любому непробельному символу
\ d Соответствует цифрам
\ D Инверсия \ d . Соответствует нецифровому номеру
\ b Соответствует границе слова, то есть позиции между словом и пробелом.
\ B Инверсия \ b . . er \ B соответствует er в глаголе , но не er в никогда .\ s + (? <число> \ d +), (? <текст>. +)

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

Командлет Select-String

Команда Select-String — это рабочая лошадка, и она очень эффективна, если вы понимаете, какой результат она производит. Я использую его в основном при поиске текста в файлах, но иногда и при поиске чего-либо в выводе команд и т.п.

Ключ к эффективности с Select-String — это знать, как добраться до совпадающих шаблонов на выходе. Внутри он использует тот же класс regex , что и оператор -match и -split , но вместо заполнения глобальной переменной результирующими группами, как это делает -match , он записывает объект в конвейер со свойством Matches , содержащим результаты сопоставления.

 Установить содержимое twitterData.-] +) - (\ d +) (@ \ w +) "|
    Foreach-Object {
        $ first, $ last, $ followers, $ handle = $ _. Соответствует [0] .Groups [1..4] .Value # это обычный способ получить группы вызова для строки выбора
        [PSCustomObject] @ {
            FirstName = $ first
            LastName = $ last
            Ручка = $ handle
            TwitterFollowers = [int] $ подписчиков
        }
    } 
  Имя Фамилия Обработать TwitterПодписчики
--------- -------- ------ ----------------
Ли Холмс @Lee_Holmes 13000
Стаффан Густафссон @StaffanGson 463
  

Поддержка нескольких паттернов

Как мы видим выше, только половина данных соответствует шаблону Select-String .,] +), (? <подписчики> \ d +) » Get-ChildItem twitterData.txt | Select-String -Pattern $ firstLastPattern, $ lastFirstPattern | Foreach-Object { # здесь мы обращаемся к группам по имени, а не по индексу $ first, $ last, $ followers, $ handle = $ _. Соответствует [0] .Groups [‘first’, ‘last’, ‘followers’, ‘handle’]. Значение [PSCustomObject] @ { FirstName = $ first LastName = $ last Ручка = $ handle TwitterFollowers = [int] $ подписчиков } }

  Имя Фамилия Обработать TwitterПодписчики
--------- -------- ------ ----------------
Стив Ли @Steve_MSFT 2992
Ли Холмс @Lee_Holmes 13000
Стаффан Густафссон @StaffanGson 463
Джои Триббиани @Matt_LeBlanc 463400
  

Разбивка на $ firstLastPattern дает нам

 (? X) # это регулярное выражение игнорирует пробелы в шаблоне.-] +) # захватить один или несколько любых символов, кроме `--`, в группу с именем 'last'
- # a '-'
(?  \ d +) # захватить 1 или более цифр в группу с именем 'followers'
\ s # пробел
(?  @. +) # захватить '@', за которым следует один или несколько символов, в группу с именем 'handle' 

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

Контекст вокруг совпадений

Select-String также имеет параметр Context , который принимает массив из одного или двух чисел, определяющих количество строк до и после совпадения, которое должно быть захвачено. Все техники синтаксического анализа текста в этом посте можно использовать для синтаксического анализа информации из контекстных строк. Объект результата имеет свойство Context , которое возвращает объект со свойствами PreContext и PostContext , оба типа string [] .

Может использоваться для получения второй строки перед матчем:

 # используя свойство context
Get-ChildItem twitterData.txt |
    Select-String -Pattern "Staffan" -Context 2,1 |
    Foreach-Object {$ _. Context.PreContext [1], $ _. Context.PostContext [0]} 
  Ли Холмс-13000 @Lee_Holmes
Триббиани, Джои- @ Matt_LeBlanc, 463400
  

Чтобы понять индексацию массивов Pre- и PostContext, рассмотрим следующее:

  Ли, Стив- @ Steve_MSFT, 2992 <- PreContext [0]
Ли Холмс-13000 @Lee_Holmes <- PreContext [1]
Staffan Gustafsson-463 @StaffanGson <- Шаблон соответствует этой строке
Триббиани, Джои- @ Matt_LeBlanc, 463400 <- PostContext [0]
  

Конвейерная поддержка Select-String отличает его от других инструментов синтаксического анализа, доступных в PowerShell, и делает его бесспорным королем однострочников.

Я хотел бы подчеркнуть, насколько более полезным становится Select-String , когда вы понимаете, как добраться до частей совпадений.

Сводка

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

В следующий раз мы рассмотрим операторы -split и -match , оператор switch (который на удивление полезен для синтаксического анализа текста) и класс регулярных выражений.

Стаффан Густафссон, @StaffanGson, github

Спасибо Джейсону Ширку, Матиасу Джессену и Стиву Ли за обзоры и отзывы.

.

Добавить комментарий

Ваш адрес email не будет опубликован.

Copyright © 2022
Дропшиппинг в России.
Сообщество поставщиков дропшипперов и интернет предпринимателей.
Все права защищены.
ИП Калмыков Семен Алексеевич. ОГРНИП: 313695209500032.
Адрес: ООО «Борец», г. Москва, ул. Складочная 6 к.4.
E-mail: [email protected] Телефон: +7 (499) 348-21-17