爬虫之代理池和BS4

# https 和http有什么区别
    -https=http+ssl/tsl  证书
   
# 没有被认证过的机构，签发的证书，用的时候，浏览器会提示不安全
# 网站是需要被一些某些认证的，然后在签发证书,这样我们在使用这个网站的时候，浏览器才不会提示

# 1 ssl认证
# 1.1 不认证证书了
import requests
respone = requests.get('https://www.12306.cn', verify=False)  # 不验证证书,报警告,返回200
print(respone.status_code)  # 只会警告但是不会报错

# 1.2 手动携带证书访问
import requests
respone=requests.get('https://www.12306.cn',cert=('/path/server.crt','/path/key'))
print(respone.status_code)

#1 有些网站会做一些频率限制，这个时候如果我们的ip被封了的时候 那么我们就会有一段时间进不去这个网站  做爬虫就需要避免调这些

封ip: 做代理
封账号:开小号

# 代理是什么?
    分正向代理和反向代理
    正向代理：就是代理客户端：给我们很多给ip地址，替我们访问网站
    反向代理：就是nginx代理服务端，多个ip请求发送过来的时候，帮我们处理到多个服务端

# 发送http请求 使用代理发送
# 2 使用代理ip发送请求
import requests
proxies = {
    'http': '192.168.10.102:9003',  # 模拟代理ip 其实是有一个代理池的
}
respone=requests.get('https://www.baidu.com',proxies=proxies)
# 这个时候就不在是我们自己的ip地址访问这个网站了 而是上面那个代理ip访问的 封也是封的这个ip

print(respone.text)

respone=requests.get('https://www.baidu23.com',timeout=3)  
# 就是如果访问这个网站三秒内没有结果就会报错
print(respone)

import requests
from requests.exceptions import * #可以查看requests.exceptions获取异常类型
try:
    r=requests.get('http://www.baidu.com',timeout=0.00001)
except ReadTimeout:
    print('===:')
except ConnectionError: #网络不通
    print('-----')
except Timeout:
    print('aaaaa')

except RequestException:
    print('Error')
# 就是针对特定错误的处理

import requests
files={'file':open('a.txt','rb')}  # 可以放到files中
respone=requests.post('http://httpbin.org/post',files=files)
print(respone.text)

# 就是上传文件到这个网站  如果是django后端 取文件 我们可以从request.FILES中取到

# github开源的，代理池的代码，本地跑起来
    -爬虫技术：爬取免费的代理网站，获取免费代理，验证过后，存到本地
    -使用flask搭建一个web后端，访问某个接口就可以随机返回一个可用的代理地址
    -https://github.com/jhao104/proxy_pool

# 1. git clone
    git clone https://github.com/jhao104/proxy_pool.git

# 2 创建虚拟环境：mkvirtualenv -p python3.8 crawl
    安装依赖：pip install -r requirements.txt

# 3 修改配置文件settings.py  ---> 启动redis服务
        # 配置API服务
        HOST = "0.0.0.0"               # IP
        PORT = 5000                    # 监听端口
        # 配置数据库

        DB_CONN = 'redis://127.0.0.1:8888/0'  # redis服务监听8888端口
        # 配置 ProxyFetcher
        PROXY_FETCHER = [  # 会有十个 如果启动项目 这十个就会向特定网站获取 ip地址存到本地
            "freeProxy01",   
            "freeProxy02",
        ]

# 4 启动爬虫，启动web服务
        # 启动调度程序
        python proxyPool.py schedule
        # 启动webApi服务
        python proxyPool.py server

# 5 随机获取ip
    127.0.0.1:5000/get  # 就会随机返回一个ip地址给我们

import requests

# http://127.0.0.1:5010/get/
# 获取一个随机ip  因为获取的ip有些是https，有些是http 所以我们需要区分它们
res = requests.get('http://127.0.0.1:5010/get/').json()
if res['https']:
    http = 'https'
else:
    http = 'http'
proxie = {
    http: res['proxy']
}
print(proxie)
res = requests.get('https://www.cnblogs.com/liuqingzheng/p/16005896.html', proxies=proxie)
print(res.status_code)

# 我们可以写一个 django后端 只要返回访问者ip即可

from django.shortcuts import HttpResponse
drf ip_demo(request):
    ip = request.META.get('REMOTE_ADDR')
    return HttpResponse(f'你的ip地址是{ip}')

# 这样我们在使用代理池访问这个接口 我们就可以知道我们访问的代理的ip是多少了

import requests

res = requests.get('http://127.0.0.1:5010/get/').json()  # 随件获取代理ip
if res['https']:
    http = 'https'
else:
    http = 'http'
proxie = {
    http: http+'://'+res['proxy']
}
print(proxie)
# 服务端部署在本地，是访问不到的，内网穿透，或者部署在服务器上
# res = requests.get('http://192.168.1.143:8000/ip/', proxies=proxie)
# res = requests.get('https://46b3k95600.zicp.fun/ip/', proxies=proxie) # 内网穿透不生效
res = requests.get('http://101.133.225.166/ip/', proxies=proxie)  # 我们可以把django部署在云服务器上
print(res.text)
# 如果代理不可用，就不用代理了

# requests 爬取好多网站，但是咱们爬回来，没法解析，re 正则匹配

# requests+正则，整站爬取视频

# 以它为例：
    https://www.pearvideo.com/

import requests
import re

res = requests.get('https://www.pearvideo.com/category_loading.jsp?reqType=5&categoryId=1&start=1')
# print(res.text)

