Как составить парсер

Написание парсера с нуля: так ли страшен черт?

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

Очевидно, что парсер нужно было переписать на C#, но при мысли о написании парсера с нуля вдруг находилась дюжина других срочных дел. Таким образом таск перекидывался и откладывался практически полгода и казался непосильным, а в итоге был сделан за 4 дня. Под катом я расскажу об удобном способе, позволившим реализовать парсер достаточно сложной грамматики без использования сторонних библиотек и не тронуться умом, а также о том, как это позволило улучшить язык LENS.

Но обо всем по порядку.

Первый блин

Как было сказано выше, в качестве ядра парсера мы использовали библиотеку FParsec. Причины данного выбора скорее исторические, нежели объективные: понравился легковесный синтаксис, хотелось поупражняться в использовании F#, и автор библиотеки очень оперативно отвечал на несколько вопросов по email.

Главным недостатком этой библиотеки для нашего проекта оказались внешние зависимости:

• Примерно десятимегабайтный F# Runtime
• 450 кб сборок самого FParsec

Кроме того, сам компилятор разбился на 3 сборки: парсер, синтаксическое дерево и точку входа. Сборка парсера занимала внушительные 130 кб. Для встраиваемого языка это абсолютно неприлично.

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

> let x =

> Ошибка: ожидается идентификатор
          или число
          или скобка
          или вызов функции
          или 'new'
          или ...

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

Еще одним неприятным моментом была скорость работы. При «холодном старте» компиляция любого, даже самого простого скрипта занимала на моей машине примерно 350-380 миллисекунд. Судя по тому, что повторный запуск такого же скрипта занимал уже всего-то 5-10 миллисекунд, задержка была вызвана JIT-компиляцией.

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

Немного теории

Сферический парсер в вакууме представляет собой функцию, которая принимает исходный код, а возвращает некое промежуточное представление, по которому удобно будет сгенерировать код для используемой виртуальной машины или процессора. Чаще всего это представление имеет древовидную структуру и называется абстрактным синтаксическим деревом — АСД (в иностранной литературе — abstract syntactic tree, AST).

Древовидная структура особенно хороша тем, что ее обход в глубину отлично сочетается со стековой организацией, используемой во многих современных виртуальных машинах (например, JVM или .NET). Генерация кода в данной статье рассматриваться не будет, однако элементы синтаксического дерева, как результат работы парсера, будут время от времени упоминаться.

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

1. Лексический анализатор: string -> IEnumerable<Lexem>
2. Синтаксический анализатор: IEnumerable<Lexem> -> IEnumerable<Node>
3. Семантический анализатор: IEnumerable<Node> -> ?

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

Лексический анализатор

Требования:

• Скорость работы
• Легкость расширения
• Простота реализации
• Отслеживание положения в исходном тексте

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

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

Статические лексемы, в свою очередь, есть резон поделить на операторы и ключевые слова. Ключевые слова сопоставляются только в том случае, если следующий за ними символ не является допустимым для идентификатора (или дальше — конец строки). В противном случае возникнут проблемы с идентификаторами, чье начало совпадает с ключевым словом: например, "information" -> keyword(in), keyword(for), identifier(mation).

enum LexemKind
{
	Var,
	Print,
	Plus,
	Minus,
	Multiply,
	Divide,
	Assign,
	Semicolon,
	Identifier,
	Number
}

class LocationEntity
{
	public int Offset;
	public int Length;
}

class Lexem : LocationEntity
{
	public LexemKind Kind;
	public string Value;
}

class LexemDefinition<T>
{
	public LexemKind Kind { get; protected set; }
	public T Representation  { get; protected set; }
}

class StaticLexemDefinition : LexemDefinition<string>
{
	public bool IsKeyword;
	
	public StaticLexemDefinition(string rep, LexemKind kind, bool isKeyword = false)
	{
		Representation = rep;
		Kind = kind;
		IsKeyword = isKeyword;
	}
}

class DynamicLexemDefinition : LexemDefinition<Regex>
{
	public DynamicLexemDefinition(string rep, LexemKind kind)
	{
		Representation = new Regex(@"G" + rep, RegexOptions.Compiled);
		Kind = kind;
	}
}

static class LexemDefinitions
{
	public static StaticLexemDefinition[] Statics = new []
	{
		new StaticLexemDefinition("var", LexemKind.Var, true),
		new StaticLexemDefinition("print", LexemKind.Print, true),
		new StaticLexemDefinition("=", LexemKind.Assign),
		new StaticLexemDefinition("+", LexemKind.Plus),
		new StaticLexemDefinition("-", LexemKind.Minus),
		new StaticLexemDefinition("*", LexemKind.Multiply),
		new StaticLexemDefinition("/", LexemKind.Divide),
		new StaticLexemDefinition(";", LexemKind.Semicolon),
	};
	
