分类爬虫下的文章

【python爬虫】爬虫编程技术的解密与实战

2024-08-23




import requests
from bs4 import BeautifulSoup
 
# 设置代理服务器
proxies = {
    'http': 'http://user:password@proxy.server.com:port',
    'https': 'https://user:password@proxy.server.com:port'
}
 
# 发送请求
def send_request(url):
    try:
        response = requests.get(url, proxies=proxies)
        if response.status_code == 200:
            return response.text
        else:
            print(f"请求失败，状态码: {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"请求出错: {e}")
 
# 解析页面
def parse_page(html):
    soup = BeautifulSoup(html, 'html.parser')
    # 解析页面内容，提取需要的数据
    # ...
    return data
 
# 主函数
def main():
    url = "http://example.com"
    html = send_request(url)
    if html:
        data = parse_page(html)
        # 处理数据
        # ...
 
if __name__ == "__main__":
    main()

这个简单的爬虫示例展示了如何使用Python的requests库发送带有代理的网络请求，以及如何使用BeautifulSoup解析HTML页面。在实际应用中，你需要根据目标网站的具体结构来编写解析页面的代码，并处理获取到的数据。

001基于Python网站爬虫的设计与实现

2024-08-23




import requests
from bs4 import BeautifulSoup
 
# 发送HTTP请求获取网页内容
def get_html(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            return response.text
        else:
            return None
    except requests.RequestException:
        return None
 
# 解析网页并提取所需数据
def parse_html(html):
    soup = BeautifulSoup(html, 'html.parser')
    # 假设我们要提取所有的段落文本
    paragraphs = soup.find_all('p')
    return [p.get_text() for p in paragraphs]
 
# 主函数，组装URL并调用函数获取和解析数据
def main():
    url = 'http://example.com'  # 替换为你要爬取的网站
    html = get_html(url)
    if html:
        paragraphs = parse_html(html)
        for p in paragraphs:
            print(p)
    else:
        print("Failed to retrieve the webpage content.")
 
if __name__ == '__main__':
    main()

这个简单的Python爬虫示例展示了如何使用requests库获取网页内容，并使用BeautifulSoup进行解析。这个例子假设我们要提取段落文本，并打印输出。在实际应用中，你需要根据目标网站的结构和你需要抓取的数据进行相应的调整。

网络爬虫：爬取静态网页与动态网页

2024-08-23

在爬取网页数据时，可以使用Python的requests库来获取静态网页和动态网页的数据。对于动态网页，可以使用Selenium、Selenium Wire等工具来模拟浏览器行为获取动态加载的数据。

以下是一个简单的示例，使用requests和Selenium来分别爬取静态和动态网页的数据。

静态网页（例如：httpbin.org/get）:




import requests
 
url = 'http://httpbin.org/get'
response = requests.get(url)
print(response.text)

动态网页（例如：使用JavaScript加载内容的网页）:




from selenium import webdriver
from selenium.webdriver.common.by import By
 
# 启动浏览器
driver = webdriver.Chrome()
 
# 打开网页
url = 'http://example.com'  # 动态网页的URL
driver.get(url)
 
# 获取网页源代码
page_source = driver.page_source
print(page_source)
 
# 关闭浏览器
driver.quit()

在实际应用中，可能需要设置代理、处理登录、处理Cookies、解决验证码等问题，以上代码仅提供了基本的爬取方法。

C++爬虫模板3.1(winhttp)

2024-08-23

由于原始代码已经是一个很好的示例，下面提供的代码是一个简化版本，去除了原始代码中的一些复杂性，并添加了必要的注释。




#include <iostream>
#include <string>
#include <winhttp.h>
 
#pragma comment(lib, "winhttp.lib")
 
bool GetHttpFile(const std::wstring& url, const std::wstring& filename) {
    HINTERNET hSession = ::WinHttpOpen(L"Crawler/3.1", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) {
        std::cerr << "WinHttpOpen failed: " << GetLastError() << std::endl;
        return false;
    }
 
    HINTERNET hConnect = ::WinHttpConnect(hSession, L"www.example.com", INTERNET_DEFAULT_HTTP_PORT, 0);
    if (!hConnect) {
        std::cerr << "WinHttpConnect failed: " << GetLastError() << std::endl;
        ::WinHttpCloseHandle(hSession);
        return false;
    }
 
    HINTERNET hRequest = ::WinHttpOpenRequest(hConnect, L"GET", url.c_str(), NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
    if (!hRequest) {
        std::cerr << "WinHttpOpenRequest failed: " << GetLastError() << std::endl;
        ::WinHttpCloseHandle(hConnect);
        ::WinHttpCloseHandle(hSession);
        return false;
    }
 
    if (!::WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0)) {
        std::cerr << "WinHttpSendRequest failed: " << GetLastError() << std::endl;
        ::WinHttpCloseHandle(hRequest);
        ::WinHttpCloseHandle(hConnect);
        ::WinHttpCloseHandle(hSession);
        return false;
    }
 
    if (!::WinHttpReceiveResponse(hRequest, NULL)) {
        std::cerr << "WinHttpReceiveResponse failed: " << GetLastError() << std::endl;
        ::WinHttpCloseHandle(hRequest);
        ::WinHttpCloseHandle(hConnect);
        ::WinHttpCloseHandle(hSession);
        return false;
    }
 
    DWORD dwSize = 0;
    DWORD dwDownloaded = 0;
    std::ofstream outfile(filename, std::ios::out | std::ios::binary);
    if (outfile) {
        do {
            char buffer[4096];
            if (!::WinHttpQueryDataAvailable(hRequest, &dwSize)) {
                std::cerr << "WinHttpQueryDataAvailable failed: " << GetLastError() << std::endl;
                ::WinHttpCloseHandle(hRequest);
                ::WinHttpCloseHandle(hConnect);
                ::WinHttpCloseHandle(hSession);
                return false;
            }
 
            if (!dwSize) {
                break;
            }
 
            if (!::WinHttpReadDa

2024-08-23

在爬虫中，常见的伪加密方式有Base64和MD5。Base64是一种简单的加密方式，可以用来加密数据，但是它很容易被解密。MD5是一种散列函数，主要用于生成消息摘要，它是不可逆的，主要用于验证数据的完整性。

以下是Python中这些加密方式的实现：

Base64加密：

Python的内置库base64提供了Base64的编码和解码功能。




import base64
 
# 编码
encoded_data = base64.b64encode(b"Hello World")
print(encoded_data)  # 输出：b'SGVsbG8gV29ybGQ='
 
# 解码
decoded_data = base64.b64decode(b'SGVsbG8gV29ybGQ=')
print(decoded_data)  # 输出：b'Hello World'

MD5加密：

Python的hashlib库提供了MD5加密功能。




import hashlib
 
# 加密
md5_data = hashlib.md5(b"Hello World").hexdigest()
print(md5_data)  # 输出：'b10a8db164e0754105b7a99be72e3fe5'

需要注意的是，MD5加密后的结果是一个128位的散列值，不可逆。

DES加密：




from Crypto.Cipher import DES
from binascii import b2a_hex, a2b_hex
 
key = b'ABCDEFGHIJKLMNOP'
 
def des_encrypt(data):
    data = data.encode('utf-8')
    mod = DES.new(key, DES.MODE_ECB)
    return b2a_hex(mod.encrypt(data))
 
def des_decrypt(data):
    mod = DES.new(key, DES.MODE_ECB)
    return mod.decrypt(a2b_hex(data)).decode('utf-8')
 
encrypted_data = des_encrypt(b"Hello World")
print(encrypted_data)  # 输出加密数据
 
decrypted_data = des_decrypt(encrypted_data)
print(decrypted_data)  # 输出解密数据

AES加密：




from Crypto.Cipher import AES
from binascii import b2a_hex, a2b_hex
from Crypto.Random import get_random_bytes
 
key = get_random_bytes(16)
 
def aes_encrypt(data):
    data = data.encode('utf-8')
    aes = AES.new(key, AES.MODE_EAX)
    ciphertext, tag = aes.encrypt_and_digest(data)
    return b2a_hex(aes.nonce), b2a_hex(tag), b2a_hex(ciphertext)
 
def aes_decrypt(nonce, tag, ciphertext):
    aes = AES.new(key, AES.MODE_EAX, nonce=nonce)
    return aes.decrypt_and_verify(a2b_hex(ciphertext), a2b_hex(tag)).decode('utf-8')
 
encrypted_data = aes_encrypt(b"Hello World")
print(encrypted_data)  # 输出加密数据
 
decrypted_data = aes_decrypt(*encrypted_data)
print(decrypted_data)  # 输出解密数据

RSA加密：




from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
from binascii import b2a_hex, a2b_hex
 
rsa = RSA.

python+selenium爬虫笔记

2024-08-23




# 导入必要的模块
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
 
# 初始化webdriver
driver = webdriver.Chrome()
 
# 打开网页
driver.get("http://www.baidu.com")
 
# 找到搜索框，输入文本，并提交
input = driver.find_element_by_id("kw")
input.send_keys("Python")
input.send_keys(Keys.ENTER)
 
# 等待页面加载完成
time.sleep(5)
 
# 获取当前页面的源代码并打印
html = driver.page_source
print(html)
 
# 清理工作：关闭浏览器
driver.close()

这段代码使用了Selenium WebDriver 来操作Chrome浏览器打开了百度首页，在搜索框中输入了"Python"并提交了搜索，然后打印了当前页面的源代码。最后，代码关闭了浏览器以清理工作。这是一个基本的Selenium爬虫示例。

get请求搜索功能爬虫

2024-08-23

为了创建一个使用GET请求实现搜索功能的爬虫，你可以使用Python的requests库来发送HTTP GET请求，并使用BeautifulSoup库来解析返回的HTML内容。以下是一个简单的例子，假设我们要搜索一个假设的网站（http://example.com）。




import requests
from bs4 import BeautifulSoup
 
def search_on_site(query):
    # 构建GET请求的URL
    url = 'http://example.com/search?q={}'.format(query)
    
    # 发送GET请求
    response = requests.get(url)
    
    # 检查请求是否成功
    if response.status_code == 200:
        # 解析返回的HTML内容
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 提取你需要的信息，例如搜索结果的标题
        results = soup.find_all('div', {'class': 'search-result'})
        for result in results:
            title = result.find('h3', {'class': 'result-title'})
            if title:
                print(title.text)
    else:
        print("Failed to retrieve search results")
 
# 使用函数进行搜索
search_on_site('python')

请注意，你需要根据实际的网站结构调整URL的构建和解析过程中的选择器。此外，不同网站可能需要额外的请求头（headers），例如User-Agent，Cookies，或者特定的认证机制。在这种情况下，你可以通过修改requests.get()方法的参数来添加这些头信息。

爬虫-搜狗搜索，基于request库的使用

2024-08-23




import requests
from bs4 import BeautifulSoup
 
def crawl_sogou(keyword, num_pages):
    for i in range(num_pages):
        page_number = i * 10
        url = f'https://www.sogou.com/web?query={keyword}&ie=utf8&start={page_number}'
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            soup = BeautifulSoup(response.text, 'lxml')
            for result in soup.find_all('a', {'href': True, 'class': 'txt-link'}):
                link = result['href']
                title = result.text.strip()
                print(f'标题: {title}, 链接: {link}')
 
if __name__ == '__main__':
    keyword = 'Python'
    num_pages = 3
    crawl_sogou(keyword, num_pages)

这段代码使用了requests库来发送HTTP请求，并使用BeautifulSoup库来解析返回的HTML内容。代码定义了一个crawl_sogou函数，该函数接受搜索词和需要爬取的页面数量，然后循环访问每一个页面，提取出页面中的链接和标题，并打印出来。这个例子展示了如何使用Python进行基本的网络爬虫。

2024-08-23




// 假设我们有一个localStorage对象和一个需要验证的网站
var localStorage = {
    getItem: function(key) {
        // 模拟获取localStorage中的值
        return this[key] || null;
    },
    setItem: function(key, value) {
        // 模拟设置localStorage中的值
        this[key] = String(value);
    }
};
 
// 网站验证函数，假设是某易的滑块验证
function verify() {
    var slider = document.getElementById('slider');
    var token = localStorage.getItem('token');
    // 通过Ajax请求发送token，验证是否可以通过滑块验证
    var xhr = new XMLHttpRequest();
    xhr.open('POST', 'https://www.example.com/verify', true);
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                var response = JSON.parse(xhr.responseText);
                if (response.success) {
                    // 验证成功，可以通过滑块
                    console.log('验证成功，滑块已解锁。');
                } else {
                    // 验证失败
                    console.log('验证失败，滑块无法解锁。');
                }
            } else {
                console.log('请求失败，状态码：' + xhr.status);
            }
        }
    };
    xhr.send('token=' + encodeURIComponent(token));
}
 
// 在这里，我们可以模拟用户滑动滑块的行为
verify();

这个代码示例展示了如何使用JavaScript模拟Ajax请求来向一个假设的网站发送一个token，以通过滑块验证。这是一种常见的反爬虫措施，可以通过Hook技术进行绕过。在实际应用中，Hook的方法和技术可能会随着网站的更新而变化。