Explication détaillée et exemples d'appels API en python

Cet article vous apporte des connaissances pertinentes sur python, qui présente principalement les problèmes liés aux appels d'API, notamment les appels d'API et les appels d'interface de données, les méthodes de requête, plusieurs exemples d'appels d'API courants, etc. Jetons un coup d'œil au contenu ci-dessous. j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : Tutoriel vidéo Python

Dans le travail quotidien, vous devrez peut-être combiner certaines API actuelles sur Internet ou des interfaces de données fournies par l'entreprise pour obtenir les données correspondantes ou implémenter les fonctions correspondantes.
Par conséquent, l'appel d'API et l'accès aux interfaces de données sont des opérations courantes pour l'analyse des données. Comment implémenter rapidement des appels aux API et aux interfaces de données ? De nombreuses versions linguistiques sont généralement disponibles en ligne, mais les méthodes utilisées pour tracer la source utilisent toutes des requêtes HTTP ? mettre en œuvre.

API

API : En termes simples, il s'agit d'un ensemble de protocoles, d'un outil ou d'un ensemble de règles qui définissent les méthodes de communication entre différentes applications, masquent le processus de mise en œuvre spécifique et n'exposent que les parties qui doivent être appelées pour que les développeurs utiliser .

La définition ci-dessus est relativement officielle. Voici un exemple simple pour illustrer. Par exemple, les restaurants fast-food comme McDonald's à l'extérieur utilisent désormais les téléphones portables pour passer des commandes en ligne et récupérer leurs repas à la réception. Dans ce processus, les consommateurs sélectionnent généralement le repas correspondant sur leur téléphone portable, cliquent pour passer une commande et payer, puis attendent que la réception appelle le numéro pour récupérer le repas. Nous ne savons pas exactement comment ce processus est mis en œuvre. L'ensemble du processus a une application ou un petit programme correspondant qui communique les données de la cuisine, puis le chef prépare le repas. Cette application et cette applet servent de fonctions API correspondantes.

Pour donner un exemple simple, une plateforme sociale reçoit chaque jour des commentaires dans différentes langues. En tant qu'analyste correspondant, faire face à un traitement complexe de données linguistiques, diront certains, développer un modèle pour réaliser la traduction. L'intégration de fonctions, bien que cette méthode semble réalisable, est très coûteuse. Deuxièmement, pour résoudre un problème, vous devez développer un problème plus difficile. Cela s'éloigne de plus en plus de l'objectif initial. À l'heure actuelle, nous pouvons utiliser l'API de la plate-forme de traduction nationale relativement mature pour traiter directement les données existantes. C’est relativement bon marché, plus pratique et permet d’atteindre rapidement les objectifs existants. Il n’y a aucun doute sur le rôle de l’API ici.

Interface de données

Interface de données : en termes simples, il s'agit d'un ensemble de mots de passe d'ensemble de données encapsulés, ce qui signifie envoyer les paramètres correspondants selon les règles correspondantes, puis renvoyer les informations de données associées correspondantes. Les appels d'API et les interfaces de données sont très similaires dans les appels quotidiens. Relativement parlant, l'API a une portée plus large et implémente plus de fonctions, tandis que l'interface de données sert davantage d'outil d'acquisition de données.

Par exemple, les grandes entreprises de commerce électronique utilisent généralement des SKU unifiés pour gérer les produits. Par exemple, cette entreprise est propriétaire d'une marque et vend sur différentes plateformes, et les logos de produits cartographiés sur ces plateformes L'ID est différent du SKU de l'entreprise. Parce que le SKU de l'entreprise n'est pas seulement basé sur les produits, mais prend également en compte divers entrepôts locaux et différents modèles de produits, et cette cartographie est relativement complexe.
Les personnes qui traitent des données sur différentes plateformes ne peuvent généralement pas utiliser directement la base de données de l'entreprise pour analyser les produits, car la granularité est trop fine et l'analyse est compliquée et difficile. À l'heure actuelle, le développement peut se faire dans le système existant selon le système existant. exigences des fonctions correspondantes. Il s'agit de développer une interface de données distincte pour permettre aux entreprises correspondantes d'éviter de demander directement des informations correspondantes telles que des processus de base de données complexes. Cependant, il existe un certain retard dans l'interface de données par rapport à la base de données en temps réel.

