python 爬虫杂七杂八

2022/2/23 20:24:09

编程Tag： 字符串爬虫 url python 匹配 re print info 杂七杂八

本文主要是介绍python 爬虫杂七杂八，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

##sample 1 爬取中国日报新闻

##原文链接：https://blog.csdn.net/carson0408/article/details/89890687
##根据上图可以定义标题匹配规则，只打印括号内的内容 pattern3='<a href=".*?" target="_blank" title="(.*?)">'
###正则表达方式   https://www.jb51.net/article/65286.htm
##.+? 代表意思是所有非空字符
##正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量 词”ab*?”，将找到”a”。
#[a-zA-Z_] 代表字符串，[0-9] 大表数字,[/hpl] 代表着特定字符/或者h或者p或者l
#UnicodeDecodeError: ‘utf-8‘ codec can‘t decode byte 0xd3 in position 252”  please refer
##https://blog.csdn.net/u012767761/article/details/119836555
##从中国日报抓取英文新闻

import re
import urllib.request


def getcontent(url):
    req = urllib.request.Request(url)
    req.add_header('User-Agent', 'Mozilla/5.0(Windows NT 10.0;Win64;x64;rv:66.0)Gecko/20100101 Firefox/66.0')
    data = urllib.request.urlopen(req).read().decode('utf-8')
    #print(data)
    #data = urllib.request.urlopen(req).read().decode('gbk')
    pattern1 = '<a href="/(.*?)" target="_blank" title=".*?">'
    urlList = re.compile(pattern1).findall(data)
    ##only some pattenn print bbs  title 只包括体育新闻
    pattern2 = '<a target="_blank" class="txt1" shape="rect" href="/.*?">.*?</a>'
    # only some pattenn print bbs  title 不包括体育新闻
    #pattern3 = '<a href=".*?" target="_blank" title=(.*?)>'
    #pattern3 = '<a href=".*?" tip="标题: <strong>.*?</strong>'
    #pattern3 = 'tip="标题: <strong>.*?</strong>'
    #pattern3 ='.*<a target="_blank" shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    #pattern3 = '<[/hpl].*?><a target="_blank" shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    #pattern3 = '<[/hpl].*?><a target="_blank".*? shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    pattern3 = '<[/hpl].*?><a target="_blank".*? shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    #pattern3 = '<[/hpl].+?><a target="_blank".+? shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    #pattern3 = '<[/hpl].*?><a target="_blank" shape="rect" href="//.*?">[a-zA-Z_].*?</a>'
    sourceList = re.compile(pattern2).findall(data)
    titleList = re.compile(pattern3).findall(data)
    #print (titleList)
    print(sourceList)
    authorList = []
    totalUrlList = []
    timeList = []
    info = []
    for url in urlList:
        url = "https://bbs.hupu.com/" + url
        totalUrlList.append(url)
        html = urllib.request.urlopen(url).read().decode('utf-8')
        pattern = '<a class="u" target="_blank" href=".*?">(.*?)</a>'
        pattern4 = '<span class="stime">(.*?)</span>'
        aulist = re.compile(pattern).findall(html)
        tiList = re.compile(pattern4).findall(html)
        authorList.append(aulist[0])
        timeList.append(tiList[0])
    #info.append(totalUrlList)
    info.append(sourceList)
    info.append(titleList)
    # info.append(authorList)
    # info.append(timeList)
    return info


if __name__ == '__main__':
    url = "http://www.chinadaily.com.cn/"
    info = getcontent(url)
    #print(info[1])
    #print (info[0])
    print (len(info[1]))
    ##打印所有记录非体育的标题
    for i in range(0,len(info[1])):
        #print (info[1][i])
        #只打印链接和标题
        text=info[1][i]
        start = text.find("href")
        print (text[start+1:-4])
    # for i in info[1]:
    #     prin i
    #print(len(info))
    # totalurlList = info[0]
    # sourceList = info[1]
    titleList = info[0]
    # authorList = info[3]
    # timeList = info[4]
    #length = len(totalurlList)
    length = len(titleList)
    ##打印体育的标题
    for i in range(0,length):
        #print (info[1][i])
        #只打印链接和标题
        text=info[0][i]
        start = text.find("href")
        print (text[start+1:-4])
    # for i in info[1]:
    # for i in range(length):
    #     str = "标题：" + titleList[i] + " "
    #     # str = "标题：" + titleList[i] + " " + "作者：" + authorList[i] + " " + "URL：" + totalurlList[i] + " " + "发布时间：" + \
    #     #       timeList[i] + " " + "帖子来源：" + sourceList[i]
    #     print(str)



