[TOC] Je vous en prie.

Les détails

À l'entrée

Comment la plateforme de trading quantitative FMZ fonctionne-t-elle?

FMZ (inventeur) plateforme de négociation quantitativeC'est la communauté de quantification la plus spécialisée dans le domaine de la quantification des transactions, où vous pouvez apprendre, écrire, partager, acheter et vendre des stratégies de quantification; répéter en ligne et utiliser des tablettes analogiques pour effectuer des transactions analogiques; exécuter, publier et visualiser des tablettes physiques; et prendre en charge presque toutes les principales plateformes d'échange de crypto-monnaie.

La série complète de tutoriels

Le blogueur a également publié un article intitulé

• La plateforme d'échange quantitatif FMZ est utilisée pour l'introduction
• Comment écrire un didacticiel pour débutants sur la plateforme de trading quantitative FMZ
• FMZ est une plateforme de négociation quantitative.

Les vidéos suivantes:

• Si vous préférez des tutoriels vidéo, la plateforme officielle de trading quantitatif FMZ est également disponible.Cours sur les transactions quantitatives dans le cloud en ligneJe ne sais pas. Il contientJavaScriptSi vous avez des bases de programmation et de trading, vous pouvez commencer à écrire une stratégie simple en environ deux jours, alors que ceux qui n'ont pas de base de programmation n'ont besoin que d'une ou deux semaines pour apprendre les bases de la programmation.
• DansbilibiliIl y a aussi des tutoriels vidéo:Les inventeurs de la plateforme de négociation quantitative - le concept de l'administrateur La plateforme d'échange quantitatif des inventeurs - aperçu du site Plateforme de trading quantifié par les inventeurs - présentation du déploiement par les gestionnaires Les inventeurs de plateformes de trading quantifiées - créent des disques virtuels Plateforme de négociation quantitative pour les inventeurs - stratégie d'enregistrement, explication du code de copie Plateforme d'échange quantifié par les inventeurs - stratégie complète, paramètres de configuration, importation et exportation La plateforme de trading quantifié par les inventeurs - outils de débogage et fonctionnalités d'édition à distance

Si vous rencontrez un problème, vous pouvez vous rendre sur le forum pour poser des questions, discuter, soumettre des demandes de travail sur la plate-forme, ou téléphoner sur le forum.TélégrammeLes questions sont généralement traitées rapidement.

Prise en charge de l'aide au développement de ChatGPT

La plateforme de trading quantitative FMZ est connectée à ChatGPT comme outil de développement auxiliaire, et vous pouvez cliquer sur "ChatGPT" dans la fenêtre de raccourci du "Control Center" pour accéder à la plateforme.Page des outils de Chat GPT。

Quel est le langage de programmation que je peux utiliser pour réaliser ma stratégie?

La plateforme de négociation quantitative FMZ est prise en chargeJavaScript、TypeScript、Python、C++、PINE、麦语言、Blockly可视化Il a écrit une stratégie de conception.

• JavaScript est un outil de démarrage
• Python pour une introduction rapide
• La version Mylanguage est utilisée dans la documentation
• Les documents du script PINE

SoutenirTypeScriptLe langage, qui est toujours défini comme étant le langage de base de la stratégie.JavaScriptLa stratégie, puis écrire au début du code de la stratégie// @ts-checkVous pouvez également cliquer sur le bouton "TypeScript" en haut à droite de la section "Éditer la stratégie" pour passer à "TypeScript".TypeScriptLa plateforme reconnaît automatiquement le code comme étant:TypeScriptNous vous proposons également des services de compilation et de vérification de type:

• Type de sécurité:TypeScriptLa fonctionnalité de vérification de type statique peut vous aider à détecter les erreurs potentielles lors de l'écriture de votre code et à améliorer la qualité de celui-ci.
• Le code est complété automatiquement:TypeScriptLe système de type de Java vous permet de trouver plus rapidement les attributs et les méthodes que vous voulez lorsque vous écrivez du code, ce qui améliore l'efficacité du développement.
• Une structure de code plus claire: utilisationTypeScriptVous pouvez ainsi mieux organiser et maintenir votre code pour qu'il soit facile à lire et à comprendre.
• Il y a aussi des fonctionnalités puissantes de programmation orientée objet:TypeScriptOffre des fonctionnalités de programmation orientée objet puissantes telles que les interfaces, les classes et les types généraux pour vous aider à écrire un code stratégique plus robuste et réutilisable.

La maîtrise de l'un ou l'autre de ces langages de conception est suffisante. En plus de soutenir la conception de la stratégie de façon à écrire du code, vous pouvez également utiliser la stratégie de création de modules visualisés (Blockly).

BlocklyLes leçons visualisées:

• Les modules visualisés construisent des stratégies de transaction - une idée de base
• Les modules visualisés construisent des stratégies de transaction - progressivement
• Les modules visualisés construisent des stratégies de transaction - en profondeur
• Les modules visualisés construisent des stratégies de transaction - débarquent

ParamètresPythonLes stratégies utiliséesPythonL'interprète

UtilisationPythonSi l'environnement système dans lequel l'hôte se trouve est installé en même temps que la politique écrite, le test ou le disque durPython2etPython3, qui peut être lancé lorsque la politique commence à exécuter la première ligne de configuration de la politiquePythonIl y a aussi une version.#!python3，#!python2Le système peut également spécifier des chemins absolus, par exemple:#!/usr/bin/python3。

Qu'est-ce que le gardien?

Le gérantCompréhensible comme l'exécuteur de votre stratégie de transaction, responsable des demandes de données complexes, de la réception de données, des liaisons réseau, de la retransmission de journaux, etc. Le gestionnaire fonctionne sur votre serveur, même si un site FMZ Quantitative Trading Platform tombe en panne de réseau, cela n'affecte pas votre gestionnaire.Le système Linux，Les fenêtres，Mac OS，Android，ARM Linux est une société basée à RaspberryIl y a aussi le système.Page de l'administrateur，Les étapes d'installation et de mise à jour des hôtes LinuxLes journaux de disque virtuel gérés par le gestionnaire sont conservés dans le répertoire où se trouve le programme du gestionnaire../logs/storageDans le document:db3Je ne sais pasSqliteDans les fichiers de la base de données.SqliteLe logiciel géré est édité directement, et ces extensions sont appeléesdb3Un fichier de base de données en disque dur est un fichier en disque dur.ID。

Accord soutenu

• Actifs blockchain: plus de 50 échanges de crypto-monnaies traditionnelles sont désormais pris en charge.
• Accès au protocole général:Accord général

Sécurité stratégique

