So filtern Sie Wertpapiere von bestimmten Börsen, um einen benutzerdefinierten Aktien-Screener in Pine Script zu erstellen

Überwindung von Herausforderungen beim Erstellen eines benutzerdefinierten Pine Script Stock Screeners

Haben Sie sich jemals gefragt, ob es möglich ist, Wertpapiere von einer bestimmten Börse in Pine Script abzurufen, sie durch benutzerdefinierte Bedingungen zu filtern und sie dann in einem Diagramm anzuzeigen? Du bist nicht allein! Viele Entwickler und Händler haben versucht, diese Idee zu knacken, stießen jedoch auf Einschränkungen innerhalb der integrierten Funktionalität von Pine Script. 🤔

Während Pine Script sich durch die Anwendung technischer Indikatoren und Visualisierungen auszeichnet, ist die Erstellung eines Aktien-Screeners, der dynamisch an bestimmten Börsen arbeitet, keine native Funktion. Mit der richtigen Codierungslogik und Kreativität können Sie diese Einschränkungen jedoch umgehen. Die Herausforderung besteht darin, zu verstehen, wie Sicherheitsdaten effektiv abgerufen und verarbeitet werden können.

Auf meiner persönlichen Reise stand ich vor ähnlichen Hindernissen. Als ich beispielsweise versuchte, einen Screener für Technologieaktien einer bestimmten Börse zu erstellen, wurde mir schnell klar, dass Pine Script nicht in der Lage ist, alle Wertpapiere einer Börse direkt abzufragen. Dies erforderte unkonventionelles Denken und die Kombination externer Datenverarbeitung mit Pine Script-Funktionen. 💻

In diesem Artikel geht es um die zentralen Herausforderungen bei der Implementierung dieser benutzerdefinierten Funktionalität, insbesondere um den ersten Schritt des Wertpapierabrufs. Gemeinsam prüfen wir, ob dieser ehrgeizige Plan machbar ist und finden praktische Problemumgehungen, um Ihren Screener zum Leben zu erwecken. 🚀

Erstellen eines benutzerdefinierten Stock Screeners mit Pine Script und externen Tools

Die zuvor vorgestellten Skripte zielen darauf ab, das Problem der Erstellung eines benutzerdefinierten Aktien-Screeners zu lösen Kiefernskript, wodurch die inhärenten Einschränkungen der Plattform überwunden werden. Das erste Skript funktioniert vollständig innerhalb von Pine Script und nutzt Arrays, um eine Liste von Tickersymbolen manuell zu verwalten. Es verwendet die Befehle „array.new_string()“ und „array.push()“, um diese Liste dynamisch zu füllen. Sobald die Ticker definiert sind, verwendet das Skript „request.security()“, um Daten für jedes Symbol abzurufen und ermöglicht so eine Echtzeitfilterung basierend auf vordefinierten Bedingungen wie Volumenschwellenwerten. Durch die Iteration über das Array identifiziert und hebt das Skript die Ticker, die die Kriterien erfüllen, direkt im Diagramm mit „label.new()“ hervor. Dieser Ansatz ist einfach, aber manuell und erfordert eine Tickereingabe im Skript selbst. 🚀

Das zweite Skript geht einen fortgeschritteneren Weg, indem es kombiniert JavaScript zur Datenaggregation und Pine Script zur Visualisierung. JavaScript wird verwendet, um mit einer externen API zu interagieren und Wertpapierdaten dynamisch basierend auf der angegebenen Börse abzurufen. Der Befehl „axios.get()“ ruft Daten ab und die Funktion „response.data.filter()“ wendet Filter wie das Volumen an. Dies ermöglicht eine programmatische Kontrolle des Wertpapierauswahlprozesses in Echtzeit. Die gefilterten Ticker werden mit „fs.writeFileSync()“ in einer Datei gespeichert, die Pine Script später lesen und zur Visualisierung verwenden kann. Diese Methode rationalisiert den Prozess, erfordert jedoch einen zweistufigen Workflow mit externen Tools. 🤔

Die Python-basierte Lösung verfolgt einen ähnlichen Hybridansatz und nutzt die robusten Bibliotheken von Python, um Daten von APIs abzurufen und zu verarbeiten. Das Skript definiert eine Funktion „fetch_securities()“, die Pythons „requests“-Bibliothek verwendet, um API-Aufrufe durchzuführen und die Wertpapiere basierend auf Volumenschwellenwerten zu filtern. Die Ticker werden dann in eine Datei geschrieben, ähnlich wie bei der JavaScript-Lösung, jedoch mit der einfachen Syntax von Python. Diese Daten können zur endgültigen Visualisierung in Pine Script importiert werden. Die Flexibilität und Benutzerfreundlichkeit von Python machen es zu einer hervorragenden Wahl für die Backend-Verarbeitung in diesem Setup, insbesondere beim Umgang mit großen Datenmengen oder komplexen Filtern. 💡

