运行环境:python3
中文文档: https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html
BeautifulSoup4 是 HTML/XML 的解析器,主要的功能便是解析和提取 HTML/XML 中的数据。
Python中用于爬取静态网页的基本方法/模块有三种:正则表达式、BeautifulSoup和Lxml。三种方法的特点大致如下:
beautifulSoup 的功能和 lxml 一样,但是 lxml 只会局部遍历数据,而 BeautifulSoup是基于HTML DOM的,所以会载入整个文档来解析整个DOM树。因此在性能上来说 BeautifulSoup 是低于lxml 的。
在 python3 中安装 BeautifulSoup4 的方法如下:
pip3 install beautifulsoup4
Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,如果我们不安装它,则 Python 会使用 Python默认的解析器,lxml 解析器更加强大,速度更快,推荐安装。
from urllib.request import urlopen
from bs4 import BeautifulSoup
html = urlopen('http://www.pythonscraping.com/pages/warandpeace.html')
bs = BeautifulSoup(html.read(), 'html.parser')
#bs.find_all(tagName, tagAttributes) 可以获取页面中所有指定的标签
nameList = bs.findAll('span', {'class':'green'})
title = bs.body.h1
print(title)
head=bs.findAll(['h1','h2'])
print(head)
nameList1 = bs.find_all(text='the prince') #文本参数 text 有点不同,它是用标签的文本内容去匹配,而不是用标签的属性
print(len(nameList1))
for name in nameList:
print(name.get_text())
bs.find_all(tagName, tagAttributes) 可以获取页面中所有指定的标签
BeautifulSoup 文档里两者的定义就是这样:
find_all(tag, attributes, recursive, text, limit, keywords)
find(tag, attributes, recursive, text, keywords)
from urllib.request import urlopen
from bs4 import BeautifulSoup
import re
html = urlopen('http://www.pythonscraping.com/pages/page3.html')
bs = BeautifulSoup(html, 'html.parser')
images = bs.find_all('img',
{'src': re.compile('\.\.\/img\/gifts\/img.*\.jpg')})
for image in images:
print(image['src'])
全面彻底地抓取网站的常用方法是从一个顶级页面(比如主页)开始,然后搜索该页面上 的所有内链,形成列表。之后,抓取这些链接跳转到的每一个页面,再把在每个页面上找 到的链接形成新的列表,接着执行下一轮抓取。
一个函数 getLinks,可以用一个 /wiki/< 词条名称 > 形式的维基百科词条 URL 作为参数, 然后以同样的形式返回一个列表,里面包含所有的词条 URL。
一个主函数,以某个起始词条为参数调用 getLinks,然后从返回的 URL 列表里随机选 择一个词条链接,再次调用 getLinks,直到你主动停止程序,或者在新的页面上没有词 条链接了。
完整的代码如下所示:
from urllib.request import urlopen
from bs4 import BeautifulSoup
import datetime
import random
import re
random.seed(datetime.datetime.now())
def getLinks(articleUrl):
html = urlopen('http://en.wikipedia.org{}'.format(articleUrl))
bs = BeautifulSoup(html, 'html.parser')
return bs.find('div', {'id': 'bodyContent'}).find_all('a',
href=re.compile('^(/wiki/)((?!:).)*$'))
links = getLinks('/wiki/Kevin_Bacon')
while len(links) > 0:
newArticle = links[random.randint(0, len(links) - 1)].attrs['href']
print(newArticle)
links = getLinks(newArticle)
通过观察几个维基百科页面,包括词条页面和非词条页面,比如隐私策略页 面,就会得出下面的规则。
所有的标题(所有页面上,不论是词条页面、编辑历史页面还是其他页面)都是在 h1 → span 标签里,而且页面上只有一个 h1 标签。
前面提到过,所有的正文文本都在 div#bodyContent 标签里。但是,如果我们只想获取 第一段文字,可能用 div#mw-content-text → p 更好(只选择第一段的标签)。这个规则 对所有内容页面都适用,除了文件页面(例如,https://en.wikipedia.org/wiki/File:Orbit_ of_274301_Wikipedia.svg),它们不包含内容文本(content text)部分。
编辑链接只出现在词条页面上。如果有编辑链接,都位于 li#ca-edit 标签的 li#ca- edit → span → a 里面。
from urllib.request import urlopen
from bs4 import BeautifulSoup
import re
pages = set()
def getLinks(pageUrl):
global pages
html = urlopen('http://en.wikipedia.org{}'.format(pageUrl))
bs = BeautifulSoup(html, 'html.parser')
try:
print(bs.h1.get_text())
print(bs.find(id='mw-content-text').find_all('p')[0])
print(bs.find(id='ca-edit').find('span')
.find('a').attrs['href'])
except AttributeError:
print("页面缺少一些属性!不过不用担心!")
for link in bs.find_all('a', href=re.compile('^(/wiki/)')):
if 'href' in link.attrs:
if link.attrs['href'] not in pages: # 我们遇到了新页面
newPage = link.attrs['href']
print('-' * 20)
print(newPage)
pages.add(newPage)
getLinks(newPage)
from urllib.request import urlopen
from bs4 import BeautifulSoup
import re
pages = set()
def getLinks(pageUrl):
global pages
html = urlopen('https://github.com/chakra-core/ChakraCore/labels/Bug{}'.format(pageUrl))
bs = BeautifulSoup(html, 'html.parser')
for link in bs.find_all('a', href=re.compile('^(\/chakra-core\/ChakraCore\/issues\/)[0-9]+')):
if 'href' in link.attrs:
if link.attrs['href'] not in pages: # 我们遇到了新页面
newPage = link.attrs['href']
print('-' * 20)
print(newPage)
pages.add(newPage)
getLinks(newPage)
getLinks('')
conda install -c conda-forge scrapy
一个蜘蛛(spider)就是一 个 Scrapy 项目,和它的名称一样,就是用来爬网(抓取网页)的
“爬虫”(crawler)表示“任意用或不用 Scrapy 抓取网页的程序”
https://scrapy-chs.readthedocs.io/zh_CN/0.24/intro/tutorial.html
Spider是用户编写用于从单个网站(或者一些网站)爬取数据的类。
其包含了一个用于下载的初始URL,如何跟进网页中的链接以及如何分析页面中的内容, 提取生成 item 的方法。
为了创建一个Spider,您必须继承 scrapy.Spider
类, 且定义以下三个属性:
name
: 用于区别Spider。 该名字必须是唯一的,您不可以为不同的Spider设定相同的名字。start_urls
: 包含了Spider在启动时进行爬取的url列表。 因此,第一个被获取到的页面将是其中之一。 后续的URL则从初始的URL获取到的数据中提取。parse()
是spider的一个方法。 被调用时,每个初始URL完成下载后生成的 Response
对象将会作为唯一的参数传递给该函数。 该方法负责解析返回的数据(response data),提取数据(生成item)以及生成需要进一步处理的URL的 Request
对象。在开始爬取之前,您必须创建一个新的Scrapy项目。 进入您打算存储代码的目录中,运行下列命令:
scrapy startproject tutorial
该命令将会创建包含下列内容的 tutorial
目录:
tutorial/
scrapy.cfg
tutorial/
__init__.py
items.py
pipelines.py
settings.py
spiders/
__init__.py
...
这些文件分别是:
scrapy.cfg
: 项目的配置文件tutorial/
: 该项目的python模块。之后您将在此加入代码。tutorial/items.py
: 项目中的item文件.tutorial/pipelines.py
: 项目中的pipelines文件.tutorial/settings.py
: 项目的设置文件.tutorial/spiders/
: 放置spider代码的目录.Item 是保存爬取到的数据的容器;其使用方法和python字典类似, 并且提供了额外保护机制来避免拼写错误导致的未定义字段错误。
从网页中提取数据有很多方法。Scrapy使用了一种基于 XPath 和 CSS 表达式机制: Scrapy Selectors 。 关于selector和其他提取机制的信息请参考 Selector文档 。
这里给出XPath表达式的例子及对应的含义:
/html/head/title
: 选择HTML文档中
标签内的
元素/html/head/title/text()
: 选择上面提到的
元素的文字//td
: 选择所有的 元素
//div[@class="mine"]
: 选择所有具有 class="mine"
属性的 div
元素
为了配合XPath,Scrapy除了提供了 Selector
之外,还提供了方法来避免每次从response中提取数据时生成selector的麻烦。
Selector有四个基本的方法(点击相应的方法可以看到详细的API文档):
xpath()
: 传入xpath表达式,返回该表达式所对应的所有节点的selector list列表 。
css()
: 传入CSS表达式,返回该表达式所对应的所有节点的selector list列表.
extract()
: 序列化该节点为unicode字符串并返回list。
re()
: 根据传入的正则表达式对数据进行提取,返回unicode字符串list列表。
在查看了网页的源码后,您会发现网站的信息是被包含在 第二个
元素中。
我们可以通过这段代码选择该页面中网站列表里所有
元素:
response.xpath('//ul/li')
网站的描述:
response.xpath('//ul/li/text()').extract()
网站的标题:
response.xpath('//ul/li/a/text()').extract()
以及网站的链接:
response.xpath('//ul/li/a/@href').extract()
之前提到过,每个 .xpath()
调用返回selector组成的list,因此我们可以拼接更多的 .xpath()
来进一步获取某个节点。我们将在下边使用这样的特性:
for sel in response.xpath('//ul/li'):
title = sel.xpath('a/text()').extract()
link = sel.xpath('a/@href').extract()
desc = sel.xpath('text()').extract()
print title, link, desc
mysql数据库
1.启动:
mysql -u root
密码为:12345678
2.显示所有数据库
输入show databases;命令,显示所有数据库
mysql> show databases;
3.创建数据库:
mysql> create database studb;
4. 使用数据库
在上面显示的数据库中,实例中使用studb数据库,输入下面命令:
mysql> use studb;
5.创建表
mysql> create table test
-> (
-> sid varchar(20) not null primary key,
-> sname varchar(20) not null,
-> sddress varchar(40)
-> );
6. 打印表结构
mysql> desc t_stu;
打印结果:
+---------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| sid | varchar(20) | NO | PRI | NULL | |
| sname | varchar(20) | NO | | NULL | |
| address | varchar(50) | YES | | NULL | |
+---------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)
7. 表中增加数据
mysql> insert into t_stu
-> select 's001' , 'jin' , 'changzhou'
-> union
-> select 's002' , 'tom' , 'yangzhou'
-> union
-> select 's003' , 'kate' , 'suzhou'
-> ;
8. 查看表数据
mysql> select * from t_stu;
查看结果:
| sid | sname | address |
+------+-------+----------+
| s001 | jin | wuhan |
| s002 | tom | shanghai |
| s003 | kate | suzhou |
+------+-------+----------+
3 rows in set (0.01 sec)
9. 修改表中数据
mysql> update t_stu set sname = "fby" where sid = "s001";
10. 删除表中数据
删除表中sid = “s002”的数据
mysql> delete from t_stu where sid = "s002";
读csv文件
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)
Python使用pandas处理CSV文件
https://blog.csdn.net/atnanyang/article/details/70832257
Python中有许多方便的库可以用来进行数据处理,尤其是Numpy和Pandas,再搭配matplot画图专用模块,功能十分强大。
CSV(Comma-Separated Values)格式的文件是指以纯文本形式存储的表格数据,这意味着不能简单的使用Excel表格工具进行处理,而且Excel表格处理的数据量十分有限,而使用Pandas来处理数据量巨大的CSV文件就容易的多了。
- Pandas读取本地CSV文件并设置Dataframe(数据格式)
import pandas as pd
import numpy as np
df=pd.read_csv('filename',header=None,sep=' ') #filename可以直接从盘符开始,标明每一级的文件夹直到csv文件,header=None表示头部为空,sep=' '表示数据间使用空格作为分隔符,如果分隔符是逗号,只需换成 ‘,’即可。
print df.head()
print df.tail()
#作为示例,输出CSV文件的前5行和最后5行,这是pandas默认的输出5行,可以根据需要自己设定输出几行的值
- 使用pandas直接读取本地的csv文件后,csv文件的列索引默认为从0开始的数字,重定义列索引的语句如下:
import pandas as pd
import numpy as np
df=pd.read_csv('filename',header=None,sep=' ',names=["week",'month','date','time','year','name1','freq1','name2','freq2','name3','data1','name4','data2'])
print df
使用pandas按列合并CSV文件
1.列合并两个csv文件
import pandas as pd
df1 = pd.read_csv('dataset/easy29.csv')
df2 = pd.read_csv('dataset/easy210.csv')
frames = [df1, df2]
all_csv = pd.concat(frames)
2.通过追加的方式合并csv文件。
with open('1.csv','ab') as f:
f.write(open('2.csv','rb').read())#将2.csv内容追加到1.csv的后面
3.在将多个csv文件拼接到一起的时候,可以用Python通过pandas包的read_csv和to_csv两个方法来完成。这里不采用pandas.merge()来进行csv的拼接,而只是通过简单的文件的读取和附加方式的写入来完成拼接。
3.1
import pandas as pd
for inputfile in os.listdir(inputfile_dir):
pd.read_csv(inputfile, header=None) #header=None表示原始文件数据没有列索引,这样的话read_csv会自动加上列索引
pd.to_csv(outputfile, mode='a', index=False, header=False) #header=0表示不保留列名,index=False表示不保留行索引,mode='a'表示附加方式写入,文件原有内容不会被清除
3.2
# 将该文件夹下的所有文件名存入列表
csv_name_list = os.listdir('E:\jupyternotebook_space\yimiaodatas')
# 获取列表的长度
length = len(csv_name_list)
# 读取第一个CSV文件并包含表头,用于后续的csv文件拼接
f= open(csv_name_list[0],encoding = "utf-8")
df = pd.read_csv( f)
# 读取第一个CSV文件并保存
df.to_csv( "E:\jupyternotebook_space\Alldatas.csv",index=False)
# 循环遍历列表中各个CSV文件名,并完成文件拼接
for i in range(0,length):
f= open(csv_name_list[i],encoding = "utf-8")
df = pd.read_csv( f )
df.to_csv("E:\jupyternotebook_space\Alldatas.csv",index=False, header=False, mode='a+')
pandas在dataframe最左侧新增一个自增列
有如下表格,需要在最左侧新增一列为“序号”,编号从1开始
代码如下:
#打开文件
import pandas as pd
df = pd.read_excel(r'test.xlsx')
#序号列为从1开始的自增列,默认加在dataframe最右侧
df['序号'] = range(1,len(df)+1)
#对原始列重新排序,使自增列位于最左侧
df = df[['序号','seats','price','price-sign']]
#输出
df.to_excel('test_new.xlsx',index=False)
爬取github项目的issues
lxml中etree.HTML()和etree.tostring()用法
https://blog.csdn.net/qq_38410428/article/details/82792730
- etree.HTML():构造了一个XPath解析对象并对HTML文本进行自动修正。(修复html文件中代码,把缺的头或尾节点补齐;)
- etree.tostring():输出修正后的结果,类型是bytes
from lxml import etree
import requests
# 根据关键词获取项目列表
def get_repos_list(key_words):
# 初始化列表
repos_list = []
# 默认
for i in range(1, 100):
url = 'https://github.com/search?p=' + str(i) + '&q=' + key_words + '&type=repositories'
response = requests.get(url)
# 获取页面源码
page_source = response.text
# print(page_source)
#etree.HTML():构造了一个XPath解析对象并对HTML文本进行自动修正。yyy
tree = etree.HTML(page_source)
# 获取项目超链接
arr = tree.xpath('//*[@class="f4 text-normal"]/a/@href')
repos_list += arr
return repos_list
# 获取一个项目的issues列表
def get_issues_list(repo_name):
issues_list = []
url = 'https://github.com' + repo_name + '/issues'
# print(url)
response = requests.get(url)
# 获取源码
page_source = response.text
tree = etree.HTML(page_source)
# 获取issues数量
number = tree.xpath('//*[@id="js-repo-pjax-container"]/div[1]/nav/ul/li[2]/a/span[2]')
if len(number) == 0:
number = '0'
else:
number = number[0].text
# 超过1K就爬取1000条(够用了)
if number.isdigit():
number = int(number)
else:
number = 1000
print(number)
# 计算分页数量,每页25个issues
page = 0
if number % 25 == 0:
page = int(number / 25)
else:
page = int(number / 25) + 1
for i in range(1, page + 1):
url = 'https://github.com' + repo_name + '/issues?page=' + str(i)
response = requests.get(url)
# 获取源码
page_source = response.text
tree = etree.HTML(page_source)
# 获取issues超链接
arr = tree.xpath('//*[@class="d-block d-md-none position-absolute top-0 bottom-0 left-0 right-0"]/@href')
issues_list += arr
# /combust/mleap/issues/716
# 返回issues数量和列表
return number, issues_list
# 获取一个issue的内容及评论
def get_issue_content(issue_name):
# 拼接issue地址
url = 'https://github.com' + issue_name
# print(url)
response = requests.get(url)
page_source = response.text
tree = etree.HTML(page_source)
# 获取issue内容
issue_content = tree.xpath('//table//td')[0].xpath('string(.)')
return issue_content
if __name__ == '__main__':
# 测试
# get_repos_list('ML pipeline')
# get_issues('/combust/mleap')
# get_issue_content('/combust/mleap/issues/716')
'''
issue="/rust-lang/rust/issues/76833"
content=get_issue_content(issue)
print(content)
'''
with open(r'result.md', 'w+', encoding='utf-8') as f:
key_words = input('please input a keyword:')
# 获取项目列表
repos_list = get_repos_list(key_words)
# 格式:/combust/mleap
for repo in repos_list:
# 拼接项目url
repos_url = 'https://github.com' + repo
print(repos_url)
f.write('\n\n')
f.write(repos_url)
f.write('\n')
# 获取项目的issues列表
number, issues_list = get_issues_list(repo)
f.write(str(number))
f.write('\n')
# 格式:/combust/mleap/issues/716
for issue in issues_list:
# 获取issue的内容
issue_url = 'https://github.com' + issue
content = get_issue_content(issue)
# content=filter_emoji(content)
print(issue_url)
f.write(issue_url)
f.write('\n')
f.write('>' * 100)
f.write('\n')
f.write(str(content).strip())
f.write('\n')
f.write('<' * 100)
f.write('\n')
f.flush()
# print(content)
# print(issue)
print('The end!')
爬commit信息
获取commit每一页的网址url
import re
from urllib.request import urlopen
from bs4 import BeautifulSoup
from urllib import request
import time
import os
from urllib.parse import urlparse
'''
获取了每一页的网址
接下来:爬取每一页内的历史commit信息,包括具体的commit_url 、时间等
'''
# 请求函数
def get_html(url):
req = request.Request(url)
response = request.urlopen(req)
html = response.read().decode('utf-8')
return html
def get_sha(user, repo_name): # 用户的每个repo对应一个commit sha
url = "https://github.com/{user}/{repo_name}/commits/master".format(user=user, repo_name=repo_name)
html=urlopen(url)
bs=BeautifulSoup(html,'html.parser')
link=bs.find('a',href=re.compile("https://github.com/.*commit/(.*?)"))
commit_url=link.attrs['href']
#print(type(commit_url))
#print(commit_url)
#req=urlparse(commit_url)
#print(req)
list_commit=commit_url.split('/')
#print(list_commit[6]) (第6个元素才是对应的哈希值)
commit_sha=list_commit[6]
#print(commit_sha)
return commit_sha
def single_repo_commits(user, repo_name):
num = 0
page_flag = 66 # 设置页面初始标志,用于判断是否到达末页
page_num = 0
data_num = 0
commit_sha = get_sha(user, repo_name)
all_date = [] # 储存时间数据
url_data=[] #存储每页的网址
while (page_flag and page_num<5): # 测试前五页
url = "https://github.com/{user}/{repo_name}/commits/master?after={commit_sha}+{num}&branch=master".format(user=user, repo_name=repo_name, commit_sha=commit_sha, num=num) # 构建链接
html = get_html(url) # 获取页面内容
url_data.append(url) #每一页的url,然后接下来在这页开始搜索commit_url和提交时间
time_data = re.findall(r'' ,html) # re匹配时间元素
#page_flag = len(time_data)
page_num = page_num + 1
num = num +35 # 进入下一页
data_num = data_num+len(time_data)
print("page %d is ok\n get %d date" % (page_num, len(time_data)))
#print(time_data[0]) 可查看第一个time_data元素的完整输出
for date in time_data:
all_date.append(date[1:20]) #1:20是日期的内容,之后是其他属性
time.sleep(1) # 适当延时一下 单位:s
print("the repo <%s> totally get %d commits'date" % (repo_name, data_num))
print(url_data)
return all_date
user='chakra-core'
repo_name='ChakraCore'
#get_sha(user,repo_name)
all_data=single_repo_commits(user,repo_name)
print(all_data)
get_data函数获取指定页面的全部commit_url
from urllib.request import urlopen
from bs4 import BeautifulSoup
import re
'''
get_data函数获取指定页面的全部commit_url
接下来要做的是:如何搜索提交的内容:title、issue?等,是否存储为excel?
'''
def get_data(url):
headers = {
'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1'}
html = urlopen(url)
baseurl = 'https://github.com'
bs = BeautifulSoup(html, 'html.parser')
pages = set() # 不存在重复
# print(bs.contents)
commit_url = bs.find_all('a', href=re.compile('^(/chakra-core/ChakraCore/commit/).*$'))
# print(commit_url)
fp=open('commit_url.txt', 'w+')
for link in commit_url:
if 'href' in link.attrs:
if link.attrs['href'] not in pages: # 我们遇到了新页面
newPage = link.attrs['href']
pages.add(newPage)
fp.write(newPage) # 将字符串写入文件中
fp.write("\n") # 换行
print(newPage)
print(len(pages))
fp.close()
get_data('https://github.com/chakra-core/ChakraCore/commits/master')
读取文件
- 从文件members.txt中以字典形式读取数据,名字作为键,年龄作为值。文件中的内容如下,以制表符(’\t’)分隔数据
content = []
with open('members.txt', 'r') as f:
for line in f.readlines():
line_list = line.strip('\n').split('\t') # 去除换行符,以制表符分隔
content.append(line_list)
keys = content[0]
for i in range(1, len(content)):
content_dict = {}
for k, v in zip(keys, content[i]):
content_dict[k] = v
print(content_dict)
'''
result:
{'Name': 'Andy', 'age': '32'}
{'Name': 'Bob', 'age': '20'}
{'Name': 'Jenny', 'age': '43'}
{'Name': 'Holly', 'age': '48'}
{'Name': 'Danie', 'age': '27'}
'''
函数的意思
etree.HTML(), etree.tostring()
from lxml import etree
import requests
url = 'https://github.com/chakra-core/ChakraCore/issues'
response = requests.get(url)
# 获取页面源码
page_source = response.text
# print(page_source)
tree = etree.HTML(page_source)
result=etree.tostring(tree)
#etree.HTML():构造了一个XPath解析对象并对HTML文本进行自动修正。
#etree.tostring():输出修正后的结果,类型是bytes
路飞学城爬虫教程
第一章 爬虫基础介绍
爬虫究竟是合法还是违法的?
- 在法律中是不被禁止
- 具有违法风险
- 善意爬虫 恶意爬虫
爬虫带来的风险可以体现在如下2方面:
- 爬虫干扰了被访问网站的正常运营
- 爬虫抓取了收到法律保护的特定类型的数据或信息
如何在使用编写爬虫的过程中避免进入局子的厄运呢?
- 时常的优化自己的程序,避免干扰被访问网站的正常运行
- 在使用,传播爬取到的数据时,审查抓取到的内容,如果发现了涉及到用户隐私
商业机密等敏感内容需要及时停止爬取或传播
爬虫在使用场景中的分类
- 通用爬虫:
抓取系统重要组成部分。抓取的是一整张页面数据。
- 聚焦爬虫:
是建立在通用爬虫的基础之上。抓取的是页面中特定的局部内容。
- 增量式爬虫:
检测网站中数据更新的情况。只会抓取网站中最新更新出来的数据。
爬虫的矛与盾
反爬机制
门户网站,可以通过制定相应的策略或者技术手段,防止爬虫程序进行网站数据的爬取。
反反爬策略
爬虫程序可以通过制定相关的策略或者技术手段,破解门户网站中具备的反爬机制,从而可以获取门户网站中相关的数据。
robots.txt协议:
君子协议。规定了网站中哪些数据可以被爬虫爬取哪些数据不可以被爬取。
http协议
- 概念:就是服务器和客户端进行数据交互的一种形式。
常用请求头信息
- User-Agent:请求载体的身份标识
- Connection:请求完毕后,是断开连接还是保持连接
常用响应头信息
- Content-Type:服务器响应回客户端的数据类型
https协议:
- 安全的超文本传输协议
加密方式
- 对称秘钥加密
- 非对称秘钥加密
- 证书秘钥加密
第二章 requests基础模块
requests模块
- urllib模块
- requests模块
requests模块:python中原生的一款基于网络请求的模块,功能非常强大,简单便捷,效率极高。
作用:模拟浏览器发请求。
如何使用:(requests模块的编码流程)
- 指定url
- UA伪装
- 请求参数的处理
- 发起请求
- 获取响应数据
- 持久化存储
环境安装:
pip install requests
实战编码:
- 需求:爬取搜狗首页的页面数据
实战巩固
- 需求:爬取搜狗指定词条对应的搜索结果页面(简易网页采集器)
- UA检测
- UA伪装
- 需求:破解百度翻译
- post请求(携带了参数)
- 响应数据是一组json数据
- 需求:爬取豆瓣电影分类排行榜 https://movie.douban.com/中的电影详情数据
- 作业:爬取肯德基餐厅查询http://www.kfc.com.cn/kfccda/index.aspx中指定地点的餐厅数据
- 需求:爬取国家药品监督管理总局中基于中华人民共和国化妆品生产许可证相关数据
http://125.35.6.84:81/xk/
- 动态加载数据
- 首页中对应的企业信息数据是通过ajax动态请求到的。
http://125.35.6.84:81/xk/itownet/portal/dzpz.jsp?id=e6c1aa332b274282b04659a6ea30430a
http://125.35.6.84:81/xk/itownet/portal/dzpz.jsp?id=f63f61fe04684c46a016a45eac8754fe
- 通过对详情页url的观察发现:
- url的域名都是一样的,只有携带的参数(id)不一样
- id值可以从首页对应的ajax请求到的json串中获取
- 域名和id值拼接处一个完整的企业对应的详情页的url
- 详情页的企业详情数据也是动态加载出来的
- http://125.35.6.84:81/xk/itownet/portalAction.do?method=getXkzsById
- http://125.35.6.84:81/xk/itownet/portalAction.do?method=getXkzsById
- 观察后发现:
- 所有的post请求的url都是一样的,只有参数id值是不同。
- 如果我们可以批量获取多家企业的id后,就可以将id和url形成一个完整的详情页对应详情数据的ajax请求的url
数据解析:
聚焦爬虫
正则
bs4
xpath
第三章 数据解析
聚焦爬虫:爬取页面中指定的页面内容。
- 编码流程:
- 指定url
- 发起请求
- 获取响应数据
- 数据解析
- 持久化存储
数据解析分类:
- 正则
- bs4
- xpath(***)
数据解析原理概述:
- 解析的局部的文本内容都会在标签之间或者标签对应的属性中进行存储
- 1.进行指定标签的定位
- 2.标签或者标签对应的属性中存储的数据值进行提取(解析)
正则解析:
ex = '.*?'
bs4进行数据解析
- 数据解析的原理:
- 1.标签定位
- 2.提取标签、标签属性中存储的数据值
- bs4数据解析的原理:
- 1.实例化一个BeautifulSoup对象,并且将页面源码数据加载到该对象中
- 2.通过调用BeautifulSoup对象中相关的属性或者方法进行标签定位和数据提取
- 环境安装:
- pip install bs4
- pip install lxml
- 如何实例化BeautifulSoup对象:
- from bs4 import BeautifulSoup
- 对象的实例化:
- 1.将本地的html文档中的数据加载到该对象中
fp = open('./test.html','r',encoding='utf-8')
soup = BeautifulSoup(fp,'lxml')
- 2.将互联网上获取的页面源码加载到该对象中
page_text = response.text
soup = BeatifulSoup(page_text,'lxml')
- 提供的用于数据解析的方法和属性:
- soup.tagName:返回的是文档中第一次出现的tagName对应的标签
- soup.find():
- find('tagName'):等同于soup.div
- 属性定位:
-soup.find('div',class_/id/attr='song')
- soup.find_all('tagName'):返回符合要求的所有标签(列表)
- select:
- select('某种选择器(id,class,标签...选择器)'),返回的是一个列表。
- 层级选择器:
- soup.select('.tang > ul > li > a'):>表示的是一个层级
- oup.select('.tang > ul a'):空格表示的多个层级
- 获取标签之间的文本数据:
- soup.a.text/string/get_text()
- text/get_text():可以获取某一个标签中所有的文本内容
- string:只可以获取该标签下面直系的文本内容
- 获取标签中属性值:
- soup.a['href']
xpath解析:最常用且最便捷高效的一种解析方式。通用性。
- xpath解析原理:
- 1.实例化一个etree的对象,且需要将被解析的页面源码数据加载到该对象中。
- 2.调用etree对象中的xpath方法结合着xpath表达式实现标签的定位和内容的捕获。
- 环境的安装:
- pip install lxml
- 如何实例化一个etree对象:from lxml import etree
- 1.将本地的html文档中的源码数据加载到etree对象中:
etree.parse(filePath)
- 2.可以将从互联网上获取的源码数据加载到该对象中
etree.HTML('page_text')
- xpath('xpath表达式')
- xpath表达式:
- /:表示的是从根节点开始定位。表示的是一个层级。
- //:表示的是多个层级。可以表示从任意位置开始定位。
- 属性定位://div[@class='song'] tag[@attrName="attrValue"]
- 索引定位://div[@class="song"]/p[3] 索引是从1开始的。
- 取文本:
- /text() 获取的是标签中直系的文本内容
- //text() 标签中非直系的文本内容(所有的文本内容)
- 取属性:
/@attrName ==>img/src
作业:
爬取站长素材中免费简历模板
第四章 验证码
验证码识别
验证码和爬虫之间的爱恨情仇?
反爬机制:验证码.识别验证码图片中的数据,用于模拟登陆操作。
识别验证码的操作:
- 人工肉眼识别。(不推荐)
- 第三方自动识别(推荐)
- 云打码:http://www.yundama.com/demo.html
云打码的使用流程:
- 注册:普通和开发者用户
- 登录:
- 普通用户的登录:查询该用户是否还有剩余的题分
- 开发者用户的登录:
- 创建一个软件: 我的软件-》添加新软件-》录入软件名称-》提交(软件id和秘钥)
- 下载示例代码:开发文档-》点此下载:云打码接口DLL-》PythonHTTP示例下载
实战:识别古诗文网登录页面中的验证码。
使用打码平台识别验证码的编码流程:
- 将验证码图片进行本地下载
- 调用平台提供的示例代码进行图片数据识别
第五章 requests模块高级
模拟登录:
- 爬取基于某些用户的用户信息。
需求:对人人网进行模拟登录。
- 点击登录按钮之后会发起一个post请求
- post请求中会携带登录之前录入的相关的登录信息(用户名,密码,验证码......)
- 验证码:每次请求都会变化
需求:爬取当前用户的相关的用户信息(个人主页中显示的用户信息)
http/https协议特性:无状态。
没有请求到对应页面数据的原因:
发起的第二次基于个人主页页面请求的时候,服务器端并不知道该此请求是基于登录状态下的请求。
cookie:用来让服务器端记录客户端的相关状态。
- 手动处理:通过抓包工具获取cookie值,将该值封装到headers中。(不建议)
- 自动处理:
- cookie值的来源是哪里?
- 模拟登录post请求后,由服务器端创建。
session会话对象:
- 作用:
1.可以进行请求的发送。
2.如果请求过程中产生了cookie,则该cookie会被自动存储/携带在该session对象中。
- 创建一个session对象:session = requests.Session()
- 使用session对象进行模拟登录post请求的发送(cookie就会被存储在session中)
- session对象对个人主页对应的get请求进行发送(携带了cookie)
代理:破解封IP这种反爬机制。
什么是代理:
- 代理服务器。
代理的作用:
- 突破自身IP访问的限制。
- 隐藏自身真实IP
代理相关的网站:
- 快代理
- 西祠代理
- www.goubanjia.com
代理ip的类型:
- http:应用到http协议对应的url中
- https:应用到https协议对应的url中
代理ip的匿名度:
- 透明:服务器知道该次请求使用了代理,也知道请求对应的真实ip
- 匿名:知道使用了代理,不知道真实ip
- 高匿:不知道使用了代理,更不知道真实的ip
第六章 高性能异步爬虫
高性能异步爬虫
目的:在爬虫中使用异步实现高性能的数据爬取操作。
异步爬虫的方式:
- 1.多线程,多进程(不建议):
好处:可以为相关阻塞的操作单独开启线程或者进程,阻塞操作就可以异步执行。
弊端:无法无限制的开启多线程或者多进程。
- 2.线程池、进程池(适当的使用):
好处:我们可以降低系统对进程或者线程创建和销毁的一个频率,从而很好的降低系统的开销。
弊端:池中线程或进程的数量是有上限。
- 3.单线程+异步协程(推荐):
event_loop:事件循环,相当于一个无限循环,我们可以把一些函数注册到这个事件循环上,
当满足某些条件的时候,函数就会被循环执行。
coroutine:协程对象,我们可以将协程对象注册到事件循环中,它会被事件循环调用。
我们可以使用 async 关键字来定义一个方法,这个方法在调用时不会立即被执行,而是返回
一个协程对象。
task:任务,它是对协程对象的进一步封装,包含了任务的各个状态。
future:代表将来执行或还没有执行的任务,实际上和 task 没有本质区别。
async 定义一个协程.
await 用来挂起阻塞方法的执行。
第七章 动态加载数据处理
selenium模块的基本使用
问题:selenium模块和爬虫之间具有怎样的关联?
- 便捷的获取网站中动态加载的数据
- 便捷实现模拟登录
什么是selenium模块?
- 基于浏览器自动化的一个模块。
selenium使用流程:
- 环境安装:pip install selenium
- 下载一个浏览器的驱动程序(谷歌浏览器)
- 下载路径:http://chromedriver.storage.googleapis.com/index.html
- 驱动程序和浏览器的映射关系:http://blog.csdn.net/huilan_same/article/details/51896672
- 实例化一个浏览器对象
- 编写基于浏览器自动化的操作代码
- 发起请求:get(url)
- 标签定位:find系列的方法
- 标签交互:send_keys('xxx')
- 执行js程序:excute_script('jsCode')
- 前进,后退:back(),forward()
- 关闭浏览器:quit()
- selenium处理iframe
- 如果定位的标签存在于iframe标签之中,则必须使用switch_to.frame(id)
- 动作链(拖动):from selenium.webdriver import ActionChains
- 实例化一个动作链对象:action = ActionChains(bro)
- click_and_hold(div):长按且点击操作
- move_by_offset(x,y)
- perform()让动作链立即执行
- action.release()释放动作链对象
12306模拟登录
- 超级鹰:http://www.chaojiying.com/about.html
- 注册:普通用户
- 登录:普通用户
- 题分查询:充值
- 创建一个软件(id)
- 下载示例代码
- 12306模拟登录编码流程:
- 使用selenium打开登录页面
- 对当前selenium打开的这张页面进行截图
- 对当前图片局部区域(验证码图片)进行裁剪
- 好处:将验证码图片和模拟登录进行一一对应。
- 使用超级鹰识别验证码图片(坐标)
- 使用动作链根据坐标实现点击操作
- 录入用户名密码,点击登录按钮实现登录
第八章 scrapy框架
scrapy框架
- 什么是框架?
- 就是一个集成了很多功能并且具有很强通用性的一个项目模板。
- 如何学习框架?
- 专门学习框架封装的各种功能的详细用法。
- 什么是scrapy?
- 爬虫中封装好的一个明星框架。功能:高性能的持久化存储,异步的数据下载,高性能的数据解析,分布式
- scrapy框架的基本使用
- 环境的安装:
- mac or linux:pip install scrapy
- windows:
- pip install wheel
- 下载twisted,下载地址为http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
- 安装twisted:pip install Twisted‑17.1.0‑cp36‑cp36m‑win_amd64.whl
- pip install pywin32
- pip install scrapy
测试:在终端里录入scrapy指令,没有报错即表示安装成功!
- 创建一个工程:scrapy startproject xxxPro
- cd xxxPro
- 在spiders子目录中创建一个爬虫文件
- scrapy genspider spiderName www.xxx.com
- 执行工程:
- scrapy crawl spiderName
- scrapy数据解析
- scrapy持久化存储
- 基于终端指令:
- 要求:只可以将parse方法的返回值存储到本地的文本文件中
- 注意:持久化存储对应的文本文件的类型只可以为:'json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle
- 指令:scrapy crawl xxx -o filePath
- 好处:简介高效便捷
- 缺点:局限性比较强(数据只可以存储到指定后缀的文本文件中)
https://www.bilibili.com/video/BV1ha4y1H7sx?p=64&spm_id_from=pageDriver
- 基于管道:
- 编码流程:
- 数据解析
- 在item类中定义相关的属性
- 将解析的数据封装存储到item类型的对象
- 将item类型的对象提交给管道进行持久化存储的操作
- 在管道类的process_item中要将其接受到的item对象中存储的数据进行持久化存储操作
- 在配置文件中开启管道
- 好处:
- 通用性强。
- 面试题:将爬取到的数据一份存储到本地一份存储到数据库,如何实现?
- 管道文件中一个管道类对应的是将数据存储到一种平台
- 爬虫文件提交的item只会给管道文件中第一个被执行的管道类接受
- process_item中的return item表示将item传递给下一个即将被执行的管道类
- 基于Spider的全站数据爬取
- 就是将网站中某板块下的全部页码对应的页面数据进行爬取
- 需求:爬取校花网中的照片的名称
- 实现方式:
- 将所有页面的url添加到start_urls列表(不推荐)
- 自行手动进行请求发送(推荐)
- 手动请求发送:
- yield scrapy.Request(url,callback):callback专门用做于数据解析
- 五大核心组件
引擎(Scrapy)
用来处理整个系统的数据流处理, 触发事务(框架核心)
调度器(Scheduler)
用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL(抓取网页的网址或者说是链接)的优先队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
下载器(Downloader)
用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立在twisted这个高效的异步模型上的)
爬虫(Spiders)
爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体(Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
项目管道(Pipeline)
负责处理爬虫从网页中抽取的实体,主要的功能是持久化实体、验证实体的有效性、清除不需要的信息。当页面被爬虫解析后,将被发送到项目管道,并经过几个特定的次序处理数据。
- 请求传参
- 使用场景:如果爬取解析的数据不在同一张页面中。(深度爬取)
- 需求:爬取boss的岗位名称,岗位描述
- 图片数据爬取之ImagesPipeline
- 基于scrapy爬取字符串类型的数据和爬取图片类型的数据区别?
- 字符串:只需要基于xpath进行解析且提交管道进行持久化存储
- 图片:xpath解析出图片src的属性值。单独的对图片地址发起请求获取图片二进制类型的数据
- ImagesPipeline:
- 只需要将img的src的属性值进行解析,提交到管道,管道就会对图片的src进行请求发送获取图片的二进制类型的数据,且还会帮我们进行持久化存储。
- 需求:爬取站长素材中的高清图片
- 使用流程:
- 数据解析(图片的地址)
- 将存储图片地址的item提交到制定的管道类
- 在管道文件中自定制一个基于ImagesPipeLine的一个管道类
- get_media_request
- file_path
- item_completed
- 在配置文件中:
- 指定图片存储的目录:IMAGES_STORE = './imgs_bobo'
- 指定开启的管道:自定制的管道类
- 中间件
- 下载中间件
- 位置:引擎和下载器之间
- 作用:批量拦截到整个工程中所有的请求和响应
- 拦截请求:
- UA伪装:process_request
- 代理IP:process_exception:return request
- 拦截响应:
- 篡改响应数据,响应对象
- 需求:爬取网易新闻中的新闻数据(标题和内容)
- 1.通过网易新闻的首页解析出五大板块对应的详情页的url(没有动态加载)
- 2.每一个板块对应的新闻标题都是动态加载出来的(动态加载)
- 3.通过解析出每一条新闻详情页的url获取详情页的页面源码,解析出新闻内容
- CrawlSpider:类,Spider的一个子类
- 全站数据爬取的方式
- 基于Spider:手动请求
- 基于CrawlSpider
- CrawlSpider的使用:
- 创建一个工程
- cd XXX
- 创建爬虫文件(CrawlSpider):
- scrapy genspider -t crawl xxx www.xxxx.com
- 链接提取器:
- 作用:根据指定的规则(allow)进行指定链接的提取
- 规则解析器:
- 作用:将链接提取器提取到的链接进行指定规则(callback)的解析
#需求:爬取sun网站中的编号,新闻标题,新闻内容,标号
- 分析:爬取的数据没有在同一张页面中。
- 1.可以使用链接提取器提取所有的页码链接
- 2.让链接提取器提取所有的新闻详情页的链接
- 分布式爬虫
- 概念:我们需要搭建一个分布式的机群,让其对一组资源进行分布联合爬取。
- 作用:提升爬取数据的效率
- 如何实现分布式?
- 安装一个scrapy-redis的组件
- 原生的scarapy是不可以实现分布式爬虫,必须要让scrapy结合着scrapy-redis组件一起实现分布式爬虫。
- 为什么原生的scrapy不可以实现分布式?
- 调度器不可以被分布式机群共享
- 管道不可以被分布式机群共享
- scrapy-redis组件作用:
- 可以给原生的scrapy框架提供可以被共享的管道和调度器
- 实现流程
- 创建一个工程
- 创建一个基于CrawlSpider的爬虫文件
- 修改当前的爬虫文件:
- 导包:from scrapy_redis.spiders import RedisCrawlSpider
- 将start_urls和allowed_domains进行注释
- 添加一个新属性:redis_key = 'sun' 可以被共享的调度器队列的名称
- 编写数据解析相关的操作
- 将当前爬虫类的父类修改成RedisCrawlSpider
- 修改配置文件settings
- 指定使用可以被共享的管道:
ITEM_PIPELINES = {
'scrapy_redis.pipelines.RedisPipeline': 400
}
- 指定调度器:
# 增加了一个去重容器类的配置, 作用使用Redis的set集合来存储请求的指纹数据, 从而实现请求去重的持久化
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用scrapy-redis组件自己的调度器
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 配置调度器是否要持久化, 也就是当爬虫结束了, 要不要清空Redis中请求队列和去重指纹的set。如果是True, 就表示要持久化存储, 就不清空数据, 否则清空数据
SCHEDULER_PERSIST = True
- 指定redis服务器:
- redis相关操作配置:
- 配置redis的配置文件:
- linux或者mac:redis.conf
- windows:redis.windows.conf
- 代开配置文件修改:
- 将bind 127.0.0.1进行删除
- 关闭保护模式:protected-mode yes改为no
- 结合着配置文件开启redis服务
- redis-server 配置文件
- 启动客户端:
- redis-cli
- 执行工程:
- scrapy runspider xxx.py
- 向调度器的队列中放入一个起始的url:
- 调度器的队列在redis的客户端中
- lpush xxx www.xxx.com
- 爬取到的数据存储在了redis的proName:items这个数据结构中
第九章 增量式爬虫
增量式爬虫
- 概念:监测网站数据更新的情况,只会爬取网站最新更新出来的数据。
- 分析:
- 指定一个起始url
- 基于CrawlSpider获取其他页码链接
- 基于Rule将其他页码链接进行请求
- 从每一个页码对应的页面源码中解析出每一个电影详情页的URL
- 核心:检测电影详情页的url之前有没有请求过
- 将爬取过的电影详情页的url存储
- 存储到redis的set数据结构
- 对详情页的url发起请求,然后解析出电影的名称和简介
- 进行持久化存储
动态加载页面分析、POST请求参数和内容爬取
https://blog.csdn.net/Strive_0902/article/details/88972722
import requests
from lxml import etree
import time
import os
import sys
import json
ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.10240"
cookie1 = "trs_uv=jtz38ebv_373_14pv; BIGipServerjigou=1079027904.20480.0000; JSESSIONID=gyDbm3t9JVAlnN7VBkEH7Gk9CrEcAsd65-YfiCCqMLv-IkyP53TY!499435313"
host1 = "jg.sac.net.cn"
orgin1 = "http://jg.sac.net.cn"
data1 = {"filter_EQS_O#otc_id":"01","filter_EQS_O#sac_id":"","filter_LIKES_aoi_name":"","sqlkey": "publicity","sqlval": "ORG_BY_TYPE_INFO"}
headers1 = {'User-agent': ua,'Cookie':cookie1,'Host':host1,'Orgin':orgin1}
Base_url = "http://jg.sac.net.cn/pages/publicity/resource!search.action"
page_url = "http://jg.sac.net.cn/pages/publicity/resource!search.action"
req = requests.post(Base_url,data = data1, headers=headers1)
print(req.text)
res = req.json()
#print(res[0]['AOI_ID'])
for i in range(len(res)):
page_data1 = {"filter_EQS_aoi_id": res[i]['AOI_ID'], "sqlkey": "publicity", "sqlval": "SELECT_ZQ_REG_INFO"}
page_data2 = {"filter_EQS_aoi_id": res[i]['AOI_ID'], "sqlkey": "publicity", "sqlval": "SEARCH_ZQGS_QUALIFATION"}
company_info = {}
page_req1 = requests.post(page_url, data=page_data1, headers=headers1).json()
page_req2 = requests.post(page_url, data=page_data2, headers=headers1).json()
company_info["Chinese_Name"] = page_req1[0]['MRI_CHINESE_NAME']
company_info["Info_Reg"] = page_req1[0]['MRI_INFO_REG']
company_info["Legal_Represent"] = page_req1[0]['MRI_LEGAL_REPRESENTATIVE']
company_info["License_Code"] = page_req1[0]['MRI_LICENSE_CODE']
company_info["Reg_Capital"] = page_req1[0]['MRI_REG_CAPITAL']
company_info["Office_Address"] = page_req1[0]['MRI_OFFICE_ADDRESS']
company_info["Office_Post_Code"] = page_req1[0]['MRI_OFFICE_ZIP_CODE']
company_info["Com_Website"] = page_req1[0]['MRI_COM_WEBSITE']
company_info["Customer_Service_Tel"] = page_req1[0]['MRI_CUSTOMER_SERVICE_TEL']
# print(page_req2)
# exit()
con = ""
for j in range(len(page_req2)):
con += page_req2[j]['PTSC_NAME']+","
company_info["Qualification_info"] = con
try:
with open("2.json", 'a+', encoding="utf-8") as fp:
fp.write(json.dumps(company_info, ensure_ascii=False) + "\n")
except IOError as err:
print('error' + str(err))
finally:
fp.close()
pass
http返回状态码详解:
https://blog.csdn.net/ithomer/article/details/10240351
当用户点击或搜索引擎向网站服务器发出浏览请求时,服务器将返回Http Header Http头信息状态码,常见几种如下:
1、Http/1.1 200 OK 访问正常
表示成功访问,为网站可正常访问时的状态。
2、Http/1.1 301 Moved Permanently 301重定向永久重定向
对搜索引擎相对友好的跳转方式,当网站更换域名时可将原域名作301永久重定向到新域名,原域名权重可传递到新域名,也常有将不含www的域名301跳转到含www的,如xxx.com通过301跳转到www.xxx.com
3、Http/1.1 302 Found 为临时重定向
易被搜索引擎判为作弊,比如asp程序的response.Redirect()跳转、js跳转或静态http跳转。
4、Http/1.1 400 Bad Request 域名绑定错误
一般是服务器上域名未绑定成功,未备案等情况。
5、Http/1.1 403 Forbidden 没有权限访问此站
你的IP被列入黑名单,连接的用户过多,可以过后再试,网站域名解析到了空间,但空间未绑定此域名等情况。
6、Http/1.1 404 Not Found 文件或目录不存在
表示请求文件、目录不存在或删除,设置404错误页时需确保返回值为404。常有因为404错误页设置不当导致不存在的网页返回的不是404而导致搜索引擎降权。
7、Http/1.1 500 Internal Server Error 程序或服务器错误
表示服务器内部程序错误,出现这样的提示一般是程序页面中出现错误,如小的语法错误,数据连接故障等。
curl
参数
说明
示例
-A
设置user-agent
curl -A “Chrome” http://www.baidu.com
-X
用指定方法请求
curl -X POST http://httpbin.org/post
-I
只返回请求的头信息
-d
以POST方法请求url,并发送相应的参数
-d a=1 -d b=2 -d c=3 | -d “a=1&b=2&c=3” |-d @filename
-O
下载文件并以远程的文件名保存
-o
下载文件并以指定的文件名保存
-H
设置头信息
-k
允许发起不安全的SSL请求
https://www.ruanyifeng.com/blog/2019/09/curl-reference.html
AJAX 尚硅谷教程
https://www.wrysmile.cn/Learn-AJAX.html
一、基础内容
1.AJAX
- AJAX 是异步的 JS 和 XML,通过 AJAX 可以在浏览器中向服务器中发送异步请求
- 优点:
- 可以无需刷新页面与服务器进行通信
- 允许根据用户时间来更新部分页面内容
- 缺点:
- 没有浏览历史,不能回退
- 存在跨域问题(同源)
- SEO 不太好
2.XML
-
XML 被设计用来传输和存储数据
-
(1).请求报文
-
请求行:GET或POST / url / HTTP协议版本
-
请求头:格式为
键值对
- Host:xxxx
- Cookie:name=wrysmile
-
请求空行:固定的
-
请求体:
- 如果请求行是 GET 请求,请求体就为空
- 如果请求行是 POST 请求,请求体可以不为空
(2).响应报文
- 响应行:HTTP协议版本 / 响应状态码 / 响应状态字符串
- 1xx:信息,服务器收到请求,需要请求者继续执行操作
- 2xx:成功,操作被成功接收并处理
- 3xx:重定向,需要进一步的操作以完成请求
- 4xx:客户端错误,请求包含语法错误或无法完成请求
- 5xx:服务器错误,服务器在处理请求的过程中发生了错误
- 具体状态码可以看这里
- 响应头:
- Content-Type:text/html;charset=utf-8
- 响应空行:固定必须有
- 响应体:html中的所有内容
xml 与 html 的区别:
-
- 前者没有预定义标签,全是自定义标签,用来表示一些数据
- 后者都是预定义标签
-
目前已被 JSON 取代
Express服务器端框架:简单框架使用
3.HTTP
- 超文本传输协议,详细规定了浏览器和万维网服务器之间互相通信的规则
你可能感兴趣的:(爬虫,python,爬虫,pycharm)