[python] 网络数据采集 操作清单 BeautifulSoup、Selenium、Tesseract、CSV等

Python 爬虫(八)常见爬虫库及相关工具(Python Crawler (8):Common Crawler Libraries and Related Tools) 选择合适的工具对于提高爬虫效率和应对各种复杂情况至关重要。本文将介绍从爬虫框架到数据处理工具,再到反爬虫处理的各类库,帮助你构建一个强大而灵活的爬虫系统。 无论你是爬虫新手还是有经验的开发者,相信都能在这里找到有用的信息,帮助你更好地进行网络数据采集工作。 阅读详情

Python网络数据采集操作清单

BeautifulSoup、Selenium、Tesseract、CSV等



常用正则表达式清单

常用正则表达式符号

image_1bbtn4jhr7ts7ra1127i951tln9.png-139.7kB

电子邮箱

[A-Za-z0-9\._+]+@[A-Za-z]+\.(com|org|edu|net)

找出所有以”/”开头的链接

    for link in bsObj.findAll("a", href=re.compile("^(/|.*"+includeUrl+")")):
        if link.attrs['href'] is not None:
            if link.attrs['href'] not in internalLinks:
                internalLinks.append(link.attrs['href'])
    return internalLinks

所有以”http”或”www”开头且不包含当前URL的链接

    for link in bsObj.findAll("a",
                              href = re.compile("^(http|www)((?!"+excludeUrl+").)*$")):
        if link.attrs['href'] is not None:
            if link.attrs['href'] not in externalLinks:
                externalLinks.append(link.attrs['href'])
    return externalLinks

查找

.get_text()

会把正在处理的HTML文档中所有的超链接、段落、标签都清楚并返回只包含文字的字符串

.findAll(tag, attributes, recursive, text, limit, keywords)

  • 标签参数tag 前面已经介绍过——你可以传一个标签的名称或多个标签名称组成的Python
    列表做标签参数。例如,下面的代码将返回一个包含HTML 文档中所有标题标签的列表:1
    .findAll({“h1”,”h2”,”h3”,”h4”,”h5”,”h6”})

  • 属性参数attributes 是用一个Python 字典封装一个标签的若干属性和对应的属性值。例如,下面这个函数会返回HTML文档里红色与绿色两种颜色的span 标签:
    .findAll(“span”, {“class”:{“green”, “red”}})

  • 递归参数recursive 是一个布尔变量。你想抓取HTML文档标签结构里多少层的信息?如果recursive 设置为True,findAll就会根据你的要求去查找标签参数的所有子标签,以及子标签的子标签。如果recursive设置为False,findAll就只查找文档的一级标签。findAll默认是支持递归查找的(recursive默认值是True);一般情况下这个参数不需要设置,除非你真正了解自己需要哪些信息,而且抓取速度非常重要,那时你可以设置递归参数。

  • 文本参数text有点不同,它是用标签的文本内容去匹配,而不是用标签的属性。假如我们想查找前面网页中包含“theprince”内容的标签数量,我们可以把之前的findAll 方法换
    成下面的代码:
    nameList = bsObj.findAll(text=”the prince”)
    print(len(nameList))
    输出结果为“7”。

  • 范围限制参数limit,显然只用于findAll 方法。find 其实等价于findAll 的limit等于1时的情形。如果你只对网页中获取的前x 项结果感兴趣,就可以设置它。但是要注意,这个参数设置之后,获得的前几项结果是按照网页上的顺序排序的,未必是你想要的那前几项。

  • 还有一个关键词参数keyword,可以让你选择那些具有指定属性的标签。例如:
    allText = bsObj.findAll(id=”text”)
    print(allText[0].get_text())

通过标签参数tag把标签列表传到.findAll() 里获取一列标签,实就是一个“或”关系的过滤器(即选择所有带标签1或标签2或标签3……的一列标签)。如果你的标签列表很长,就需要花很长时间才能写完。而关键词参数keyword 可以让你增加一个“与”关系的过滤器来简化工作。

.find(tag, attributes, recursive, text, keywords)

同上


导航树

.children

如果你只想找出子标签,可以用.children 标签:

from urllib.request import urlopen
from bs4 import BeautifulSoup
html = urlopen("http://www.pythonscraping.com/pages/page3.html")
bsObj = BeautifulSoup(html)
for child in bsObj.find("table",{"id":"giftList"}).children:
    print(child)

.next_siblings

BeautifulSoup 的next_siblings() 函数可以让收集表格数据成为简单的事情,尤其是处理带标题行的表格:

from urllib.request import urlopen
from bs4 import BeautifulSoup
html = urlopen("http://www.pythonscraping.com/pages/page3.html")
bsObj = BeautifulSoup(html)
for sibling in bsObj.find("table",{"id":"giftList"}).tr.next_siblings:
    print(sibling)

任何时候你获取一个标签的兄弟标签,都不会包含这个标签本身。其次,这个函数只调用后面的兄弟标签。

.previous_sibling

如果你很容易找到一组兄弟标签中的最后一个标签, 那么previous_siblings 函数也会很有用。
当然,还有next_sibling和previous_sibling 函数,与next_siblings 和previous_siblings的作用类似,只是它们返回的是单个标签,而不是一组标签。

.parent和.parents

from urllib.request import urlopen
from bs4 import BeautifulSoup
html = urlopen("http://www.pythonscraping.com/pages/page3.html")
bsObj = BeautifulSoup(html)
print(bsObj.find("img",{"src":"../img/gifts/img1.jpg"
}).parent.previous_sibling.get_text())

获取属性

.attrs

对于一个标签对象,可以用下面的代码获取它的全部属性:
myTag.attrs
要注意这行代码返回的是一个Python 字典对象,可以获取和操作这些属性。比如要获取图
片的资源位置src,可以用下面这行代码:
myImgTag.attrs["src"]


Lambda表达式

