python之最常用的模块一箩筐

最新推荐文章于 2024-02-16 14:30:13 发布

SoulCat.

最新推荐文章于 2024-02-16 14:30:13 发布

阅读量1.1k

点赞数 3

分类专栏： Python

本文链接：https://blog.csdn.net/csacs/article/details/100156677

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

python之最常用的模块一箩筐

 其实我挺羡慕火车的
 为什么？
 他们连擦肩而过都那么久

文章目录

python之最常用的模块一箩筐

request模块:

requests 是一个功能强大、简单易用的 HTTP 请求库

请求

requests.get('http://httpbin.org/get')
requests.post('http://httpbin.org/post')
requests.put('http://httpbin.org/put')
requests.delete('http://httpbin.org/delete')
requests.head('http://httpbin.org/get')
requests.options('http://httpbin.org/get')

响应

r.url：返回请求网站的 URL
r.status_code：返回响应的状态码
r.encoding：返回响应的编码方式
r.cookies：返回响应的 Cookie 信息
r.headers：返回响应头
r.headers[‘host’]：返回响应头某属性
r.content：返回 bytes 类型的响应体
r.text：返回字符串，也就是页面文本
r.content:  返回内容的二进制形式  
r.json()：返回josn字典

最常用也就get/post，常用参数

url 	
cookie  
params 	get形式的参数
data 	post形式的参数
headers 	修改请求头，伪装浏览器等等
timeout 	超时时间
proxies 	设置代理

举个荔枝，请求百度

# encoding:utf-8
import requests

head = {
    'User-Agent': '',
    'Referer': '11111'
}

values = {
    'name': 'cat',
    'id': '1'
}

proxy = {"http": "http://127.0.0.1:8080"}
cookie = {'name': 'gggg'}

site = "http://www.baidu.com/"
# 请求方式主要为get传值用params，post传值用data
#response = requests.get(url=site,headers=head,params=values,proxies=proxy,cookies=cookie, timeout=3)
response = requests.post(url=site, headers=head, data=values, proxies=proxy, cookies=cookie)

print(response)
print(response.url)
print(response.cookies)
print(response.status_code)
print(response.encoding)
print(response.content)
print(response.headers)
print(response.url)
print(response.text)
print(response.json())
print(response.history)

在这里插入图片描述

BeautifulSoup模块：

简单来说，Beautiful Soup是python的一个库，最主要的功能是从网页抓取数据，将 html 解析为对象进行处理。
BeautifulSoup 不仅支持 HTML 解析器，还lxml，XML，html5lib 解析器，需要安装相应的库。如果不安装，则 Python 会使用 Python 默认的解析器，其中 lxml 解析器推荐
在这里插入图片描述
一般BS4将HTML文档对象会转换成如下四种类型组合的文档树：

Tag：标签对象
NavigableString：字符内容, soup.p.string
BeautifulSoup：表示的是一个文档的全部内容
Comment：特殊类型的NavigableString, 如果标签中有注释，则是 comment 对象，可通过 if type(soup.p.string) != bs4.element.Comment:.判断

主要还是Tag也就是标签，如html页面中的<title>，<p>,<h1>等等都是tag，而Beautiful Soup可以轻松获取各种Tags
如：

soup.title  
soup.head
soup.a  
soup.p
soup.p.name              #p标签的名字
soup.p.string            #p标签的内容
soup.p.attrs             #p标签的属性，返回的是一个字典
soup.p['class']          #p标签的class属性

在这里插入图片描述

需求总是多样的，也可以利用find() 和 find_all()是这两个函数，可以准确的通过标签的不同属性轻松地过滤 HTML 页面，查找需要的标签组或单个标签。唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.这个语句可以完美诠释两者关系：
soup.find_all('title', limit=1)==soup.find('title')
主要介绍find_all() 方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件。
find_all( name , attrs , recursive , text , **kwargs )

  name ：查找所有名字为 name 的tag,字符串对象会被自动忽略掉；
  attrs：根据属性查询，使用字典类型；
  text ：可以搜搜文档中的字符串内容.与 name 参数的可选值一样, text 参数接受字符串 , 正则表达式 , 列表, True ；
  recursive：调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False ；
  limit：find_all() 方法返回全部的搜索结构,如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果；
  class_ ：通过 class_ 参数搜索有指定CSS类名的tag，class_ 参数同样接受不同类型的 过滤器 ,字符串,正则表达式,方法或 True。

