python---requests和beautifulsoup4模块的使用

Requests：是使用 Apache2 Licensed 许可证的 基于Python开发的HTTP 库，其在Python内置模块的基础上进行了高度的封装，从而使得Pythoner进行网络请求时，变得美好了许多，使用Requests可以轻而易举的完成浏览器可有的任何操作。

BeautifulSoup：是一个模块，该模块用于接收一个HTML或XML字符串，然后将其进行格式化，之后遍可以使用他提供的方法进行快速查找指定元素，从而使得在HTML或XML中查找指定元素变得简单。

一：安装模块

pip3 install requests
pip3 install beautifulsoup4

二：requests和beautifulsoup4模块的简单联合使用

获取每条新闻的标题，标题链接和图片

import requests
from bs4 import BeautifulSoup
import uuid


reponse = requests.get(url="https://www.autohome.com.cn/news/")
reponse.encoding = reponse.apparent_encoding　　#获取文本原来编码，使两者编码一致才能正确显示

soup = BeautifulSoup(reponse.text,'html.parser')　　#使用的是html解析，一般使用lxml解析更好
target = soup.find(id="auto-channel-lazyload-article")　　#find根据属性去获取对象，id,attr,tag...自定义属性
li_list = target.find_all('li')　　#列表形式
for li in li_list:
    a_tag = li.find('a')
    if a_tag:
        href = a_tag.attrs.get("href")　　#属性是字典形式，使用get获取指定属性
        title = a_tag.find("h3").text　　#find获取的是对象含有标签，获取text
        img_src = "http:"+a_tag.find("img").attrs.get('src')
        print(href)
        print(title)
        print(img_src)
        img_reponse = requests.get(url=img_src)
        file_name = str(uuid.uuid4())+'.jpg'　　#设置一个不重复的图片名
        with open(file_name,'wb') as fp:
            fp.write(img_reponse.content)

总结使用：

（1）requests模块

reponse = requests.get(url)　　#根据url获取响应对象
reponse.apparent_encoding　　  #获取文本的原来编码
reponse.encoding　　　　　　　　 #对文本编码进行设置
reponse.text                  #获取文本内容，str类型
reponse.content　　　　　　　　  #获取数据，byte类型
reponse.status_code　　　　　　 #获取响应状态码

（2）beautifulsoup4模块

soup = BeautifulSoup('网页代码','html.parser')      　　　　 #获取HTML对象
target = soup.find(id="auto-channel-lazyload-article")    #根据自定义属性获取标签对象，默认找到第一个
li_list = target.find_all('li')    　　　　　　　　　　　　　　#根据标签名，获取所有的标签对象，放入列表中

注意：是自定义标签都可以查找
v1 = soup.find('div')
v1 = soup.find(id='il')
v1 = soup.find('div',id='i1')

find_all一样

对于获取的标签对象，我们可以使用
obj.text    　　　　获取文本
obj.attrs    　　  获取属性字典

 三.requests模块详解

含有下面几种接口api,最后都会调用request方法，所以开始讨论request方法的详细使用。

def get(url, params=None, **kwargs):
    r"""Sends a GET request.

    :param url: URL for the new :class:`Request` object.
    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    kwargs.setdefault('allow_redirects', True)
    return request('get', url, params=params, **kwargs)


def options(url, **kwargs):
    r"""Sends an OPTIONS request.

    :param url: URL for the new :class:`Request` object.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    kwargs.setdefault('allow_redirects', True)
    return request('options', url, **kwargs)


def head(url, **kwargs):
    r"""Sends a HEAD request.

    :param url: URL for the new :class:`Request` object.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    kwargs.setdefault('allow_redirects', False)
    return request('head', url, **kwargs)


def post(url, data=None, json=None, **kwargs):
    r"""Sends a POST request.

    :param url: URL for the new :class:`Request` object.
    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
    :param json: (optional) json data to send in the body of the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    return request('post', url, data=data, json=json, **kwargs)