	public static DynamicLexemDefinition[] Dynamics = new []
	{
		new DynamicLexemDefinition("[a-zA-Z_][a-zA-Z0-9_]*", LexemKind.Identifier),
		new DynamicLexemDefinition("(0|[1-9][0-9]*)", LexemKind.Number),
	};
}

class Lexer
{
	private char[] SpaceChars = new [] { ' ', 'n', 'r', 't' };
	private string Source;
	private int Offset;
	
	public IEnumerable<Lexem> Lexems { get; private set; }
	
	public Lexer(string src)
	{
		Source = src;
		Parse();
	}
	
	private void Parse()
	{
		var lexems = new List<Lexem>();
		
		while(InBounds())
		{
			SkipSpaces();
			if(!InBounds()) break;
				
			var lex = ProcessStatic() ?? ProcessDynamic();
			if(lex == null)
				throw new Exception(string.Format("Unknown lexem at {0}", Offset));
				
			lexems.Add(lex);
		}
		
		Lexems = lexems;
	}
	
	private void SkipSpaces()
	{
		while(InBounds() && Source[Offset].IsAnyOf(SpaceChars))
			Offset++;
	}
	
	private Lexem ProcessStatic()
	{
		foreach(var def in LexemDefinitions.Statics)
		{
			var rep = def.Representation;
			var len = rep.Length;
			
			if(Offset + len > Source.Length || Source.Substring(Offset, len) != rep)
				continue;
				
			if(Offset + len < Source.Length && def.IsKeyword)
			{
				var nextChar = Source[Offset + len];
				if(nextChar == '_' || char.IsLetterOrDigit(nextChar))
					continue;
			}
			
			Offset += len;
			return new Lexem { Kind = def.Kind, Offset = Offset, Length = len };
		}
		
		return null;
	}
	
	private Lexem ProcessDynamic()
	{
		foreach(var def in LexemDefinitions.Dynamics)
		{
			var match = def.Representation.Match(Source, Offset);
			if(!match.Success)
				continue;
				
			Offset += match.Length;
			return new Lexem { Kind = def.Kind, Offset = Offset, Length = match.Length, Value = match.Value };
		}
		
		return null;
	}
	
	private bool InBounds()
	{
		return Offset < Source.Length;
	}
}

Преимущества:

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

Недостатки:

• Танцы с бубном при разборе языка со значимыми пробелами
• Порядок объявления лексем важен: желательно сортировать по длине

Синтаксический анализатор

Требования:

• Легкость расширения при изменении грамматики
• Возможность описывать подробные сообщения об ошибках
• Возможность заглядывать вперед на неограниченное количество позиций
• Автоматическое отслеживание положения в исходном коде
• Лаконичность, близость к исходной грамматике

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

• Описание — один конкретный узел:
  (var_expr = "var" identifier "=" expr)
• Повторение — один конкретный узел повторяется многократно, возможно с разделителем:
  main = { stmt ";" }
• Альтернатива — выбор из нескольких узлов
  (stmt = var_expr | print_expr | assign_expr | other)

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

Правило-перечисление — это цикл. Чтобы вернуть последовательность значений, в C# есть очень удобный функционал для создания генераторов с помощью yield return.

Правило-альтернатива по очереди вызывает правила-варианты с помощью специальной обертки, которая позволяет откатиться в исходное состояние. Правила просто вызываются по порядку, пока хотя бы одно из них не совпадет, связанные оператором coalesce (??).

Тут пытливый читатель спросит:
— Как это, просто вызываются по порядку? А как же опережающие проверки? Например, так:

if(CurrentLexem.Type == LexemType.Var) return parseVar();
if(CurrentLexem.Type == LexemType.For) return parseFor();
...

Признаюсь, свой первый серьезный парсер я написал именно так. Однако это плохая идея!

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

assign = id_assign | member_assign | index_assign
id_assign = identifier "=" expr
member_assign = lvalue "." identifier "=" expr
index_assign = lvalue "[" expr "]" "=" expr

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

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

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

Рассмотрим на примере выше. Допустим, у нас есть текст: a.1 = 2:

1. Первой вызывается альтернатива id_assign.
2. Идентификатор a успешно совпадает.
3. Дальше идет точка, а ожидается знак «равно». Однако с идентификатора могут начинаться и другие правила, поэтому ошибка не выбрасывается.
4. Правило assign откатывает состояние назад и пробует дальше.
5. Вызывается альтернатива member_assign.
6. Идентификатор и точка успешно совпадают. В грамматике нет других правил, которые начинаются с идентификатора и точки, поэтому дальнейшие ошибки не имеет смысл пытаться обработать откатыванием состояния.
7. Число 1 не является идентификатором, поэтому выкидывается ошибка.

Сначала напишем несколько полезных методов:

partial class Parser
{
	private List<Lexem> Lexems;
	private int LexemId;
	
	#region Lexem handlers
	
	[DebuggerStepThrough]
	private bool Peek(params LexemType[] types)
	{
		var id = Math.Min(LexemId, Lexems.Length - 1);
		var lex = Lexems[id];
		return lex.Type.IsAnyOf(types);
	}
	