BeautifulSoup允许我们把特定函数类型当作findAll 函数的参数。唯一的限制条件是这些函数必须把一个标签作为参数且返回结果是布尔类型。BeautifulSoup用这个函数来评估它遇到的每个标签对象,最后把评估结果为“真”的标签保留,把其他标签剔除。
例如,下面的代码就是获取有两个属性的标签:

soup.findAll(lambda tag: len(tag.attrs) == 2)

这行代码会找出下面的标签:
<div class="body" id="content"></div>
<span style="color:red" class="title"></span>

如果你愿意多写一点儿代码,那么在BeautifulSoup 里用Lambda表达式选择标签,将是正则表达式的完美替代方案。


获取资源

urllib.request.urlretrieve

可以根据文件的URL下载文件:

from urllib.request import urlretrieve
from urllib.request import urlopen
from bs4 import BeautifulSoup

html = urlopen("http://www.pythonscraping.com")
bsObj = BeautifulSoup(html)
imageLocation = bsObj.find("a",{"id":"logo"}).find("img")["src"]
urlretrieve(imageLocation, "logo.jpg")

清洗下载地址并计算保存路径

import os
from urllib.request import urlretrieve
from urllib.request import urlopen
from bs4 import BeautifulSoup

downloadDirectory = "downloaded"
baseUrl = "http://pythonscraping.com"

def getAbsoluteURL(baseUrl, source):
    if source.startswith("http://www."):
        url = "http://"+source[11:]
    elif source.startswith("http://"):
        url = source
    elif source.startswith("www."):
        url = "http://"+source[4:]
    else:
        url = baseUrl+"/"+source
    if baseUrl not in url:
        return None
    return url

def getDownloadPath(baseUrl, absoluteUrl, downloadDirectory):
    path = absoluteUrl.replace("www.","")
    path = path.replace(baseUrl, "")
    path = downloadDirectory+path
    directory = os.path.dirname(path)

    if not os.path.exists(directory):
        os.makedirs(directory)

    return path

html = urlopen("http://www.pythonscraping.com")
bsObj = BeautifulSoup(html)
downloadList = bsObj.findAll(src=True)

for download in downloadList:
    fileUrl = getAbsoluteURL(baseUrl, download["src"])
    if fileUrl is not None:
        print(fileUrl)

urlretrieve(fileUrl, getDownloadPath(baseUrl, fileUrl, downloadDirectory))

用CSV保存表格

import csv
from urllib.request import urlopen
from bs4 import BeautifulSoup

html = urlopen("http://en.wikipedia.org/wiki/Comparison_of_text_editors")
bsObj = BeautifulSoup(html, "html.parser")
#The main comparison table is currently the first table on the page
table = bsObj.findAll("table",{"class":"wikitable"})[0]
rows = table.findAll("tr")

csvFile = open("files/editors.csv", 'wt', newline='', encoding='utf-8')
writer = csv.writer(csvFile)
try:
    for row in rows:
        csvRow = []
        for cell in row.findAll(['td', 'th']):
            csvRow.append(cell.get_text())
        writer.writerow(csvRow)
finally:
    csvFile.close()

PyMySQL

要让PyMySQL连上MySQL的话,默认情况下得用到sock文件,
unix_socket='/var/run/mysqld/mysqld.sock'

否则要到
/etc/mysql/mysql.conf.d中修改mysqld.cnf文件,将
bind-address = 127.0.0.1注释掉,这时候就不用sock登录MySQL了。

import pymysql
coon = pymysql.connect(host='127.0.0.1',
                       user='root',
                       passwd='gmf1230132',
                       db='mysql',
                       charset='utf8')
cur = coon.cursor()
cur.execute("USE scraping")

cur.execute("SELECT * FROM pages WHERE id =1")
print(cur.fetchone())
cur.close()
coon.close()

让数据库支持Unicode