Appel API et appel d'interface de données

L'API et l'interface de données sont abordées à travers les exemples précédents, et elles sont relativement simples à comprendre en général. Voici une brève introduction sur la façon d'implémenter l'appel API et l'appel d'interface de données.
Pour faire simple, les appels d'API et les appels d'interface sont similaires à une requête HTTP. La principale chose à appeler est d'encapsuler la méthode de requête, l'en-tête de la requête, l'URL et le corps de la requête selon les règles correspondantes, puis d'envoyer la requête pour y parvenir. l'appel correspondant.

Mais comparée aux appels d'interface de données et d'API, l'interface de données générale est relativement simple. Dans de nombreux cas, l'interface de données est utilisée pour accéder aux données sur l'intranet de l'entreprise, donc la demande d'informations est relativement simple, tandis que les API sont principalement développées. par des sociétés tierces pour un usage externe. Le service est un service commercial. Relativement parlant, afin d'assurer la sécurité de la demande, il est plus compliqué d'ajouter des informations telles que AK, SK, signature et. horodatage.
Les deux appels pour remonter à la source sont similaires aux requêtes HTTP. Les appels spécifiques sont à peu près les mêmes, principalement parce que les appels API contiennent plus d'informations sur les paramètres de la requête. La mise en œuvre spécifique sera brièvement présentée ci-dessous.

La base de l'appel - méthode de requête

De manière générale, il existe de nombreuses méthodes d'appel de requête HTTP courantes. Il existe de nombreuses ressources dans ce domaine. Vous pouvez les consulter en ligne. Ici, nous parlerons brièvement des deux méthodes de requête courantes.

Requête GET

Une requête GET obtient simplement des ressources du serveur et peut être chargée dans le cache du navigateur.

Requête POST

La requête POST envoie généralement une requête au serveur sous la forme d'un formulaire. Les paramètres de requête inclus dans le corps de la requête peuvent conduire à la création et à la modification de ressources. Les informations des requêtes POST ne peuvent pas être mises en cache dans le navigateur.
Ces deux méthodes de requêtes sont très simples à énoncer, mais le point le plus important est de comprendre la différence entre ces deux requêtes, afin de mieux se familiariser avec le design de l'interface et l'utilisation de l'API.

La différence entre les requêtes GET et POST

1. La longueur de la requête GET peut aller jusqu'à 1024 Ko, et POST n'a aucune limite sur les données de la requête. La raison en est que les requêtes GET placent souvent les informations correspondantes dans l'URL et que la longueur de l'URL est limitée, ce qui entraîne une certaine limite sur la longueur de la requête GET. Les informations sur les paramètres correspondants de la requête POST sont placées dans le corps de la requête, elles ne sont donc généralement pas soumises à des restrictions de longueur.
2. La requête POST est plus sûre que GET, car l'URL de la requête GET contient les informations correspondantes, la page sera mise en cache par le navigateur et d'autres personnes pourront voir les informations correspondantes.
3.GET génère un paquet de données TCP et POST génère deux paquets de données TCP.
Lors d'une requête GET, l'en-tête et les données sont envoyés ensemble, puis le serveur répond par 200. POST envoie d'abord l'en-tête, attend que le serveur réponde avec 100, puis envoie les données et enfin le serveur répond avec 200. Mais notez ici que la requête POST est divisée en deux fois, mais le corps de la requête est envoyé immédiatement après l'en-tête. , donc ce Le temps entre les deux peut être négligeable.
4. Les requêtes GET ne prennent en charge que l'encodage d'URL, tandis que POST propose diverses méthodes d'encodage.
5. Les paramètres de la requête GET sont transmis via l'URL, plusieurs paramètres sont connectés à & et les requêtes POST sont placées dans le corps de la requête.
Les requêtes 6.GET ne prennent en charge que les caractères ASCII, tandis que POST n'a aucune restriction.
De manière générale, la requête GET est directement accessible en saisissant l'URL dans le navigateur.

Python implémente les requêtes GET et POST

Ce qui précède a introduit certaines interfaces de données, les connaissances liées à l'API et les méthodes de requête en un laps de temps important. Ci-dessous, vous pouvez vous familiariser avec le. méthodes de requête correspondantes. Généralement, vous pouvez utiliser directement la bibliothèque de requêtes de Python.