	[DebuggerStepThrough]
	private Lexem Ensure(LexemType type, string msg, params object[] args)
	{
		var lex = Lexems[LexemId];

		if(lex.Type != type)
			error(msg, args);

		Skip();
		return lex;
	}
	
	[DebuggerStepThrough]
	private bool Check(LexemType lexem)
	{
		var lex = Lexems[LexemId];

		if (lex.Type != lexem)
			return false;

		Skip();
		return true;
	}
	
	[DebuggerStepThrough]
	private void Skip(int count = 1)
	{
		LexemId = Math.Min(LexemId + count, Lexems.Length - 1);
	}
	
	#endregion
	
	#region Node handlers
	
	[DebuggerStepThrough]
	private T Attempt<T>(Func<T> getter) where T : LocationEntity
	{
		var backup = LexemId;
		var result = Bind(getter);
		if (result == null)
			LexemId = backup;
			
		return result;
	}
	
	[DebuggerStepThrough]
	private T Ensure<T>(Func<T> getter, string msg) where T : LocationEntity
	{
		var result = Bind(getter);
		if (result == null)
			throw new Exception(msg);

		return result;
	}
	
	[DebuggerStepThrough]
	private T Bind<T>(Func<T> getter) where T : LocationEntity
	{
		var startId = LexemId;
		var start = Lexems[LexemId];

		var result = getter();

		if (result != null)
		{
			result.StartLocation = start.StartLocation;

			var endId = LexemId;
			if (endId > startId && endId > 0)
				result.EndLocation = Lexems[LexemId - 1].EndLocation;
		}

		return result;
	}
	
	#endregion
}

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

partial class Parser
{
	public Node ParseAssign()
	{
		return Attempt(ParseIdAssign)
			   ?? Attempt(ParseMemberAssign)
			   ?? Ensure(ParseIndexAssign, "Неизвестный тип выражения!");
	}
	
	public Node ParseIdAssign()
	{
		var id = TryGetValue(LexemType.Identifier);
		if (id == null) return null;
		if (!Check(LexemType.Assign)) return null;
		var expr = Ensure(ParseExpr, "Ожидается присваиваемое выражение!");
		
		return new IdAssignNode { Identifier = id, Expression = expr };
	}
	
	public Node ParseMemberAssign()
	{
		var lvalue = Attempt(ParseLvalue);
		if (lvalue == null) return null;
		if (!Check(LexemType.Dot)) return null;
		
		var member = TryGetValue(LexemType.Identifier);
		if (member == null) return null;
		if (!Check(LexemType.Assign)) return null;
		
		var expr = Ensure(ParseExpr, "Ожидается присваиваемое выражение!");
		
		return new MemberAssignNode { Lvalue = lvalue, MemberName = member, Expression = expr };
	}
	
	public Node ParseIndexAssign()
	{
		var lvalue = Attempt(ParseLvalue);
		if (lvalue == null) return null;
		if (!Check(LexemType.SquareBraceOpen)) return null;
		
		var index = Ensure(ParseExpr, "Ожидается выражение индекса!");
		Ensure(LexemType.SquareBraceClose, "Не закрыта скобка!");
		Ensure(LexemType.Assign, "Ожидается знак присваивания!");
		
		var expr = Ensure(ParseExpr, "Ожидается присваиваемое выражение!");
		
		return new IndexAssignNode { Lvalue = lvalue, Index = index, Expression = expr };
	}
}

Атрибут DebuggerStepThrough сильно помогает при отладке. Поскольку все вызовы вложенных правил так или иначе проходят через Attempt и Ensure, без этого атрибута они будут постоянно бросаться в глаза при Step Into и забивать стек вызовов.

Преимущества данного метода:

• Откат состояния — очень дешевая операция
• Легко управлять тем, до куда можно откатываться
• Легко отображать детальные сообщения об ошибках
• Не требуются никакие внешние библиотеки
• Небольшой объем генерируемого кода

Недостатки:

• Реализация парсера вручную занимает время
• Сложность написания и оптимальность работы зависят от качества грамматики
• Леворекурсивные грамматики следует разруливать самостоятельно

Операторы и приоритеты

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

expr = expr_1 { op_1 expr_1 }
expr_1 = exp2_2 { op_2 expr_2 }
expr_2 = exp2_3 { op_3 expr_3 }
expr_3 = int | float | identifier
op_1 = "+" | "-"
op_2 = "*" | "/" | "%"
op_3 = "**"

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

Вместо этого, можно убрать из грамматики вообще все описание приоритетов и закодить его декларативно.

expr = sub_expr { op sub_expr }
sub_expr = int | float | identifier