ALTER DATABASE scraping CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;
ALTER TABLE pages CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
ALTER TABLE pages CHANGE title title VARCHAR(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
ALTER TABLE pages CHANGE content content VARCHAR(10000) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

用函数存储数据

def store(title, content):
    cur.execute("INSERT INTO pages (title, content) VALUES (\"%s\", \"%s\")", (title, content))
    cur.connection.commit()

CSV

StringIO(data)和csv.reader(dataFile)

由于CSV库主要是面向本地文件,就是说CSV文件得存储在电脑上,而进行网络数据采集的时候,很多文件都是在线的。所以从网上直接把文件读成一个字符串,然后转换成StringIO对象,使它具有文件的属性:

from urllib.request import urlopen
from io import StringIO
import csv

data = urlopen("http://pythonscraping.com/files/MontyPythonAlbums.csv").read().decode('ascii','ignore')
dataFile = StringIO(data)
csvReader = csv.reader(dataFile)

for row in csvReader:
    print(row)

csv.DictReader(dataFile)

会返回把CSV文件每一行转换成Python的字典对象返回,而不是列表对象,并保存在dictReader.fieldnames里,

from urllib.request import urlopen
from io import StringIO
import csv

data = urlopen("http://pythonscraping.com/files/MontyPythonAlbums.csv").read().decode('ascii','ignore')
dataFile = StringIO(data)
dictReader = csv.DictReader(dataFile)

print(dictReader.fieldnames)

for row in dictReader:
    print(row)

输出:

['Name', 'Year']
{'Name': "Monty Python's Flying Circus", 'Year': '1970'}
{'Name': 'Another Monty Python Record', 'Year': '1971'}
{'Name': "Monty Python's Previous Record", 'Year': '1972'}

PDF格式与PDFMiner3K

from urllib.request import urlopen
from pdfminer.pdfinterp import PDFResourceManager, process_pdf
from pdfminer.converter import TextConverter
from pdfminer.layout import LAParams
from io import StringIO
from io import open

#下面的例子可以把任意 PDF 读成字符串,然后用 StringIO 转换成文件对象:
def readPDF(pdfFile):
    rsrcmgr = PDFResourceManager()
    retstr = StringIO()
    laparms = LAParams()
    device = TextConverter(rsrcmgr, retstr, laparams=laparms)

    process_pdf(rsrcmgr, device, pdfFile)
    device.close()

    content = retstr.getvalue()
    retstr.close()
    return content

pdfFile = urlopen("http://pythonscraping.com/pages/warandpeace/chapter1.pdf")
outputString = readPDF(pdfFile)
print(outputString)
pdfFile.close()

DOCX格式

from zipfile import ZipFile
from urllib.request import urlopen
from io import BytesIO
from bs4 import BeautifulSoup

wordFile = urlopen("http://pythonscraping.com/pages/AWordDocument.docx").read()
wordFile = BytesIO(wordFile)
document = ZipFile(wordFile)
xml_content = document.read('word/document.xml')

wordObj = BeautifulSoup(xml_content.decode('utf-8'),'lxml')
textStrings = wordObj.findAll("w:t")
for textElem in textStrings:
    closeTag = ""
    try:
        style = textElem.parent.previousSibling.find("w:pstyle")
        if style is not None and style["w:val"] == "Title":
            print("<h1>")
            closeTag = "</h1>"
    except AttributeError:
        pass
    print(textElem.text)
    print(closeTag)

数据清洗

n-gram

在语言学里有一个模型叫n-gram,表示文字或语言中的n个连续的单词组成的序列。在进行自然语言分析时,使用n-gram或者寻找常用词组,可以很容易地把一句话分解成若干个文字片段。

def cleanInput(input):
    input = re.sub('\n+', " ",input)
    input = re.sub('\[[0-9]*\]',"",input)
    input = re.sub(' +'," ",input)
    input = bytes(input, "UTF-8")
    input = input.decode("ascii", "ignore")
    cleanInput = []
    input = input.split(' ')
    for item in input:
        #string.punctuation获取Python所有的标点符号,单词两端的任何标点符号都会被去掉
        item = item.strip(string.punctuation)
        if len(item) > 1 or (item.lower() == 'a' or item.lower() =='i'):
            cleanInput.append(item)
    return cleanInput

def ngrams(input, n):
    input = cleanInput(input)
    output=[]
    for i in range(len(input)-n+1):
        output.append(input[i:i+n])
    return output

OpenRefine

安装时要export JAVA_HOME=/usr/才可以运行./refine
用GREL清洗数据:(在Edit cells→transform里)
if(value.length() != 4, "invalid", value)
OpenRefine 还有许多关于单元格编辑和 GERL 数据变换的方法。详细介绍在 OpenRefine
的 GitHub 页面。


自然语言处理

grams简单的数据清理和化成2-grams

(可以直接from nltk import ngrams,通过使用ngrams(text,n)函数来生成ngrams)

def cleanInput(input):
    input = re.sub('\n+'," ",input).lower()
    input = re.sub('\[[0-9]*\]', "", input)
    input = re.sub(' +', " ", input)
    #input = input.decode("ascii", "ignore")
    cleanInput = []
    input = input.split(' ')
    for item in input:
        item = item.strip(string.punctuation)
        if len(item) > 1 or (item.lower() == 'a' or item.lower() == 'i'):
            cleanInput.append(item)
    return cleanInput


def ngrams(input, n):
    input = cleanInput(input)
    output = {}
    for i in range(len(input)-n+1):
        ngramTemp = " ".join(input[i:i+n])
        if ngramTemp not in output:
            output[ngramTemp] = 0
        output[ngramTemp]+=1
    return output

马尔可夫链

from urllib.request import urlopen
from random import randint

def wordListSum(wordList):
    sum = 0
    for word, value in wordList.items():
        sum += value
    return sum

def retrieveRandomWord(wordList):

    randIndex = randint(1, wordListSum(wordList))
    for word, value in wordList.items():
        randIndex -= value
        if randIndex <=0:
            return word

def buildWordDict(text):
    #剔除换行符和引号
    text = text.replace("\n", " ")
    text = text.replace("\"","")

    #保证每个标点符号都和前面的单词在一起
    #这样不会被剔除,保留在马尔可夫链中
    punctuation = [',','.',';',':']
    for symbol in punctuation:
        text = text.replace(symbol, " "+symbol+" ")

    words = text.split(" ")
    #过滤空单词
    words = [word for word in words if word != ""]

    wordDict = {}
    for i in range(1,len(words)):
        if words[i-1] not in wordDict:
            wordDict[words[i-1]]={}
        if words[i] not in wordDict[words[i-1]]:
            wordDict[words[i-1]][words[i]] = 0
        wordDict[words[i-1]][words[i]] = wordDict[words[i-1]][words[i]] + 1

    return wordDict

text = str(urlopen("http://pythonscraping.com/files/inaugurationSpeech.txt").read(), 'utf-8')
wordDict = buildWordDict(text)

#生成链长位100的马尔可夫链
length = 100
chain =""
currentWord = "I"
for i in range(0,length):
    chain += currentWord+" "
    currentWord = retrieveRandomWord(wordDict[currentWord])

print(chain)

buildWordDict 函数把网上获取的演讲文本的字符串作为参数,然后对字符串做一些清理和格式化处理,去掉引号,把其他标点符号两端加上空格,这样就可以对每一个单词进行有效的处理。最后,再建立如下所示的一个二维字典——字典里有字典:
{word_a : {word_b : 2, word_c : 1, word_d : 1},
word_e : {word_b : 5, word_d : 2},…}
如果我们要画出这个结果的节点模型,那么“word_a”可能就有带 50% 概率的箭头指向“word_b”(四次中的两次),带25%概率的箭头指向“word_c”,还有带 25% 概率的箭头指向“word_d”。
一旦字典建成,不管你现在看到了文章的哪个词,都可以用这个字典作为查询表来选择下一个节点。这个字典的字典是这么使用的,如果我们现在位于“word_e”节点,那么下一步就要把字典 {word_b : 5, word_d : 2}传递到retrieveRandomWord函数。这个函数会按照字典中单词频次的权重随机获取一个单词。

广度优先搜索

class SolutionFound(RuntimeError):
    def __init__(self, message):
        self.message = message

def getLinks(fromPageId):
    cur.execute("SELECT toPageId FROM links WHERE fromPageId = %s", (fromPageId))
    if cur.rowcount == 0:
        return None
    else:
        return [x[0] for x in cur.fetchall()]

def constructDict(currentPageId):
    links = getLinks(currentPageId)
    if links:
        return dict(zip(links, [{}]*len(links)))
    return {}

#链接要么位空,要么包含多个链接
def searchDepth(targetPageId, currentPageId, linkTree, depth):
    if depth == 0:
        return linkTree
    if not linkTree:
        linkTree = constructDict(currentPageId)
        if not linkTree:
            return {}
    if targetPageId in linkTree.keys():
        print("TARGET "+str(targetPageId)+" FOUND!")
        raise SolutionFound("PAGE: "+str(currentPageId))

    for branchKey, branchValue in linkTree.items():
        try:
            # 递归建立链接树
            linkTree[branchKey] = searchDepth(targetPageId, branchKey, branchValue, depth-1)
        except SolutionFound as e:
            print(e.message)
            raise SolutionFound("PAGE: "+str(currentPageId))
    return linkTree

try:
    searchDepth(134951, 1, {}, 4)
    print("No solution found")
except SolutionFound as e:
    print(e.message)

穿越网页表单与登录窗口进行采集

在Python中用Selenium执行JavaScript与Selenium的选择器说明

Selenium 可以让浏览器自动加载页面,获取需要的数据,甚至页面截屏,或者判断网站上某些动作是否发生。
PhantomJS 是一个“无头”(headless)浏览器。它会把网站加载到内存并执行页面上的JavaScript,但是它不会向用户展示网页的图形界面。把Selenium 和PhantomJS结合在一起,就可以运行一个非常强大的网络爬虫了,可以处理cookie、JavaScrip、header,以及任何你需要做的事情。

from selenium import webdriver
import time

#注意设置路径的时候要先把路径带r赋值给一个变量再使用
phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(
    executable_path=phantomjs_path)
driver.get("http://pythonscraping.com/pages/javascript/ajaxDemo.html")
time.sleep(3)
print(driver.find_element_by_id('content').text)
driver.close()

image_1bdfsjp6014ilgg011221sk3s8qp.png-131.2kB

Selenium的隐式等待

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(
    executable_path=phantomjs_path)
driver.get("http://pythonscraping.com/pages/javascript/ajaxDemo.html")
#WebDriverWait和expected_conditions两个模块组合起来构成了Selenium的隐式等待
try:
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_all_elements_located((By.ID, "loadedButton")))