def put(url, data=None, **kwargs):
    r"""Sends a PUT request.

    :param url: URL for the new :class:`Request` object.
    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
    :param json: (optional) json data to send in the body of the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    return request('put', url, data=data, **kwargs)


def patch(url, data=None, **kwargs):
    r"""Sends a PATCH request.

    :param url: URL for the new :class:`Request` object.
    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
    :param json: (optional) json data to send in the body of the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    return request('patch', url, data=data, **kwargs)


def delete(url, **kwargs):
    r"""Sends a DELETE request.

    :param url: URL for the new :class:`Request` object.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """

    return request('delete', url, **kwargs)

from . import sessions


def request(method, url, **kwargs):
    """Constructs and sends a :class:`Request <Request>`.

    :param method: method for the new :class:`Request` object.
    :param url: URL for the new :class:`Request` object.
    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
    :param data: (optional) Dictionary or list of tuples ``[(key, value)]`` (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
    :param json: (optional) json data to send in the body of the :class:`Request`.
    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
    :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
    :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
        ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
        or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
        defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
        to add for the file.
    :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
    :param timeout: (optional) How many seconds to wait for the server to send data
        before giving up, as a float, or a :ref:`(connect timeout, read
        timeout) <timeouts>` tuple.
    :type timeout: float or tuple
    :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
    :type allow_redirects: bool
    :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
    :param verify: (optional) Either a boolean, in which case it controls whether we verify
            the server's TLS certificate, or a string, in which case it must be a path
            to a CA bundle to use. Defaults to ``True``.
    :param stream: (optional) if ``False``, the response content will be immediately downloaded.
    :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response

    Usage::

      >>> import requests
      >>> req = requests.request('GET', 'http://httpbin.org/get')
      <Response [200]>
    """

    # By using the 'with' statement we are sure the session is closed, thus we
    # avoid leaving sockets open which can trigger a ResourceWarning in some
    # cases, and look like a memory leak in others.
    with sessions.Session() as session:
        return session.request(method=method, url=url, **kwargs)

参数介绍：

    :param method: 　提交方式get,post,put,patch,delete,options,head

    :param url: 　　 提交地址

    :param params: 　在URL中传递的参数 GET
　　　　　　　　　　　  request.request(method='GET',url='http://xxxx.com',params={'k1':'v1','k2':'v2'})
　　　　　　　　　　  　会自动装换为http://xxxx.com?k1=v1&k2=v2

    :param data:   　在请求体中传递的数据，字典，字节，文件对象 POST
　　　　　　　　　　  　request.request(method='GET',url='http://xxxx.com',data={'user':'aaaa','password':'bbb'})
　　　　　　　　　　  　虽然显示为字典形式，但是会在传递时也转换为data = "user=aaaa&password=bbbb"

    :param json:　　 存放在Django中请求体中的body中--->request.body中
　　　　　　　　　　　　request.request(method='GET',url='http://xxxx.com',json={'user':'aaaa','password':'bbb'})
　　　　　　　　　　　　会将json数据装换为字符串形式 json="{'user':'aaaa','password':'bbb'}",存放在请求体的body中
　　　　　　　　　　　　和data相比：data中只能存放基础类型，不能存放字典，列表等，二json只是将数据字符串化，所以可以存放这些数据类型

    :param headers: 请求头
　　　　　　　　　　　　可以用于防止别人使用脚本登录网站，例如上面抽屉自动登录就是根据请求头中用户代理，来过滤用户。也可以使用Referer看上一步网站位置，可以防止盗链等
　　　　　　　
    :param cookies: cookies,存放在请求头中，传递时是放在headers中传递过去的

    :param files: 　用于post方式传递文件时使用。使用键值对形式
