Pycon 2019 @Shenzhen
. 上一篇文章時間沒錯，2016年10月，一路向南。在金山的最後一篇博文，恰好也是向南回歸廣東的創業創意開始見起色的時間。然後就係回歸廣東，創業3年。
準確離職時間是17年吧，都已經覺得猴年馬月了，近期時間過得好像特別快，而回看離職那時，又覺得特別漫長，或許最近有點閒吧，閒得報了個PyCon的主題，演講了一篇《從Python開始錢賺錢》。
其實內容不是特別深奧，我也是特意簡單概括簡明扼要地講解了一下，說實話，是個有花了10個工作日精心設計了的演講，內容水中點進階，簡單得嚟又要引起疑問。最後還是說了下人生大道理，知行合一。不是說真的教大家怎麼賺錢，好吧，我的確也能盈利，更重要的是，希望可以讓大家感受下知行合一的過程，感受下自己編程的初心，感受下這一份樂趣，希望大家工作的路上不要這麼無聊地996了。
這也權作我這麼一個從Python走出社會的人，對Python社區的一份回報吧。
至於創業沒啥好說的，挺成功的，嗯，餓不死了，後面應該就學怎樣理財，讓我的10萬資本變100萬了：）。
PPT-PDF版本
#!/usr/bin/python
# -*- coding: utf-8 -*-
""" One Trader
Trade some pairs once
"""
__author__ = 'Zagfai'
__date__ = '2019-02'
import datetime
import math
import asyncio
import aiohttp
import json
import logging
import time
import requests
import binance.client as binanceclient
import binance.exceptions as binanceexceptions
from collections import OrderedDict
TRADE_PAIRS = {
# PAIRX: (upper_bound, lower_bound, capital, min_buy/sell_precise)
'ETHUSDT': (350, 100, 3000, 4),
'BNBUSDT': (42, 12, 3000, 2),
'XMRUSDT': (120, 50, 2400, 4),
}
MIN_TRADE = 0.48 # min trade percentage of volatility
class MixClient():
proxies = {
}
# proxies = {'https': 'http://192.168.3.57:1080'}
api_key = "" # NOQA
api_secret = "" # NOQA
def __init__(self, k, s):
self.api_key = k
self.api_secret = s
self.c = binanceclient.Client(
self.api_key, self.api_secret, {
'proxies': self.proxies})
def get_valuable_balance(self):
info = self.c.get_account()
balance = {
i['asset']: round(
float(i['free']),
TRADE_PAIRS.get("%sUSDT", (0, 0, 0, 2))[3])
for i in info['balances']
if float(i['free']) > 0.0001}
return balance
def get_open_orders(self):
orders = self.c.get_open_orders()
return orders
def get_my_last_trade(self, symbol):
trades = self.c.get_my_trades(symbol=symbol, limit=1)
return (round(float(trades[0]['price']), 7),
datetime.datetime.utcfromtimestamp(trades[0]['time']/1000))
def get_orderbook_price(self, symbol):
# trades = self.c.get_recent_trades(symbol='LTCUSDT', limit=1)
ticker = self.c.get_orderbook_ticker(symbol=symbol)
return (float(ticker['askPrice']),
float(ticker['bidPrice']))
def get_orderbook_prices(self):
ticker = self.c.get_orderbook_tickers()
return (float(ticker['askPrice']),
float(ticker['bidPrice']))
def get_all_tickers(self):
return {
i['symbol']: float(round(float(i['price']), 7))
for i in self.c.get_all_tickers()}
def order(self, **params):
return self.c.create_order(**params)
def get_least_volatility(self, pair):
klines = self.c.get_klines(
symbol=pair,
interval=binanceclient.Client.KLINE_INTERVAL_1HOUR,
limit=168)
blines = list(reversed([
round((float(i[2])-float(i[3]))/float(i[3]) * 100, 2)
for i in klines]))
last = blines[0] * 0.8
last6h = sorted(blines[:6])[1]
last24h = sorted(blines[:24])[24//6]
sf2 = sum(blines[22::24])/len(blines[22::24])
sf1 = sum(blines[23::24])/len(blines[23::24])
sf0 = sum(blines[::24])/len(blines[::24])
sf = (sf2 + sf1 + sf0) / 3 * 0.8 # future two hours last week
weighted = last * 0.2 + last6h * 0.3 + last24h * 0.2 + sf * 0.3
if weighted > 1.5:
weighted = 1.5
return round(weighted, 2)
class Counter():
def parts(self, upper, lower, delta):
return math.log(upper / lower) / math.log(delta)
def one_part_cap(self, cap, upper, lower, delta):
return cap / self.parts(upper, lower, delta)
def should_hold(self, cap, upper, lower, nowprice):
if nowprice <= lower or nowprice >= upper:
return None
delta = nowprice / lower
shares_to_hold = cap - self.one_part_cap(cap, upper, lower, delta)
avg_bought_price = (nowprice + upper) / 2
return shares_to_hold / avg_bought_price * nowprice
class LoggingBeautiful():
def assets_balance(tickers, balances, pairs):
sum_usdt = 0
for symb in balances:
pair = '%sUSDT' % symb
if symb == 'USDT':
sum_usdt += balances[symb]
elif symb in balances and pair in tickers:
sum_usdt += balances[symb] * tickers[pair]
logging.info(
"Current assets balance: %s %s" %
(int(sum_usdt),
json.dumps(OrderedDict(sorted(balances.items())))))
def init_hold(tickers, pairs):
logstrs = []
for pi in pairs:
pa = pairs[pi]
s = Counter().should_hold(pa[2], pa[0], pa[1], tickers[pi])
if not s:
s = 0
sh = round(s / tickers[pi], 2)
logstrs.append("%s: %s; " % (pi, sh))
logging.info("Should hold: " + ' '.join(logstrs))
def market_order_info(price_info):
logstrs = []
for pi in price_info.values():
price = pi.get('price')
logstrs.append("%s (%s %s%s%% %s($%s));" % (
pi['pair'], price,
pi.get('trade_mark') == "BUY" and '-' or '+',
round(pi.get('pc_delta_pct', 0), 2), pi.get('quan', 0),
round(pi.get('quan', 0)*pi.get('price', 0), 2)))
logging.info("Market: " + ' '.join(sorted(logstrs)))
def minvol(pairs):
mintradedollar = 10
minvols = []
logstrs = []
for pair in pairs:
pp = pairs[pair]
a = mintradedollar*math.log(pp[0]/pp[1])/pp[2]
minvol = (math.pow(math.e, a) - 1) * 100
minvols.append(minvol)
logstrs.append("%s: %s%%; " % (pair, round(minvol, 2)))
logging.info("Lowest trade volatility: " + ' '.join(logstrs))
if any(i > MIN_TRADE for i in minvols):
logging.error("Error start with too high minimal volatility.")
logging.error("Should lower that MIN_TRADE.")
exit()
def least_volatility(vols):
logging.info("Aim volatility: %s" %
(json.dumps(OrderedDict(sorted(vols.items())))))
def trade_one(c, pi, last_trade_price, balance, least_vola, last_trade_time):
pair = pi['pair']
pi['upper'], pi['lower'], pi['cap'], pi['minbs'] = TRADE_PAIRS[pair]
pi['ask'], pi['bid'] = c.get_orderbook_price(pair)
if last_trade_price < pi['bid']:
pi['price'] = pi['bid']
elif last_trade_price > pi['ask']:
pi['price'] = pi['ask']
else:
pi['price'] = round((pi['ask']+pi['bid'])/2, 7)
delta_price = abs(last_trade_price-pi['price'])
pi['pc_delta_pct'] = delta_price / min(last_trade_price, pi['price']) * 100
s = Counter().should_hold(pi['cap'], pi['upper'], pi['lower'], pi['price'])
if not s:
return False
pi['should_hold'] = round(s, 2)
pi['quan'] = round(pi['should_hold']/pi['price'] - balance, pi['minbs'])
pi['trade_mark'] = pi['quan'] > 0 and 'BUY' or 'SELL'
timedelta = abs(datetime.datetime.now() - last_trade_time)
traded_inhour = timedelta < datetime.timedelta(0, 3600)
traded_in1min = timedelta < datetime.timedelta(0, 60)
if pi['pc_delta_pct'] < MIN_TRADE: # No profitable
return False
if pi['pc_delta_pct'] < least_vola and traded_inhour:
return False
if pi['pc_delta_pct'] < 2.0 and traded_in1min:
return False
if abs(pi['quan']*pi['price']) <= 10: # Minimax trade $10
return False
if pi['ask'] <= pi['lower'] or pi['bid'] <= pi['lower'] or \
pi['ask'] >= pi['upper'] or pi['bid'] >= pi['upper']:
return False
order = c.order(
symbol=pi['pair'],
side=pi['trade_mark'],
type='MARKET',
quantity=abs(pi['quan']))
logging.info("Trade: %s %s %s as $%s (hold $%s) %s%%" %
(pi['pair'], pi['trade_mark'], pi['quan'],
round(pi['quan']*pi['price'], 2),
pi['should_hold'], round(pi['pc_delta_pct'], 2)))
logging.info("OrderDetail: %s" % str(order))
time.sleep(2)
return True
def run(c):
loop = 1
interval_sec = 3
last_trade_price_dict = {
}
last_trade_time_dict = {
}
least_vola_dict = {
}
balances = {
}
ordered = False
while True:
# every 1.5 hours recount least volatility
if loop % (1.5*60*60//interval_sec) == 1:
least_vola_dict = {
i: c.get_least_volatility(i)
for i in TRADE_PAIRS}
LoggingBeautiful.least_volatility(least_vola_dict)
# reset blnc & ltp or ordered
if loop % (3*60//interval_sec) == 1 or ordered:
balances = c.get_valuable_balance()
for i in TRADE_PAIRS:
tinfo = c.get_my_last_trade(i)
last_trade_price_dict[i], last_trade_time_dict[i] = tinfo
# print assets and needfix
if loop % (30*60//interval_sec) == 1 or ordered:
LoggingBeautiful.assets_balance(
c.get_all_tickers(), balances, TRADE_PAIRS)
# check existed order
if ordered and c.get_open_orders():
logging.error("Order not finish.")
time.sleep(5)
break
ordered = False
price_info = {
}
for pair in TRADE_PAIRS:
if not pair.endswith('USDT'):
logging.error("Not support pairs base on other than USDT.")
exit()
pi = {
'pair': pair, 'symb': pair[:-4]}
price_info[pair] = pi
ltp = last_trade_price_dict[pair]
ltt = last_trade_time_dict[pair]
if trade_one(c, pi, ltp, balances.get(pi['symb'], 0),
least_vola_dict[pair], ltt):
ordered = True
if loop % (10*60//interval_sec) == 1 or ordered:
LoggingBeautiful.market_order_info(price_info)
time.sleep(interval_sec)
loop += 1
if __name__ == "__main__":
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s',
level=logging.INFO)
with open('/etc/binanceapikey') as f:
key = f.readline().strip()
sec = f.readline().strip()
logging.info("Trade started.")
LoggingBeautiful.minvol(TRADE_PAIRS)
LoggingBeautiful.init_hold(
MixClient(key, sec).get_all_tickers(), TRADE_PAIRS)
time.sleep(3)
while True:
try:
run(MixClient(key, sec))
except (requests.exceptions.ProxyError,
requests.exceptions.ReadTimeout,
requests.exceptions.ConnectTimeout,
requests.exceptions.ConnectionError,
requests.exceptions.SSLError,
requests.exceptions.RetryError,
requests.packages.urllib3.exceptions.ProtocolError,
binanceexceptions.BinanceAPIException) as e:
logging.warn("Restarted trade because of %s" % str(e))
time.sleep(5)
except OSError as e:
if 'OSError("(104,' in str(e):
logging.warn("Restarted trade because of %s" % str(e))
time.sleep(2)
else:
logging.error("UNKNOWN ERROR OSError: %s" % repr(e))
break
except SystemExit:
logging.error("System exit by SystemExit except.")
break
except Exception as e:
logging.error("UNKNOWN ERROR: %s" % repr(e))
break