finally:
    print(driver.find_element_by_id("content").text)
    driver.close()

隐式等待与显式等待的不同之处在于,隐式等待是等DOM 中某个状态发生后再继续运行代码(没有明确的等待时间,但是有最大等待时限,只要在时限内就可以),而显式等待明确设置了等待时间,如前面例子的等待三秒钟。在隐式等待中,DOM 触发的状态是用expected_conditions定义的(这里导入后用了别名EC,是经常使用的简称)。在Selenium库里面元素被触发的期望条件(expected condition)有很多种,包括:
• 弹出一个提示框
• 一个元素被选中(比如文本框)
• 页面的标题改变了,或者某个文字显示在页面上或者某个元素里
• 一个元素在DOM 中变成可见的,或者一个元素从DOM 中消失了

如果你可以不用定位器,就不要用,毕竟这样可以少导入一个模块。但是,定位器是一种十分方便的工具,可以用在不同的应用中,并且具有很好的灵活性。
下面是定位器通过By 对象进行选择的策略。

• ID
在上面的例子里用过;通过HTML 的id 属性查找元素。
• CLASS_NAME
通过HTML的class属性来查找元素。为什么这个函数是CLASS_NAME,而不是简单的CLASS?在Selenium 的Java 库里使用object.CLASS可能会出现问题,.class是Java保留的一个方法。为了让Selenium 语法可以兼容不同的语言,就用CLASS_NAME 代替。
• CSS_SELECTOR
通过CSS 的class、id、tag 属性名来查找元素,用#idName、.className、tagName表示。
• LINK_TEXT
通过链接文字查找HTML 的标签。例如,如果一个链接的文字是“Next”,就可以用(By.LINK_TEXT, “Next”) 来选择。
• PARTIAL_LINK_TEXT
与LINK_TEXT 类似,只是通过部分链接文字来查找。
• NAME
通过HTML 标签的name 属性查找。这在处理HTML 表单时非常方便。
• TAG_NAME
通过HTML 标签的名称查找。
• XPATH
用XPath 表达式(语法在下面介绍)选择匹配的元素。
image_1bdfu21ab1feb151rjfvpip1b1016.png-98.5kB
image_1bdfu2kfrb30qpdpsb179mrdf1j.png-138.8kB

XPATH入门说明

使用正则表达式处理XPATH采集标签

page = driver.find_elements_by_xpath(
        '//tbody[starts-with(@id,"normalthread_")]')

处理重定向

我们可以用一种智能的方法来检测客户端重定向是否完成,首先从页面开始加载时就“监视”DOM 中的一个元素, 然后重复调用这个元素直到Selenium抛出一个StaleElementReferenceException 异常;也就是说,元素不在页面的DOM 里了,说明这时网站已经跳转:

from selenium import webdriver
import time
from selenium.webdriver.remote.webelement import WebElement
from selenium.common.exceptions import StaleElementReferenceException


