$ brew tap kei-sato/usdex
$ brew install usdex
$ usdex -p 2.5 -v
1(USD) => 122.54078(JPY)
2.5(USD) => 306.35195(JPY)
Gist est ici https://gist.github.com/kei-sato/98675769952ec7538d6a
Voici comment activer l'installation d'infusion Autoriser l'installation des outils de ligne de commande en Python
Les informations d'échange actuelles sont publiées dans différents formats, y compris JSON ([http://api.aoikujira.com/kawase/[/ ./ ./http://api.aoikujira.com/kawase/)). Puisqu'il y avait une personne, j'ai utilisé ceci pour créer une commande pour convertir des dollars en yens à partir de la ligne de commande. Tout d'abord, vérifiez la valeur renvoyée par l'API.
$ curl -s http://api.aoikujira.com/kawase/json/usd | jq .
{
"result": "ok",
"basecode": "USD",
"update": "2015-07-13 17:41:44",
"source": "*",
"API_URL": "http://api.aoikujira.com/kawase/",
...(Omission)
"JPY": "123.44644",
"KRW": "1131.46557",
"HKD": "7.75138",
...(Omission)
"LBP": "1514.20449"
}
Vous pouvez voir que JPY contient la valeur de 1 dollar converti en yen. (Il y a aussi KRW (won) et HKD (dollar de Hong Kong)) Pour le moment, écrivons un script simple qui extrait simplement cette valeur et la multiplie par la valeur numérique donnée par l'argument.
exchange1.py
#coding:utf-8
import sys
import urllib
import json
URL = "http://api.aoikujira.com/kawase/json/usd"
if __name__ == "__main__":
price = float(sys.argv[1])
response = urllib.urlopen(URL)
data = json.loads(response.read())
rate = float(data[u'JPY'])
print "{0}(USD) => {1}(JPY)".format(1, rate)
print "{0}(USD) => {1}(JPY)".format(price, price * rate)
$ python exchange1.py 2.5
1(USD) => 122.568(JPY)
2.5(USD) => 306.42(JPY)
Quand j'ai donné 2,5 (dollar) comme argument, la réponse était de 306 yens. Je retourne également le yen par dollar.
Vous avez atteint votre objectif. C'est tout.
J'aimerais y aller, mais cette fois je veux le publier, donc je vais l'améliorer un peu.
Il n'est pas bon de frapper l'API en continu, je vais donc essayer d'accéder à l'API une fois par jour.
import urllib
import json
URL = "http://api.aoikujira.com/kawase/json/usd"
FPATH = "/tmp/exchange"
def readCache():
with open(FPATH, 'r') as f:
body = f.read()
return body
def writeCache(body):
with open(FPATH, 'w') as f:
f.write(body)
def fetchRates():
# fetch rate list from remote
response = urllib.urlopen(URL)
body = response.read()
writeCache(body)
return body
Accédez à l'API avec fetchRates et enregistrez le contenu dans un fichier avec writeCache. Lisez le contenu enregistré dans le fichier avec readCache.
import os.path
from datetime import date, datetime
FPATH = "/tmp/exchange"
def hasCache():
if os.path.isfile(FPATH):
d = date.today()
today = datetime.combine(d, datetime.min.time())
mtime = datetime.fromtimestamp(os.path.getmtime(FPATH))
if mtime > today:
return True
return False
Vérifie avec HasCache les fichiers de cache et renvoie True si la dernière date de modification est aujourd'hui. Renvoie False si le fichier cache n'existe pas ou si le fichier cache a été modifié pour la dernière fois avant aujourd'hui.
Lorsqu'ils sont combinés, cela ressemble à ceci:
exchange2.py
#!/usr/bin/env python
import sys
import os.path
from datetime import date, datetime
import urllib
import json
URL = "http://api.aoikujira.com/kawase/json/usd"
FPATH = "/tmp/exchange"
def hasCache():
if os.path.isfile(FPATH):
d = date.today()
today = datetime.combine(d, datetime.min.time())
mtime = datetime.fromtimestamp(os.path.getmtime(FPATH))
if mtime > today:
return True
return False
def readCache():
with open(FPATH, 'r') as f:
body = f.read()
return body
def writeCache(body):
with open(FPATH, 'w') as f:
f.write(body)
def fetchRates():
# fetch rate list from remote
response = urllib.urlopen(URL)
body = response.read()
writeCache(body)
return body
if __name__ == "__main__":
price = float(sys.argv[1])
if hasCache():
body = readCache()
else:
body = fetchRates()
data = json.loads(body)
rate = float(data[u'JPY'])
print "{0}(USD) => {1}(JPY)".format(1, rate)
print "{0}(USD) => {1}(JPY)".format(price, price * rate)
Si hasCache renvoie True, readCache le lira à partir du fichier de cache, et si hasCache retourne False, fetchRates le récupérera à partir de l'API.
Vous pouvez facilement créer des outils de ligne de commande en utilisant argparse
options.py
#coding:utf-8
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='convert usd to any currency.')
parser.add_argument('-p', '--price', nargs='?', type=float, help='price', default=1.0)
parser.add_argument('-c', '--currency', nargs='?', help='currency', default=u'JPY')
parser.add_argument('-r', '--reverse', action='store_true', help='reverse the direction')
parser.add_argument('-v', '--verbosity', action='count', help='increase output verbosity')
args = parser.parse_args()
price = args.price
currency = args.currency
reverse = args.reverse
verbosity = args.verbosity
print "price:", price
print "currency:", currency
print "reverse:", reverse
print "verbosity:", verbosity
Enregistrez ce qui précède et exécutons-le
#Aucun argument
$ python options.py
price: 1.0
currency: JPY
reverse: False
verbosity: None
#Avec argument
$ python options.py -p 2.5 -c EUR -r -vvv
price: 2.5
currency: EUR
reverse: True
verbosity: 3
#Le message d'aide est généré automatiquement
$ python options.py -h
usage: options.py [-h] [-p [PRICE]] [-c [CURRENCY]] [-r] [-v]
convert usd to any currency.
optional arguments:
-h, --help show this help message and exit
-p [PRICE], --price [PRICE]
price
-c [CURRENCY], --currency [CURRENCY]
currency
-r, --reverse reverse the direction
-v, --verbosity increase output verbosity
C'est facile!
Le tout jusqu'à ce point est sur Gist https://gist.github.com/kei-sato/98675769952ec7538d6a
Recommended Posts