partial class Parser
{
	private static List<Dictionary<LexemType, Func<Node, Node, Node>>> Priorities =
		new List<Dictionary<LexemType, Func<Node, Node, Node>>>
		{
			new Dictionary<LexemType, Func<Node, Node, Node>>
			{
				{ LexemType.Plus, (a, b) => new AddNode(a, b) },
				{ LexemType.Minus, (a, b) => new SubtractNode(a, b) }
			},
			
			new Dictionary<LexemType, Func<Node, Node, Node>>
			{
				{ LexemType.Divide, (a, b) => new DivideNode(a, b) },
				{ LexemType.Multiply, (a, b) => new MultiplyNode(a, b) },
				{ LexemType.Remainder, (a, b) => new RemainderNode(a, b) }
			},
			
			new Dictionary<LexemType, Func<Node, Node, Node>>
			{
				{ LexemType.Power, (a, b) => new PowerNode(a, b) }
			},
		};
		
	public NodeBase ProcessOperators(Func<Node> next, int priority = 0)
	{
		if (priority == Priorities.Count)
			return getter();
	
		var node = ProcessOperators(next, priority + 1);

		var ops = Priorities[priority];
		while (Lexems[LexemId].IsAnyOf(ops.Keys))
		{
			foreach (var curr in ops)
			{
				if (check(curr.Key))
				{
					node = curr.Value(
						node,
						ensure(() => ProcessOperators(next, priority + 1), "Ожидается выражение!")
					);
				}
			}
		}

		return node;
	}
}

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

Добавление поддержки унарных префиксных операторов оставляю в качестве тренировки для особо любопытных.

Что нам это дало?

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

Итого, сравнительная таблица результатов:

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

Избавившись от головной боли с изменениями в грамматике, мы смогли запилить в LENS несколько приятных вещей:

Цикл for

Используется как для обхода последовательностей, так и для диапазонов:

var data = new [1; 2; 3; 4; 5]
for x in data do
    println "value = {0}" x

for x in 1..5 do
    println "square = {0}" x

Композиция функций

С помощью оператора :> можно создавать новые функции, «нанизывая» существующие:

let invConcat = (a:string b:string) -> b + a
let invParse = incConcat :> int::Parse

invParse "37" "13" // 1337

Частичное применение возможно с помощью анонимных функций:

fun add:int (x:int y:int) -> x + y
let addTwo = int::TryParse<string> :> (x:int -> add 2 x)
addTwo "40" // 42

Улучшения синтаксиса

• Однострочные комментарии:

  somecode () // comment

• Неинициализированные переменные:

  var x : int

• Скобки вокруг единственного аргумента лямбды опциональны:

  var inc = x:int -> x + 1

• Скобки в управляющих конструкциях убраны:

  if x then
      a ()
  else
      b ()
  
  while a < b do
      println "a = {0}" a
      a = a + 1

• Появился блок try/finally
• Скобки при передаче индекса или поля в функцию опциональны:

  print "{0} = {1}" a[1] SomeType::b

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

• Объявление generic-типов и функций
• Возможность пометить функции или типы атрибутами
• Поддержку событий

Также можно скачать собранные демки под Windows.

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

Что делаем

Сегодня мы спарсим все статьи «Кода» кроме новостей и задач, причём сделаем всё так:

Чтобы потом можно было нормально работать с текстом, мы не будем парсить вставки с примерами кода, а ещё постараемся избавиться от титров, рекламных баннеров и плашек.

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

Выбираем страницу для отладки

Технически самый простой парсинг делается двумя командами в Python, одна из которых — подключение сторонней библиотеки. Но этот код не слишком полезен для нашей задачи, сейчас объясним.

from urllib.request import urlopen
inner_html_code = str(urlopen('АДРЕС СТРАНИЦЫ').read(),'utf-8')

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

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

Для настройки скрипта мы возьмём нашу старую статью. В ней есть всё нужное для отладки:

Получаем сырой текст

Вот что мы сейчас сделаем:

На языке Python это выглядит так:

# подключаем urlopen из модуля urllib
from urllib.request import urlopen

# подключаем библиотеку BeautifulSoup
from bs4 import BeautifulSoup

# получаем исходный код страницы
inner_html_code = str(urlopen('https://thecode.media/parsing/').read(),'utf-8')

# отправляем исходный код страницы на обработку в библиотеку
inner_soup = BeautifulSoup(inner_html_code, "html.parser")

# выводим содержимое страницы
print(inner_soup.get_text())

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

Чистим текст

Так как нам требуется только сама статья, найдём раздел, в котором она лежит. Для этого посмотрим исходный код страницы, нажав Ctrl+U или ⌘+⌥+U. Видно, что содержимое статьи лежит в блоке <div class="article-content line-numbers">, причём такой блок на странице один.

Чтобы из всего исходного кода оставить только этот блок, используем команду find() с параметром 'div', {"class": 'article-content'} — она найдёт нужный нам блок, у которого есть характерный признак класса. 

Добавим эту команду перед выводом текста на экран:

# оставляем только блок с содержимым статьи
​​inner_soup = inner_soup.find('div', {"class": 'article-content'})

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

