Crawler (2) - expressions régulières

01 Préface

L'article précédent a présenté en détail ce qu'est un crawler, quelques concepts de base qu'un crawler doit maîtriser, et la première bibliothèque qu'un crawler a maîtrisée. Pour plus de détails, vous pouvez cliquer ici : Crawler (1) - Vous amène à requestscomprendre le Concept le plus basique des crawlers, un article peut être pratiqué

Ensuite, je détaillerai un autre outil indispensable pour les robots d'exploration, les expressions régulières.

Cet article fait référence au lien suivant :
https://blog.csdn.net/xuemoyao/article/details/8033138?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168006967216800215067670%2522%252C%2 522 mc%2522% 253A% 252220140713.130102334…%2522%257D&request_id=168006967216800215067670&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2 tous top_positif~ default -2-803 3138-nu ll-null.142 v77 insert_down38 , 201 v4 _{add_ask} , ²³⁹ v2 ^{insert_chatgpt} & ^utm_term = %E6% AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F&spm=1018.2226.3001.4187

02 expressions régulières

  Définition : Les expressions régulières sont des outils puissants pour le traitement des chaînes et sont généralement utilisées pour récupérer et remplacer du texte qui respecte certaines règles.

2.1 rebibliothèque

Python prend en charge les expressions régulières via la bibliothèque re, mais avant d'utiliser des expressions régulières, vous devez importer le module re pour appeler la fonction du module.

Plusieurs paramètres communs de re

• re.I: faire en sorte que la correspondance ignore la casse
• re.M: Autoriser la correspondance multiligne
• re.S: correspond à tous les caractères, y compris les nouvelles lignes

En Python, l'utilisation d'expressions régulières nécessite généralement l'utilisation du module re. Plusieurs méthodes couramment utilisées comprennent :

• re.search(pattern, string): Rechercher les chaînes qui correspondent à l'expression régulièrepremière sous-chaîneet renvoie un objet Match contenant les informations correspondantes. Renvoie None si aucune correspondance n'est trouvée.

• re.findall(pattern, string): Rechercher les chaînes qui correspondent à l'expression régulièretoutes les sous-chaînes, et le renvoie sous forme de liste. Si aucune correspondance n'est trouvée, une liste vide est retournée.

• re.sub(pattern, repl, string): Recherche dans une chaîne toutes les sous-chaînes qui correspondent à l'expression régulière et les remplace par la chaîne spécifiée repl. retourla chaîne remplacée。

Voici un exemple de sortie de code par ligne :

import re

# 定义要匹配的正则表达式
pattern = r'^\d+\..*'

# 打开文件
with open('example.txt', 'r') as f:
    # 按行读取文件内容
    for line in f:
        # 使用re.match()函数进行匹配
        match_obj = re.match(pattern, line)
        # 如果匹配成功，则输出该行内容
        if match_obj:
            print(line.strip())

Dans le code ci-dessus, l'expression régulière à rechercher est d'abord définie, qui peut rechercher des lignes commençant par un nombre suivi de n'importe quel caractère. Ouvrez ensuite le fichier, lisez le contenu du fichier ligne par ligne et utilisez la fonction re.match() pour faire correspondre le contenu de chaque ligne. Si la correspondance est réussie, affichez le contenu de la ligne.

Notez que strip()la fonction peut supprimer les espaces et les retours à la ligne aux deux extrémités de la chaîne.

2.2 Paramètres des expressions régulières

Deux paramètres couramment utilisés :
Dans les expressions régulières, . et ? sont tous deux des métacaractères ayant une signification particulière.

• .Représente une correspondancearbitrairementUn seul caractère (sauf retour à la ligne).

Par exemple, l'expression régulière ab peut correspondre à axb, a#b, ab, etc.

• ?Représente la correspondance précédentesous-expression0 ou 1 fois.

Par exemple, l'expression régulière ab?c correspond à ac et abc, mais pas à abc.

? peut également être utilisé après d'autres métacaractères pour indiquerappariement non gourmand. Par exemple, l'expression régulière a.*?b peut correspondre à ab, axxxb, etc., mais lorsqu'elle correspond à axxxbyyyb, elle correspond uniquement à axxxb.

  Il convient de noter que . et ? n'ont la signification spéciale mentionnée ci-dessus que lorsqu'ils sont utilisés comme métacaractères dans des expressions régulières. S'ils doivent se correspondre, ils doivent utiliser le caractère d'échappement \. Par exemple, l'expression régulière ab peut correspondre à ab, mais pas à axb, a#b, etc.