GET request

import request
# GET请求发送的参数一定要是字典的形式，可以发送多个参数。
# 发送格式：{'key1':value1', 'key2':'value2', 'key3', 'value3'}
# 样例不能运行
url ='http://www.xxxxx.com'
params = {'user':'lixue','password':111112333}
requests.get(url,data = parms)

POST request

Les requêtes POST ont généralement trois formulaires de soumission : application/x-www-form-urlencoded, multipart/form-data, application/json.
Il existe trois types à afficher plus précisément. Quelle méthode de requête : Vérifiez avec Google Chrome → Réseau → Sélectionnez pour charger le fichier → En-têtes → En-têtes de requête → Type de contenu
Les méthodes d'encodage spécifiques sont les trois suivantes. Vous pouvez comprendre la mise en œuvre spécifique de la requête. Généralement, les données internes. L'interface de l'entreprise a mis en place un réseau local. Certains n'ont donc pas besoin d'ajouter d'en-têtes.

Trois formulaires de soumission de demandes POST

1. Les données de soumission de publication les plus courantes sont principalement le formulaire : application/x-www-form-urlencoded

import request
data={'k1':'v1','k2':'v2'}
headers= {'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36'}
requests.post(url,headers = headers,data=data)

2. Soumettez les données au format json : application/json

data = {'user':'lixue','password':12233}
data_json = json.dumps(params)
requests.post(url,headers = headers,data = data_json)

.

3. Généralement utilisé pour transférer des fichiers (rarement utilisé par les robots) : multipart/form-data

files = {'files':open('c://xxx.txt','rb')}
requests.post(url = url,headers = headers,files = files)

Un exemple de requête API simple

Grâce à la simple introduction ci-dessus, vous pouvez avoir une compréhension générale des requêtes spécifiques. , collectés ici Un centre d'agrégation d'API simple a été créé, qui fournit de nombreuses fonctions utiles. Ce qui suit utilise cette API simple comme simple adresse d'API de démonstration.
Ce petit exemple utilise l'interface API météo pour obtenir la météo des 15 derniers jours. Pensez à vous procurer l'apiKey correspondante et à consulter la documentation d'utilisation spécifique avant d'utiliser cette API. Ce site Web API offre généralement un certain nombre de temps gratuits pour l'API correspondante, qui peuvent être utilisées à des fins d'apprentissage, et prend en charge les requêtes GET et POST. Parfait pour s'entraîner.

GET request

params = {
    "apiKey":'换成你的apikey',
    "area":'武汉市',
}
url = 'https://api.apishop.net/common/weather/get15DaysWeatherByArea'
response = requests.get(url,params)
print(response.text)

POST request

La requête POST correspond ici aux données de post-soumission les plus courantes ci-dessus, principalement le formulaire : application/x-www-form-urlencoded

url = 'https://api.apishop.net/common/weather/get15DaysWeatherByArea'
params = {
    "apiKey":'换成你的apikey',
    "area":'武汉市武昌区',
}
response = requests.post(url,params)
print(response.text)

Appelle cette interface API Généralement, c'est nécessaire d'effectuer un test de code d'état et d'autres informations de retour pour vérifier si la demande est normale. Vous pouvez vous référer à ce qui suit.

params = {
    "apiKey":'换成你的apikey,
    "area":'武汉市',
}
url = 'https://api.apishop.net/common/weather/get15DaysWeatherByArea'
response = requests.post(url,params)
print(response.text)
if response.status_code != 200:
    raise ConnectionError(f'{url} status code is {response.status_code}.')
response = json.loads(response.content)
if 'desc' not in response.keys():
    raise ValueError(f'{url} miss key msg.')
if response['desc'] != '请求成功':
    print(11)

Extraction de données

En fait, l'appel API est très simple, mais le cœur de celui-ci est l'extraction des données dans les informations renvoyées. De manière générale, les informations renvoyées sont sous forme json et les données doivent être extraites. en utilisant des paires clé-valeur de dictionnaire. Le bloc suivant renvoie les informations correspondantes en fonction des données demandées et les extrait. Les informations obtenues seront affichées plus tard.