是不是想说什么乱七八糟的，举个栗子看看，看完还可以吃了

# encoding:utf-8
from bs4 import BeautifulSoup
import re

html = '''
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<body>
		<div>
			<ul>
				<li class="cls1" name='one'><a href="www.abc.com">1111111111111111111</a></li>
				<li class="cls2" name='two'><a href="www.abc.com">222222222222</a></li>
				<li class="cls3" name='three'><a href="www.abc.com">3333333333</a></li>
				<li class="cls4" name='four'><a href="www.abc.com">4444444abc4444</a></li>
				<li class="cls5" name='five'><a id='aaa' href="www.abc.com">5555555555555</a></li>
			</ul>
		</div>
	</body>
</html>
'''
soup = BeautifulSoup(html, 'html.parser')
# 根据name查询节点
print("name为ul的节点：", soup.find_all(name='ul'))
# 根据attrs查询节点
print('根据attr查询节点：', soup.find_all(attrs={'name': 'one'}))
print('根据attr查询节点：', soup.find_all(attrs={'class': 'cls5'}))
# 根据text查询节点
print('根据text查询节点：', soup.find_all(text='3333333333'))
print('根据text查询节点1：', soup.find_all(text=re.compile("abc")))
# 根据class_查询
print('根据class_查询节点：', soup.find_all(class_='cls3'))
# 根据id查询
print('根据id查询节点：', soup.find_all(id='aaa'))
# 设置limit
print('不设置limit：', soup.ul.find_all(name='li'))
print('设置limit为1：', soup.ul.find_all(name='li', limit=2))

在这里插入图片描述
如果取其中href，可以link.a['href'] or link.a.get('href')

也可以通过css类名查找
在查找的时候，如果是标签名不加任何修饰，如果是类名前加点，如果id名前加#
利用 soup.select() , 返回类型是list
举个例子:

<title>111</title><a class=b id=abc>111</a>

通过标签名查找
print(soup.select('title'))   ##打印出标签是title的
通过类名查找
print(soup.select('.b'))      ##打印出class类名是b的
通过id名查找
print(soup.select('#abc'))  ##打印出id名是abc的
组合查找
print(soup.select('p #abc’ b'))  ##打印出p标签中，id=abc，class=b的
属性查找(注意属性和标签属于同一节点.)
print(soup.select("a[class='b']"))  ##打印出a标签中class属性是b的
以上的select方法返回的结果都是列表形式，可以遍历形式输出，然后用get_text()方法来获取他的内容
    for i in soup.select('a'):
        print(i.get_text())   ##打印出a标签中的文本

在这里插入图片描述

urlparse模块：

urlparse.urlparse模块主要就是将url解析为6个组件，并以元组形式返回，返回的6个部分，分别是：scheme(协议)、netloc(网络位置)、path(路径)、params(路径段参数)、query(查询)、fragment(片段)。
举个例子:

Import urlparse
	a = urlparse.urlparse(‘https:www.cat.com:8080/cat.php?cat=1’)