###sample 2

get 60oldbbs  数据

##原文链接：https://blog.csdn.net/carson0408/article/details/89890687
##根据上图可以定义标题匹配规则， pattern3='<a href=".*?" target="_blank" title="(.*?)">'
###正则表达方式   https://www.jb51.net/article/65286.htm
##.+? 代表意思是所有非空字符
##正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量 词”ab*?”，将找到”a”。
#UnicodeDecodeError: ‘utf-8‘ codec can‘t decode byte 0xd3 in position 252”  please refer
##https://blog.csdn.net/u012767761/article/details/119836555
#get 60oldbbs  数据
import re
import urllib.request


def getcontent(url):
    req = urllib.request.Request(url)
    req.add_header('User-Agent', 'Mozilla/5.0(Windows NT 10.0;Win64;x64;rv:66.0)Gecko/20100101 Firefox/66.0')
    #data = urllib.request.urlopen(req).read().decode('utf-8')
    data = urllib.request.urlopen(req).read().decode('gbk')
    pattern1 = '<a href="/(.*?)" target="_blank" title=".*?">'
    urlList = re.compile(pattern1).findall(data)
    pattern2 = '<a href="/.+?" target="_blank">(.*?)</a>'
    # only print bbs  title
    #pattern3 = '<a href=".*?" target="_blank" title=(.*?)>'
    #pattern3 = '<a href=".*?" tip="标题: <strong>.*?</strong>'
    pattern3 = 'tip="标题: <strong>.*?</strong>'
    sourceList = re.compile(pattern2).findall(data)
    titleList = re.compile(pattern3).findall(data)
    #print (titleList)
    authorList = []
    totalUrlList = []
    timeList = []
    info = []
    for url in urlList:
        url = "https://bbs.hupu.com/" + url
        totalUrlList.append(url)
        html = urllib.request.urlopen(url).read().decode('utf-8')
        pattern = '<a class="u" target="_blank" href=".*?">(.*?)</a>'
        pattern4 = '<span class="stime">(.*?)</span>'
        aulist = re.compile(pattern).findall(html)
        tiList = re.compile(pattern4).findall(html)
        authorList.append(aulist[0])
        timeList.append(tiList[0])
    info.append(totalUrlList)
    # info.append(sourceList)
    info.append(titleList)
    # info.append(authorList)
    # info.append(timeList)
    return info


if __name__ == '__main__':
    url = "http://www.60old.cn/forum.php"
    info = getcontent(url)
    print(info[0])
    print (len(info[0]))
    ##只取前10条记录
    for i in range(0,10):
        print (info[1][i])
    # for i in info[1]:
    #     prin i
    #print(len(info))
    # totalurlList = info[0]
    # sourceList = info[1]
    titleList = info[0]
    # authorList = info[3]
    # timeList = info[4]
    #length = len(totalurlList)
    length = len(titleList)
    for i in range(length):
        str = "标题：" + titleList[i] + " "
        # str = "标题：" + titleList[i] + " " + "作者：" + authorList[i] + " " + "URL：" + totalurlList[i] + " " + "发布时间：" + \
        #       timeList[i] + " " + "帖子来源：" + sourceList[i]
        print(str)


###sample 3   从虎扑nba 抓取数据

##原文链接：https://blog.csdn.net/carson0408/article/details/89890687
##根据上图可以定义标题匹配规则， pattern3='<a href=".*?" target="_blank" title="(.*?)">'
###正则表达方式   https://www.jb51.net/article/65286.htm
##.+? 代表意思是所有非空字符
##正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量 词”ab*?”，将找到”a”。
##get 虎扑nba 数据
import re
import urllib.request


def getcontent(url):
    req = urllib.request.Request(url)
    req.add_header('User-Agent', 'Mozilla/5.0(Windows NT 10.0;Win64;x64;rv:66.0)Gecko/20100101 Firefox/66.0')
    data = urllib.request.urlopen(req).read().decode('utf-8')
    pattern1 = '<a href="/(.*?)" target="_blank" title=".*?">'
    urlList = re.compile(pattern1).findall(data)
    pattern2 = '<a href="/.+?" target="_blank">(.*?)</a>'
    ##only print bbs  title
    #pattern3 = '<a href=".*?" target="_blank" title=(.*?)>'
    pattern3 ='<span class="t-title">(.*?)</span>'
    sourceList = re.compile(pattern2).findall(data)
    titleList = re.compile(pattern3).findall(data)
    #print (titleList)
    authorList = []
    totalUrlList = []
    timeList = []
    info = []
    for url in urlList:
        url = "https://bbs.hupu.com/" + url
        totalUrlList.append(url)
        html = urllib.request.urlopen(url).read().decode('utf-8')
        pattern = '<a class="u" target="_blank" href=".*?">(.*?)</a>'
        pattern4 = '<span class="stime">(.*?)</span>'
        aulist = re.compile(pattern).findall(html)
        tiList = re.compile(pattern4).findall(html)
        authorList.append(aulist[0])
        timeList.append(tiList[0])
    info.append(totalUrlList)
    # info.append(sourceList)
    info.append(titleList)
    # info.append(authorList)
    # info.append(timeList)
    return info