Développer des stratégies sur la plate-forme de trading quantitative FMZ, les stratégies sont uniquement visibles par les titulaires de comptes de trading quantitatif FMZ.PythonLes paquets sont chargés dans le code de la stratégie, ce qui permet la localisation de la stratégie.

PythonLa sécurité du code: Pourquoi?PythonC'est un langage open source et très facile à contre-compiler, qui peut être loué si la politique n'est pas autosuffisante, et peut être loué sous forme de sous-compte ou de gestion de l'ensemble de l'hôte si une fuite de politique est crainteuse.

PythonLe code de la stratégie de cryptage: Il y a aussi une autre version.PythonLes auteurs du code stratégique ne cryptent pas lorsqu'ils utilisent le code eux-mêmes, mais le cryptent lorsqu'ils le louent à d'autres.PythonLa stratégie de démarrage est éditée avec le code suivant, qui peut être spécifié pour être utilisé par vous-même ou louéPythonSi la stratégie est en cours d'exécution, le code de la stratégie est crypté.PythonLa version est:Python 2.7Le blogueur a écrit:Python 3.5Le blogueur a écrit:Python 3.6Je ne sais pas.

• Les auteurs de la stratégie utilisent eux-mêmes le code de la stratégie de cryptage et le partagent avec d'autres personnes en utilisant leur code d'enregistrement:#!pythonUtilisez le point de virage pour spécifier la version de l'interpréteur Python,Intervalle, saisissez les instructions de chiffrementencryptÀ défautPythonLes versions sont ajoutées#!encrypt。

  #!python,encrypt
  

  Ou alors

  #!encrypt
  

• Les auteurs de la stratégie utilisent eux-mêmes le code de la stratégie sans le chiffrer et ne le partagent pas avec d'autres utilisateurs en utilisant des codes d'enregistrement:

  #!python,not encrypted
  

  Ou alors

  #!not encrypted
  

Le jugementPythonSi le code de stratégie est crypté, il est efficace d'utiliser le codeos.getenv('__FMZ_ENV__')Retourne la chaîne"encrypt"Cette explication est déjà en vigueur.PythonLe code stratégique.

#!encrypt
def main():
    ret = os.getenv('__FMZ_ENV__')
    # 打印变量ret为字符串encrypt或者ret == "encrypt"为真，即代表加密生效
    Log(ret, ret == "encrypt")

Sécurité des clés

Les informations sensibles telles que les informations de compte configurées sur la plate-forme de trading quantitative FMZ, les chaînes de chiffrement dans les paramètres de la politique sont cryptées sur le côté du navigateur. Ces informations stockées sur la plate-forme de trading quantitative FMZ sont des informations cryptées ("données non explicites"). Seuls les appareils privés de l'utilisateur peuvent être déchiffrés, ce qui améliore considérablement la sécurité des données sensibles.

• La plate-forme prend en charge la localisation et la configuration des informations sensibles telles que les informations relatives aux comptes d'échange et les clés secrètes.

  Sur la page de configuration des informations d'échange de la plate-forme, tous les contrôles de boîtes de texte cryptées masquées sont pris en charge pour charger les fichiers locaux des gestionnaires de manière à configurer le chemin du fichier.RSA KEYLa méthode de vérification, par exemple, explique en détail comment configurer les informations sensibles sur le site de l'appareil où se trouve le programme de l'hôte.

  1, créer des clés publiques ou privées RSA.PKCS#8Il existe de nombreux outils pour créer des clés publiques ou privées, par exemple:opensslJe ne sais pas. 2° Créé dans une bourseRSA KEYCréer et téléchargerLa première étapeLa clé publique a été créée par. 3° estLa première étapeLes clés privées créées danstxtLe format de fichier conserve les répertoires de niveau hôte et peut également conserver d'autres chemins dans le répertoire où se trouve le programme hôte. 4, lors de la configuration des échanges sur FMZAccess KeyLes éditeurs peuvent choisir de remplir la case créée sur l'échange.RSA KEYJe ne sais pas. 5. Configurer les échanges sur FMZSecret KeyDans la zone d'édition, remplissezTroisième étapeLe contenu de l'appareil est placé dans le répertoire de l'administrateur.txtLe chemin du fichier, par exemple le nom du fichier placé:rsaKey.txtLe document et l'administrateur doivent remplir dans le même répertoire:file:///rsaKey.txt; si le document est dans le prochain niveau du répertoire dans lequel se trouve la procédure de l'administrateurrsa_keyIl y a aussi une photo de la photo de la victime.file:///rsa_key//rsaKey.txt◦ Si vous le placezrsaKey.txtLe fichier peut être placé dans d'autres voies, en fonction de la configuration, mais il est important de noter que le fichier ne prend en charge que la mise dans des répertoires ou sous-répertoires de niveau hôte.

  La localisation des clés privées est ainsi plus sécurisée, et les processus détaillés peuvent être consultésVidéo expliquée

Système de détection

Qu'est-ce qu'un système de retouche et à quoi sert-il?

Lorsque vous avez terminé de concevoir une stratégie de négociation quantitative, comment pouvez-vous connaître les bases de votre stratégie, la logique, l'orientation de la stratégie vers les bénéfices? Bien sûr, nous ne pouvons pas utiliser l'or et l'argent réels pour exécuter des stratégies directement sur le marché, nous pouvons tester votre stratégie à l'aide de données historiques.

Les données du système de retouche sont-elles exactes, quelle est l'exactitude des résultats?

La plateforme d'échange quantitatif FMZ divise les modes de retouche en:Retour à niveau disqueetRetour à l'échelle de l'analogie❖ Le retrait au niveau du disque réel est entièrement basé sur les données historiques complètes; le retrait au niveau de l'analogue est basé sur les données de la ligne K réelletickLes deux sont basées sur des données historiques réelles, mais les données à disque réel sont plus précises et les résultats sont plus crédibles.Les mécanismes de retouche FMZMais les retrospectives ne sont que des stratégies basées sur des données historiques, qui ne représentent pas entièrement les tendances futures. Les tendances historiques peuvent se répéter ou s'envoler.

Les questions à prendre en compte lors de la révision des différentes stratégies linguistiques:

JavaScriptetC++La vérification des stratégies est effectuée à l'écran du navigateur, sur le disque dur ou sur la carte mère.Nous avons une application.La plate-forme de trading quantifié FMZ est une plate-forme de trading simulée.Nous avons une application.Les échanges simulés fonctionnent sans installation d'autres logiciels, bibliothèques ou modules.PythonLe retouchage est effectué sur un hôte, peut être retouché sur un serveur public quantifié FMZ, ou peut être retouché sur le propre hôte de l'utilisateur. Le disque réel et le retouchage dépendent du système sur lequel le hôte est installé.PythonSi vous avez besoin d'utiliser certaines bibliothèques, vous devez les installer vous-même (support uniquement des bibliothèques courantes sur le serveur public).