2.2.1 Métacaractères couramment utilisés

le code	illustrer
.	correspond à n'importe quel caractère sauf à la nouvelle ligne
\w	Faire correspondre des lettres ou des chiffres ou des traits de soulignement ou des caractères chinois
\s	correspond à n'importe quel espace blanc
\d	faire correspondre les numéros
\b	correspond au début ou à la fin d'un mot
^	correspondre au début de la chaîne
$	correspond à la fin de la chaîne

Exemple:

• ^\d{8}$ correspond au nombre qq à 8 chiffres.

• \bOlive\b correspond au mot Olive.

Remarque : J'aime Olivier et Olive. Pour le moment, Olivier est renvoyé à la place d'Olivier, car \b...\b renvoie les mots correspondants

2.2.2 Antonymes

Caractères antonymes : il est principalement utilisé pour trouver n'importe quel caractère, à l'exception d'un certain caractère.

code/syntaxe	illustrer
\W	Correspond à n'importe quel caractère qui n'est pas une lettre, un chiffre, un trait de soulignement ou un caractère chinois
\S	correspond à tout caractère qui n'est pas un espace
\D	correspond à n'importe quel caractère non numérique
\B	correspond à une position qui n'est ni le début ni la fin d'un mot
[^x]	correspond à n'importe quel caractère sauf x
[^données]	Correspond à n'importe quel caractère à l'exception des données

2.2.3 Caractères délimités

Caractères délimités : les caractères délimités sont principalement utilisés pour les heures de correspondance répétées.

code/syntaxe	illustrer
*	Répéter zéro ou plusieurs fois
+	répéter une ou plusieurs fois
?	sous-chaîne répétée zéro ou une fois
{n}	répéter n fois
{n,}	répéter n ou plusieurs fois
{n,m}	Répéter n à m fois

2.2.4 Caractères d'échappement

Caractère d'échappement : ajoutez \.

Exemple : comme les métacaractères. * \ doit être converti en \. \* \\

Branche de caractères : elle est principalement utilisée pour répondre à la sélection de différentes situations. Utilisez "|" pour séparer différentes conditions. Par exemple, certains indicatifs régionaux de ligne fixe ont trois chiffres et d'autres ont quatre chiffres. À ce stade, la branche de caractères peut être utilisée

Par exemple : \d{3}-\d{8}|\d{4}-\d{8} peut faire correspondre des lignes fixes avec des indicatifs régionaux de deux longueurs différentes

2.2.5 Regroupement de caractères

Le groupement de caractères est principalement utilisé pour répéter plusieurs caractères, principalement en utilisant des parenthèses () pour grouper

La forme ressemble à : (\d\w){3} Correspond à 3 fois de manière répétée (\d\w)

Syntaxe de regroupement commune :

Classification	le code	illustrer
capture	(exp)	correspond à exp et capture le texte dans des groupes nommés automatiquement
	(?<nom>exp)	Faites correspondre exp et capturez le texte dans un groupe nommé name, qui peut également être écrit comme (?'name'exp)
	(?:exp)	Faites correspondre exp, ne capturez pas le texte correspondant et n'attribuez pas de numéro de groupe à ce groupe
assertion de largeur nulle	(?=exp)	Faites correspondre la position devant exp
	(?<=exp)	Faites correspondre la position après exp
	(?!exp)	Correspond à une position qui n'est pas suivie de exp
	(?<!exp)	Correspond à une position qui n'est pas précédée de exp