Im Wesentlichen zeigen diese Lösungen, wie die Lücke zwischen den Diagrammstärken von Pine Script und seinen Einschränkungen beim Datenabruf geschlossen werden kann. Unabhängig davon, ob Sie reines Pine-Skript verwenden oder externe Tools wie JavaScript oder Python integrieren, liegt der Schlüssel in der Nutzung optimierter Methoden zur Datenfilterung und -visualisierung. Durch den Einsatz von Befehlen wie „request.security()“ in Pine Script oder „axios.get()“ in JavaScript können Entwickler leistungsstarke und individuelle Screener erstellen, die auf ihre individuellen Bedürfnisse zugeschnitten sind. Die Kombination der Tools erweitert nicht nur die Möglichkeiten von Pine Script, sondern sorgt auch für einen effizienteren und skalierbareren Ansatz bei der Wertpapieranalyse. 🚀

// Step 1: Define security list (manual input as Pine Script lacks database access)
var securities = array.new_string(0)
array.push(securities, "AAPL") // Example: Apple Inc.
array.push(securities, "GOOGL") // Example: Alphabet Inc.
array.push(securities, "MSFT") // Example: Microsoft Corp.

// Step 2: Input filter criteria
filter_criteria = input.float(100, title="Minimum Volume (in millions)")

// Step 3: Loop through securities and fetch data
f_get_filtered_securities() =>
    var filtered_securities = array.new_string(0)
    for i = 0 to array.size(securities) - 1
        ticker = array.get(securities, i)
        [close, volume] = request.security(ticker, "D", [close, volume])
        if volume > filter_criteria
            array.push(filtered_securities, ticker)
    filtered_securities

// Step 4: Plot filtered securities on the chart
var filtered_securities = f_get_filtered_securities()
for i = 0 to array.size(filtered_securities) - 1
    ticker = array.get(filtered_securities, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

// JavaScript Code: Fetch and filter securities from an API
const axios = require('axios');
async function fetchSecurities(exchange) {
    const response = await axios.get(`https://api.example.com/securities?exchange=${exchange}`);
    const filtered = response.data.filter(security => security.volume > 1000000);
    return filtered.map(security => security.ticker);
}
// Save tickers to a file for Pine Script
const fs = require('fs');
fetchSecurities('NASDAQ').then(tickers => {
    fs.writeFileSync('filtered_tickers.txt', tickers.join(','));
});

// Pine Script Code: Import and visualize filtered securities
// Load tickers from an external source
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")

// Plot the tickers on the chart
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

# Python Code: Fetch securities and write filtered data to a file
import requests
def fetch_securities(exchange):
    response = requests.get(f'https://api.example.com/securities?exchange={exchange}')
    data = response.json()
    return [sec['ticker'] for sec in data if sec['volume'] > 1000000]

tickers = fetch_securities('NASDAQ')
with open('filtered_tickers.txt', 'w') as file:
    file.write(','.join(tickers))

// Pine Script Code: Visualize pre-filtered data
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

Anpassen der Pine-Skript-Screener für erweiterte Funktionalität

Ein entscheidender Aspekt beim Aufbau eines Aktien-Screeners Kiefernskript ist sich seiner Grenzen beim Zugriff auf Daten direkt von Börsen bewusst. Während Pine Script erweiterte Berechnungen und Chart-Overlays verarbeiten kann, unterstützt es nicht nativ das Abrufen einer vollständigen Wertpapierliste von einer Börse. Um dieses Problem zu lösen, kombinieren Entwickler Pine Script häufig mit externen Datenquellen. Beispielsweise kann die Verwendung von APIs wie Alpha Vantage oder Quandl dabei helfen, Daten abzurufen, die dann für Bedingungen wie Volumenschwellenwerte, RSI-Werte oder gleitende Durchschnittsübergänge verarbeitet werden können. Dieser Ansatz ermöglicht es Händlern, datengesteuerte Erkenntnisse in ihre Strategien zu integrieren. 📊

Eine andere Technik ist die Verwendung von Pine Scripts Sicherheit kreativ arbeiten. Während es traditionell zum Abrufen von Daten über Zeitrahmen für ein bestimmtes Symbol verwendet wird, nutzen einige Entwickler es, um Metriken aus mehreren vordefinierten Tickern abzurufen. Bei dieser Methode wird ein Array von Tickern eingerichtet, diese durchlaufen und das Diagramm basierend auf den erfüllten Bedingungen dynamisch aktualisiert. Obwohl diese Methode für neue Ticker nicht dynamisch ist, eignet sie sich gut für vordefinierte Watchlists oder beliebte Indizes. 💡

Um sicherzustellen, dass Ihr Screener effektiv ist, ist es wichtig, die Filterbedingungen zu optimieren. Beispielsweise kann das Hinzufügen von Regeln wie „Nur Ticker mit einem Volumen von mehr als 1 Million und einem Schlusskurs über dem 50-Tage-SMA anzeigen“ dazu führen, dass ein Screener umsetzbar ist. Bei solchen Regeln helfen visuelle Hilfsmittel wie farbige Etiketten oder Plotmarkierungen dabei, potenzielle Kandidaten schnell zu identifizieren. Durch die Kombination der Funktionen von Pine Script mit der externen Datenverarbeitung können Händler hochgradig individuelle Screener erstellen, die auf ihre individuellen Handelsstrategien zugeschnitten sind. 🚀