Pour utiliser la bibliothèque de requêtes en Python, vous devez d'abord l'installer à l'aide de pip. Vous pouvez le faire en exécutant la commande suivante dans le terminal :
pip install requests
Après avoir installé la bibliothèque, vous pouvez l'utiliser pour effectuer des requêtes HTTP. Voici un exemple de la façon de faire une requête GET :
import requests response = requests.get('https://www.baidu.com') print(response.text)
Dans cet exemple, nous importons la bibliothèque de requêtes puis utilisons la méthode get pour effectuer une requête GET à https://www.baidu.com. La réponse du serveur est stockée dans la variable de réponse et nous imprimons le texte de la réponse sur la console.
Vous pouvez également transmettre des paramètres à la méthode get pour inclure des paramètres de requête dans la requête :
import requests
params = {'key1': 'value1', 'key2': 'value2'}
response = requests.get('https://www.example.com', params=params)
print(response.url)Dans cet exemple, nous transmettons un dictionnaire de paramètres de requête au paramètre params de la méthode get. L'URL générée inclura les paramètres de requête et nous imprimerons l'URL sur la console.
Vous pouvez également utiliser la méthode post pour faire des requêtes POST :
import requests
data = {'key1': 'value1', 'key2': 'value2'}
response = requests.post('https://www.example.com', data=data)
print(response.text)Dans cet exemple, nous passons un dictionnaire de données au paramètre data de la méthode post. Les données seront envoyées dans le corps de la demande et nous imprimons le texte de la réponse sur la console.
Ouvrez l'adresse de traduction Baidu, puis appuyez sur F12 pour ouvrir le mode développeur, entrez le contenu traduit, cliquez sur Traduire, vous pouvez le voir clairement à travers l'image ci-dessous Adresse demandée et paramètres demandésF12打开开发者模式，输入翻译的内容，点击翻译，通过下图，可以清楚看到请求的地址和请求的参数
百度翻译通过向https://fanyi.baidu.com/v2transapi发送post请求，发送的数据中只有sign是不断变化的，搜索v2transapi发现sign字段是通过js通过你要发送的数据字符串进行加密得到的。
通过百度翻译的js分析得出加密的关键代码如下：
现在已经搞清楚了整个调用的流程，所有的参数都可以自己构造。这样就可以写代码了。
1、为了防止请求失败，需要模仿浏览器请求，在请求时加上请求头，我们采用fake_useragent这个第三方库，随机生成不同的User-Agent。关键代码如下：
from fake_useragent import UserAgent
headers = {'User-Agent': UserAgent().random}2、生成sign参数，由于加密的js代码我们看不明白，直接调用python的第三方库执行js代码，使用前需要安装execjs库，执行如下的代码：
pip3 install PyExecJS
这个库使用方法也很简单，例如，上面我们已经把百度的加密js代码已经提取出来了，并新建一个js文件,把内容复制进去。关键代码如下：
def generate_sign(self,query):
try:
if os.path.isfile("./baidu.js"):
with open("./baidu.js", 'r', encoding="utf-8") as f:
baidu_js = f.read()
ctx = execjs.compile(baidu_js)
return ctx.call('b', query)
except Exception as e:
print(e)先把js文件读到缓存中，再通过execjs调用该对象。最后通过调用call方法执行js文件的里面的方法，其中b是对应js的方法，query是js中b方法的参数。
调用成功后，返回如下:
3、获取token值，通过观察百度翻译页面的源码，发现token是存放在页面中的，这样我们就可以通过请求页面获取到token.
res = request.get("https://fanyi.baidu.com").content.decode()
token = re.findall(r"token: '(.*)',", res, re.M)[0]4、到目前为止所有的请求参数已经有了，这样我们就可以开始构造请求。核心代码如下：
url = 'https://fanyi.baidu.com/v2transapi'
sign = generate_sign("你好")
data = {
"from": "zh",
"to": 'en',
"query": "你好",
"transtype": "translang",
"simple_means_flag": "3",
"sign": sign,
"token": self.token,
"domain": "common"
}
res = requests.post(
url=url,
params={"from": "zh", "to": 'en'},
data=data,
headers = {
'User-Agent': UserAgent().random,
}
)
res.json().get("trans_result").get("data")[0].get("dst")请求成功后，会返回如下图：
通过实际的调用中发现不是每次请求成功的，所以需要多次进行请求，通过一个循环操作，当清楚成功就跳出循环，关键代码如下：
tryTimes = 0
try:
while tryTimes < 100:
res = self.session.post(
url=url,
params={"from": fromLan, "to": toLan},
data=data,
)
if "trans_result" in res.text:
break
tryTimes += 1
return res.json().get("trans_result").get("data")[0].get("dst")这样我们就已经完成利用百度翻译接口，做成自己的翻译接口调用了。可以根据自己的需求采用Flask或Fastapi
🎜🎜Baidu Translation envoie une demande de publication à https://fanyi.baidu.com/v2transapi. Seul le signe dans les données envoyées change constamment. Recherchez v2transapi et constatez que le champ de signe correspond aux données chaîne que vous souhaitez envoyer via js. Obtenu par cryptage. 🎜🎜🎜 🎜via Baidu Translate L'analyse js montre que le code clé pour le cryptage est le suivant : 🎜🎜
🎜🎜Maintenant, nous avons compris l'intégralité du processus d'appel et tous les paramètres peuvent être construits par nous-mêmes. De cette façon, vous pouvez écrire du code. 🎜🎜Écrire le code de l'interface🎜🎜1. Afin d'éviter l'échec des requêtes, nous devons imiter les requêtes du navigateur et ajouter des en-têtes de requête lors des requêtes. Nous utilisons la bibliothèque tierce fake_useragent pour générer aléatoirement différents <. code> Agent Utilisateur. Le code clé est le suivant : 🎜import requests
import execjs
import os
import re
import json
from loguru import logger
from fake_useragent import UserAgent
class Baidu_translate:
def __init__(self):
self.session=request.Session()
self.session.headers={
'User-Agent': UserAgent( ).random,
"Host":"fanyi.baidu.com",
"X-Requested-With":"XMLHttpRequest",
"sec-ch-ua":'"Not?A_Brand";="8","Chromium";v="108","Microsoft Edge";V="108",
"sec-ch-ua-mobile":"?0",
"Sec-Fetch-Dest":"document",
"Sec-Fetch-Mode":"navigate",
"Sec-Fetch-Site": "same-origin",
"Sec-Fetch-User":"?1",
"Connection":"keep-alive",
}
self.session.get("https://fanyi.baidu.com" )
res = self.session.get("https://fanyi.baidu.com").content.decode( )
self.token = re.findall(r"token: '(.*)',",res,re.M)[0]
def generate_sign(self,query):
try:
if os.path.isfile("./baidu.js"):
with open("./baidu.js",'r',encoding="utf-8") as f:
baidu_js = f.read( )
ctx = execjs.compile(baidu_js)
return ctx.call('b',query)
except Exception as e:
print(e)
def lang_detect(self,src: str) -> str:
url = "https://fanyi.baidu.com/langdetect"
fromLan = self.session.post(url, data={"query": src}).json()["lan"]
return fromLan
def translate(self,query: str, tolan: str = "", fromLan: str = "") -> str:
if fromLan == "":
fromLan = self.lang_detect(query)
if toLan == "":
toLan = "zh" if fromLan != "zh" else "en"
url = 'https://fanyi.baidu.com/v2transapi'
sign = self.generate_sign(query)
data = {
"from" : fromLan,
"to": toLan,
"query": query,
"transtype":"translang",
"simple_means_flag":"3",
"sign" : sign,
"token": self.token,
"domain":"common"
}
tryTimes = 0
try:
while tryTimes < 100:
res = self.session.post(
url=url,
params={"from": fromLan,"to": toLan},
data=data,
)
if "trans_result" in res.text:
break
tryTimes +=1
return res.json().get("trans_result").get("data")[0].get("dst")
except Exception as e:
print(e)
def test():
url ='https://fanyi.baidu.com/v2transapi'
sign = generate_sign("你好")
data = {
"from":"zh",
"to":' en',
"query":"你好",
"transtype":"translang",
"simple_means_flag":"3",
"sign": sign,
"token": self.token,
"domain": "common"
}
res = requests.post(
url=url,
params={"from": "zh","to":'en'},
data=data,
headers = {
'User-Agent': UserAgent( ).random,
}
)
res .json()
if _name__ == "__main__":
baidu_tran = Baidu_Translate()
sign = baidu_tran.generate_sign("你好")sign Comme nous ne pouvons pas comprendre le code js crypté, nous appelons directement le tiers de python. La bibliothèque exécute le code js. Vous devez installer la bibliothèque execjs avant utilisation. Exécutez le code suivant : 🎜rrreee🎜La méthode d'utilisation de cette bibliothèque est également. très simple. Par exemple, ci-dessus, nous avons mis le code js crypté de Baidu a été extrait, et un nouveau fichier js a été créé et le contenu y a été copié. . Le code clé est le suivant : 🎜rrreee🎜Lisez d'abord le fichier js dans le cache, puis appelez l'objet via execjs. Enfin, la méthode du fichier js est exécutée en appelant la méthode call, où b est la méthode correspondant à js code>, <code>query est le paramètre de la méthode b dans js. 🎜🎜Une fois l'appel réussi, le retour est le suivant :🎜🎜🎜🎜3. Obtenez la valeur du token. En observant le code source de la page de traduction Baidu, nous avons constaté que le token est stocké dans la page, afin que nous puissions demander à la page Get token.🎜🎜
🎜rrreee🎜4. Jusqu'à présent, tous les paramètres de requête sont disponibles, nous pouvons donc commencer à construire la requête. Le code principal est le suivant : 🎜rrreee🎜Une fois la demande réussie, l'image suivante sera renvoyée : 🎜🎜
🎜🎜L'appel réel révèle que toutes les requêtes n'aboutissent pas, donc plusieurs requêtes doivent être effectuées via une opération en boucle. Lorsqu'il est clair que l'opération réussit, la boucle sera sautée. Le code clé est le suivant : 🎜 rrreee🎜De cette façon, nous avons terminé d'utiliser l'interface de traduction Baidu pour effectuer notre propre appel d'interface de traduction. Vous pouvez utiliser Flask ou Fastapi pour développer des interfaces API selon vos propres besoins. Ci-dessous tous les codes 🎜rrreeeCe qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