Чтобы избавиться и от этого, нам нужно знать, в каких тегах или блоках это лежит. Для этого нам снова понадобится заглянуть в исходный код страницы. Логика будет такая: находим фрагмент текста → смотрим код, который за него отвечает, → удаляем этот код из нашей переменной.Например, если мы хотим убрать титры, то находим блок, где они лежат, а потом в цикле удаляем его командой decompose().

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

# очищаем код от выбранных элементов
def delete_div(code,tag,arg):
     # находим все указанные теги с параметрами
     for div in code.find_all(tag, arg): 
        # и удаляем их из кода
        div.decompose()

А теперь добавим такой код перед выводом содержимого:

# удаляем титры
delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-titry'})

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

# удаляем боковые ссылки
delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-link-aside'})

# удаляем баннеры, перебирая все их возможные индексы в цикле (потому что баннеры в коде имеют номера от 1 до 99)
for i in range(99):
    delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-banner'+str(i)})

# удаляем кат
delete_div(inner_soup, "div", {'class':'accordion'})

# удаляем преформатированный код
delete_div(inner_soup, 'pre','')

# удаляем вставки с кодом
delete_div(inner_soup,'code','')

Теперь всё в порядке: у нас есть только текст статьи, без внешнего обвеса, лишнего кода и ссылок. Можно переходить к массовой обработке.

Собираем функцию

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

Если запустить этот скрипт, получим тот же результат, что и в предыдущем разделе.

# подключаем urlopen из модуля urllib
from urllib.request import urlopen

# подключаем библиотеку BeautifulSout
from bs4 import BeautifulSoup

# очищаем код от выбранных элементов
def delete_div(code,tag,arg):
     # находим все указанные теги с параметрами
     for div in code.find_all(tag, arg): 
        # и удаляем их из кода
        div.decompose()

# очищаем текст по указанному адресу
def clear_text(url):
    # получаем исходный код страницы
    inner_html_code = str(urlopen(url).read(),'utf-8')
    # отправляем исходный код страницы на обработку в библиотеку
    inner_soup = BeautifulSoup(inner_html_code, "html.parser")
    # оставляем только блок с содержимым статьи
    inner_soup = inner_soup.find('div', {"class": 'article-content'})
    # удаляем титры
    delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-titry'})
    
    # удаляем боковые ссылки
    delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-link-aside'})
   
    # удаляем баннеры
    for i in range(11):
        delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-banner'+str(i)})
   
    # удаляем кат
    delete_div(inner_soup, "div", {'class':'accordion'})
    
    # удаляем преформатированный код
    delete_div(inner_soup, 'pre','')
  
    # удаляем вставки с кодом
    delete_div(inner_soup,'code','')
    
    # возвращаем содержимое страницы
    return(inner_soup.get_text())

print(clear_text('https://thecode.media/parsing/'))

Получаем адреса всех страниц

Одна из самых сложных вещей в парсинге — получить список адресов всех нужных страниц. Для этого можно использовать:

В нашем случае мы воспользуемся готовой страницей — там собраны все статьи с разбивкой по рубрикам: https://thecode.media/all. Но даже в этом случае нам нужно написать код, который обработает эту страницу и заберёт оттуда только адреса статей. Ещё нужно предусмотреть, что нам не нужны ссылки из новостей и задач.

Идём в исходный код общей страницы и видим, что все ссылки лежат внутри списка:

При этом каждая категория статей лежит в своём разделе — именно это мы и будем использовать, чтобы обработать только нужные нам категории. Например, вот как рубрика «Ахах» выглядит на странице:

А вот она же — но в исходном коде. По названию легко понять, какой блок за неё отвечает:

Чтобы найти раздел в коде по атрибуту, используем команду find() с параметром attrs — в нём мы укажем название рубрики. А чтобы найти адрес в ссылке — используем команду select(), в которой укажем, что ссылка должна лежать внутри элемента списка.

Теперь логика будет такая:

def get_all_url(data_title):
    html_code = str(urlopen('https://thecode.media/all').read(),'utf-8')
    soup = BeautifulSoup(html_code, "html.parser")

    # находим рубрику по атрибуту
    s = soup.find(attrs={"data-title": data_title})

     # тут будут все найденные адреса
    url = []
    
    # перебираем все теги ссылок, которые есть в списке 
    for tag in s.select("li:has(a)"):
        # добавляем адрес ссылки в нашу общую переменную
        url.append(tag.find("a")["href"])

    # выводим найденные адреса  
    print(url)

# названия рубрик, которые нам нужны
division = ['Ахах','Не стыдно','Это баг','Это как']
# перебираем все рубрики
for el in division:
    # и обрабатываем каждую рубрику отдельно
    get_all_url(el)

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

Сохраняем текст в файл

Единственное, чего нам сейчас не хватает, — это сохранения в файл. Чтобы каждая рубрика хранилась в своём файле, привяжем имя файла к названию рубрики. Дальше логика будет такая:

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