if __name__ == '__main__':
    url = "https://bbs.hupu.com/all-nba"
    info = getcontent(url)
    #print(info[1])
    #print (len(info[1]))
    for i in range(0,len(info[1])):
        print (info[1][i])
    # for i in info[1]:
    #     prin i
    #print(len(info))
    # totalurlList = info[0]
    # sourceList = info[1]
    titleList = info[0]
    # authorList = info[3]
    # timeList = info[4]
    #length = len(totalurlList)
    length = len(titleList)
    for i in range(length):
        str = "标题：" + titleList[i] + " "
        # str = "标题：" + titleList[i] + " " + "作者：" + authorList[i] + " " + "URL：" + totalurlList[i] + " " + "发布时间：" + \
        #       timeList[i] + " " + "帖子来源：" + sourceList[i]
        print(str)


###sample 4  正则算法贪婪算法和非贪婪算法 和带括号的打印

###正则算法贪婪算法和非贪婪算法

#https://docs.python.org/zh-cn/3/library/re.html
#https://blog.csdn.net/m0_37852369/article/details/79101892
import re

example = "<div>test1</div><div>test2</div>"

##贪婪算法会从最开始的标注符找，一直找，直到找到最后一个标识符
greedPattern = re.compile("<div>.*</div>")
#print(greedPattern)
##非贪婪算法会从最开始的标注符找，找到最后一个标识符第一个就中止

#notGreedPattern = re.compile("<div>.*?</div>")
notGreedPattern = re.compile("<div>.+?</div>")


greedResult = greedPattern.search(example)
notGreedResult = notGreedPattern.search(example)

print("greedResult = %s" % greedResult)
print("notGreedResult = %s" % notGreedResult)



#######和带括号的打印

data="<a target=\"_blank\" shape=\"rect\" href=\"//www.chinadaily.com.cn/a/202202/23/WS62156e5da310cdd39bc88468.html\">E-commerce boosts rural development</a>"

##不带括号的，打印一行的所有
pattern1 = '<a target="_blank".*? shape="rect" href="//.*?">[a-zA-Z_].*?</a>'

#result
#['<a target="_blank" shape="rect" href="//www.chinadaily.com.cn/a/202202/23/WS62156e5da310cdd39bc88468.html">E-commerce boosts rural development</a>']

##带括号的只打印括号里的匹配
pattern3 = '<a target="_blank".*? shape="rect" href="//.*?">([a-zA-Z_].*?)</a>'
#result
#['E-commerce boosts rural development']

pattern2 = '<a target="_blank" shape="rect" href="/.*?">(.*?)</a>'
#result
#['E-commerce boosts rural development']

##验证
titleList1 = re.compile(pattern1).findall(data)
print(titleList1)

titleList3 = re.compile(pattern3).findall(data)
print(titleList3)
titleList2 = re.compile(pattern2).findall(data)
print(titleList2)


###sample 5
https://docs.python.org/zh-cn/3/library/re.html

正则表达式操作

`re` --- 正则表达式操作¶

源代码: Lib/re.py

本模块提供了与 Perl 语言类似的正则表达式匹配操作。

模式和被搜索的字符串既可以是 Unicode 字符串 (str) ，也可以是8位字节串 (bytes)。但是，Unicode 字符串与 8 位字节串不能混用：也就是说，不能用字节串模式匹配 Unicode 字符串，反之亦然；同理，替换操作时，替换字符串的类型也必须与所用的模式和搜索字符串的类型一致。