import requestsimport pandas as pd 
import numpy as npimport jsondef get_url(area):
    url = 'https://api.apishop.net/common/weather/get15DaysWeatherByArea'
    params = {
        "apiKey":'换成你的apikey',
        "area":area,
    }
    response = requests.get(url,params)
    if response.status_code != 200:
        raise ConnectionError(f'{url} status code is {response.status_code}.')
    response = json.loads(response.content)
    if 'desc' not in response.keys():
        raise ValueError(f'{url} miss key msg.')
    if response['desc'] != '请求成功':
        print(11)
    return responsedef  extract_data(web_data):
    data= web_data['result']['dayList']
    weather_data = pd.DataFrame(columns = ['city','daytime','day_weather','day_air_temperature','day_wind_direction','day_wind_power',                                           'night_weather','night_air_temperature','night_wind_direction','night_wind_power'])
    for i in range(len(data)):
        city = data[i]["area"]
        daytime = data[i]["daytime"]
        daytime = daytime[:4]+'-'+daytime[4:6]+'-'+daytime[-2:]
        day_weather = data[i]["day_weather"]
        day_air_temperature = data[i]['day_air_temperature']
        day_wind_direction = data[i]["day_wind_direction"]
        day_wind_power = data[i]['day_wind_power']
        night_weather = data[i]['night_weather']
        night_air_temperature = data[i]["night_air_temperature"]
        night_wind_direction = data[i]['night_wind_direction']
        night_wind_power = data[i]["night_wind_power"]
        c = {"city": city,"daytime": daytime,"day_weather":day_weather,"day_air_temperature":day_air_temperature,
             "day_wind_direction":day_wind_direction,"day_wind_power":day_wind_power,"night_weather":night_weather,
             "night_air_temperature":night_air_temperature,"night_wind_direction":night_wind_direction,
             "night_wind_power":night_wind_power}
        weather_data = weather_data.append(c,ignore_index = True)
    weather_data.to_excel(r"C:\Users\zhangfeng\Desktop\最近十五天天气.xlsx",index = None)
    return weather_dataif __name__ == '__main__':
    print("请输入对应的城市")
    web_data = get_url(input())
    weather_data = extract_data(web_data)

Une partie des résultats est la suivante :

Exemples d'interfaces de données

L'utilisation d'interfaces de données peut être relativement rare dans l'apprentissage quotidien. Dans la plupart des cas, les scénarios d'application des interfaces de données sont utilisés pour récupérer des données dans le. entreprise.Il y en a beaucoup, donc c'est rarement vu.Nous montrons ici l'utilisation de deux interfaces de données rencontrées dans le travail. Pour des raisons de travail, le code affiché est un exemple et ne peut pas être appelé. Vous pouvez vous référer à l'implémentation et aux spécifications de l'appel.

POST请求调用数据接口

# 销售状态查询def id_status(id_dir):
    id_data = pd.read_excel(id_dir,sheet_name="Sheet1") 
    id_data.columns = ['shop', 'Campaign Name','Ad Group Name','Item Id']  # 方便后期处理更改列名
    id_data["Item Id"] = id_data["Item Id"].astype(str)
    id_list = list(id_data['Item Id'])
    print(len(id_list))
    id_list = ','.join(id_list)
    if isinstance(id_list, int):
        id_list = str(id_list)
    id1 = id_list.strip().replace('，', ',').replace(' ', '')
    request_url = "http://xxx.com"
    # 通过item_id查询id状态
    params = {
        "item_id":id1,
    }
    data_json = json.dumps(params) # 属于POST第二种请求方式
    response = requests.post(request_url, data = data_json)
    print(response.text)
    if response.status_code != 200:
        raise ConnectionError(f'{request_url} status code is {response.status_code}.')
    response = json.loads(response.content)
    if 'message' not in response.keys():
        raise ValueError(f'{request_url} miss key msg.')
    if response['message'] != 'ok':
        print(11)
    data= response['result']
    ad_data = pd.DataFrame(columns = ['Item Id','saleStatusName'])
    for j in range(len(data)):
        item_id =data[j]["item_id"]
        saleStatusName = data[j]['saleStatusName']
        c = {"Item Id": item_id,
         "saleStatusName": saleStatusName,
         }
        ad_data = ad_data.append(c,ignore_index = True)
    total_data = pd.merge(ad_data,id_data,on ='Item Id', how ='left')
    df_column =  ['shop', 'Campaign Name','Ad Group Name','Item Id','saleStatusName']
    total_data = total_data.reindex(columns=df_column)
    return total_data