输出的结果为
ParseResult(scheme='https', netloc='www.cat.com:8080', path='/cat.php', params='', query='cat=1, fragment='')
Print a.netloc 为 www.cat.com
Print a.hostname 为 www.cat.com
Print a.port 为 8080

urlparse.urlsplit和urlparse差不多，将url分为5部分，返回一个包含5个字符串项目的元组：协议、位置、路径、查询、片段
urlparse.urljoin主要是拼接URL，它以base作为其基地址，然后与url中的相对地址相结合组成一个绝对URL地址.最重要就是看/进行替换添加，如果最后路径没有/,即追溯到上一个/进行替换添加
举个例子：

Import urlparse
A = urlparse.urljoin('http://www.cat.com/cat.php,'dog.php')
输出为
http://www.cat.com/dog.php
A = urlparse.urljoin('http://www.cat.com/cat.php/,'dog.php')
输出为
http://www.cat.com/cat.php/dog.php

os、sys模块：

OS模块提供方便的使用操作系统函数的方法，
SYS 模块提供可供访问由解释器使用或维护的变量和与解释器进行交互的函数。
简单来说os负责程序与操作系统的交互，提供程序访问操作系统底层的接口；sys主要负责程序与python解析器的交换，提供一系列函数与变量，用于操控pyhton的运行环境。

os 常用方法

os.name：返回当前使用平台的代表字符，Windows用 nt 表示，Linux用 posix 表示
•  os.listdir(path)：列举目录下的所有文件。返回的是list类型。
•  os.getcwd()：查看当前所在路径。
•  os.system(command)：函数用来运行shell命令。
•  os.curdir：返回当前目录（'.')
•  os.chdir(dirname)：改变工作目录到dirname
•  os.path.isfile(path)：检验给出的路径是不是文件。
•  os.path.isdir(path)：检验给出的路径是不是目录。
•  os.path.exists()：用来检验给出的路径是否真地存在
•  os.path.dirname(path)：返回文件路径
•  os.path.basename(path)：返回文件名
•  os.path.join(path, name)：连接目录与文件名或目录，使用‘\’连接
•  os.path.splitext()：分离文件名与扩展名
•  os.path.split(path)：将path分割成目录和文件名二元组返回。
•  os.path.normpath(path)：规范path字符串形式
•  os.path.abspath(name)：获得绝对路径
•  os.path.getsize(name)：获得文件大小，如果name是目录返回0L
•  os.mkdir(path)：创建path目录（只能创建一级目录）
•  os.makedirs(path)：创建多级目录
•  os.remove(path)：函数用来删除一个文件。
•  os.rmdir(path)：删除path目录(只能删除一级目录，如'/Users/XXX/SSS'，只删除SSS目录)
•  os.removedirs(path)：删除多级目录(如'/Users/XXX/SSS'，必须为空目录，删除SSS、XXX目录)
•  os.path.getmtime(path)：返回文件或目录的最后修改时间，结果为秒数
•  os.path.getatime(path)：返回文件或目录的最后访问时间，结果为秒数
•  os.path.getctime(path)：返回文件或目录得创建时间，结果为秒数
•  os.sep：返回当前操作系统特定的路径分隔符
•  os.linesep：返回当前平台使用的行终止符
•  os.extsep：返回文件名与扩展名的分隔符

sys 常用方法
sys.argv 实现从程序外部向程序传递参数。简单来说就是cmd中命令行参数，返回是一个List，第一个元素是程序名，第二个即输入第二个参数，以此类推。

Python  1.py  www.cat.com  10
Sys.argv[0]=1.py 
Sys.argv[1]=www.cat.com 
Sys.argv[2]=10

sys.modules.keys()   #返回所有已经导入的模块列表 
sys.exc_info()    #获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息 
sys.exit(n)    #程序，正常退出时exit(0) 
sys.hexversion    #获取Python解释程序的版本值，16进制格式如：0x020403F0 
sys.version    #获取Python解释程序的版本信息 
sys.maxint     #最大的Int值 
sys.maxunicode    #最大的Unicode值 
sys.modules    #返回系统导入的模块字段，key是模块名，value是模块 
sys.path     #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 
sys.platform    #返回操作系统平台名称 
sys.stdout     #标准输出  
sys.stdin     #标准输入 
sys.stderr     #错误输出  
sys.exc_clear()   #用来清除当前线程所出现的当前的或最近的错误信息 
sys.exec_prefix   #返回平台独立的python文件安装的位置 
sys.byteorder    #本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little' 
sys.copyright    #记录python版权相关的东西 
sys.api_version   #解释器的C的API版本 
sys.version_info   #获取Python解释器的版本信息 
sys.getwindowsversion  #获取Windows的版本
sys.getdefaultencoding  #返回当前你所用的默认的字符编码格式
sys.getfilesystemencoding #返回将Unicode文件名转换成系统文件名的编码的名字
sys.setdefaultencoding(name) #用来设置当前默认的字符编码
sys.builtin_module_names #Python解释器导入的模块列表 
sys.executable    #Python解释程序路径 
sys.stdin.readline   #从标准输入读一行，sys.stdout.write("a") 屏幕输出a

optparse模块：

optparse可以说是sys.argv的升级版主要用来为脚本传递cmd中命令参数，采用预先定义好的选项来解析命令行参数。

parser.add_option()是为解析器添加选项,定义命令行参数常用的五种即
		action:存储方式，分为三种store、store_false、store_true
        type:类型
        dest:存储的变量
        default:默认值
        help:帮助信息

举个橘子：
简单来说就是创建optparse对象parser，使用add_option()来定义命令行参数，最后利用parse_args()来解析命令行。

# coding=utf-8
import optparse

parser=optparse.optionParser("python %prog -u host -p port")  #创建一个对象实例,()中用于cmd提示，可以省略 %prog=程序名。
parser.add_option('-u',dest='Host',type='string',help='test host')   
parser.add_option('-p',dest='Ports',type='string',help='test ports',default="80,8080")  ##需要的命令行参数 默认-h查看
(options,args)=parser.parse_args() # 传递一个参数列表给parse_args(),只要知道命令行参数名即dest，如host,就可以访问其对应的值：options.host。
print(options.Host)
print(options.Ports)

在这里插入图片描述

socket模块：

Socket也就是套接字，使用的时候每一个socket，都被绑定特定的IP地址和端口，主要实现网络上两个程序上的数据交换。
简单来说就是本地建立socket，被访问的服务器也建立一个socket监听，两端用各种的socket及进行数据交换

服务端
首先要创建sockert对象

Sock_server = socket.socket(family,type)
Family参数代表地址家族,分为AF_INET(IPV4网络通信)和AF_UNIX(同一主机进程通信)和AF_INET6(IPV6通信)
Type参选为套接字类型，分为SOCK_STREAM(tcp流套接字)和SOCK_DGRAM(udp数据包套接字)和SOCK_RAW(可以监听所有数据帧)和SOCKE_RDM(可靠udp形式，保证交付数据)

举个苹果吧，直接创建个socket服务端

# coding=utf-8
import socket

#服务端
sock_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建一个ipv4，tcp连接对象
sock_server.bind(("127.0.0.1",8888)) #绑定主机名和端口
sock_server.listen(2) #设置服务端，最多可以被多少客户连接
connection,address =sock_server.accept()#服务端通过accept等待客户请求连接，连接建立时，返回新的connection对象(通过这个新的对象与客户端通讯)，和address客户端地址
connection.send('i am servce ')             #服务器和客户端通过“send”发送byte和“recv”接受方法通信：
mess = connection.recv(1024) #接受多大字节
print(mess)
connection.close()				#先关闭新对象，在关闭最开始对象
sock_server.close()

客户端

# coding=utf-8
import socket

sock_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock_client.connect(("127.0.0.1",8888))   #使用connect方法连接服务器
mess = sock_client.recv(1024)
print(mess)
sock_client.send('i am client')
sock_client.close()

在这里插入图片描述

threading模块：

threading 模块中最核心的内容是 Thread 这个类。
我们要创建 Thread 对象,然后让它们运行，每个 Thread 对象代表一个线程，在每个线程中我们可以让程序处理不同的任务，这就是多线程编程。
threading.Thread目前还没有优先级和线程组的功能，而且创建的线程也不能被销毁、停止、暂定、恢复或中断。

守护线程：只有所有守护线程都结束，整个Python程序才会退出，但并不是说Python程序会等待守护线程运行完毕，相反，当程序退出时，如果还有守护线程在运行，程序会去强制终结所有守护线程，当守所有护线程都终结后，程序才会真正退出。可以通过修改daemon属性或者初始化线程时指定daemon参数来指定某个线程为守护线程。

非守护线程：一般创建的线程默认就是非守护线程，包括主线程也是，即在Python程序退出时，如果还有非守护线程在运行，程序会等待直到所有非守护线程都结束后才会退出。

注：守护线程会在程序关闭时突然关闭（如果守护线程在程序关闭时还在运行），它们占用的资源可能没有被正确释放，比如正在修改文档内容等，需要谨慎使用。

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

如果这个类的初始化方法被重写，请确保在重写的初始化方法中做任何事之前先调用threading.Thread类的__init__方法。

group：应该设为None，即不用设置，使用默认值就好，因为这个参数是为了以后实现ThreadGroup类而保留的。

target：在run方法中调用的可调用对象，即需要开启线程的可调用对象，比如函数或方法。
name：线程名称，默认为“Thread-N”形式的名称，N为较小的十进制数。
args：在参数target中传入的可调用对象的参数元组，默认为空元组()。
kwargs：在参数target中传入的可调用对象的关键字参数字典，默认为空字典{}。
daemon：默认为None，即继承当前调用者线程（即开启线程的线程，一般就是主线程）的守护模式属性，如果不为None，则无论该线程是否为守护模式，都会被设置为“守护模式”。
start()：开启线程活动。它将使得run()方法在一个独立的控制线程中被调用，需要注意的是同一个线程对象的start()方法只能被调用一次，如果调用多次，则会报RuntimeError错误。
run()：此方法代表线程活动。
join(timeout=None)：让当前调用者线程（即开启线程的线程，一般就是主线程）等待，直到线程结束（无论它是什么原因结束的），timeout参数是以秒为单位的浮点数，用于设置操作超时的时间，返回值为None。如果想要判断线程是否超时，只能通过线程的is_alive方法来进行判断。join方法可以被调用多次。如果对当前线程使用join方法（即线程在内部调用自己的join方法），或者在线程没有开始前使用join方法，都会报RuntimeError错误。
name：线程的名称字符串，并没有什么实际含义，多个线程可以赋予相同的名称，初始值由初始化方法来设置。
ident：线程的标识符，如果线程还没有启动，则为None。ident是一个非零整数，参见threading.get_ident()函数。当线程结束后，它的ident可能被其他新创建的线程复用，当然就算该线程结束了，它的ident依旧是可用的。
is_alive()：线程是否存活，返回True或者False。在线程的run()运行之后直到run()结束，该方法返回True。
daemon：表示该线程是否是守护线程，True或者False。设置一个线程的daemon必须在线程的start()方法之前，否则会报RuntimeError错误。这个值默认继承自创建它的线程，主线程默认是非守护线程的，所以在主线程中创建的线程默认都是非守护线程的，即daemon=False。

举个例子

import requests
import threading

def post(user,pwd):

  response = requests.get('http://oa.jst-hosp.com.cn/j_acegi_security_check', headers=headers)


uesr=123
pwd=123
th = []
for user in users:
  for pwd in pwds:
    post(user,pwd)
    p = threading.Thread(target=post,args=(user,pwd))
    th.append(p)
for t in th:
  t.start()

xpach模块

XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。

选取节点
XPath 使用路径表达式在 XML 文档中选取节点。节点是通过沿着路径或者 step 来选取的
在这里插入图片描述
举例子
//+@ #通过//选择节点，然后利用@确定属性，来实现具体table位子

谓语
在这里插入图片描述
选取未知节点
XPath 通配符可用来选取未知的 XML 元素。

选取若干路径
通过在路径表达式中使用"|"运算符，您可以选取若干个路径。

在这里插入图片描述

parsel模块

主要用来将请求后的字符串格式解析成re,xpath,css进行内容的匹配
导入from parsel import Selector

response = requests.get(url)
sel = parsel.Selector(response.text)  #注意这里的S要大写

# re正则
# print(sel.re('正则匹配格式'))

# xpath
# print(sel.xpath('xpath').getall()) #getall获取所有
# print(sel.xpath('xpath'). extract_first()  返回第一个

# css选择器
# print(sel.css('css选择器 ::text').extract_first())#获取第一个

爬虫结合xptch以及threading综合使用

import requests
from parsel import Selector
import threading


def get_page(num):
    params = (
        ('p',f'{num}'),)

    response = requests.get('https://so.gushiwen.org/mingju/default.aspx', headers=headers, params=params)
    response.encoding = "utf8"
  
    sel = Selector(response.text)
    cont = sel.xpath('//div[@class="sons"]//div[@class="cont"]')
    res = []
    for s in cont:
        l1 = s.xpath(".//a[1]/text()").extract_first()
        l2 = s.xpath(".//a[2]/text()").extract_first()
        #data = open("data.txt","a")
        #data.write(l1+"---------"+l2+"\n")
        print("num",num,l1+l2)
        res.append((l1,l2))
    #print(num,res,"\n")
    return res
th = []        
for p in range(1,30):
    t = threading.Thread(target=get_page,args=(p,))
    th.append(t)
for t in th:
    t.start()

余生很长，请多指教。
在这里插入图片描述

SoulCat.

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
python之最常用的模块一箩筐

python之最常用的模块一箩筐其实我挺羡慕火车的为什么？他们连擦肩而过都那么久request模块:requests 是一个功能强大、简单易用的 HTTP 请求库请求requests.get('http://httpbin.org/get')requests.post('http://httpbin.org/post')requests.put('http://htt...
复制链接

扫一扫