正则表达式用反斜杠字符 ('\') 表示特殊形式，或是允许在使用特殊字符时，不引发它们的特殊含义。这与 Python 的字符串字面值中对相同字符出于相同目的的用法产生冲突；例如，要匹配一个反斜杠字面值，用户可能必须写成 '\\\\' 来作为模式字符串，因为正则表达式必须为 \\，而每个反斜杠在普通 Python 字符串字面值中又必须表示为 \\。而且还要注意，在 Python 的字符串字面值中使用的反斜杠如果有任何无效的转义序列，现在会触发 DeprecationWarning，但以后会改为 SyntaxError。此行为即使对于正则表达式来说有效的转义字符同样会发生。

解决办法是对于正则表达式样式使用 Python 的原始字符串表示法；在带有 'r' 前缀的字符串字面值中，反斜杠不必做任何特殊处理。因此 r"\n" 表示包含 '\' 和 'n' 两个字符的字符串，而 "\n" 则表示只包含一个换行符的字符串。样式在 Python 代码中通常都使用原始字符串表示法。

绝大多数正则表达式操作都提供为模块函数和方法，在编译正则表达式. 这些函数是一个捷径，不需要先编译正则对象，但是损失了一些优化参数。

参见

第三方模块 regex , 提供了与标准库 re 模块兼容的 API 接口，同时，还提供了更多功能和更全面的 Unicode 支持。

正则表达式语法

正则表达式（或 RE）指定了一组与之匹配的字符串；模块内的函数可以检查某个字符串是否与给定的正则表达式匹配（或者正则表达式是否匹配到字符串，这两种说法含义相同）。

正则表达式可以拼接；如果 A 和 B 都是正则表达式，则 AB 也是正则表达式。通常，如果字符串 p 匹配 A，并且另一个字符串 q 匹配 B，那么 pq 可以匹配 AB。除非 A 或者 B 包含低优先级操作，A 和 B 存在边界条件；或者命名组引用。所以，复杂表达式可以很容易的从这里描述的简单源语表达式构建。更多正则表达式理论和实现，详见 the Friedl book [Frie09] ，或者其他构建编译器的书籍。

以下是正则表达式格式的简要说明。更详细的信息和演示，参考正则表达式HOWTO。

正则表达式可以包含普通或者特殊字符。绝大部分普通字符，比如 'A', 'a', 或者 '0'，都是最简单的正则表达式。它们就匹配自身。你可以拼接普通字符，所以 last 匹配字符串 'last'. （在这一节的其他部分，我们将用 this special style 这种方式表示正则表达式，通常不带引号，要匹配的字符串用 'in single quotes' ，单引号形式。）

有些字符，比如 '|' 或者 '('，属于特殊字符。特殊字符既可以表示它的普通含义，也可以影响它旁边的正则表达式的解释。

重复修饰符 (*, +, ?, {m,n}, 等) 不能直接嵌套。这样避免了非贪婪后缀 ? 修饰符，和其他实现中的修饰符产生的多义性。要应用一个内层重复嵌套，可以使用括号。比如，表达式 (?:a{6})* 匹配6个 'a' 字符重复任意次数。

特殊字符有：

.: (点) 在默认模式，匹配除了换行的任意字符。如果指定了标签 DOTALL ，它将匹配包括换行符的任意字符。

^: (插入符号) 匹配字符串的开头，并且在 MULTILINE 模式也匹配换行后的首个符号。

$: 匹配字符串尾或者在字符串尾的换行符的前一个字符，在 MULTILINE 模式下也会匹配换行符之前的文本。 foo 匹配 'foo' 和 'foobar'，但正则表达式 foo$ 只匹配 'foo'。更有趣的是，在 'foo1\nfoo2\n' 中搜索 foo.$，通常匹配 'foo2'，但在 MULTILINE 模式下可以匹配到 'foo1'；在 'foo\n' 中搜索 $ 会找到两个（空的）匹配：一个在换行符之前，一个在字符串的末尾。

*: 对它前面的正则式匹配0到任意次重复，尽量多的匹配字符串。 ab* 会匹配 'a'，'ab'，或者 'a' 后面跟随任意个 'b'。

+: 对它前面的正则式匹配1到任意次重复。 ab+ 会匹配 'a' 后面跟随1个以上到任意个 'b'，它不会匹配 'a'。

?: 对它前面的正则式匹配0到1次重复。 ab? 会匹配 'a' 或者 'ab'。

*?, +?, ??: '*', '+'，和 '?' 修饰符都是 贪婪的；它们在字符串进行尽可能多的匹配。有时候并不需要这种行为。如果正则式 <.*> 希望找到 '<a> b <c>'，它将会匹配整个字符串，而不仅是 '<a>'。在修饰符之后添加 ? 将使样式以 非贪婪`方式或者 :dfn:`最小 方式进行匹配；尽量少的字符将会被匹配。使用正则式 <.*?> 将会仅仅匹配 '<a>'。

{m}: 对其之前的正则式指定匹配 m 个重复；少于 m 的话就会导致匹配失败。比如， a{6} 将匹配6个 'a' , 但是不能是5个。
{m,n}: 对正则式进行 m 到 n 次匹配，在 m 和 n 之间取尽量多。比如，a{3,5} 将匹配 3 到 5个 'a'。忽略 m 意为指定下界为0，忽略 n 指定上界为无限次。比如 a{4,}b 将匹配 'aaaab' 或者1000个 'a' 尾随一个 'b'，但不能匹配 'aaab'。逗号不能省略，否则无法辨别修饰符应该忽略哪个边界。
{m,n}?: 前一个修饰符的非贪婪模式，只匹配尽量少的字符次数。比如，对于 'aaaaaa'， a{3,5} 匹配 5个 'a' ，而 a{3,5}? 只匹配3个 'a'。

\

转义特殊字符（允许你匹配 '*', '?', 或者此类其他），或者表示一个特殊序列；特殊序列之后进行讨论。

如果你没有使用原始字符串（ r'raw' ）来表达样式，要牢记Python也使用反斜杠作为转义序列；如果转义序列不被Python的分析器识别，反斜杠和字符才能出现在字符串中。如果Python可以识别这个序列，那么反斜杠就应该重复两次。这将导致理解障碍，所以高度推荐，就算是最简单的表达式，也要使用原始字符串。

[]

用于表示一个字符集合。在一个集合中：

字符可以单独列出，比如 [amk] 匹配 'a'， 'm'，或者 'k'。

可以表示字符范围，通过用 '-' 将两个字符连起来。比如 [a-z] 将匹配任何小写ASCII字符， [0-5][0-9] 将匹配从 00 到 59 的两位数字， [0-9A-Fa-f] 将匹配任何十六进制数位。如果 - 进行了转义（比如 [a\-z]）或者它的位置在首位或者末尾（如 [-a] 或 [a-]），它就只表示普通字符 '-'。
特殊字符在集合中，失去它的特殊含义。比如 [(+*)] 只会匹配这几个文法字符 '(', '+', '*', or ')'。

字符类如 \w 或者 \S (如下定义) 在集合内可以接受，它们可以匹配的字符由 ASCII 或者 LOCALE 模式决定。

不在集合范围内的字符可以通过取反来进行匹配。如果集合首字符是 '^' ，所有不在集合内的字符将会被匹配，比如 [^5] 将匹配所有字符，除了 '5'， [^^] 将匹配所有字符，除了 '^'. ^ 如果不在集合首位，就没有特殊含义。
在集合内要匹配一个字符 ']'，有两种方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如， [()[\]{}] 和 []()[{}] 都可以匹配括号。

Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未来添加。这将会改变语法，所以为了帮助这个改变，一个 FutureWarning 将会在有多义的情况里被 raise，包含以下几种情况，集合由 '[' 开始，或者包含下列字符序列 '--', '&&', '~~', 和 '||'。为了避免警告，需要将它们用反斜杠转义。

在 3.7 版更改: 如果一个字符串构建的语义在未来会改变的话，一个 FutureWarning 会 raise 。

|

#######sample 6
https://blog.csdn.net/m0_37852369/article/details/79101892

三、原理分析
在正则表达式中一般默认采用的是贪婪模式，在上面的例子当中已经匹配到了“ab”时已经可以使整个表达式匹配成功，但是由于采用的是贪婪模式，所以还需要往后继续匹配，检查时候存在更长的可以匹配成功的字符串。一直到匹配到最后一个”b”的时候，后面已经没有可以成功匹配的字符串了，匹配结束。返回匹配结果“abbbbbb”。
所以，我们可以将贪婪模式理解为：在整个表达式匹配成功的前提下，尽可能多的匹配。

非贪婪模式也就是将我们例子中的正则表达式“ab+”改为”ab+?”，当匹配到“ab”时，已经匹配成功，直接结束匹配，不在向后继续尝试，返回匹配成功的字符串”ab”。
所以，我们可以将非贪婪模式理解为：在整个表达式匹配成功的前提下，尽可能少的匹配

四、实例
import re

example = "<div>test1</div><div>test2</div>"

greedPattern = re.compile("<div>.*</div>")
notGreedPattern = re.compile("<div>.*?</div>")

greedResult = greedPattern.search(example)
notGreedResult = notGreedPattern.search(example)

print("greedResult = %s" % greedResult.group())
print("notGreedResult = %s" % notGreedResult.group())
————————————————
版权声明：本文为CSDN博主「坚强的狗蛋」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37852369/article/details/79101892

这篇关于python 爬虫杂七杂八的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

python 爬虫 杂七杂八

正则表达式操作

re --- 正则表达式操作¶

正则表达式语法

相关编程文章

python 爬虫杂七杂八

`re` --- 正则表达式操作¶