GET请求调用数据接口

### 库存数据查询def Smart_investment_treasure(investment_dir):
    product_data = pd.read_excel(investment_dir,sheet_name="product")
    if len(product_data)>0:
        product_data['商品ID']=product_data['商品ID'].astype(str)
        product_list=list(product_data['商品ID'])
        product_id = ','.join(product_list)
    else:
        product_id='没有数据' 
    return product_id    
def stock_query(investment_dir):
        product_data = pd.read_excel(investment_dir,sheet_name="product")
    if len(product_data)>0:
        product_data['商品ID']=product_data['商品ID'].astype(str)
        product_list=list(product_data['商品ID'])
        product_id = ','.join(product_list)
    else:
        product_id='没有数据' 
    if isinstance(product_id, int):
        product_id = str(id)
    product_id = product_id.strip().replace('，', ',').replace(' ', '')
    request_url = "http://xxx.com"
    # 通过ali_sku查询erpsku
    params = {
        "product_id":product_id,
    }
    
    response = requests.get(request_url, params) #属于GET请求
    if response.status_code != 200:
        raise ConnectionError(f'{request_url} status code is {response.status_code}.')
    response = json.loads(response.content)
    if 'msg' not in response.keys():
        raise ValueError(f'{request_url} miss key msg.')
    if response['msg'] != 'success':
        print(11)
    data= response['data']['data']
    # requestProductId = id.split(',')
    id_state=[]
    overseas_stock=[]
    china_stock=[]
    id_list=[]
    for j in range(len(data)):
        inventory_data= data[j]['list']
        overseas_inventory=0
        ep_sku_list=[]
        sea_test=0
        china_inventory=0
        test="paused"
        id_test=""
        id_test=data[j]['product_id']
        for i in range(len(inventory_data)):
            if inventory_data[i]["simple_code"] in ["FR","DE","PL","CZ","RU"] and inventory_data[i]["erp_sku"] not in ep_sku_list:
                overseas_inventory+=inventory_data[i]["ipm_sku_stock"]
                ep_sku_list.append(inventory_data[i]["erp_sku"])
                sea_test=1
            elif inventory_data[i]["simple_code"] == 'CN':
                china_inventory+=int(inventory_data[i]["ipm_sku_stock"])
        if overseas_inventory>30:
            test="open"
        elif overseas_inventory==0 and china_inventory>100:
            test="open"
        id_list.append(id_test)
        overseas_stock.append(overseas_inventory)
        china_stock.append(china_inventory)           
        id_state.append(test)
    c={"id":id_list,
       "id_state":id_state,
       "海外仓库存":overseas_stock,
       "国内大仓":china_stock       }
    ad_data=pd.DataFrame(c)
    return ad_data

几种常见API调用实例

百度AI相关API

百度API是市面上面比较成熟的API服务，在大二期间由于需要使用一些文本打标签和图像标注工作了解了百度API,避免了重复造轮子，当时百度API的使用比较复杂，参考文档很多不规范，之前也写过类似的百度API调用极其不稳定，但最近查阅了百度API参考文档，发现目前的调用非常简单。
通过安装百度开发的API第三方包，直接利用Python调包传参即可使用非常简单。这里展示一个具体使用，相应安装第三方库官方文档查阅。

'''
第三方包名称：baidu-aip 
百度API 
""" 你的 APPID AK SK """
APP_ID = '你的 App ID'
API_KEY = '你的 Api Key'
SECRET_KEY = '你的 Secret Key'
参考文档：https://ai.baidu.com/ai-doc/NLP/tk6z52b9z
'''
from aip import AipNlp
APP_ID = 'xxxxxx'
API_KEY = '换成你的apikey'
SECRET_KEY = '换成你的SECRET_KEY'
client = AipNlp(APP_ID, API_KEY, SECRET_KEY)
text = "我还没饭吃"
# 调用文本纠错 
client.ecnet(text)

百度地图API

这个API当时为了设计一个推荐体系引入经纬度换算地址，这样为数据计算带来极大的方便，而且对于一般人来说文本地址相比经纬度信息更加直观，然后结合Python一个第三方包实现两个地址之间经纬度计算得出相对的距离。