video_list = re.findall('<a href="(.*?)" class="vervideo-lilink actplay">', res.text)
# print(video_list)
for video in video_list:
    # print(video)
    video_url = 'https://www.pearvideo.com/' + video
    # print(video_url)
    res = requests.get(video_url)
    # print(res.text)  # 找到视频播放器 查看视频的地址在哪
    # https://www.pearvideo.com/videoStatus.jsp?contId=%s&mrd=0.6761335369801458
    # break

    video_id = video.split('_')[-1]
    # print(video_id)  # 获取视频id

    header = {  # 现在我们获取出这个是地址 朝该地址发送请求 发现查看不了 所以我们需要加上请求头
        'Referer': 'https://www.pearvideo.com/%s' % video
    }
    res1 = requests.get('https://www.pearvideo.com/videoStatus.jsp?contId=%s&mrd=0.6761335369801458' % video_id, headers=header).json()
    # print(res1)  # 返回的是一个字典
    real_mp4_url = res1['videoInfo']['videos']['srcUrl']  # 获取到的地址是访问不到的 所以我们需要替换
    # print(real_mp4_url)
    # https://video.pearvideo.com/mp4/adshort/20200330/ 1669277139588  -15051215_adpkg-ad_hd.mp4  获取到的
    # https://video.pearvideo.com/mp4/adshort/20200322/ cont-1663530   -15032637_adpkg-ad_hd.mp4  能播放的
    # 所以需要把中间的数字替换掉  
    # 首先按照 / 分割分割一次 取后面的 
    # 再按照 - 分割 取前面的  然后再用后面的字符串替换
    real_mp4_url = real_mp4_url.replace(real_mp4_url.rsplit('/', 1)[-1].split('-')[0], 'cont-%s' % video_id)
    print(real_mp4_url)  # 这个时候的地址才是可以播放的

# 然后我们就可以把这些视频地址存到本地了
    res = requests.get(real_mp4_url)
    with open('./video/%s.mp4' % video_id, 'wb') as f:
        for line in res.iter_content():
            f.write(line)

# requests+BautifulSoup4(解析库：bs4，lxml...)
# https://www.autohome.com.cn/news/

import requests
from bs4 import BeautifulSoup

res = requests.get('https://www.autohome.com.cn/news/1/#liststart')
# print(res.text)  # 从返回的html查找 bs4解析的是html,xml格式的
# 我们可以知道新闻都是在一个一个ul中
soup = BeautifulSoup(res.text, 'html.parser')

ul_list = soup.find_all(name='ul', class_='article')
# print(len(ul_list))  # 然后我们在for循环出一个一个ul
for ul in ul_list:
    li_list = ul.find_all(name='li')
    # print(li) 在li中获取新闻信息
    for li in li_list:
        h3 = li.find(name='h3')
        if h3:
            title = h3.text
            # print(title)  # 所有的新闻标题
            desc = li.find(name='p').text
            # print(desc)  # 所有的文章概要
            url = 'http:' + li.find(name='a').attrs.get('href')  # attrs获取标签属性
            # print(url)  # 新闻地址
            img = li.find(name='img').attrs.get('src')
            # print(img)  # 因为有些地址开头没有https所以我们手动加上
            if not img.startswith('http'):
                img = 'https:' + img
            # print(img)

        print(f'''
        文章标题:{title}
        文章概要:{desc}
        文章地址:{url}
        文章图片:{img}
        ''')

# 就像上面我们爬取的网址 爬取下来之后是一推html文件 很难获取我们想要的信息  所以我们需要解析文件 BeautifulSoup4就是可以帮我们解析

# Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库

# pip3 install BeautifulSoup4
# 解析库解释
    BeautifulSoup('要解析的内容：xml格式字符串', "html.parser") #内置解析库html.parser
    BeautifulSoup('要解析的内容：xml格式字符串',  "lxml")  # 速度快 必须要装lxml pip3 install lxml

from bs4 import BeautifulSoup

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" id='id_p' name='lqz' xx='yy'>lqz is handsome <b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""
soup = BeautifulSoup(html_doc, 'lxml')
# 1 美化html:了解
print(soup.prettify())

# 2 遍历文档树
'''
#遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个
#1、用法
#2、获取标签的名称
#3、获取标签的属性
#4、获取标签的内容
#5、嵌套选择
#6、子节点、子孙节点
#7、父节点、祖先节点
#8、兄弟节点
'''
# 1 基本用法，直接  .标签名字
res=soup.title
print(res)
res=soup.a
print(res)
# 可以嵌套使用
res=soup.head.title
print(res)

# 2 获取标签的名称
# 拿到的所有标签都是一个对象，Tag对象  bs4.element.Tag
res=soup.head.title
res=soup.body
print(res.name)

# 3 获取标签的属性
res=soup.p
print(res.attrs)  # 属性字典


# 4 获取标签的内容
res = soup.p
print(res.text) # 把该标签子子孙孙内容拿出来拼到一起 字符串
print(res.string) # None 必须该标签没有子标签，才能拿出文本内容
print(list(res.strings) )# generator 生成器，把子子孙孙的文本内容放到生成器中

# 5 嵌套选择

res=soup.html.body.a
print(res.text)


# 6、子节点、子孙节点
print(soup.p.contents) #p下所有子节点
print(soup.p.children) #得到一个迭代器,包含p下所有子节点

# 7、父节点、祖先节点
print(soup.a.parent) #获取a标签的父节点,直接父节点
print(list(soup.a.parents)) #找到a标签所有的祖先节点，父亲的父亲，父亲的父亲的父亲...


# 8、兄弟节点
print(soup.a.next_sibling)  # 下一个兄弟
print(soup.a.previous_sibling)  # 上一个兄弟

print(list(soup.a.next_siblings)) #下面的兄弟们=>生成器对象
print('-----')
print(list(soup.a.previous_siblings)) #上面的兄弟们=>生成器对象