# подключаем urlopen из модуля urllib
from urllib.request import urlopen

# подключаем библиотеку BeautifulSout
from bs4 import BeautifulSoup

# очищаем код от выбранных элементов
def delete_div(code,tag,arg):
     # находим все указанные теги с параметрами
     for div in code.find_all(tag, arg): 
        # и удаляем их из кода
        div.decompose()

# очищаем текст по указанному адресу
def clear_text(url):
    # получаем исходный код страницы
    inner_html_code = str(urlopen(url).read(),'utf-8')
    # отправляем исходный код страницы на обработку в библиотеку
    inner_soup = BeautifulSoup(inner_html_code, "html.parser")
    # оставляем только блок с содержимым статьи
    inner_soup = inner_soup.find('div', {"class": 'article-content'})
    # удаляем титры
    delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-titry'})
    
    # удаляем боковые ссылки
    delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-link-aside'})
   
    # удаляем баннеры
    for i in range(11):
        delete_div(inner_soup, "div", {'class':'wp-block-lazyblock-banner'+str(i)})
   
    # удаляем кат
    delete_div(inner_soup, "div", {'class':'accordion'})
    
    # удаляем преформатированный код
    delete_div(inner_soup, 'pre','')
  
    # удаляем вставки с кодом
    delete_div(inner_soup,'code','')
    
    # возвращаем содержимое страницы
    return(inner_soup.get_text())

# формируем список адресов для указанной рубрики
def get_all_url(data_title):
    # считываем страницу со всеми адресами
    html_code = str(urlopen('https://thecode.media/all').read(),'utf-8')
    # отправляем исходный код страницы на обработку в библиотеку
    soup = BeautifulSoup(html_code, "html.parser")

    # находим рубрику по атрибуту
    s = soup.find(attrs={"data-title": data_title})

     # тут будут все найденные адреса
    url = []
    
    # перебираем все теги ссылок, которые есть в списке 
    for tag in s.select("li:has(a)"):
        # добавляем адрес ссылки в нашу общую переменную
        url.append(tag.find("a")["href"])

    # имя файла для содержимого каждой рубрики
    content_file_name = data_title + '_content.txt'
    # открываем файл и стираем всё, что там было
    file = open(content_file_name, "w")
    # перебираем все адреса из списка
    for x in url:
        # сохраняем обработанный текст в файле и переносим курсор на новую строку
        file.write(clear_text(x) + 'n')
    # закрываем файл
    file.close()
         
# названия рубрик, которые нам нужны
division = ['Ахах','Не стыдно','Это баг','Это как']
# перебираем все рубрики
for el in division:
    # и обрабатываем каждую рубрику отдельно
    get_all_url(el)

Что дальше

Теперь у нас есть все тексты всех статей. Как-нибудь проанализируем частотность слов в них (как в проекте с текстами Льва Толстого) или научим нейросеть писать новые статьи на основе старых.

Шаг 1. Подготовка

Шаг 2. Установка зависимостей

pip install requests
pip install beautifulsoup4

Также мы будем использовать стандартную библиотеку json для записи результата в файл JSON формата.

Шаг 3. Программирование

# -*- coding: utf-8 -*-

PAGES_COUNT = 10


def crawl_products(pages_count):
    urls = []
    return urls


def parse_products(urls):
    data = []
    return data


def main():
    urls = crawl_products(PAGES_COUNT)
    data = parse_products(urls)


if __name__ == '__main__':
    main()

def get_soup(url, **kwargs):
    response = requests.get(url, **kwargs)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, features='html.parser')
    else:
        soup = None
    return soup

Приступим к реализации функции crawl_products. Смотрим, как формируется URL-адрес конкретной страницы, на примере страницы с номером 2:

https://parsemachine.com/sandbox/catalog/?page=2

Видим GET-параметр page=2, который является номером страницы. Объявим переменную fmt, которая будет шаблоном URL-адреса страницы с товарами. Пройдемся по страницам с 1 по pages_count.

Cформируем URL-адрес страницы с номером page_n и получим для него объект BeautifulSoup, используя метод get_soup. Если soup страницы является None, то произошла ошибка при получении HTML-кода страницы, поэтому мы прерываем обработку с помощью оператора break.

Если soup получен, то нас интересует элемент «Название товара», который является ссылкой на товар. Копируем CSS-селектор .product-card .title и передаем его аргументов в метод soup.select(), который вернет множество найденных на странице элементов. Для каждого из них мы получим атрибут href, а затем сформируем URL и добавим его в общий массив. Ниже приведен полный текст данной функции.

def crawl_products(pages_count):
    urls = []
    fmt = 'https://parsemachine.com/sandbox/catalog/?page={page}'

    for page_n in range(1, 1 + pages_count):
        print('page: {}'.format(page_n))

        page_url = fmt.format(page=page_n)
        soup = get_soup(page_url)
        if soup is None:
            break

        for tag in soup.select('.product-card .title'):
            href = tag.attrs['href']
            url = 'https://parsemachine.com{}'.format(href)
            urls.append(url)

    return urls