　　　　　　　　　　　 request.post(usl='xxx',files={
　　　　　　　　　　　　　　'f1':open('s1.py','rb'),　　#传递的name:文件对象/文件内容 'f1':'dawfwafawfawf'
　　　　　　　　　　　　　　'f2':('newf1name',open('s1.py','rb')　　#元组中第一个参数，是上传到服务器中的文件名，可指定
　　　　　　　　　　　 })

    :param auth: 　权限验证，一般用于在web前端对数据进行加密base64加密。，一些网站在登录时，使用登录框输入用户密码后，在前端进行加密，然后将数据存放在请求头中
　　　　　　　　　　　ret = requests.get('https://api.github.com/user', 
　　　　　　　　　　　　　　　　　　　　　　auth=HTTPBasicAuth('用户名', '密码')
　　　　　　　　　　　)

    :param timeout: 超时float或者元组 一个参数时为float，代表等待服务器返回响应内容的时间，两个参数时为元组形式，第一个代表连接网站超时时间，第二个代表等待服务器响应的超时时间
　　　　　　　　　　　  ret = requests.get('http://google.com/', timeout=1)　
　　　　　　　　　　　　ret = requests.get('http://google.com/', timeout=(5, 1))

    :param allow_redirects: 允许重定向，类型为布尔型，默认为True，允许后，会去获取重定向后的页面数据进行返回
　　　　　　　　　　　　requests.get('http://127.0.0.1:8000/test/', allow_redirects=False)

    :param proxies: 代理，例如电脑出口IP（公网IP，非局域网）限制，以实现同IP操作限制。我们联系不同人员通过不同公网IP去操作，以实现解除操作限制，这些人员称为代理
　　　　　　　　　　　　技术上使用：代理服务器，我们向代理服务器上发送数据，让服务器替我们去选用代理IP去向指定的网站发送请求　　
　　　　　　　　　　　　request.post(
　　　　　　　　　　　　　　url = "http://dig.chouti.com/log",
　　　　　　　　　　　　　　data = form_data,
　　　　　　　　　　　　　　proxys = {
　　　　　　　　　　　　　　　　'http':'http://代理服务器地址:端口',
　　　　　　　　　　　　　　　　'https':'http://代理服务器地址:端口',
　　　　　　　　　　　　　　}
　　　　　　　　　　　　)

    :param stream: 流方式获取文件数据，下载一点数据到内存，就保存到磁盘中，每下载一点就保存一点。防止因为内存不足文件过大而不能完成下载任务情况
　　　　　　　　　　　from contextlib import closing
　　　　　　　　　　　with closing(requests.get('http://httpbin.org/get', stream=True)) as r:
　　　　　　　　　　　　　　# 在此处理响应。
　　　　　　　　　　　　　　for i in r.iter_content():
　　　　　　　　　　　　　　　　print(i)

    :param cert:　　带HTTPS时，通道进行ssl加密,原来http是使用socket，数据未加密，不安全。现在的HTTPS是含有加密解密过程。需要证书存在

　　　　　　　　　　　 一种是：自定义证书，客户端需要客户自己去安装证书
　　　　　　　　　　　　　　　request.get(
　　　　　　　　　　　　　　　　url="https:...",
　　　　　　　　　　　　　　　　cert="xxx.pem",　　#每次访问需要携带证书，格式是pem,('.crt','.key')<两个文件都需要携带，一起拼接加密>,两种文件验证方法
　　　　　　　　　　　　　　　)
　　　　　　　　　　　另一种是：在系统中带有的认证证书，需要去购买，厂家和系统联合，系统内置，直接对网站解析验证

    :param verify: 布尔类型，当为false时，忽略上面cert证书的存在，照样可以获取结果，一般网站为了用户便利，是允许这种情况

补充：request模块中session方法

对于上面的自动登录时，cookie和session等会话期间产生的数据需要我们自己手动管理。而session方法，会将请求获取的响应cookie和响应体等放入全局变量中，以后我们访问该网站时，会将这些数据自动携带一起发生过去。

注意：对于请求头我们自己还是需要去配置的

import requests

headers = {}
headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36'
headers['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8'

session = requests.session()

i1 = session.get("https://dig.chouti.com/",headers=headers)
i1.close()

form_data = {
    'phone':"xxxx",
    'password':"xxxx",
    'oneMonth':''
}

i2 = session.post(url="https://dig.chouti.com/login",data=form_data,headers=headers)

i3 = session.post("https://dig.chouti.com/link/vote?linksId=20324146",headers=headers)
print(i3.text)


{"result":{"code":"9999", "message":"推荐成功", "data":{"jid":"cdu_52941024478","likedTime":"1529507291930000","lvCount":"7","nick":"山上有风景","uvCount":"3","voteTime":"小于1分钟前"}}}

 

 

 

---

 

补充：Django中request对象（不是上面的request模块）

 推文：django-request对象

无论我们发送什么样的格式，都会到request.body中，而request.post中可能没有值
依据的是请求头中的content-type来判断类型

例如： Content-Type: text/html;charset:utf-8;
 常见的媒体格式类型如下：

    text/html ： HTML格式
    text/plain ：纯文本格式      
    text/xml ：  XML格式
    image/gif ：gif图片格式    
    image/jpeg ：jpg图片格式 
    image/png：png图片格式
   以application开头的媒体格式类型：

   application/xhtml+xml ：XHTML格式
   application/xml     ： XML数据格式
   application/atom+xml  ：Atom XML聚合格式    
   application/json    ： JSON数据格式
   application/pdf       ：pdf格式  
   application/msword  ： Word文档格式
   application/octet-stream ： 二进制流数据（如常见的文件下载）
   application/x-www-form-urlencoded ： <form encType=””>中默认的encType，form表单数据被编码为key/value格式发送到服务器（表单默认的提交数据的格式）
   另外一种常见的媒体格式是上传文件之时使用的：
   multipart/form-data ： 需要在表单中进行文件上传时，就需要使用该格式
     以上就是我们在日常的开发中，经常会用到的若干content-type的内容格式。

　 例如：当我使用post传递数据，在服务端接收请求体，存放在request.body中，
　 然后到请求头中查询content-type：application/x-www-form-urlencoded
　 再将接收的请求体拷贝到request.post中存放

 

四.beautifulsoup4模块详解

 标签的使用方法

HTML代码

from bs4 import BeautifulSoup

html = '''
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <a href="/wwewe/fafwaw" class="btn btn2">666daw6fw</a>
    <div id="content" for='1'>
        <p>div>p
            <label>title</label>
        </p>
    </div>
    <hr/>
    <p id="bott">div,p</p>
</body>
</html>
'''

soup = BeautifulSoup(html,features="lxml")

1.name,标签名称

tag = soup.find("a")
print(tag.name) #a
tag = soup.find(id="content")
print(tag.name) #div

2.标签attrs属性的操作

tag = soup.find('a')
print(tag.attrs)    #{'href': '/wwewe/fafwaw', 'class': ['btn', 'btn2']}
print(tag.attrs['href'])    #/wwewe/fafwaw
tag.attrs['id']="btn-primary"   #添加
del tag.attrs['class']  #删除
tag.attrs['href']="/change"　　#改
print(tag.attrs)    #{'id': 'btn-primary', 'href': '/change'}

3.children所有子标签

body = soup.find("body")
print(body.children)    #list_iterator object,只会获取子标签，对于内部子孙标签是作为字符串形式存在
from bs4.element import Tag
for child in body.children:
    # print(type(child))
    # <class 'bs4.element.NavigableString'>字符串类型，一般是换行符，空格等
    # <class 'bs4.element.Tag'>子节点类型
    if type(child) == Tag:
        print(child)

4.descendants所有子孙标签

body = soup.find("body")
for child in body.descendants:  #会将内部子孙标签提出来，再次进行一次操作
    # print(type(child))
    # <class 'bs4.element.NavigableString'>字符串类型，一般是换行符，空格等
    # <class 'bs4.element.Tag'>子节点类型
    if type(child) == Tag:
        print(child)

5.clear，递归清空子标签，保留自己

body = soup.find("body")
body.clear()  #清空子标签,保留自己
print(soup) #body标签存在，内部为空

6.decompose递归删除所有标签，包含自己

body = soup.find('body')
body.decompose()    #递归删除，包含自己
print(soup) #body标签不存在

7.extract，递归删除所有标签（同decompose）,获取删除的标签

body = soup.find('body')
deltag = body.extract() #递归删除，包含本标签
print(soup) #无body标签
print(deltag)   #是所有我们删除的标签

8.decode，转化为字符串（含当前标签）；decode_contents（不含当前标签）

#用字符串形式输出，也可以直接输出，内置__str__方法
body = soup.find('body')
v = body.decode()   #含有当前标签
print(v)
v = body.decode_contents()  #不含当前标签
print(v)

9.encode,转换为字节（含当前标签）；encode_contents（不含当前标签）

#转换为字节类型
body = soup.find('body')
v = body.encode()      #含有body
print(v)
v = body.encode_contents()  #不含body
print(v)

10.find的灵活使用：按照标签名，属性，文本，recursive是否递归查找

tag = soup.find(name="p")    #默认是寻找所有子孙节点的数据,递归查找
print(tag)  #找到子孙下的第一个
tag = soup.find(name='p',recursive=False)
print(tag)  #None   是因为，当前标签是html标签，而不是body

tag = soup.find('body').find('p')
print(tag)  ##找到子孙下的第一个
tag = soup.find('body').find('p',recursive=False)
print(tag)  #<p>div,p</p>

tag = soup.find('body').find('div',attrs={"id":"content","for":"1"},recursive=False)
print(tag)  #找到该标签

11.find_all的灵活使用：标签名，属性，文本，正则，函数，limit，recursive查找

tags = soup.find_all('p')
print(tags)

tags = soup.find_all('p',limit=1)   #只去获取一个，但是返回还是列表
print(tags)

tags = soup.find_all('p',attrs={'id':"bott"}) #按属性查找
print(tags)

tags = soup.find_all(name=['p','a'])    #查找所有p,a标签
print(tags)

tags = soup.find("body").find_all(name=['p','a'],recursive=False)    #查找所有p,a标签,只找子标签
print(tags)

tags = soup.find("body").find_all(name=['p','a'],text="div,p")  #查找所有文本时div,p的标签
print(tags)

正则匹配：
import re
pat = re.compile("p")
tags = soup.find_all(name=pat)
print(tags)

pat = re.compile("^lab")    #查找所有以lab开头的标签
tags = soup.find_all(name=pat)
print(tags)

pat = re.compile(".*faf.*")
tags = soup.find_all(attrs={"href":pat})    #或者直接href=pat
print(tags)

pat = re.compile("cont.*")
tags = soup.find_all(id=pat)
print(tags)

函数匹配：

def func(tag):
    return tag.has_attr("class") and tag.has_attr("href")

tags = soup.find_all(name=func)
print(tags)

12.标签属性的获取get，判断has_attr

tag = soup.find('a')
print(tag.get("href"))  #获取标签属性
print(tag.attrs.get("href"))  #获取标签属性

print(tag.has_attr("href"))

13.标签文本的获取get_text,string和修改string

tag = soup.find(id='content')
print(tag.get_text())   #获取标签的文本内容,会获取所有的子孙标签文本

tag = soup.find("label")
print(tag.get_text())   #title
print(tag.string)   #title
tag.string = "test"
print(tag.get_text())   #test

14.index查看标签在其父标签中的索引位置

body = soup.find("body")
child_tag = body.find("div",recursive=False)
if child_tag:
    print(body.index(child_tag))    #必须是其子标签，不是子孙标签

15.is_empty_element判断是否是空标签，或者闭合标签

tag = soup.find('hr')
print(tag.is_empty_element) #判断是不是空标签，闭合标签

16.当前标签的关联标签

tag.next
tag.next_element
tag.next_elements　　#会包含有字符串文本类型
tag.next_sibling　　#只获取标签对象Tag
tag.next_siblings

tag.previous
tag.previous_element
tag.previous_elements
tag.previous_sibling
tag.previous_siblings

tag.parent
tag.parents

tag = soup.find(id="content")
print(tag)
print(tag.next) #下一个元素，这里是换行符
print(tag.next_element) #下一个元素，这里是换行符
print(tag.next_elements)    #下面的所有子孙标签，都会提出来进行一次迭代
for ele in tag.next_elements:
    print(ele)

print(tag.next_sibling) #只去获取子标签
print(tag.next_siblings)    #只含有子标签
for ele in tag.next_siblings:
    print(ele)

17.find_根据条件去操作当前标签的关联标签,使用方法和上面类似

tag.find_next(...)
tag.find_all_next(...)
tag.find_next_sibling(...)
tag.find_next_siblings(...)

tag.find_previous(...)
tag.find_all_previous(...)
tag.find_previous_sibling(...)
tag.find_previous_siblings(...)

tag.find_parent(...)
tag.find_parents(...)

tag = soup.find("label")

# print(tag.parent)
# for par in tag.parents:
#     print(par)

print(tag.find_parent(id='content'))    #根据条件去上面查找符合条件的一个标签
print(tag.find_parents(id='content'))   #根据条件去向上面查找所有符合条件的标签，列表形式

18.select,select_one, CSS选择器

soup.select("title")
 
soup.select("p nth-of-type(3)")
 
soup.select("body a")
 
soup.select("html head title")
 
tag = soup.select("span,a")
 
soup.select("head > title")
 
soup.select("p > a")
 
soup.select("p > a:nth-of-type(2)")
 
soup.select("p > #link1")
 
soup.select("body > a")
 
soup.select("#link1 ~ .sister")
 
soup.select("#link1 + .sister")
 
soup.select(".sister")
 
soup.select("[class~=sister]")
 
soup.select("#link1")
 
soup.select("a#link2")
 
soup.select('a[href]')
 
soup.select('a[href="http://example.com/elsie"]')
 
soup.select('a[href^="http://example.com/"]')
 
soup.select('a[href$="tillie"]')
 
soup.select('a[href*=".com/el"]')
 
 
from bs4.element import Tag
 
def default_candidate_generator(tag):
    for child in tag.descendants:
        if not isinstance(child, Tag):
            continue
        if not child.has_attr('href'):
            continue
        yield child
 
tags = soup.find('body').select("a", _candidate_generator=default_candidate_generator)
print(type(tags), tags)
 
from bs4.element import Tag
def default_candidate_generator(tag):
    for child in tag.descendants:
        if not isinstance(child, Tag):
            continue
        if not child.has_attr('href'):
            continue
        yield child
 
tags = soup.find('body').select("a", _candidate_generator=default_candidate_generator, limit=1)
print(type(tags), tags)

19.Tag类新建标签

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"
print(tag_obj)  #<pre col="30">这是一个新建标签</pre>

20.append将新建标签，追加到内部标签，是放在最后面的（注意append可以将已存在的标签对象移动到另一个标签下面，原来的不存在了）

soup = BeautifulSoup(html,features="lxml")

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"
# print(tag_obj)  #<pre col="30">这是一个新建标签</pre>

soup.find(id="content").append(tag_obj) #追加放在最后面

print(soup)

21.insert为当前标签内部指定位置插入标签

soup = BeautifulSoup(html,features="lxml")

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"
# print(tag_obj)  #<pre col="30">这是一个新建标签</pre>

soup.find(id="content").insert(0,tag_obj) #追加放在最前面

print(soup)

22.insert_after,insert_before 在当前标签后面或前面插入

soup = BeautifulSoup(html,features="lxml")

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"
# print(tag_obj)  #<pre col="30">这是一个新建标签</pre>

soup.find(id="content").insert_before(tag_obj) #放在当前标签前面
soup.find(id="content").insert_after(tag_obj) #放在当前标签后面

print(soup)

23.replace_with 将当前标签替换为指定标签

soup = BeautifulSoup(html,features="lxml")

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"
# print(tag_obj)  #<pre col="30">这是一个新建标签</pre>

soup.find(id="content").replace_with(tag_obj) #原来div标签被替换

print(soup)

24. setup创建标签之间的关系（用途不明显，用途不大）

def setup(self, parent=None, previous_element=None, next_element=None,
          previous_sibling=None, next_sibling=None):

soup = BeautifulSoup(html,features="lxml")

div = soup.find('div')
a = soup.find('a')

div.setup(next_sibling=a)
print(soup) #没有变化

print(div.next_sibling) #是我们设置的那个标签对象

25.wrap，用指定标签将当前标签包裹起来

soup = BeautifulSoup(html,features="lxml")

from bs4.element import Tag
tag_obj = Tag(name='pre',attrs={"col":30})
tag_obj.string="这是一个新建标签"

a = soup.find("a")

a.wrap(tag_obj) #用新建标签将当前a标签包含起来

div = soup.find('div')
tag_obj.wrap(div)   #用原本存在的标签包含现在的tag_obj,包含数放在最后面
print(soup)

26.unwrap，去掉当前标签，将保留其包裹（内部）的标签

div = soup.find('div')
div.unwrap()
print(soup)

 

五：实现自动登录github网站

import requests
from bs4 import BeautifulSoup

html1 = requests.get(url="https://github.com/login")　　#先到登录页，获取token，cookies
html1.encoding = html1.apparent_encoding
soup = BeautifulSoup(html1.text,features="html.parser")
login_token_obj = soup.find(name='input', attrs={'name': 'authenticity_token'})
login_token = login_token_obj.get("value")　　#获取到页面的令牌
cookie_dict = html1.cookies.get_dict()
html1.close()

#填写form表单需要的数据
login_data = {　　
    'login':"账号",
    'password':"密码",
    'authenticity_token':login_token,
    "utf8": "",
    "commit":"Sign in"
}

session_reponse = requests.post("https://github.com/session",data=login_data,cookies=cookie_dict)　　#必须传入cookies
cookie_dict.update(session_reponse.cookies.get_dict())　　#更新网站的cookies

index_reponse = requests.get("https://github.com/settings/repositories",cookies=cookie_dict)　　#必须携带cookies
soup2 = BeautifulSoup(index_reponse.text,features="html.parser")　　#解析下面的列表数据，获取项目名和项目大小
item_list = soup2.find_all("div",{'class':'listgroup-item'})
for item in item_list:
    a_obj = item.find("a")
    s_obj = item.find('small')
    print(a_obj.text)
    print(s_obj.text)

六：实现自动登录抽屉新热榜，实现点赞

推文：为何大量网站不能抓取?爬虫突破封禁的6种常见方法

1.其中抽屉网防止直接被爬取数据，使用的是对请求头进行验证，所以我们需要修改请求头，防止被网站防火墙拦截

2.抽屉网，对于第一次传递的cookies中gpsd数据进行了授权，在我们后续的操作中需要的是第一次请求中的gpsd,我们若是使用了其他的请求中的cookie，那么会出错

import requests

headers = {}　　#设置请求头
headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36'
headers['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8'
i1 = requests.get("https://dig.chouti.com/",headers=headers)

i1_cookie = i1.cookies.get_dict()
print(i1_cookie)
i1.close()

form_data = {
    'phone':"xxxx",
    'password':"xxxx",
    'oneMonth':''
}
headers['Accept'] = '*/*'
i2 = requests.post(url="https://dig.chouti.com/login",headers=headers,data=form_data,cookies=i1_cookie)
i2_cookie = i2.cookies.get_dict()

i2_cookie.update(i1_cookie)

i3 = requests.post("https://dig.chouti.com/link/vote?linksId=20306326",headers=headers,cookies=i2_cookie)
print(i3.text)

{'JSESSIONID': 'aaaoJAuXMtUytb02Uw9pw', 'route': '0c5178ac241ad1c9437c2aafd89a0e50', 'gpsd': '91e20c26ddac51c60ce4ca8910fb5669'}

{"result":{"code":"9999", "message":"推荐成功", "data":{"jid":"cdu_52941024478","likedTime":"1529420936883000","lvCount":"23","nick":"山上有风景","uvCount":"2","voteTime":"小于1分钟前"}}}

七：自动登录知乎

Python模拟登陆新版知乎（代码全）

模拟登陆改版后的知乎（讲解详细）

知乎改版使用restapi后模拟登录（讲了signature）

八：自动登录博客园