Données dans le système de retouche

FMZ quantifier la plate-forme de trading de la résolution de la résolution à l'échelle de l'analogue et de la résolution à l'échelle du disque réel, deux types de résolution à l'échelle de l'analogue basée sur les cycles générés par l'analogue de la ligne K du fondtick, 12 points de temps de retouche seront générés sur chaque cycle de ligne K de la couche inférieure, tandis que les niveaux de disque réel sont réellement collectés.tickLe mécanisme de retouche de FMZ permet à la stratégie de négocier plusieurs fois sur une ligne K, évitant ainsi de ne pouvoir conclure que des transactions à prix brut, et est plus précis et prend en compte la vitesse de retouche.Les liens。

Mode DEBUG de la politique dans le système de débogage

Débogage des stratégies JavaScript dans DevTools dans Chrome。

Les échanges pris en charge par le système de retouche

• Cryptocurrency (monnaie numérique)

  Nom	Le type	Expliquer
  Bitfinex	Objets des bourses	Les transactions limitées sont prises en charge par exemple:BTC_USD,ETH_USD,LTC_USDAttention, les transactions sont effectuées en devises.USDIl est en dollars.
  Le bien-être	Objets des bourses	Les transactions limitées sont prises en charge par exemple:BTC_USDT,ETH_USDT,ETH_BTC,LTC_BTCJe vous en prie.
  - Ça va.	Objets des bourses	Les transactions limitées sont prises en charge par exemple:BTC_USDT,ETH_USDT,ETH_BTC,LTC_BTCJe vous en prie.
  Les pièces	Objets des bourses	Les transactions limitées sont prises en charge par exemple:BTC_USDT,ETH_USDT,ETH_BTC,LTC_BTCJe vous en prie.
  Les contrats à terme	Objets des marchés à terme	Les transactions limitées sont prises en charge par exemple:BTC_USD,ETH_USDLes transactions sont effectuées en devises.USD, définir le code du contrat spécifique ((voirexchange.SetContractTypeLe code de contrat supporté est le suivant:this_week、next_week、quarter、swap。
  HuobiDM	Objets des marchés à terme	HuobiDM, qui est synonyme de token futures ("contrats de tokens"), prend en charge des paires de transactions limitées telles que:BTC_USD,ETH_USDLes transactions sont effectuées en devises.USD, définir le code du contrat spécifique ((voirexchange.SetContractTypeLe code de contrat supporté est le suivant:this_week、next_week、quarter、swap。
  BitMEX	Objets des marchés à terme	Les paires de transactions sont:XBT_USD, définir le code du contrat spécifique ((voirexchange.SetContractTypeLe code de contrat supporté est le suivant:XBTUSD。
  Futures sur le Binance	Objets des marchés à terme	Les transactions limitées sont prises en charge par exemple:BTC_USDT,ETH_USDTLes transactions sont effectuées en devises.USDT, définir le code du contrat spécifique ((voirexchange.SetContractTypeLe contrat est alors:USDTLes codes de contrats suivants sont pris en charge:swap。
  Options dérivées	Objets des bourses d'options	Les paires de transactions sont:BTC_USD,ETH_USD, définir le code du contrat spécifique ((voirexchange.SetContractTypeLe contrat est un contrat de monnaie locale.

  Les objets de l'échange à terme du système de retouche ne supportent pas temporairement les paires de transactions de commutation dans le code de stratégie.

Le niveau d'analogie

Le repérage au niveau d'analogie est effectué sur la base des données de la ligne K du système de repérage, selon un certain algorithme dans un cadre composé de la valeur du prix le plus élevé, le prix le plus bas, le prix d'ouverture, le prix de clôture du K-Line Bar donné.tickLes données, en temps réeltickLes données sont renvoyées à l'interface demandée.Mécanisme de retouche de niveau analogique quantifié par l'inventeur。

Le niveau du disque

Les tests de niveau réel sont vrais.tickLes données de niveau sont dans la séquence de temps de Bar.tickLa stratégie pour les données de niveau est d'utiliser une vérification au niveau du disque réel plus proche de la réalité.tickLes données enregistrées sont des données réelles et non des générations analogiques. Les données de profondeur sont prises en charge. Les données de l'enregistrement des transactions sur le marché sont prises en charge. Les données de profondeur personnalisées sont prises en charge.GetDepth、GetTradesLes fonctions récupèrent les données de transaction.GetTicker，GetTrades，GetDepth，GetRecords, ne déplace pas plusieurs fois le temps sur l'axe de réévaluation (ne déclenche pas le saut à l'instant de données du marché suivant); pour une des fonctions ci-dessus, l'appel répété déplace le temps de réévaluation sur l'axe de réévaluation (saut à l'instant de données du marché suivant); le réévaluation au niveau du disque ne doit pas être effectuée trop tôt, car il peut ne pas y avoir de données au niveau du disque trop tôt.

Retour à niveau disque actuel：

• Le bien-être
• OKX (en anglais seulement)
• HuobiDM (à propos des futures de jetons)

Optimisation des paramètres du système de détection

La fonctionnalité de réglage des paramètres du système de réglage de la plateforme de trading quantitative FMZ consiste à régler les paramètres en fonction des options de réglage de chaque paramètre lors du réglage, comme suit:

• Valeur minimale: la valeur initiale du paramètre limité.
• Valeur maximale: la valeur maximale après une variation progressive du paramètre limitatif.
• La longueur de pas: les paramètres augmentent la variabilité.

Générer des combinaisons de paramètres et les retoucher (c'est-à-dire que chaque combinaison de paramètres est retouchée une fois); les paramètres de stratégie ne peuvent être ajustés dans le système de retouche que pour les paramètres de type numérique (number) *.

Par exemple, dans la page de révision, vous pouvez définir l'option Optimisation des paramètres:

Les paramètres de modélisation sont réévalués:

Sauvegarder les paramètres de réévaluation

Dans la page d'édition de la stratégie, dans la section "Analogue Retest", vous pouvez définir des options telles que la configuration de la configuration, les paramètres de la configuration pour effectuer la configuration de la configuration. Les paramètres de la configuration sont utilisés pour définir la durée de la configuration, le lieu d'échange, le point de glissement de la configuration et les frais de traitement. Lorsque ces paramètres sont configurés correctement, vous pouvez enregistrer les informations de configuration selon les paramètres de configuration.

PourJavaScriptPar exemple, cliquez sur le bouton "Enregistrer les paramètres de rétrospection dans le fichier source":

JavaScript/Python/C++/麦语言Les paramètres de sauvegarde sont légèrement différents pour le format du fichier source:

/*backtest
start: 2021-06-26 00:00:00
end: 2021-09-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

'''backtest
start: 2021-06-26 00:00:00
end: 2021-09-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''

/*backtest
start: 2021-06-26 00:00:00
end: 2021-09-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

La langue Ma:

(*backtest
start: 2021-06-26 00:00:00
end: 2021-09-23 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD"}]
*)

Source de données personnalisée

Le systèmeGETLa méthode demande une URL personnalisée (adresse Web accessible au public) pour récupérer une source de données externe, avec les paramètres de demande suivants:

Paramètres	Signification	Expliquer
le symbole	Nom de la variété	Par exemple: BTC_USD_OKCoin_EN
- Je vous en prie.	Les bourses	Par exemple: OKCoin_EN
ronde	La précision des prix	Si c'est 3, alors le prix dans la donnée est multiplié par 1000.
- Je suis désolé.	Précision numérique	Si c'est 2, alors le nombre de données que vous renvoyez doit être multiplié par 100.
période	cycle de bar (mm/s)	Par exemple, 60000 pour une demande de barres par minute
profondeur	Nombre de profondeurs	1-20
commerces	Est-ce que vous avez besoin d'un écart de données?	vrai/faux
de	Le temps commence	Le chronomètre Unix
à	Heure de fin	Le chronomètre Unix

Attention:

round与vround是为了避免网络传输过程中浮点数的精度丢失设计的两个参数，价格数据和成交量、订单量数据都采用整型传输。

Voici un exemple de données jointes:

http://customserver:80/data?symbol=BTC_USD_OKCoin_EN&eid=OKCoin_EN&round=3&vround=3&period=900000&from=1564315200&to=1567267200

Le format retourné doit être l'un des deux formats suivants (auto-identifié par le système):

Retour à la normale de niveau Bar

{
    "schema":["time","open","high","low","close","vol"],
    "data":[[1564315200000,9531300,9531300,9497060,9497060,787],[1564316100000,9495160,9495160,9474260,9489460,338]]
}

Données de retouche au niveau de la tique (contient des informations de profondeur de la plaque, l'arithmétique de profondeur est formatée en [prix, quantité], il peut y avoir plusieurs niveaux de profondeur, les demandes sont classées par ordre de prix, les offres sont classées par ordre de prix)

{
    "schema":["time","asks", "bids","trades","close","vol"],
    "data":[[1564315200000,[[9531300,10]], [[9531300,10]],[[1564315200000,0,9531300,10]],9497060,787]]
}

Expliquer

Les champs	Expliquer
le schéma	Spécifiez les propriétés des lignes d'un tableau de données, en minuscules, limitées à time, open, high, low, close, vol, asks, bids
données	Une matrice qui renvoie à une colonne de données stockées par schéma

Formats de données

Les champs	Expliquer
demandes/offres	[Prix, quantité,...]
commerces	[Temps, direction, 0: acheter, 1: vendre, prix, quantité]

Les données sur les taux de financement sont fournies: Par exemple, une revue des contrats à terme sur le Binance nécessite des données supplémentaires sur les taux de fonds et des sources de données personnalisées.

{
	"detail": {},
	"symbol": "futures_binance.eth_usdt.funding",
	"schema": ["time", "open", "high", "low", "close", "vol"],
	"data": [
		[1582876800000, 25289, 25289, 25289, 25289, 0],
		[1582905600000, 30522, 30522, 30522, 30522, 0],
		[1582934400000, 40998, 40998, 40998, 40998, 0],
        ...
		[1626652800000, 198, 198, 198, 198, 0],
		[1626681600000, 691, 691, 691, 691, 0],                  // 相邻的周期间隔8小时
		[1626710400000, 310, 310, 310, 310, 0],                  // 币安资金费率8小时更新一次，资金费率数据为什么为310？
		[1626739200000, 310, 310, 310, 310, 0],                  // 因为和K线数据一样，为了避免网络传输过程中浮点数的精度丢，数据采用整型，所以需要根据round参数处理数据，处理后用于返回给回测系统的数据就为310
		[1626768000000, -41610, -41610, -41610, -41610, 0],      // 资金费率数据也可能为负值
		[1626796800000, -5125, -5125, -5125, -5125, 0],
        ...		
		[1627977600000, 10000, 10000, 10000, 10000, 0]
	]
}

Voici quelques exemples de demandes de données émises par le système de retouche:

http://customserver:80/data?symbol=futures_binance.eth_usdt.funding&eid=Futures_Binance&round=8&vround=5&depth=20&trades=1&custom=0&period=3600000&from=1360771200&to=1628006400

Des exemples de sources de données personnalisées:

Veuillez spécifier la source et l'adresse:http://xxx.xx.x.xx:9090/dataLe serveur de données personnalisé, écrit avec golang:

package main 
import (
    "fmt"
    "net/http"
    "encoding/json"
)

func Handle (w http.ResponseWriter, r *http.Request) {
    // e.g. set on backtest DataSourse: http://xxx.xx.x.xx:9090/data
    // r.URL: /data?depth=20&detail=true&eid=Binance&from=1566820800&period=900000&round=3&symbol=BTC_USDT_Binance&to=1569686400&trades=1&vround=5
    // response
    defer func() {
        // response data
        /* e.g. data
        {
            "schema":["time","open","high","low","close","vol"],
            "data":[
                [1564315200000,9531300,9531300,9497060,9497060,787],
                [1564316100000,9495160,9495160,9474260,9489460,338]
            ]
        }
        */
        ret := map[string]interface{}{
            "schema" : []string{"time","open","high","low","close","vol"},
            "data" : []interface{}{
                []int64{1564315200000,9531300,9531300,9497060,9497060,787},
                []int64{1564316100000,9495160,9495160,9474260,9489460,338},
            },
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()
}

func main () {
    fmt.Println("listen http://localhost:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe(":9090", nil)
}

Le gouvernement a décidé de mettre en place une stratégie de test.JavaScriptPar exemple:

/*backtest
start: 2019-07-28 00:00:00
end: 2019-07-29 00:00:00
period: 1m
exchanges: [{"eid":"OKX","currency":"BTC_USDT","feeder":"http://120.24.2.20:9090/data"}]
*/

function main() {
    var ticker = exchange.GetTicker()
    var records = exchange.GetRecords()
    Log(ticker)
    Log(records)
}

Les données personnalisées dans le système de retouche sont illustrées par un graphique:

La stratégie est d'imprimer des informations:

Moteur de retouche local

La plateforme d'échange quantitatif FMZ est ouverteJavaScriptLangue etPythonMoteur de retouche natif de la langue, qui prend en charge les paramètres de retoucheCycles de la ligne K inférieure。

• Moteur de retouche de langage JavaScript

• Le moteur de retouche Python

Cliquez sur le bouton de raccourci

• Buttons de raccourci pour les pages d'édition de stratégie et les pages de révision de stratégie

  

  UtilisationCtrl + ,Appuyez sur le bouton, la page de redémarrage et la page d'édition de la politiqueCtrlAppuyez sur le bouton,Je ne sais pas.

• Le bouton de raccourci pour enregistrer la stratégie

  

  UtilisationCtrl + sLes mots clés, la politique de sauvegarde.

• Le bouton de raccourci pour démarrer la révision

  

  UtilisationCtrl + bLe bouton pour lancer le test.

Les codes

Fonction d'entrée

Nom de la fonction	Expliquer
main()	Pour les fonctions d'entrée.
onexit()	Pour la fonction de balayage à la sortie normale, la durée d'exécution maximale est de 5 minutes, vous pouvez ne pas déclarer, si le temps est écoulé, une erreur sera signalée.interrompreIl y a une erreur.
onerror()	Les fonctions qui déclenchent l'exécution d'une sortie d'exception ont une durée d'exécution maximale de 5 minutes et ne peuvent pas être déclarées.PythonJe ne sais pas.C++Les stratégies écrites dans le langage ne supportent pas cette fonction.
init()	Pour les fonctions d'initialisation, les stratégies sont appelées automatiquement au début de l'exécution et ne peuvent pas être déclarées.

• Il a écrit:
  • Le système de retouche n'est pas compatibleonerror()Les fonctions.
  • Il a été déclenché en direct.onerror()La fonction n'est plus déclenchéeonexit()Les fonctions.

Une sortie

onexit()La tâche de nettoyage de l'arrière-train, réalisée par l'utilisateur, dure 5 minutes maximum.

function main(){
    Log("开始运行, 5秒后停止，并执行扫尾函数！")
    Sleep(1000 * 5)
}

// 扫尾函数实现
function onexit(){
    var beginTime = new Date().getTime()
    while(true){
        var nowTime = new Date().getTime()
        Log("程序停止倒计时..扫尾开始，已经过去：", (nowTime - beginTime) / 1000, "秒！")
        Sleep(1000)
    }
}

import time 
def main():
    Log("开始运行, 5秒后停止，并执行扫尾函数！")
    Sleep(1000 * 5)

def onexit():
    beginTime = time.time() * 1000
    while True:
        ts = time.time() * 1000
        Log("程序停止倒计时..扫尾开始，已经过去：", (ts - beginTime) / 1000, "秒！")
        Sleep(1000)

void main() {
    Log("开始运行, 5秒后停止，并执行扫尾函数！");
    Sleep(1000 * 5);
}

void onexit() {
    auto beginTime = Unix() * 1000;
    while(true) {
        auto ts = Unix() * 1000;
        Log("程序停止倒计时..扫尾开始，已经过去：", (ts - beginTime) / 1000, "秒！");
        Sleep(1000);
    }
}

init (()

init(), l'utilisateur implémentera la fonction d'initialisationinit()La stratégie s'exécute automatiquement dès son lancement.init()Fonction, pour terminer les tâches d'initialisation conçues dans la stratégie.

function main(){
    Log("程序第一行代码执行！", "#FF0000")
    Log("退出！")
}

// 初始化函数
function init(){     
    Log("初始化！")
}

def main():
    Log("程序第一行代码执行！", "#FF0000")
    Log("退出！")

def init():
    Log("初始化！")

void main() {
    Log("程序第一行代码执行！", "#FF0000");
    Log("退出！");
}

void init() {
    Log("初始化！");
}

Une erreur.

onerror()Il y a une différence entre les deux.onerror()Exécution d'une fonction non prise en chargePython、C++La stratégie de la langue.

function main() {
    var arr = []
    Log(arr[6].Close)
}

function onerror() {
    Log("错误")
}

# python不支持

// C++不支持

Le cadre stratégique classique

DansJavaScript、Python、C++Les stratégies écrites dans la langue doivent être appelées dans le cycle principal de la stratégie.Sleep()Les fonctions ─ sont utilisées pour contrôler la vitesse de rétroaction lors de la mise à jour, et les intervalles de temps pour contrôler les requêtes stratégiques lors de la mise à jour, afin de contrôler la fréquence des demandes d'accès à l'interface API de l'échange ─.

• Le cadre de base de la stratégie de la monnaie numérique est le suivant:

  function onTick(){
      //在这里写策略逻辑，将会不断调用，例如打印行情信息
      Log(exchange.GetTicker())
  }
  
  function main(){
      while(true){
          onTick()
          // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
          Sleep(60000)
      }
  }
  

  def onTick():
      Log(exchange.GetTicker())
  
  def main():
      while True:
          onTick()
          Sleep(60000)
  

  void onTick() {
      Log(exchange.GetTicker());
  }
  
  void main() {
      while(true) {
          onTick();
          Sleep(60000);
      }
  }
  

  Pour donner l'exemple le plus simple, si je voulais afficher un prix de 100 sur un échange toutes les 1 seconde, le nombre de paiements de 1 peut s'écrire comme ceci:

  function onTick(){
      // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用
      exchange.Buy(100, 1)
  }
  
  function main(){
      while(true){
          onTick()
          // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒
          Sleep(1000)
      }
  }
  

  def onTick():
      exchange.Buy(100, 1)
  
  def main():
      while True:
          onTick()
          Sleep(1000)
  

  void onTick() {
      exchange.Buy(100, 1);
  }
  
  void main() {
      while(true) {
          onTick();
          Sleep(1000);
      }
  }
  

Bibliothèque de modèles

Bibliothèque de modèlesest un module de code réutilisable dans la plate-forme de trading quantitative FMZ, une catégorie de code de stratégie.Bibliothèque de modèlesLa création d'une bibliothèque de catégories de modèles dans la bibliothèque de stratégies des comptes auxquels l'inventeur est actuellement connecté à la plate-forme de trading quantitative ne permet pas de modifier la catégorie en stratégie générale.

JavaScriptLa bibliothèque de modèles de langues:

PythonLa bibliothèque de modèles de langues:

C++La bibliothèque de modèles de langues:

• Fonction d'exportation de la bibliothèque de classes de modèles La fonction export est une fonction d'interface de la bibliothèque de classes de modèles, qui peut être appelée en référence à la bibliothèque de classes de modèles. La fonction export est déclarée dans la bibliothèque de classes de modèles et l'exemple de code est le suivant:

  /*
  -- 策略引用该模板以后直接用 $.Test() 调用此方法
  -- main 函数在策略中不会触发, 只做为模板调试的入口
  */
  $.Test = function() {
      Log('Test')
  }
  
  function main() {
      $.Test()
  }
  

  def Test():
      Log("template call")
  
  # 导出Test函数, 主策略可以通过ext.Test()调用
  ext.Test = Test 
  

  // 策略引用该模板以后直接用 ext::Test() 调用此方法
  void Test() {
      Log("template call");
  }
  

• Paramètres pour les bibliothèques de modèles La bibliothèque de modèles peut également configurer ses propres paramètres d'interface. Les paramètres de la bibliothèque de modèles sont utilisés sous forme de variables globales dans le code de la bibliothèque de modèles.

  Les paramètres de la bibliothèque de modèles:

  

  Le code de la bibliothèque de modèles:

  $.SetParam1 = function(p1) {
      param1 = p1
  }
  
  $.GetParam1 = function() {
      Log("param1:", param1)
      return param1
  }
  

  def SetParam1(p1):
      global param1
      param1 = p1
  
  def GetParam1():
      Log("param1:", param1)
      return param1
  
  ext.SetParam1 = SetParam1
  ext.GetParam1 = GetParam1
  

  void SetParam1(float p1) {
      param1 = p1;
  }
  
  float GetParam1() {
      Log("param1:", param1);
      return param1;
  }
  

  Citation précédenteBibliothèque de modèlesLe code de stratégie de l'exemple:

  function main () {
      Log("调用$.GetParam1:", $.GetParam1())
      Log("调用$.SetParam1:", "#FF0000")
      $.SetParam1(20)
      Log("调用$.GetParam1:", $.GetParam1())
  }
  

  def main():
      Log("调用ext.GetParam1:", ext.GetParam1())
      Log("调用ext.SetParam1:", "#FF0000")
      ext.SetParam1(20)
      Log("调用ext.GetParam1:", ext.GetParam1())
  

  void main() {
      Log("调用ext::GetParam1:", ext::GetParam1());
      Log("调用ext::SetParam1:", "#FF0000");
      ext::SetParam1(20);
      Log("调用ext::GetParam1:", ext::GetParam1());
  }
  

  

• Citation de la bibliothèque de modèles

  Une fois que vous avez sélectionné une référence dans la barre de modèle de la page d'édition de la politique, vous pouvez enregistrer la politique.

  

Structure intégrée

Variables mondiales

échange

exchangeConsidéré comme un objet d'échange, le premier objet d'échange ajouté par défaut dans les paramètres de stratégie. Toutes les interactions avec l'échange sont réalisées par des fonctions dans cet objet.

• Réévaluez l'ajout d'objets d'échange

  

• Ajouter des objets d'échange à la page du disque dur

  

L'objet de l'échange ajouté correspond au code.exchangeL'objet:

function main() {
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel())
}

def main():
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel())

void main() {
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel());
}

les échanges

On peut comprendre que le stockage est le même.exchangeL'ensemble de tous les objets d'un échange peut contenir plusieurs objets d'un échange.exchanges[0]Je veux dire,exchange。

Les objets d'échange ajoutés correspondent au code de la stratégieexchanges[0]、exchanges[1]、exchanges[2]Dans le même ordre d'idées,

function main() {
    for(var i = 0; i < exchanges.length; i++) {
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel())
    }
}

def main():
    for i in range(len(exchanges)):
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel())

void main() {
    for(int i = 0; i < exchanges.size(); i++) {
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel());
    }
}

État des commandes

Orderdans la structureStatusLes attributs.

Nom de la constante	Définition	Valeur
Résultats de l'enquête	Pas encore terminé	0
- Je ne sais pas.	C'est fait.	1
L'ordre est annulé.	Elle a été annulée.	2
L'ordre est inconnu.	État inconnu (autres)	3

L'ordre est inconnu.Le statut peut être appeléexchange.GetRawJSON()Pour obtenir des informations sur l'état des commandes originales, consultez les documents de l'échange et consultez les descriptions. Les noms de variables dans les tables peuvent être utilisés directement dans le code de stratégie etOrderLa structureStatusComparaison des attributs, jugement de l'égalité pour déterminer l'état de l'ordre.Nom de la constanteCorrespondantValeurLes autres équations de noms de constantes suivantes ne sont plus décrites.

Type de commande

Orderdans la structureTypeLes attributs.

Nom de la constante	Définition	Valeur
Nom de l'entreprise	Le paiement	0
Nom de l'entreprise	Les enchères	1

Type de poste

Positiondans la structureTypeLes attributs.

Nom de la constante	Définition	Expliquer	À appliquer	Valeur
Résultats de l'analyse	Indique les positions de plusieurs têtes	Utilisation à terme de la monnaie numériqueexchange.SetDirection("closebuy")Régler la direction de l'équilibre et l'équilibre de ce type d'équilibre	Les contrats à terme sur la monnaie numérique	0
PD_SHORT	Indique la position de la tête blanche	Utilisation à terme de la monnaie numériqueexchange.SetDirection("closesell")Régler la direction de l'équilibre et l'équilibre de ce type d'équilibre	Les contrats à terme sur la monnaie numérique	1

Les contrats à terme ouverts

Orderdans la structureOffsetLes attributs.

Nom de la constante	Définition	Valeur
Le code de commande est le même.	Les commandes ouvertes	0
REMARQUE de l'opérateur	Les commandes de stockage	1

Paramètres stratégiques

Les paramètres de stratégie définis sur l'interface de stratégie dans le code de stratégie sont exprimés sous forme de variables globales.JavaScriptDans la langue, les paramètres définis sur l'interface de stratégie peuvent être consultés ou modifiés directement.PythonUtilisé pour modifier les variables globales dans une fonction de stratégieglobalLes mots clés.

Type de paramètre:

Variables	Décrire	Nom de l'auteur	Le type	Par défaut	Expliquer
Numéro	Type de valeur	Nom de l'auteur	Numéros	1	Les stratégies C++ sont de type floating point.
une chaîne	Les chaînes	Nom de l'auteur	Une chaîne.	Bonjour FMZ	Les valeurs par défaut ne nécessitent pas de guillemets et sont traitées comme des chaînes.
boîte à outils	Le tirage au sort	Nom de l'auteur	Boîte de défilement ((selected))	1|2|3	Les variables combox sont elles-mêmes des valeurs numériques qui représentent l'index de la sélection de l'élément de la barre de défilement.
Boole	Sélectionnez	Nom de l'auteur	Bulle (true/false)	vrai	Si le paramètre bool est sélectionné, le paramètre true est sélectionné, si le paramètre bool n'est pas sélectionné, le paramètre false est sélectionné.
secretStreuil	Chaîne de chiffrement	Nom de l'auteur	Chaîne de chiffrement	mot de passe	En utilisant la même méthode que pour les chaînes, les chaînes cryptées sont envoyées cryptées et ne sont pas transmises en texte clair.

• Paramètres d'interface, dans la zone de paramètres de stratégie sous la zone de modification du code de la page d'édition de la politique.
• Les paramètres d'interface existent sous forme de variables globales dans le code de stratégie, c'est-à-dire que les paramètres d'interface peuvent être modifiés dans le code.
• Paramètres d'interface Nom de la variable dans le code de la stratégie: c'est-à-dire dans le graphique ci-dessusnumber、string、combox、bool、secretString。
• Décrire l'option: Nom du paramètre d'interface dans l'interface de stratégie.
• Option de notes: description détaillée des paramètres d'interface qui s'affichent lorsque la souris reste sur les paramètres d'interface.
• Options de type: type du paramètre de l'interface.
• Option de valeur par défaut: la valeur par défaut du paramètre de l'interface.

Les paramètres dépendent des paramètres suivants: On peut définir un paramètre pour que l'autre paramètre soit affiché et caché en fonction du choix de ce paramètre.numberA, est un type de valeur numérique.numberAIl est basé sur un paramètre:isShowALa décision de Boole est fausse.numberAAfficher et masquer.numberALa variable est définie sur les paramètres de l'interface comme:numberA@isShowA。

Il n'y a pas de sélection.isShowAParamètresnumberALes paramètres sont cachés. Pour les paramètres du type de contrôleur de la barre de basculement, les paramètres dépendent en partie pour déterminer si une option de la barre de basculement est égale ou non à une option de la barre de basculement.Valeur de l'indexIl est aussi connu sous le nomisShowALes paramètres, par exemple, sont écrits comme suit:numberA@combox==2。numberALes paramètres sont basés surcomboxSi le paramètre est sélectionné pour afficher ou masquer la troisième option (index 0 correspond à la première option, index 1 correspond à la deuxième option, index 2 correspond à la troisième option).

Les paramètres de l'interface stratégique, les contrôles interactifs, les paramètres de groupage sur les modèles: Il suffit de commencer par la description du paramètre au début du regroupement.(?第一组)Il y a aussi des sites de jeux vidéo.

Les paramètres sont regroupés en fonction des stratégies utilisées:

La valeur par défaut des paramètres est conservée: Si vous souhaitez conserver la valeur par défaut du paramètre de stratégie lors de la réévaluation, vous pouvez cliquer après avoir modifié le paramètre de stratégie.保存回测设置Le bouton.

Les paramètres de stratégie définis peuvent également être conservés sous forme de code dans la stratégie:

/*backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
*/

'''backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
'''

/*backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
*/

Structure des données

Certaines fonctions sont accompagnées de la requête initiale retournée lors de l'appel.JSONLes données, cette matière premièreJSONLes données sont stockées et renvoyées à l'objetInfoDans l'attribut ⇒ aucune donnée n'est renvoyée lors de la retouche car elle n'est pas une visite d'une interface d'échange.InfoAttributs, voici la description des principales propriétés de chaque structure de données.

Le commerce

Retrouvez l'historique de toutes les transactions (autres que les vôtres)exchange.GetTrades()La fonction retourne ∞.

{
    Id      : 9585306,          // 交易记录ID，如果交易所接口没有提供订单ID则使用时间戳填充
    Time    : 1567736576000,    // 时间(Unix timestamp 毫秒)
    Price   : 1000,             // 价格
    Amount  : 1,                // 数量
    Type    : 0                 // 订单类型，参考常量里的订单类型，0即为ORDER_TYPE_BUY，ORDER_TYPE_BUY的值为0
}

Les tiques

Le marché est dominé parexchange.GetTicker()La fonction retourne ∞.

{
    Info    : {...},             // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    High    : 1000,              // 最高价，如果交易所接口没有提供24小时最高价则使用卖一价格填充
    Low     : 500,               // 最低价，如果交易所接口没有提供24小时最低价则使用买一价格填充
    Sell    : 900,               // 卖一价
    Buy     : 899,               // 买一价
    Last    : 900,               // 最后成交价
    Volume  : 10000000,          // 最近成交量，原则上现货成交量单位为交易币种(baseCurrency)，期货成交量单位为合约张数。如果交易所接口没有提供此类数据则使用交易所接口现有的数据填充，例如可能为计价币（quoteCurrency）为单位的成交量
    Time    : 1567736576000      // 毫秒级别时间戳
}

Enregistrement

La normeOHLCStructure utilisée pour tracer les lignes K et les calculs d'indicateurs.exchange.GetRecords()La fonction renvoie l'ensemble de cette structure.RecordLa structure représente une colonne de K, une ligne K.BAR。RecordParmi eux:TimePour cette ligne K, le temps de début du cycle de la colonne.

{
    Time    : 1567736576000,     // 一个时间戳，精确到毫秒，与Javascript的new Date().getTime()得到的结果格式一样
    Open    : 1000,              // 开盘价
    High    : 1500,              // 最高价
    Low     : 900,               // 最低价
    Close   : 1200,              // 收盘价
    Volume  : 1000000            // 交易量，原则上现货成交量单位为交易币（baseCurrency），期货成交量单位为合约张数，如果交易所接口没有提供此类数据则使用交易所接口现有的数据填充，例如可能为计价币（quoteCurrency）为单位的成交量
}

Les ordres

La structure des commandes peut êtreexchange.GetOrder()、exchange.GetOrders()La fonction retourne ∞.exchange.GetOrders()Retournez l'arbre de cette structure ou l'arbre vide (s'il n'y en a pas)Commandes en attenteRetour[], c'est-à-dire un ensemble d'arithmétiques vides).

{
    Info        : {...},         // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    Id          : 123456,        // 交易单唯一标识
    Price       : 1000,          // 下单价格，注意市价单的该属性可能为0或者-1
    Amount      : 10,            // 下单数量，注意市价单的该属性可能为金额并非币数
    DealAmount  : 10,            // 成交数量，如果交易所接口不提供该数据则可能使用0填充
    AvgPrice    : 1000,          // 成交均价，注意有些交易所不提供该数据。不提供、也无法计算得出的情况该属性设置为0
    Status      : 1,             // 订单状态，参考常量里的订单状态，例如：ORDER_STATE_CLOSED
    Type        : 0,             // 订单类型，参考常量里的订单类型，例如：ORDER_TYPE_BUY
    Offset      : 0              // 数字货币期货的订单数据中订单的开平仓方向。ORDER_OFFSET_OPEN为开仓方向，ORDER_OFFSET_CLOSE为平仓方向
    ContractType : ""            // 现货订单中该属性为""即空字符串，期货订单该属性为具体的合约代码
}

Commande de marché

Le marché de la profondeur,exchange.GetDepth()Retournez la fonction dans la structure de donnéesLes offres、Il demandeStructure des données des éléments dans l'arithmétique.

{
    Price   : 1000,              // 价格
    Amount  : 1                  // 数量
}

Profondeur

La profondeur du marché,exchange.GetDepth()La fonction retourne ∞.

{
    Asks    : [...],             // 卖单数组，MarketOrder数组,按价格从低向高排序
    Bids    : [...],             // 买单数组，MarketOrder数组,按价格从高向低排序
    Time    : 1567736576000      // 毫秒级别时间戳
}

Compte

Les informations sur le compte sont fournies parexchange.GetAccount()Retourne la fonction. Les données dans la structure retournée sont liées à la paire de transactions actuellement en cours de configuration.

{
    Info            : {...},     // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    Balance         : 1000,      // 可用计价币数量，现货中如果交易对是BTC_USDT，Balance指的是当前可用USDT数量。U本位期货合约中Balance指的是可用保证金USDT的数量
    FrozenBalance   : 0,         // Balance表示的资产用于挂单的冻结数量
    Stocks          : 1,         // 可用交易币数量，现货中如果交易对是BTC_USDT，Stocks指的是当前可用BTC数量。币本位期货合约中Stocks指的是可用保证金的币（baseCurrency）的数量
    FrozenStocks    : 0          // Stocks表示的资产用于挂单的冻结数量
}

Position de l'appareil

L'information sur les positions détenues dans les transactions futures est fournie par:exchange.GetPosition()La fonction retourne ici.PositionLa structureEnsemble。

{
    Info            : {...},     // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    MarginLevel     : 10,        // 持仓杆杠大小，如果交易所接口没有提供该数据则通过计算填充，可能会有误差
    Amount          : 100,       // 持仓量，持仓合约张数，通常是正整数。注意每个交易所的合约乘数、价值等合约规格可能不一样，下单规则也可能不一样，例如币安合约可以0.1张下单
    FrozenAmount    : 0,         // 仓位冻结量，用于平仓挂单时的临时冻结仓位数量
    Price           : 10000,     // 持仓均价，原则上该属性为仓位总体的平均价格（不参与结算），如果交易所接口没有提供该数据则用交易所接口现有的持仓均价填充（参与结算）
    Profit          : 0,         // 持仓浮动盈亏，原则上为持仓的未实现盈亏，如果交易所接口没有提供该数据则用交易所接口其它盈亏数据填充，盈亏数值的单位和当前合约保证金的单位相同
    Type            : 0,         // PD_LONG为多头仓位，PD_SHORT为空头仓位
    ContractType    : "quarter", // 合约代码，具体可以参看SetContractType函数描述中传入的参数
    Margin          : 1          // 仓位占用的保证金，如果交易所接口没有提供该数据则使用0填充
}

Les futures en crypto-monnaie doivent être prises en compte.exchange.GetPosition()La fonction renvoiePositionStructured Array.FrozenAmount、Profit、MarginAttributs: les données fournies par les bourses ne sont pas uniformes et les objets de différentes bourses sont appelésexchange.GetPosition()La définition des données renvoyées à l'interface peut être différente. Par exemple, certains échanges ne conservent pas de données de blocage de positions dans les données de stockage.FrozenAmountPour 0; si vous avez besoin de calculer certaines données peuvent être utiliséesInfoL'analyse de calcul des données primitives dans l'attribut.

Le marché

Les informations sur le marché des variétés de négociation sont fournies parexchange.GetMarkets()La fonction renvoie ceciMarketLa structureLe dictionnaire。

{
    Symbol          : "btcusdt",       // 该交易品种在交易所的原始名称
    BaseAsset       : "BTC",           // baseCurrency 交易币，统一大写
    QuoteAsset      : "USDT",          // quoteCurrency 计价币，统一大写
    TickSize        : 0.01,            // 价格最小变动数值
    AmountSize      : 0.01,            // 下单量最小变动数值
    PricePrecision  : 2,               // 价格精度，表示价格精确到2位小数
    AmountPrecision : 3,               // 下单量精度，表示下单量精确到3位小数
    MinQty          : 0.001,           // 最小下单量
    MaxQty          : 1000,            // 最大下单量
    MinNotional     : 5,               // 最小下单金额
    MaxNotional     : 9999999,         // 最大下单金额
    CtVal           : 100,             // 合约价值
    Info            : {...}            // 交易所该品种的原始数据
}

Les champs qui ne sont pas pris en charge par l'échange sont ignorés car les échanges ont des niveaux de support différents pour les données d'information sur le marché. Les données de valorisation des champs ci-dessus proviennent des données brutes de l'interface de l'échange.InfoLe contenu des champs.

Fonction globale

Version (en)

Version(), renvoie le numéro de version actuel du système.

Le sommeil (milliseconde)

Sleep(Millisecond)La fonction de sommeil, qui suspend le programme pendant un certain temps.MillisecondLes paramètres sont des milli-secondes, par exemple:Sleep(1000)Pour une seconde de sommeil. Prise en charge d'opérations avec une durée de sommeil inférieure à 1 milliseconde, telles que la configurationSleep(0.1)Le paramètre le plus petit supporté est0.000001, le sommeil à la nanoseconde. 1 nanoseconde est égal à1e-6Il y a des millilitres de seconde.

Attention: En cours d'utilisationPythonLorsque vous écrivez une stratégie linguistique, vous devez utiliser les opérations d'intervalle de consultation et d'attente.Sleep(Millisecond)Fonction. Ne pas recommanderPythonJe ne sais pastimeLe coffretime.sleep(second)Fonction. Parce qu'elle est utilisée dans les stratégiestime.sleep(second)Les fonctions permettent à un programme de stratégie d'attendre des secondes lors de la réévaluation.secondLe paramètre est le nombre de secondes pour mettre en pause), ce qui rend la répétition de la stratégie très lente.

C' est virtuel?

IsVirtual(), pour déterminer si la politique actuelle est exécutée pour la répétition d'analogie. Retour de l'état d'analogietrueLe disque est de retour.false。

Le courrier

Mail(smtpServer, smtpUsername, smtpPassword, mailTo, title, body), Envoyer des messages ⇒ Paramètres de valeur: tous les paramètres sont de type de chaîne ⇒ Retour de valeur: type Boole, envoi réussitrue。 smtpServerPour envoyer le courriersmtpLes servicessmtpUsernameIl y a aussi des gens qui ont des comptes de messagerie.smtpPasswordLe mot de passe SMTP pour la boîte mail (pas le mot de passe de connexion à la boîte mail)mailToPour recevoir des e-mails, il faut un compte de messagerie.titleLe titre de l'e-mail envoyé est:bodyLe contenu des e-mails envoyés, par exemple:

function main(){
    Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
}

def main():
    Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")

Plus de