def waitForLoad(driver):
    elem = driver.find_element_by_tag_name("html")
    count = 0
    while True:
        count += 1
        # 检测该driver十秒钟,当检测不到html标签时抛出异常
        if count > 20:
            print("Timing out after 10 seconds and returning")
            return
        time.sleep(.5)
        # 每隔半秒钟检查一次html标签还在不在,时限为10秒钟,不在的时候会抛出异常,然后结束函数
        try:
            elem == driver.find_element_by_tag_name("html")
        except StaleElementReferenceException:
            return


phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
driver.get("http://pythoncraping.com/pages//javascript/redirectDemo1.html")
waitForLoad(driver)
print(driver.page_source)

#输出结果
Timing out after 10 seconds and returning
<html><head></head><body></body></html>

图像识别与文字处理

Pillow(PIL)

from PIL import Image, ImageFilter

pic = Image.open("avatar.jpg")
blurryAvatar = pic.filter(ImageFilter.GaussianBlur)
blurryAvatar.save("avatar_blurred.jpg")
blurryAvatar.show()

Tesseract

Tesseract 是一个Python的命令行工具,安装之后,要用tesseract命令在Python的外面运行。

中文库也在github中,名字为chi_sim,放到tesseract-ocr安装目录下的tessdata 目录。

需要添加环境变量到PATH: C:\Program Files (x86)\Tesseract-OCR
和TESSDATA_PREFIX:C:\Program Files (x86)\Tesseract-OCR

$tesseract text.tif textoutput

使用pillow过滤掉渐变的背景色,调用命令行执行tesseract(subprocess)

from PIL import Image
import subprocess


def cleanFile(filePath, newFilePath):
    image = Image.open(filePath)
    %常见的过滤方式,将图片处理成高对比度图片
    image = image.point(lambda x: 0 if x < 143 else 255)
    image.save(newFilePath)

    subprocess.call(["tesseract", newFilePath, "output"])

    outputFile = open("output.txt", 'r')
    print(outputFile.read())
    outputFile.close()


cleanFile("text_2.jpg", "text_2_clean.png")

运行结果:
>> & python d:/Library/PythonScrapy/pillowtest.py
Tesseract Open Source OCR Engine v4.00.00alpha with Leptonica
Warning. Invalid resolution 0 dpi. Using 70 instead.
This is some text. written in Arial, that will be read by
Tesseract Here are some symbols: !@#$%"&*()

使用Tesseract爬取ajax图片并进行分析(代码不可用,amazon标签已修改)

import time
from urllib.request import urlretrieve
import subprocess
from selenium import webdriver

phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(executable_path=phantomjs_path)

driver.get("http://www.amazon.com/War-Peace-Leo-Nikolayevich-Tolstoy/dp/1427030200")
time.sleep(2)
# 单机图书预览按钮
driver.find_element_by_id("sitbLogoImg").click()
imageList = set()

# 等待页面加载完成
time.sleep(5)
# 当向右箭头可以点击时,开始翻页
while "pointer" in driver.find_element_by_id("sitbReaderRightPageTurner").get_attribute("style"):
    driver.find_element_by_id("sitbReaderRightPageTurner").click()
    time.sleep(2)
    # 获取已加载的新页面(一次可以加载多个页面,但是重复的页面不能加载到集合中)
    pages = driver.find_elements_by_xpath("//div[@class='pageImage']/div/img")
    for page in pages:
        image = page.get_attribute("src")
        imageList.add(image)

driver.quit()

