பைன் ஸ்கிரிப்ட்டில் தனிப்பயன் ஸ்டாக் ஸ்கிரீனரை உருவாக்க, குறிப்பிட்ட பரிமாற்றங்களிலிருந்து பத்திரங்களை வடிகட்டுவது எப்படி

தனிப்பயன் பைன் ஸ்கிரிப்ட் ஸ்டாக் ஸ்கிரீனரை உருவாக்குவதில் உள்ள சவால்களை சமாளித்தல்

பைன் ஸ்கிரிப்டில் குறிப்பிட்ட பரிமாற்றத்திலிருந்து பத்திரங்களைப் பெறுவது, தனிப்பயன் நிலைமைகள் மூலம் அவற்றை வடிகட்டுவது, பின்னர் அவற்றை விளக்கப்படத்தில் காட்டுவது சாத்தியமா என்று நீங்கள் எப்போதாவது யோசித்திருக்கிறீர்களா? நீங்கள் தனியாக இல்லை! பல டெவலப்பர்கள் மற்றும் வர்த்தகர்கள் பைன் ஸ்கிரிப்ட்டின் உள்ளமைக்கப்பட்ட செயல்பாட்டிற்குள் வரம்புகளை எதிர்கொள்ள மட்டுமே, இந்த யோசனையை சிதைக்க முயன்றனர். 🤔

தொழில்நுட்ப குறிகாட்டிகள் மற்றும் காட்சிப்படுத்தல்களைப் பயன்படுத்துவதில் பைன் ஸ்கிரிப்ட் சிறந்து விளங்கும் அதே வேளையில், குறிப்பிட்ட பரிமாற்றங்களில் மாறும் வகையில் செயல்பட ஸ்டாக் ஸ்கிரீனரை உருவாக்குவது ஒரு சொந்த அம்சம் அல்ல. இருப்பினும், சரியான குறியீட்டு தர்க்கம் மற்றும் படைப்பாற்றல் மூலம், நீங்கள் இந்த தடைகளைச் சுற்றி வேலை செய்யலாம். பாதுகாப்புத் தரவை எவ்வாறு திறம்பட மீட்டெடுப்பது மற்றும் செயலாக்குவது என்பதைப் புரிந்துகொள்வதில் சவால் உள்ளது.

எனது தனிப்பட்ட பயணத்தில், இதுபோன்ற தடைகளை நான் எதிர்கொண்டேன். எடுத்துக்காட்டாக, ஒரு குறிப்பிட்ட பரிமாற்றத்திலிருந்து தொழில்நுட்பப் பங்குகளுக்கான ஸ்கிரீனரை உருவாக்க முயற்சித்தபோது, ​​எக்ஸ்சேஞ்சில் இருந்து அனைத்துப் பத்திரங்களையும் நேரடியாகக் கேட்கும் திறன் பைன் ஸ்கிரிப்ட்டிற்கு இல்லை என்பதை விரைவாக உணர்ந்தேன். இதற்கு வெளியே சிந்திக்கவும், பைன் ஸ்கிரிப்ட் திறன்களுடன் வெளிப்புற தரவு செயலாக்கத்தை இணைக்கவும் தேவைப்பட்டது. 💻

இந்தக் கட்டுரை இந்த தனிப்பயன் செயல்பாட்டைச் செயல்படுத்துவதில் உள்ள முக்கிய சவால்களை உள்ளடக்கியது, குறிப்பாக பத்திரங்களைப் பெறுவதற்கான ஆரம்ப கட்டத்தை நிவர்த்தி செய்கிறது. ஒன்றாக, இந்த லட்சியத் திட்டம் சாத்தியமானதா என்பதை நாங்கள் ஆராய்வோம், மேலும் உங்கள் ஸ்கிரீனரை உயிர்ப்பிப்பதற்கான நடைமுறைப் பணிகளைக் கண்டுபிடிப்போம். 🚀

பைன் ஸ்கிரிப்ட் மற்றும் வெளிப்புற கருவிகள் மூலம் தனிப்பயன் ஸ்டாக் ஸ்கிரீனரை உருவாக்குதல்

முன்பு வழங்கப்பட்ட ஸ்கிரிப்டுகள் தனிப்பயன் ஸ்டாக் ஸ்கிரீனரை உருவாக்குவதில் உள்ள சிக்கலைத் தீர்ப்பதை நோக்கமாகக் கொண்டுள்ளன பைன் ஸ்கிரிப்ட், தளத்தின் உள்ளார்ந்த வரம்புகளை மீறுதல். முதல் ஸ்கிரிப்ட் முழுவதுமாக பைன் ஸ்கிரிப்ட்டிற்குள் வேலை செய்கிறது, டிக்கர் சின்னங்களின் பட்டியலை கைமுறையாக நிர்வகிக்க வரிசைகளை மேம்படுத்துகிறது. இந்தப் பட்டியலை மாறும் வகையில் நிரப்புவதற்கு இது `array.new_string()` மற்றும் `array.push()` கட்டளைகளைப் பயன்படுத்துகிறது. டிக்கர்களை வரையறுத்தவுடன், ஸ்கிரிப்ட் ஒவ்வொரு சின்னத்திற்கும் தரவைப் பெற `request.security()` ஐப் பயன்படுத்துகிறது, தொகுதி வரம்புகள் போன்ற முன் வரையறுக்கப்பட்ட நிபந்தனைகளின் அடிப்படையில் நிகழ்நேர வடிகட்டலை செயல்படுத்துகிறது. வரிசையின் மீது திரும்பத் திரும்பச் செய்வதன் மூலம், ஸ்கிரிப்ட் `label.new()` ஐப் பயன்படுத்தி விளக்கப்படத்தில் நேரடியாக அளவுகோல்களை சந்திக்கும் டிக்கர்களை அடையாளம் கண்டு தனிப்படுத்துகிறது. இந்த அணுகுமுறை எளிமையானது ஆனால் கைமுறையானது, ஸ்கிரிப்ட்டிலேயே டிக்கர் உள்ளீடு தேவைப்படுகிறது. 🚀