# https://lbsyun.baidu.com/
# 计算校验SN(百度API文档说明需要此步骤)
import pandas as pd
import numpy as np
import warnings
import requests
import urllib
import hashlib
import json
from geopy.distance import geodesic
location = input("输入所在的位置\n")  # "广州市天河区"
ak = "ak1111" # 参照自己的应用
sk = "sk111111" # 参照自己的应用
url = "http://api.map.baidu.com"
query = "/geocoding/v3/?address={0}&output=json&ak={1}&callback=showLocation".format(location, ak)
encodedStr = urllib.parse.quote(query, safe="/:=&?#+!$,;'@()*[]")
sn = hashlib.md5(urllib.parse.quote_plus(encodedStr + sk).encode()).hexdigest()
# 使用requests获取返回的json
response = requests.get("{0}{1}&sn={2}".format(url, query, sn))
data1=response.text.replace("showLocation&&showLocation(","").replace(")","")
data = json.loads(data1)
print(data)
lat = data["result"]["location"]["lat"]
lon = data["result"]["location"]["lng"]
print("纬度: ", lat, " 经度: ", lon)
distance=geodesic((lat,lon), (39.98028,116.30495))
print("距离{0}这个位置大概{1}".format(location, distance))

有道API

在网上查阅了很多API,前面介绍的几种API,他们携带的请求参数信息相对比较简单，调用实现和基础请求没啥区别，这里找了一个相对而言比较多的请求参数的API,相对而言这种API数据付费API,它的安全性以及具体的实现都相对复杂,但是更适合商用。下面可以简单看看。

import requests
import time
import hashlib
import uuid
youdao_url = 'https://openapi.youdao.com/api'   # 有道api地址
translate_text = "how are you!"
input_text = ""
# 当文本长度小于等于20时，取文本
if(len(translate_text)  20):
    input_text = translate_text[:10] + str(len(translate_text)) + translate_text[-10:]

uu_id = uuid.uuid1()
now_time = int(time.time())
app_id = '1111111'
app_key = '11111111111'
sign = hashlib.sha256((app_id + input_text + str(uu_id) + str(now_time) + app_key).encode('utf-8')).hexdigest()   # sign生成
data = {
    'q':translate_text,   # 翻译文本
    'from':"en",   # 源语言
    'to':"zh-CHS",   # 翻译语言
    'appKey':app_id,   # 应用id
    'salt':uu_id,   # 随机生产的uuid码
    'sign':sign,   # 签名
    'signType':"v3",   # 签名类型，固定值
    'curtime':now_time,   # 秒级时间戳
}
r = requests.get(youdao_url, params = data).json()   # 获取返回的json()内容
print("翻译后的结果：" + r["translation"][0])   # 获取翻译内容

翻译后的结果：你好!
这个API调用中引用了几个真正商用中的一些为了安全性等设置的验证信息，比如uuid、sign、timestamp,这几个在API调用中也是老生常谈的几个概念，是比较全面的。下面简单介绍一下。

uuid

uuid码:UUID是一个128比特的数值，这个数值可以通过一定的算法计算出来。为了提高效率，常用的UUID可缩短至16位。UUID用来识别属性类型，在所有空间和时间上被视为唯一的标识。一般来说，可以保证这个值是真正唯一的任何地方产生的任意一个UUID都不会有相同的值。使用UUID的一个好处是可以为新的服务创建新的标识符。是一种独特的唯一标识符，python 第三方库uuid 提供对应的uuid生成方式，有以下的几种 uuid1(),uuid3(),uuid4(),uuid5()上面采用的是uuid1()生成，还可以使用uuid4()生成。

sign

sign：一般为了防止被恶意抓包，通过数字签名等保证API接口的安全性。为了防止发送的信息被串改，发送方通过将一些字段要素按一定的规则排序后，在转化成密钥，通过加密机制发送，当接收方接受到请求后需要验证该信息是否被篡改过，也需要将对应的字段按照同样的规则生成验签sign，然后在于后台接收到的进行比对，可以发现信息是否被串改过。在上面的例子利用hashlib.sha256()来进行随机产生一段密钥，最后使用.hexdigest()返回最终的密钥。
curtime：引入一个时间戳参数，保证接口仅在一分钟内有效，需要和客户端时间保持一致。避免重复访问。

推荐学习：python视频教程

Ce 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!