# 用Tesseract处理我们收集的图片URL链接
for image in sorted(imageList):
    urlretrieve(image, "page.jpg")
    p = subprocess.Popen(["tesseract", "page.jpg", "page"],
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    p.wait()
    f = open("page.txt", "r")
    print(f.read())

训练Tesseract

一个图片的矩形定位文件如下所示:

image_1bdq5ctoieidfibli31eiq36l9.png-6.6kB

第一列符号是图片中的每个字符,后面的4个数字分别是包围这个字符的最小矩形的坐标(图片左下角是原点(0,0),4 个数字分别对应每个字符的左下角x 坐标、左下角y 坐标、右上角x 坐标和右上角y 坐标),最后一个数字“0”表示图片样本的编号。

矩形定位文件必须保存在一个.box后缀的文本文件中。和图片文件一样,文本文件也是用验证码的实际结果命名(例如,4MmC3.box)

同时包含图片文件和.box 文件的数据文件夹,然后自动创建所有必需的训练文件。

训练完成后把eng.trainedddata复制到C:\Program Files (x86)\Tesseract-OCR\tessdata下即可


避开采集陷阱

调用requests库的session来传递cookie

import requests
from bs4 import BeautifulSoup
session = requests.Session()
headers = {"User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5)
            AppleWebKit 537.36 (KHTML, like Gecko) Chrome",
            "Accept":"text/html,application/xhtml+xml,application/xml;
            q=0.9,image/webp,*/*;q=0.8"}
url = "https://www.whatismybrowser.com/developers/what-http-headers-is-my-browser-sending"
req = session.get(url, headers=headers)
bsObj = BeautifulSoup(req.text)
print(bsObj.find("table",{"class":"table-striped"}).get_text)

调用driver的get_cookie()、delete_cookie()、add_cookie()、delete_all_cookies()方法

from selenium import webdriver
phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"

driver = webdriver.PhantomJS(phantomjs_path)
driver.get("http://pythonscraping.com")
driver.implicitly_wait(1)
print(driver.get_cookies())

判断哪些元素是陷阱(包含从一个元素获取另外一个属性的值的方法,get_attribute)

from selenium import webdriver
from selenium.webdriver.remote.webelement import WebElement
phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"

driver = webdriver.PhantomJS(phantomjs_path)
driver.get("http://pythonscraping.com/pages/itsatrap.html")
links = driver.find_elements_by_tag_name("a")
for link in links:
    if not link.is_displayed():
        #从显示不了的a标签中获取href属性
        print("The link " + link.get_attribute("href") + " is a trap")

fields = driver.find_elements_by_tag_name("input")
for field in fields:
    if not field.is_displayed():
        print("Do not change value of " + field.get_attribute("name"))
driver.implicitly_wait(1)
print(driver.get_cookies())

执行结果:
The link http://pythonscraping.com/dontgohere is a trap
Do not change value of phone
Do not change value of email

使用Selenium与网站进行交互

myElement.click()
myElement.click_and_hold()
myElement.release()
myElement.double_click()
myElement.send_keys_to_element("content to enter")

为了一次性完成一个元素的多个操作,可以用动作链(actionchain)储存多个操作,然后在一个程序中执行一次或多次。

填写表单的两种方法(send_keys和ActionChains)

from selenium import webdriver
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.common.keys import Keys
from selenium.webdriver import ActionChains

phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(phantomjs_path)
driver.get("http://pythonscraping.com/pages/files/form.html")

firstnameField = driver.find_element_by_name("firstname")
lastnameField = driver.find_element_by_name("lastname")
submitButton = driver.find_element_by_id("submit")

# 方法1
firstnameField.send_keys("Ryan")
lastnameField.send_keys("Mitchell")
submitButton.click()

# 方法2
actions = ActionChains(driver).click(firstnameField).send_keys("Ryan") \
    .click(lastnameField).send_keys("Mitchell") \
    .send_keys(Keys.RETURN)
actions.perform()

print(driver.find_element_by_tag_name("body").text)

鼠标拖放动作

from selenium import webdriver
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.common.keys import Keys
from selenium.webdriver import ActionChains

phantomjs_path = r"D:\Library\PythonScrapy\phantomjs-2.1.1-windows\bin\phantomjs.exe"
driver = webdriver.PhantomJS(phantomjs_path)
driver.get("http://pythonscraping.com/pages/javascript/draggableDemo.html")

print(driver.find_element_by_id("message").text)

element = driver.find_element_by_id("draggable")
target = driver.find_element_by_id("div2")
actions = ActionChains(driver)
actions.drag_and_drop(element, target).perform()

print(driver.find_element_by_id("message").text)

截屏

driver.get_screenshot_as_file('tmp/pythonscraping.png')

博主随便说说

这个学期比较忙,抽了几个周末的空看完了这本两百多页的,可以算是爬虫入门的书籍,比较让人失望的一点是书中并没有提及有关多线程、并发爬虫的内容,博主接下来打算去了解有关scrapy的资料。同时也很感谢这本书能带给我这些基础知识。如果我整理的操作清单中有什么不对的地方,欢迎大家指出!谢谢大家!

参考资料:

《Python网络数据采集》

Python自动化求职脚本:基于Requests与BeautifulSoup的实习僧海投工具实现 Web自动化是提升工作效率的关键技术,其核心原理是通过程序模拟浏览器操作,自动执行网页交互任务。在Python生态中,Requests库负责处理HTTP请求与会话管理,而BeautifulSoup则用于解析HTML文档结构,两者结合能高效实现数据抓取与表单提交。这类技术在实际工程中价值显著,尤其适用于需要批量处理、规则明确的重复性网络操作场景。例如,在求职季,手动投递简历耗时耗力,通过编写自动化脚本,可以基于预设条件自动搜索职位、解析详情并完成投递,将求职者从繁琐劳动中解放出来。本文以实习僧平台为例,详细拆 阅读详情

相关推荐

Selenium Python动态网页爬虫实战:从环境搭建到反反爬策略

在Web数据采集领域,动态网页爬取是核心挑战之一。其原理在于现代网站普遍采用客户端渲染技术,数据通过JavaScript异步加载,传统的静态HTML解析方法因此失效。这要求爬虫技术必须能够模拟真实浏览器行为,执行JS并等待页面动态渲染完成,才能获取完整数据。Selenium作为浏览器自动化工具,其技术价值在于提供了完整的WebDriver协议,能够精准控制浏览器,实现点击、输入、滚动等交互,完美应对AJAX加载、无限滚动等动态场景。在Python生态中,结合Requests库进行静态抓取与Selenium处

weixin_30861797的博客 533

python爬虫获取网页的外链和内链(巨详细)

xxx = {scheme(网络协议),netloc(服务器位置),path(路径),params(参数),query(查询条件),fragment(片段)}.......这个正则表达式弄了半天也搞不懂,这里我就理解为匹配includeUrl+以/开头的内链接 或者 是以/开头的链接。内链:同一网站域名下的内容页面之间的互相链接(自己网站的内容链接到自己网站的内部页面,也称之为站内链接)外链:在自己的网站导入别人的网站(比如有些网站加入了百度这个链接,而百度就是这个网站的外链)

weixin_65525703的博客 3878

开源 tesseract-ocr-文字识别软件

google 开源ocr文字识别软件,可以自己训练数据,内置39.5MB中文文字识别库chi_sim.traineddata.附加jTessBoxEditor训练软件

Python爬虫小实践:获取某个网站所有的外部链接以及内部链接

我们在进行爬虫时有的时候不可能只是在一个网站上进行内容上的爬取,理想中的爬虫应该是顺着一个链接从一个页面到另外一个页面,这需要获取页面上的所有的外链,同时收集每个页面上的内链。网站首页上不一定会发现外链,为了防止程序出错,就要递归深入到一个网站直到找到一个外链为止。 但在爬取的过程中出现了TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机...

HW140701的博客 2万+

【Qt】Window环境下搭建Qt6、MSVC2022开发环境(无需提前安装Visual Studio)

本文介绍 Windows 环境下无需安装 Visual Studio,搭建 Qt6 与 MSVC2022 开发环境的方法,以节省磁盘空间。核心步骤包括:用中科大镜像提速 Qt6 在线安装,需勾选 Qt Creator 17.0.1、MSVC 2022 x64 等组件;配置环境变量,添加 mingw_64、msvc2022_64 及 Qt Creator 的二进制目录;安装 MSVC 2022 编译器与 Windows 10 SDK 并记录版本;配置 Qt Creator 构建套件,可选设置 vcvarsal

油炸自行车的博客 2940

五、2K0300 久久派开发板的GPIO控制与Shell脚本自动化实战

本文详细介绍了基于龙芯2K0300处理器的久久派开发板的GPIO控制方法,通过sysfs文件系统实现LED控制和传感器读取。重点讲解了Shell脚本自动化实战,包括LED闪烁、流水灯效果和传感器数据采集,为物联网项目开发提供完整解决方案。

silver的专栏 689

1.1 数据采集总览

数据采集,也称为数据收集,是将原始数据从各种来源获取并存储起来的过程。这个过程是数据分析和数据仓库建设的第一步,涉及到从不同的数据源中提取数据。

在路上的专栏 3023

C语言版数字锁相放大器实现指南:从复数运算到嵌入式MCU移植的坑我都帮你踩了

本文详细介绍了C语言实现数字锁相放大器的关键技术,包括复数运算优化、嵌入式MCU移植的实战经验及内存管理策略。针对STM32等资源受限平台,提供了从浮点到定点数转换的优化方案,帮助工程师高效处理微弱信号提取问题。

weixin_30721077的博客 433

MES系统需要采集的数据及如何采集

数据采集在企业信息化建设中至关重要,是实现物料跟踪、生产计划制定、产品历史记录维护等生产管理活动的基础。MES系统需要采集工艺数据、生产计划和库存数据、物料齐套清单等数据。数据的准确性和实时性直接影响企业信息化落地和效率。

weixin_52213728的博客 2236

【CAPL实用开发】--- 使用VN1640A测试Busoff快慢恢复

使用VN1640A测试Busoff快慢恢复,包含具体的CAPL代码实现。

LabVIEW、CAPL、python、车载以太网等学习分享,文章正在写 2100

【半桥LLC】半桥LLC谐振开环闭环软启动DCDC变换器的设计与仿真

本文详细分析了半桥LLC谐振DC-DC变换器的开环与闭环控制设计原理,重点探讨了软启动功能的实现。通过仿真验证,展示了开环与闭环情况下的电压输出差异以及系统效率的提升。该研究为提高DC-DC变换器性能提供了参考。

2401_84610415的博客 2599

Python爬虫商业项目实战,python中Counter用法实例

爬虫案例,对美国总统的一篇演讲稿分析 要点: 1、Counter用法:统计分析,类似于tf-itf词频统计 常用的函数有subtract update 2、python中'delimer'.JOIN(sentence)的使用 对sentence按照delimer分割 from urllib.request import urlopen from bs4 import BeautifulSoup ...

qianyuanruqu的博客 476

图像识别火灾检测系统实战:从火焰特征到YOLO部署全解析

计算机视觉技术正深入改变传统消防的感知方式。图像识别火灾检测利用摄像头采集的视频流,通过颜色、动态和形态特征分析,实现早期火情的自动发现与定位。其核心原理在于,火焰在视觉上具有独特的颜色分布、闪烁特性和轮廓变化,借助目标检测模型如YOLO,可在复杂场景中区分真实火焰与干扰物。这项技术广泛应用于仓库、园区、隧道等大空间场所,是智慧消防的重要支撑。本文从火焰视觉特征、数据集构建、模型选型与系统架构设计出发,结合部署实践中的误报与算力优化经验,为开发者提供一套可落地的视频火焰检测方案。

weixin_42533751的博客 246

网络爬虫入门到实战:从数据采集原理到Python代码实现

网络爬虫是一种自动化数据采集技术,其核心原理是通过模拟浏览器行为,向目标服务器发送HTTP请求并解析响应内容,从而高效获取互联网上的公开信息。这项技术打破了信息孤岛,实现了数据的聚合与结构化,为搜索引擎、市场分析、学术研究等场景提供了关键的数据支撑。在工程实践中,Python凭借Requests、BeautifulSoup、Scrapy等成熟库和框架,成为构建爬虫的主流选择。开发者需掌握网页解析、并发处理、反爬应对等核心技能,并始终遵循robots.txt协议与访问频率控制等合规要求,确保数据采集的合法性与

weixin_33842304的博客 371

代码的自由之旅:用AI写出无版权烦恼的Verilog

他们还基于这个数据集,训练了一个名叫“FreeV”的AI模型,不仅能写出好用的Verilog代码,还把版权侵权的风险降到了仅3%。为了让AI安全地写Verilog,研究团队提出了三个“法宝”:一个检测AI是否会生成侵权代码的测试方法、一个干净的Verilog数据集FreeSet,还有一个基于FreeSet训练的AI模型FreeV。AI的记忆力超强,能记住训练时见过的代码。测试发现,一些用Verilog数据训练过的AI,比如VeriGen,生成侵权代码的概率从9%涨到了15%,说明它们可能学了不该学的代码。

步子哥的博客 1810

Multisim14.0仿真应用设计(三十九)74LS183 高速全加器应用仿真

74LS183是一种高速全加器,可以同时执行四位二进制数的加法运算。它的输入端包括两个4位二进制数和一个进位信号,输出端则为一个4位二进制数和一个进位信号。

zhusl6688的博客 3857

Python网络爬虫开发指南:从基础到实战

网络爬虫作为数据采集的核心技术,通过模拟浏览器行为实现自动化信息提取。其工作原理基于URL队列管理、页面下载解析和数据存储的循环流程,关键技术涉及HTTP协议、HTML解析和反爬应对。在Python生态中,Requests+BeautifulSoup组合适合入门开发,而Scrapy框架则满足工程化需求。针对动态内容渲染,Selenium和API逆向工程是两种典型解决方案。实际应用中需注意分布式架构设计(如Scrapy-Redis)和存储优化(MongoDB/MySQL选型),同时必须遵守robots.txt

weixin_30267785的博客 422

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Python网络爬虫实战:合规数据采集与信息关联技术解析

网络爬虫作为自动化数据采集的核心技术,其原理是通过模拟浏览器行为向服务器发送HTTP请求并解析响应内容,实现大规模信息的高效提取。这项技术在数据挖掘、市场研究和用户画像构建等领域具有重要价值,能够帮助开发者从公开信息源中建立数据关联模型。在实际应用中,爬虫技术常与HTML解析库(如BeautifulSoup)和请求库(如requests)结合,处理网页结构解析、会话管理和反爬策略应对等工程挑战。本文以信息关联查询为具体场景,深入探讨了如何通过Python实现合规的网络数据采集流程,涵盖了从请求伪装、动态参数

weixin_34198453的博客 387

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

Python爬虫实战:从静态解析到动态渲染,高效采集网络题库数据

网络爬虫作为数据采集的核心技术,其基本原理是通过模拟HTTP请求获取网页内容,再通过解析技术提取结构化信息。在Python生态中,Requests库负责处理网络请求,而BeautifulSoup和lxml则用于解析HTML文档,构成了静态页面抓取的基础技术栈。这项技术的工程价值在于能够自动化地完成大规模数据采集任务,显著提升信息获取效率。在教育、内容聚合、市场分析等场景中,爬虫技术被广泛应用于数据采集与整理。针对网络题库这类典型的结构化数据源,开发者需要综合运用请求模拟、页面解析、反爬应对等技能。本文以“考

weixin_34224941的博客 336

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Python爬虫入门:从数据抓取到Scrapy框架实战

网络爬虫是一种自动化数据采集技术,通过模拟浏览器行为从网页中提取结构化信息。其核心原理基于HTTP协议通信,涉及DNS解析、TCP连接、请求响应等网络基础。Python凭借requests、BeautifulSoup等库成为爬虫开发的首选语言,能够高效完成电商监控、舆情分析等场景的数据采集任务。Scrapy框架则提供了企业级解决方案,支持分布式爬取和数据处理流水线。在实际应用中,开发者需要注意遵守robots协议,合理设置请求频率,并应对反爬机制如User-Agent检测、IP限制等挑战。通过代理IP池、请

weixin_34228387的博客 405

Python爬虫与数据分析实战:从零到项目落地的完整路径

在数据驱动的时代,Python已成为数据获取与分析的核心工具。其原理在于通过简洁的语法和丰富的库生态,实现从网页抓取到数据洞察的自动化流程。掌握这项技术不仅能提升个人工作效率,更是求职市场的重要竞争力。实际应用中,无论是电商价格监控、舆情分析还是业务报表自动化,Python爬虫与数据分析都扮演着关键角色。本文聚焦于**环境搭建**与**工程化实践**,通过一个完整的电商数据分析案例,系统讲解如何将分散的知识点串联成可落地的解决方案,帮助学习者跨越从‘看懂教程’到‘独立完成项目’的鸿沟。

chulilang8944的博客 423

Python Selenium动态爬虫实战:手把手教你爬取淘宝商品数据

动态网页爬取是现代网络数据采集的核心技术之一,其原理在于模拟浏览器行为,等待JavaScript执行并渲染页面后获取完整数据。这项技术对于电商数据分析、价格监控和竞品研究具有重要价值,广泛应用于市场调研和商业智能场景。通过Selenium操控无头浏览器,可以有效解决传统静态爬虫无法获取动态内容的问题。本文以淘宝网为例,详细解析了如何利用Selenium和BeautifulSoup构建稳定可靠的动态爬虫,并深入探讨了反反爬策略与数据清洗技巧,为Python爬虫进阶提供完整解决方案。

weixin_30687051的博客 420

Python网络爬虫核心原理与实战技巧详解

网络爬虫作为数据采集的核心技术,通过模拟浏览器行为自动化获取网页数据。其工作原理主要基于HTTP协议通信,包含请求发送、响应解析和数据存储三个关键环节。在Python生态中,requests和Scrapy等工具链提供了完善的开发支持,结合XPath/CSS选择器可以实现高效数据提取。工程实践中需要处理反爬机制、动态渲染等挑战,常用解决方案包括代理IP池、Selenium自动化等。当前爬虫技术正向智能化方向发展,结合机器学习实现网页结构识别,同时云原生架构提升了系统扩展性。对于企业级应用,分布式爬虫架构和ET

weixin_33713503的博客 349

Python网络爬虫权威指南:从HTTP协议到Scrapy框架的完整学习路径

网络爬虫作为数据采集的核心技术,其本质是模拟浏览器客户端与服务器进行HTTP/HTTPS通信,遵循请求-响应模型获取网页数据。理解HTTP协议中的请求方法、状态码、请求头等基础概念,是应对反爬机制和设计高效爬取策略的基石。通过掌握数据解析技术如XPath和BeautifulSoup,开发者能够从HTML/JSON中精准提取结构化信息,为数据分析与机器学习项目提供高质量数据源。在实际工程中,面对动态渲染、验证码识别等复杂场景,需要结合Selenium等自动化工具或直接调用API接口。而Scrapy框架则提供了

weixin_30835649的博客 352

Python爬虫18个实战案例:从环境搭建到数据存储完整指南

网络爬虫作为数据采集的核心技术,其工作原理是通过模拟浏览器行为向目标服务器发送HTTP请求,获取网页原始数据,再通过解析技术提取结构化信息。这项技术的价值在于能够自动化、大规模地获取互联网公开数据,为数据分析、市场研究、信息聚合等应用场景提供数据基础。在工程实践中,爬虫开发常涉及静态网页抓取、动态内容加载处理、模拟登录、反爬虫策略应对以及数据存储等关键环节。本文基于Python生态,通过requests、BeautifulSoup、Selenium等核心库的实战应用,系统讲解从环境配置、请求发送、数据解析到

weixin_30216561的博客 311
上一篇: C++ Primer 第3章 字符串、向量和数组
下一篇: [C++] 数据结构应用——链表
EnergyOverflow
博客等级 码龄10年 1粉丝 15原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值