இரண்டாவது ஸ்கிரிப்ட் இணைப்பதன் மூலம் மிகவும் மேம்பட்ட பாதையில் செல்கிறது ஜாவாஸ்கிரிப்ட் தரவு ஒருங்கிணைப்பு மற்றும் காட்சிப்படுத்தலுக்கான பைன் ஸ்கிரிப்ட். ஜாவாஸ்கிரிப்ட் வெளிப்புற API உடன் தொடர்பு கொள்ள பயன்படுகிறது, குறிப்பிட்ட பரிமாற்றத்தின் அடிப்படையில் மாறும் வகையில் பத்திரங்களின் தரவைப் பெறுகிறது. `axios.get()` கட்டளை தரவை மீட்டெடுக்கிறது, மேலும் `response.data.filter()` செயல்பாடு தொகுதி போன்ற வடிப்பான்களைப் பயன்படுத்துகிறது. இது பத்திரங்கள் தேர்வு செயல்முறையின் மீது நிகழ்நேர, நிரல் கட்டுப்பாட்டை அனுமதிக்கிறது. வடிகட்டப்பட்ட டிக்கர்கள் ஒரு கோப்பில் `fs.writeFileSync()` ஐப் பயன்படுத்தி சேமிக்கப்படும், அதை பைன் ஸ்கிரிப்ட் பின்னர் படித்து காட்சிப்படுத்துவதற்குப் பயன்படுத்தலாம். இந்த முறை செயல்முறையை நெறிப்படுத்துகிறது ஆனால் வெளிப்புற கருவிகளை உள்ளடக்கிய இரண்டு-படி வேலைப்பாய்வு தேவைப்படுகிறது. 🤔

பைதான் அடிப்படையிலான தீர்வு இதேபோன்ற கலப்பின அணுகுமுறையை எடுக்கிறது, API களில் இருந்து தரவைப் பெறவும் செயலாக்கவும் பைத்தானின் வலுவான நூலகங்களைப் பயன்படுத்துகிறது. API அழைப்புகளைச் செய்ய பைத்தானின் `கோரிக்கைகள்` நூலகத்தைப் பயன்படுத்தும் `fetch_securities()` செயல்பாட்டை ஸ்கிரிப்ட் வரையறுக்கிறது மற்றும் தொகுதி வரம்புகளின் அடிப்படையில் பத்திரங்களை வடிகட்டுகிறது. டிக்கர்ஸ் பின்னர் ஜாவாஸ்கிரிப்ட் தீர்வு போன்ற ஒரு கோப்பில் எழுதப்படும், ஆனால் பைத்தானின் நேரடியான தொடரியல் மூலம். இறுதி காட்சிப்படுத்தலுக்காக இந்தத் தரவை பைன் ஸ்கிரிப்ட்டில் இறக்குமதி செய்யலாம். பைத்தானின் நெகிழ்வுத்தன்மை மற்றும் பயன்பாட்டின் எளிமை இந்த அமைப்பில் பின்தளத்தில் செயலாக்கத்திற்கு சிறந்த தேர்வாக அமைகிறது, குறிப்பாக பெரிய தரவுத்தொகுப்புகள் அல்லது சிக்கலான வடிப்பான்களைக் கையாளும் போது. 💡

சாராம்சத்தில், பைன் ஸ்கிரிப்ட்டின் சார்ட்டிங் பலம் மற்றும் தரவு மீட்டெடுப்பில் அதன் வரம்புகளுக்கு இடையே உள்ள இடைவெளியை எப்படிக் குறைப்பது என்பதை இந்தத் தீர்வுகள் விளக்குகின்றன. தூய பைன் ஸ்கிரிப்டைப் பயன்படுத்தினாலும் அல்லது ஜாவாஸ்கிரிப்ட் அல்லது பைதான் போன்ற வெளிப்புறக் கருவிகளை ஒருங்கிணைத்தாலும், தரவு வடிகட்டுதல் மற்றும் காட்சிப்படுத்துதலுக்கான உகந்த முறைகளை மேம்படுத்துவதில் முக்கியமானது. பைன் ஸ்கிரிப்ட்டில் `request.security()` அல்லது JavaScript இல் `axios.get()` போன்ற கட்டளைகளைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் தங்கள் தனிப்பட்ட தேவைகளுக்கு ஏற்ப சக்திவாய்ந்த மற்றும் தனிப்பயனாக்கப்பட்ட ஸ்கிரீனர்களை உருவாக்க முடியும். கருவிகளின் கலவையானது பைன் ஸ்கிரிப்ட்டின் திறன்களை விரிவுபடுத்துவது மட்டுமல்லாமல் பத்திரப் பகுப்பாய்விற்கு மிகவும் திறமையான மற்றும் அளவிடக்கூடிய அணுகுமுறையை உறுதி செய்கிறது. 🚀