Переходим к реализации parse_products. Пройдемся по каждому товару и получим soup аналогично предыдущей функции.

Первое поле, которое мы парсим – «Название товара». Вызываем метод select_one у объекта soup, который аналогичен методу select за исключением, что возвращает один элемент, найденный на странице. В качестве аргумента передаем CSS-селектор #product_name. Получаем видимый текст и очищаем от пробельных символов с обеих сторон.

Аналогично получаем поле «Цена» по CSS-селектору #product_amount.

Переходим к парсингу характеристик товара. Найдем строки по CSS-селектору #characteristics tbody tr и для каждой из них получим значения ячеек, которые сохраним в переменную techs. Данные по товару мы спарсили, теперь сохраним их в переменую item и добавим в массив data. Ниже представлен полный код функции.

def parse_products(urls):
    data = []

    for url in urls:
        print('product: {}'.format(url))

        soup = get_soup(url)
        if soup is None:
            break

        name = soup.select_one('#product_name').text.strip()
        amount = soup.select_one('#product_amount').text.strip()
        techs = {}
        for row in soup.select('#characteristics tbody tr'):
            cols = row.select('td')
            cols = [c.text.strip() for c in cols]
            techs[cols[0]] = cols[1]

        item = {
            'name': name,
            'amount': amount,
            'techs': techs,
        }
        data.append(item)

    return data

Осталось добавить запись в файл и парсер будет готов!

Импортируем библиотеку json для записи данных в JSON-файл. Объявляем глобальную переменную OUT_FILENAME – имя файла для записи результата.

Переходим к сохранению. Вызовем метод json.dump() с передачей аргументов:
1. Сохраняемый объект – у нас это data.
2. Файл.
Также передадим ensure_ascii=False, чтобы символы кириллицы не экранировались при записи в файл. И зададим отступ в 1 символ indent=1.

Итог

Все, сохранение в файл готово, и разработка парсера завершена!

import json

...
OUT_FILENAME = 'out.json'

...
def main():
    urls = crawl_products(PAGES_COUNT)
    data = parse_products(urls)

    with open(OUT_FILENAME, 'w') as f:
        json.dump(data, f, ensure_ascii=False, indent=1)

Ссылка на полный текст исходного кода – catalog.py

Если у вас возникли какие-то вопросы, можете задать их в комментариях к этой статье или под видео на YouTube. Предлагайте темы следующих уроков.

Спасибо за внимание!

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

Содержание:

1. Постановка задачи для парсинга
2. Анализ html разметки страницы
3. Создание парсера на Python
4. Запись данных в csv
5. Домашнее задание
6. Заключение

Постановка задачи для парсинга

И так открываем сайт wordpress.org, и переходим в раздел «Плагины». В этом разделе мы видим четыре блока, в которых отображаются различные плагины.

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

1. Название каждого плагина
2. Ссылку на плагин
3. Количество отзывов
4. Сохранить полученные данные в csv файл

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

1. Открываем свой Pycharm (Или редактор, который вы используете)
2. Создаем новый проект
3. Импортируем библиотеки, как и в предыдущем уроке
4. Дополнительно импортируем библиотеку csv (import csv)

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

                    
import requests
from bs4 import BeautifulSoup
LINK = 'https://wordpress.org'

def get_html(link):
    response = requests.get(link)
    return response.text

def get_data(html):
    soup = BeautifulSoup(html, 'lxml')

def main():
    pass

if __name__=="__main__":
    main()

1. Функция get_html() — принимает адрес сайта, и возвращает свойство text объекта response
2. Функция get_data() — принимает html код. Создаем экземпляр класса BS. Как и в первом уроке, мы передали два параметра (html, и lxml)
3. Функция main() — пока пустая функция, если не знакомы с оператором pass, советую почитать про данный оператор
4. Точка входа

Анализ html разметки страницы

Следующим шагом, нам необходимо провести анализ html разметки страницы. Переходим на сайт wordpress.org, и открываем инспектор кода в браузере (наводим мышью на нужную область, и кликаем правой кнопкой мыши, в появившемся меню, выбираем «Исследовать элемент«)

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

1. Ссылка на плагин
2. Текст ссылки на плагин
3. Количество отзывов

Отлично! Мы с вами проанализировали html код страницы, и выяснили в каких тегах хранятся наши данные. Ниже я описал структуру html страницы.

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

Ниже представлен листинг кода, который возвращает нам все найденные теги section.

                    
import requests
from bs4 import BeautifulSoup
LINK = 'https://wordpress.org/plugins/'

def get_html(link):
    response = requests.get(link)
    return response.text

def get_data(html):
    soup = BeautifulSoup(html, 'lxml')
    articles = soup.find_all('article')
    return articles

def main():
    link = LINK
    print(get_data(get_html(link)))


if __name__=="__main__":
    main()