note	(?#commentaire)	Ce type de regroupement n'a aucun effet sur le traitement des expressions régulières et est utilisé pour fournir des commentaires à lire

2.2.6 Appariement paresseux et gourmand

Correspondance gourmande : lorsque l'expression régulière contient des qualificateurs répétés, le comportement habituel estcorrespondre autant que possiblecaractère de.

Correspondance paresseuse : Parfois, il est nécessaire de faire correspondre le moins de caractères possible.

Par exemple : a.*b, il correspondra à la chaîne la plus longue commençant par a et se terminant par b. Si vous l'utilisez pour rechercher aabab, il correspondra à la chaîne entière aabab. Mais ce que nous pouvons avoir besoin de faire correspondre à ce moment est ab, nous devons donc utiliser la correspondance paresseuse. La correspondance paresseuse correspond au moins de caractères possible.

code/syntaxe	illustrer
* ?	Répétez n'importe quel nombre de fois, mais aussi peu de fois que possible
+ ?	Répétez 1 ou plusieurs fois, mais aussi peu de fois que possible
??	Répétez 0 ou 1 fois, mais le moins de fois possible
{n,m} ?	Répéter n à m fois, mais le moins de fois possible
{n,} ?	Répétez n fois de plus, mais le moins possible

2.2.7 Références arrières

Les références arrière sont utilisées pour rechercher à plusieurs reprises du texte correspondant à un groupement précédent.

Après avoir spécifié une sous-expression entre parenthèses, le texte correspondant à la sous-expression (c'est-à-dire le contenu capturé par ce groupe) peut être traité ultérieurement dans l'expression ou dans d'autres programmes. Par défaut, chaque groupe a automatiquement un numéro de groupe.

• Numéro de groupe par défaut :
  Exemple : \b(\w+)\b\s+\1\b peut être utilisé pour faire correspondre des mots répétés, comme go go ou minou minou.

Cette expression est d'abord un mot, c'est-à-dire plus d'une lettre ou chiffre (\b(\w+)\b) entre le début et la fin du mot, ce mot sera capturé dans le groupe numéroté 1, puis un ou plus de caractères blancs (\s+), et enfin le contenu capturé dans le groupe 1 (c'est-à-dire le mot correspondant plus tôt) (\1).

• Auto-spécifié : vous pouvez également spécifier vous-même le nom de groupe de la sous-expression.
  Pour spécifier le nom de groupe d'une sous-expression, utilisez cette syntaxe : (?<Word>\w+) (ou remplacez les crochets angulaires par ' : (?'Word'\w+)), donc put\w+ Le nom de groupe est spécifié comme Mot. vouloirPour référencer ce que ce groupe capture, vous pouvez utiliser \k<Word>,所以上一个例子也可以写成这样：\b(?< Word>\w+)\b\s+\k< Word>\b

2.2.8 零宽断言

有时候需要查找某些匹配之前或之后的东西，这个时候就需要指定一个位置，这个位置应该满足一定的条件(即断言)。具体请看 本章的2.2.5

比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I’m singing while you’re dancing.时，它会匹配sing和danc。
比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

2.3 常用的正则表达式

• 如果你自己实在学不会正则表达式，请点击这里，转载自其他大神：点击这里，他里面归纳了基本所有你想要的用的正则表达式。
• 如果里面没有你想要的，请私信我。

2.4 正则表达式的实例

(1) 抓取html里面的<title>间的内容

#方法一
title = re.findall(r'<title>(.*?)</title>', content.decode('utf-8'))

# 方法二
pat = r'(?<=<title>).*?(?=</title>)'    
ex = re.compile(pat, re.M|re.S)
obj = re.search(ex, content.decode('utf-8'))
title = obj.group()  
print(title)

（2）爬取超链接<a>标签间的内容

#获取完整超链接
res = r"<a.*?href=.*?<\/a>"
urls = re.findall(res, content.decode('utf-8'))

#获取超链接<a>和</a>之间内容
res = r'<a .*?>(.*?)</a>'  
texts = re.findall(res, content.decode('utf-8'), re.S|re.M)  

（3）抓取超链接标签的url

res = r"(?<=href=\").+?(?=\")|(?<=href=\').+?(?=\')"
urls = re.findall(res, content, re.I|re.S|re.M)
for url in urls:
    print(url)

（4）抓取图片超链接标签的url

content = '''<img alt="Python" src="http://www.yangxiuzhang.com/eastmount.jpg" />'''
urls = re.findall('src="(.*?)"', content, re.I|re.S|re.M)
print urls

（5）获取url中最后一个参数
  在使用Python爬取图片过程中，通常会遇到图片对应的url最后一个字段用来命名图片的情况，如“photo1.jpg”，需要通过解析url“/”后面的参数来获取图片。

urls = 'http://www..csdn.net/photo1.jpg'
name = urls.split('/')[-1]  
print name

补充：如果取得的text有其他字符，可以进行数据的预处理

使用.replace()方法，将需要替换的特殊字符统统替换成空字符，可以看数据分析这一讲，详细学习该方法的用法。

03 还在学习（ing）

想要学好爬虫，还需要学习以下基础知识：

• Beautiful Soup 4
• XPATH技术：分析网页的DOM树结构，通过XPATH技术定位网页所爬取内容的节点，再抓取数据
• Scrapy框架
• Selenium库