// 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)

மேம்படுத்தப்பட்ட செயல்பாட்டிற்காக பைன் ஸ்கிரிப்ட் ஸ்க்ரீனர்களைத் தனிப்பயனாக்குதல்

ஸ்டாக் ஸ்கிரீனரை உருவாக்குவதற்கான ஒரு முக்கியமான அம்சம் பைன் ஸ்கிரிப்ட் பரிமாற்றங்களிலிருந்து நேரடியாக தரவை அணுகுவதில் அதன் வரம்புகளைப் புரிந்துகொள்கிறது. பைன் ஸ்கிரிப்ட் மேம்பட்ட கணக்கீடுகள் மற்றும் விளக்கப்பட மேலடுக்குகளைக் கையாள முடியும் என்றாலும், பரிமாற்றத்திலிருந்து பத்திரங்களின் முழுமையான பட்டியலை மீட்டெடுப்பதை இது ஆதரிக்காது. இதை நிவர்த்தி செய்ய, டெவலப்பர்கள் பெரும்பாலும் பைன் ஸ்கிரிப்டை வெளிப்புற தரவு மூலங்களுடன் இணைக்கிறார்கள். எடுத்துக்காட்டாக, Alpha Vantage அல்லது Quandl போன்ற APIகளைப் பயன்படுத்துவது, தரவை மீட்டெடுக்க உதவும், இது தொகுதி வரம்புகள், RSI மதிப்புகள் அல்லது நகரும் சராசரி குறுக்குவழிகள் போன்ற நிபந்தனைகளுக்கு செயலாக்கப்படும். இந்த அணுகுமுறை வர்த்தகர்கள் தங்கள் உத்திகளில் தரவு சார்ந்த நுண்ணறிவுகளை இணைக்க அனுமதிக்கிறது. 📊

மற்றொரு நுட்பம் பைன் ஸ்கிரிப்டைப் பயன்படுத்துவது பாதுகாப்பு ஆக்கப்பூர்வமாக செயல்படும். ஒரு குறிப்பிட்ட குறியீட்டிற்கான காலவரையறைகளில் தரவை இழுக்க பாரம்பரியமாக இது பயன்படுத்தப்படுகிறது, சில டெவலப்பர்கள் பல முன் வரையறுக்கப்பட்ட டிக்கர்களில் இருந்து அளவீடுகளை இழுக்க இதைப் பயன்படுத்துகின்றனர். இந்த முறையானது டிக்கர்களின் வரிசையை அமைப்பது, அவற்றின் மூலம் திரும்பச் செய்வது மற்றும் சந்தித்த நிபந்தனைகளின் அடிப்படையில் விளக்கப்படத்தை மாறும் வகையில் புதுப்பித்தல் ஆகியவை அடங்கும். புதிய டிக்கர்களுக்கு டைனமிக் இல்லை என்றாலும், இந்த முறை முன் வரையறுக்கப்பட்ட கண்காணிப்பு பட்டியல்கள் அல்லது பிரபலமான குறியீடுகளுக்கு நன்றாக வேலை செய்கிறது. 💡

உங்கள் ஸ்கிரீனர் பயனுள்ளதாக இருப்பதை உறுதிசெய்ய, வடிகட்டுவதற்கான நிலைமைகளை மேம்படுத்துவது அவசியம். எடுத்துக்காட்டாக, "1M க்கும் அதிகமான வால்யூம் கொண்ட டிக்கர்களை மட்டும் காட்டவும் மற்றும் 50-நாள் SMAக்கு மேல் இறுதி விலை" போன்ற விதிகளைச் சேர்ப்பது ஸ்கிரீனரைச் செயல்பட வைக்கும். இத்தகைய விதிகள் மூலம், வண்ண லேபிள்கள் அல்லது ப்ளாட் மார்க்கர்கள் போன்ற காட்சி எய்ட்ஸ் சாத்தியமான வேட்பாளர்களை விரைவாக அடையாளம் காண உதவும். பைன் ஸ்கிரிப்ட்டின் அம்சங்களை வெளிப்புற தரவு கையாளுதலுடன் இணைப்பதன் மூலம், வர்த்தகர்கள் தங்கள் தனிப்பட்ட வர்த்தக உத்திகளுக்கு ஏற்றவாறு மிகவும் தனிப்பயனாக்கப்பட்ட ஸ்கிரீனர்களை வடிவமைக்க முடியும். 🚀