Как видите в данном коде, появилось небольшое дополнение.

1. В функции get_data() мы создали переменную articles
2. Обратились к soup с помощью find_all, что бы найти все теги article, которые есть на странице
3. Для того, что бы убедиться в том, что мы идем в правильном направлении, мы можем воспользоваться методом len()
4. return len(article), в случае если все правильно, то функция вернет нам 16, так как у нас всего 16 плагинов на странице
5. Если у вас возникает ошибка, опишите проблему в комментариях

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

                    
import requests
from bs4 import BeautifulSoup


def get_html(url):
    r = requests.get(url)
    return r.text


def refinde(str):
    s = str.split(' ')[0]
    return s.replace(',','')


def get_data(html):
    soup = BeautifulSoup(html, 'lxml')
    articles = soup.find_all('article')
    for article in articles:
        h3 = article.find('h3', class_='entry-title').text
        link = article.find('h3', class_='entry-title').find('a').get('href')
        rating = article.find('div', class_="plugin-rating").find('span', class_="rating-count").find('a').text
        print (h3,link,refinde(rating))


def main():
    url ='https://wordpress.org/plugins'
    print(get_data(get_html(url)))

if __name__ == '__main__':
    main()

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

1. В функции get_data(), мы нашли все теги article, с помощью метода find_all. Данный метод возвращает нам все найденные элементы в виде списка.
2. Запускаем цикл for, и перебираем полученный список.
   1. Сначала ищем теги h3, и забираем текст заключенный между ними. Это и есть заголовок нашего плагина
   2. Затем ищем ссылку на заголовок
   3. Далее ищем количество отзывов

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

• 1,985 total ratings (без функции refinde)
• 1985 с функцией refinde()

Сама функция работает достаточно просто.

• Функция принимает один аргумент в виде строки
• Для строки используем метод split(), который по пробелу разбивает строку, и возвращает нам ее в виде списка, из этого списка, мы забираем первый элемент.
• Первым элементом является число (количество скачиваний), но она содержит запятую, а так как мы хотим сохранить наши данные в csv, то лучше нам от нее избавиться
• Используем метод replace(), и заменяем запятую на пустой символ

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

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

Запись в csv

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

                    
import requests
from bs4 import BeautifulSoup
import csv

def get_html(url):
    r = requests.get(url)
    return r.text


def refinde(str):
    s = str.split(' ')[0]
    return s.replace(',','')


def write_csv(data):
    with open('listplugins3.csv', 'a') as f:
        recorder = csv.writer(f)

        recorder.writerow((data['h3'],
                           data['link'],
                           data['rating']))

def get_data(html):
    soup = BeautifulSoup(html, 'lxml')
    articles = soup.find_all('article')
    for article in articles:
        h3 = article.find('h3', class_='entry-title').text
        link = article.find('h3', class_='entry-title').find('a').get('href')
        rating = article.find('div', class_="plugin-rating").find('span', class_="rating-count").find('a').text
        rating = refinde(rating)



        data ={'h3':h3,
               'link':link,
               'rating':rating}
        write_csv(data)


def main():
    url ='https://wordpress.org/plugins'
    print(get_data(get_html(url)))

if __name__ == '__main__':
    main()

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

• Внутри функции get_data() мы создали словарь, куда внесли все полученные ранее нами значения
• Создали функцию write_csv()
  • Функция работает довольно просто, создаем/открываем файл для записи
  • Будьте внимательны с флагами, которые вы указываете. К примеру ‘w‘, всегда будет перезаписывать существующий файл, а флаг ‘a‘, это как append в списках, добавлять новые данные в конец файла
  • Далее используем writerow() и передаем туда кортеж с нашими данными
• И в самом конце, в функции get_data() мы вызываем нашу новую функцию write_csv() и передаем туда наш словарь

После запуска нашего скрипта, у нас появится файл listplugins3.csv. Открыть данный файл можно как в Excel, так и в другом стороннем редакторе. Конечный результат сбора данных, вы можете увидеть ниже.

Домашнее задание

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

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

Заключение

В этом уроке, я постарался насколько это возможно подробно объяснить как все устроено. В следующих уроках, такие подробности будут опущены. Сегодня нам удалось спарсить название/ссылку/рейтинг 16 плагинов. Конечно, это можно было бы сделать и в ручную, и не пришлось бы копаться в коде, и изучать что то. Но представьте себе, что у вас не 16 плагинов, а 10 000.Для таких случаев и создаются парсеры. Достаточно понять, как устроена структура страницы, и вы одним махом сможете собрать все данные подходящие под ваш шаблон.

На следующих уроках, мы будем рассматривать и другие виды сайтов, и в целом как правильно писать парсеры, что бы они не падали во время работы, будем использовать try…except конструкции, и прочие. Запомните, чем больше парсеров вы напишите, тем быстрее у вас появится опыт, и понимание того, как все устроено изнутри.

Урок 3. Парсинг таблиц на Python