பைத்தானின் இன்

Gabriel Martim

புதன், 1 ஜனவரி, 2025 ’அன்று’ முற்பகல் 10:50:18

பைத்தானின் தேடல் பொறிமுறையின் நுணுக்கங்களை ஆராய்தல்

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

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

வரைபடத்தில் தனித்துவமான செங்குத்து கோடுகளை உருவாக்குவது மிகவும் குழப்பமான கண்டுபிடிப்புகளில் ஒன்றாகும். பட்டியலில் முற்றிலும் வேறுபட்ட நிலைகளில் எண்களைக் கண்டறியும் நேரம் ஏன் கிட்டத்தட்ட ஒரே மாதிரியாக இருக்கும்? இது பைத்தானின் உள் நேர பொறிமுறையின் வினோதமாக இருக்கலாம் அல்லது ஆழமான ஏதாவது இருக்கலாம் "உள்" ஆபரேட்டரின் செயல்பாடு?

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

கட்டளை	பயன்பாட்டின் உதாரணம்
time.time_ns()	இந்த கட்டளை தற்போதைய நேரத்தை நானோ வினாடிகளில் மீட்டெடுக்கிறது. குறிப்பிட்ட குறியீடு தொகுதிகளின் செயல்பாட்டின் நேரத்தை அளவிடுவது போன்ற செயல்திறன்-முக்கியமான பணிகளில் அதிக துல்லியமான நேரத்திற்கு இது பயன்படுத்தப்படுகிறது.
np.linspace()	ஒரு குறிப்பிட்ட இடைவெளியில் சம இடைவெளி எண்களை உருவாக்குகிறது. ஒரு பெரிய வரிசைக்கான குறியீடுகளை உருவாக்குவது போன்ற பெரிய தரவுத்தொகுப்புகளில் சோதனைப் புள்ளிகளை உருவாக்குவதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.
plt.scatter()	தரவு புள்ளிகளைக் காட்சிப்படுத்த ஒரு சிதறல் சதியை உருவாக்குகிறது. பட்டியல் அல்லது வரிசைக்குள் தேடல் நேரங்களுக்கும் குறியீடுகளுக்கும் இடையிலான உறவைக் காட்ட இது ஸ்கிரிப்ட்டில் பயன்படுத்தப்படுகிறது.
plt.plot()	தொடர்ச்சியான வரி சதியை உருவாக்குகிறது. வெவ்வேறு அல்காரிதம்களில் தேடல் செயல்திறனை ஒப்பிடுவது போன்ற தரவுகளின் போக்குகளைக் காட்சிப்படுத்த இது உதவுகிறது.
binary_search()	பைனரி தேடல் அல்காரிதத்தை செயல்படுத்தும் தனிப்பயன் செயல்பாடு. தேடல் இடத்தை பாதியாகப் பிரிப்பதன் மூலம் வரிசைப்படுத்தப்பட்ட பட்டியலை இது திறமையாகத் தேடுகிறது.
range(start, stop, step)	வரையறுக்கப்பட்ட படியுடன் எண்களின் வரிசையை உருவாக்குகிறது. ஸ்கிரிப்ட்டில், துல்லியமான அளவீட்டிற்காக ஒரு பட்டியல் அல்லது வரிசையின் குறிப்பிட்ட குறியீடுகளை மீண்டும் செய்ய உதவுகிறது.
plt.xlabel()	ப்ளாட்டின் x அச்சில் லேபிளைச் சேர்க்கிறது. எடுத்துக்காட்டுகளில், வரைபட வெளியீட்டில் தெளிவுக்காக அளவிடப்படும் குறியீடுகள் அல்லது நேரங்களை தெளிவாக லேபிளிட இது பயன்படுகிறது.
zip(*iterables)	பன்மடங்கு இட்டேரபிள்களை ஒரு டூப்பிள்களின் ஒற்றை இயக்கக்கூடியதாக இணைக்கிறது. இது tuples பட்டியலிலிருந்து வரைவதற்கு x மற்றும் y மதிப்புகளைப் பிரிக்கப் பயன்படுகிறது.
np.arange()	சம இடைவெளி மதிப்புகளுடன் NumPy வரிசையை உருவாக்குகிறது. செயல்திறன் சோதனைக்காக விரைவாகவும் திறமையாகவும் சோதனை தரவுத்தொகுப்புகளை உருவாக்க இது பயன்படுகிறது.
plt.legend()	பல தரவுத்தொகுப்புகளை வேறுபடுத்துவதற்காக ஒரு புளொட்டில் ஒரு புராணக்கதையைக் காட்டுகிறது. வெவ்வேறு தேடல் முறைகளின் செயல்திறன் முடிவுகளை வேறுபடுத்துவதற்கு இது ஸ்கிரிப்ட்டில் பயன்படுத்தப்படுகிறது.

பைத்தானின் "இன்" ஆபரேட்டர் செயல்திறனுக்குப் பின்னால் உள்ள மர்மத்தை அவிழ்த்தல்

பகுப்பாய்வு செய்யும் போது "உள்" பைத்தானில் உள்ள ஆபரேட்டர், முதல் ஸ்கிரிப்ட் ஒரு பட்டியலின் வெவ்வேறு பகுதிகளில் எண்ணைக் கண்டறிய எடுக்கும் நேரத்தை அளவிடுகிறது. இந்த அணுகுமுறை பலப்படுத்துகிறது time.time_ns() உயர் துல்லியத்திற்கான செயல்பாடு. எண்களின் பெரிய பட்டியலை மீண்டும் செய்வதன் மூலம், ஒவ்வொரு எண்ணும் பட்டியலுக்குள் இருக்கிறதா என்பதைச் சரிபார்க்க எவ்வளவு நேரம் ஆகும் என்பதை ஸ்கிரிப்ட் பதிவு செய்கிறது. பட்டியலில் உள்ள எண்ணின் நிலையுடன் தேடல் நேரம் எவ்வாறு தொடர்புடையது என்பதைக் காட்சிப்படுத்துவதன் மூலம் முடிவுகள் சிதறல் சதித்திட்டமாகத் திட்டமிடப்பட்டுள்ளன. பைதான் எவ்வாறு தொடர்ச்சியான தேடல்களை உள்நாட்டில் கையாளுகிறது என்பதைப் புரிந்துகொள்வதற்கும், அதன் மீது வெளிச்சம் போடுவதற்கும் இத்தகைய முறை பயனுள்ளதாக இருக்கும். மீண்டும் செயல்படும் பொறிமுறை. 📈

செயல்திறன் மற்றும் துல்லியத்தை மேம்படுத்த NumPy வரிசைகளை இணைப்பதன் மூலம் இரண்டாவது ஸ்கிரிப்ட் ஒரு படி மேலே செல்கிறது. NumPy, அதன் உகந்த எண்ணியல் செயல்பாடுகளுக்கு பெயர் பெற்றது, பெரிய வரிசைகளை உருவாக்கவும், தரவை திறமையாக கையாளவும் அனுமதிக்கிறது. பயன்படுத்தி np.linspace(), சோதனை புள்ளிகள் வரிசை முழுவதும் சமமாக உருவாக்கப்படுகின்றன. பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது இந்த அணுகுமுறையின் நன்மை தெளிவாகத் தெரிகிறது, ஏனெனில் NumPy இன் செயல்திறன் கணக்கீட்டு மேல்நிலையை கணிசமாகக் குறைக்கிறது. நிஜ உலகக் காட்சிகளில், பெரிய அளவிலான தரவைச் செயலாக்கும்போது அல்லது அல்காரிதம்களை மேம்படுத்தும் போது இத்தகைய துல்லியமும் வேகமும் முக்கியமானதாக இருக்கும். 🚀

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

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

பைத்தானில் "இன்" ஆபரேட்டரின் செயல்திறனை பகுப்பாய்வு செய்தல்

பைத்தானைப் பயன்படுத்தி பட்டியல் தேடல் செயல்திறனைப் பல்வேறு முறைகள் மூலம் பகுப்பாய்வு செய்ய, மீண்டும் மீண்டும் தேடுதல் மற்றும் விவரக்குறிப்பு கருவிகள்.

# Solution 1: Timing with Python's built-in list search
import time
import matplotlib.pyplot as plt
# Parameters
list_size = 100000
points = 100000
lst = list(range(list_size))
results = []
# Measure search time for different indices
for number in range(0, list_size + 1, int(list_size / points)):
    start_time = time.time_ns()
    if number in lst:
        end_time = time.time_ns()
        elapsed_time = (end_time - start_time) / 1e9  # Convert ns to seconds
        results.append((elapsed_time, number))
# Extract and plot results
x_values, y_values = zip(*results)
plt.scatter(y_values, x_values, c='red', marker='o', s=5)
plt.xlabel('List Index')
plt.ylabel('Time (s)')
plt.title('Search Time vs Index in Python List')
plt.grid(True)
plt.show()

மேம்படுத்தப்பட்ட துல்லியத்திற்காக NumPy உடன் மேம்படுத்துதல் மற்றும் விவரக்குறிப்பு

தேடல் செயல்பாடுகளின் போது செயல்திறன் மற்றும் விவரக்குறிப்பு துல்லியத்தை மேம்படுத்த NumPy வரிசைகளைப் பயன்படுத்துதல்.

# Solution 2: Using NumPy arrays for better profiling
import numpy as np
import time
import matplotlib.pyplot as plt
# Parameters
list_size = 100000
points = 1000
array = np.arange(list_size)
results = []
# Measure search time for different indices
for number in np.linspace(0, list_size, points, dtype=int):
    start_time = time.time_ns()
    if number in array:
        end_time = time.time_ns()
        elapsed_time = (end_time - start_time) / 1e9
        results.append((elapsed_time, number))
# Extract and plot results
x_values, y_values = zip(*results)
plt.plot(y_values, x_values, label='NumPy Search', color='blue')
plt.xlabel('Array Index')
plt.ylabel('Time (s)')
plt.title('Search Time vs Index in NumPy Array')
plt.legend()
plt.grid(True)
plt.show()

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

தேடல் சிக்கலைக் குறைக்கவும் வேகத்தை மேம்படுத்தவும் வரிசைப்படுத்தப்பட்ட பட்டியல்களுக்கு பைனரி தேடல் செயல்பாட்டை உருவாக்குதல்.

# Solution 3: Binary search implementation
def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1
# Parameters
list_size = 100000
points = 1000
lst = list(range(list_size))
results = []
# Measure binary search time
for number in range(0, list_size, int(list_size / points)):
    start_time = time.time_ns()
    binary_search(lst, number)
    end_time = time.time_ns()
    elapsed_time = (end_time - start_time) / 1e9
    results.append((elapsed_time, number))
# Extract and plot results
x_values, y_values = zip(*results)
plt.plot(y_values, x_values, label='Binary Search', color='green')
plt.xlabel('List Index')
plt.ylabel('Time (s)')
plt.title('Binary Search Time vs Index')
plt.legend()
plt.grid(True)
plt.show()

பைத்தானின் "இன்" ஆபரேட்டரின் டைமிங் மெக்கானிசத்தை வெளிப்படுத்துதல்

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

கருத்தில் கொள்ள வேண்டிய மற்றொரு முக்கியமான காரணி, ஒற்றை-திரிக்கப்பட்ட செயல்பாட்டின் போது பைத்தானின் குளோபல் மொழிபெயர்ப்பாளர் பூட்டின் (ஜிஐஎல்) தாக்கம் ஆகும். உடன் சோதனை செய்யும் போது time.time_ns(), பைதான் ஒரு மையத்தில் இயங்கினாலும், சிஸ்டத்தில் உள்ள மற்ற த்ரெட்களால் செயல்பாடுகள் குறுக்கிடப்படலாம் அல்லது தாமதமாகலாம். வெவ்வேறு பட்டியல் நிலைகளில் எண்களைத் தேடுவது ஏன் சில சமயங்களில் ஒரே நேரத்தை எடுக்கலாம் என்பது போன்ற முரண்பாடுகளை இது விளக்கலாம். இந்த நுட்பமான காரணிகள் செயல்திறன் விவரக்குறிப்பின் சிக்கலான தன்மையையும் வெளிப்புற மாறிகள் எவ்வாறு முடிவுகளைத் திசைதிருப்பக்கூடும் என்பதையும் எடுத்துக்காட்டுகின்றன.

கடைசியாக, ஐடிரேட்டர் நெறிமுறையைப் புரிந்துகொள்வது "உள்" ஆபரேட்டர் ஆழமான நுண்ணறிவுகளை வழங்குகிறது. ஆபரேட்டர் வரிசையாக அழைப்பதன் மூலம் வேலை செய்கிறார் __iter__() பட்டியலில் உள்ள முறை மற்றும் ஒவ்வொரு உறுப்பையும் கொண்டு மதிப்பீடு செய்தல் __eq__() முறை. இந்த பொறிமுறையானது, அடிப்படை தரவு கட்டமைப்பின் செயலாக்கத்தில் ஆபரேட்டரின் சார்புநிலையை வலியுறுத்துகிறது. பெரிய அளவிலான பயன்பாடுகளுக்கு, தொகுப்புகள் அல்லது அகராதிகள் போன்ற மிகவும் உகந்த தரவு வகைகளுடன் பட்டியல்களை மாற்றுவது தேடல் செயல்திறனை கணிசமாக மேம்படுத்தலாம், இது நேர செயல்திறன் மற்றும் அளவிடுதல் இரண்டையும் வழங்குகிறது. 🧠

பைத்தானின் "இன்" ஆபரேட்டர் மற்றும் அதன் செயல்திறன் பற்றிய பொதுவான கேள்விகள்

"இன்" ஆபரேட்டரின் முதன்மை செயல்பாடு என்ன?
தி "in" ஆபரேட்டர் என்பது பட்டியல்கள், சரங்கள் அல்லது அகராதிகள் போன்ற செயலிகளில் உறுப்பினராக இருப்பதைச் சரிபார்க்கப் பயன்படுகிறது, கட்டமைப்பிற்குள் ஒரு உறுப்பு இருக்கிறதா என்பதைத் தீர்மானிக்கிறது.
வெவ்வேறு குறியீடுகளுக்கான தேடல் நேரம் ஏன் சில நேரங்களில் மாறாமல் இருக்கும்?
CPU கேச்சிங் மற்றும் பைத்தானின் நினைவக மேலாண்மை போன்ற காரணிகளால், உறுப்புகள் ஏற்கனவே வேகமான அணுகல் நினைவகத்தில் இருக்கலாம், இதனால் சீரான தேடல் நேரங்கள் ஏற்படும்.
பெரிய தரவுத்தொகுப்புகளுக்கு "இன்" ஆபரேட்டரை மேம்படுத்த முடியுமா?
ஆம், பட்டியல்களை செட் அல்லது அகராதிகளுடன் மாற்றுவது, இந்த கட்டமைப்புகள் பயன்படுத்துவதால் செயல்திறனை மேம்படுத்தலாம் hashing தேடுதலுக்காக, பெரும்பாலான சந்தர்ப்பங்களில் O(n) இலிருந்து O(1) வரை சிக்கலைக் குறைக்கிறது.
"இன்" ஆபரேட்டரை பைதான் எவ்வாறு உள்நாட்டில் செயல்படுத்துகிறது?
இது ஒவ்வொரு உறுப்பையும் பயன்படுத்தி தொடர்ச்சியாக மதிப்பீடு செய்கிறது __iter__() மற்றும் __eq__() முறைகள், இது மீண்டும் இயக்கக்கூடிய அமைப்பு மற்றும் அளவைப் பொறுத்தது.
மிகவும் துல்லியமான நேர பகுப்பாய்விற்கு நான் என்ன கருவிகளைப் பயன்படுத்தலாம்?
நீங்கள் பயன்படுத்தலாம் timeit அல்லது cProfile விரிவான விவரக்குறிப்புக்காக, இந்த தொகுதிகள் நம்பகமான மற்றும் நிலையான நேர முடிவுகளை வழங்குவதால், கணினி தொடர்பான குறுக்கீடுகளைக் குறைக்கிறது.

பைத்தானின் தேடல் இயக்கவியலை மூடுதல்

பைத்தானின் பகுப்பாய்வு "உள்" ஆபரேட்டர் தனித்துவமான நடத்தைகளை வெளிப்படுத்துகிறது, குறிப்பாக அது தொடர் தேடல்களை எவ்வாறு கையாளுகிறது என்பதில். சோதனையானது கேச்சிங் மற்றும் தரவு அணுகல் முறைகள் காரணமாக நேர முரண்பாடுகளைக் காட்டுகிறது, செயல்திறன் சரிப்படுத்தும் வாய்ப்புகளை வெளிப்படுத்துகிறது.

செட் அல்லது பைனரி தேடல் போன்ற உகந்த கட்டமைப்புகளை ஆராய்வது சரியான தரவு கட்டமைப்புகளைத் தேர்ந்தெடுப்பதன் முக்கியத்துவத்தை எடுத்துக்காட்டுகிறது. இந்த கண்டுபிடிப்புகள் டெவலப்பர்களுக்கு பைத்தானைப் பற்றிய புரிதலை ஆழப்படுத்தும்போது பெரிய தரவுத்தொகுப்புகளை உள்ளடக்கிய பணிகளில் செயல்திறனை மேம்படுத்த உதவுகின்றன. 📈

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

மலைப்பாம்பின் நடத்தையை விவரிக்கிறது "உள்" ஆபரேட்டர் மற்றும் இடிரேட்டர் நெறிமுறை. இல் மேலும் அறிக பைதான் தரவு மாதிரி ஆவணம் .
பைதான்களைப் பயன்படுத்தி செயல்திறன் அளவீட்டு நுட்பங்களைப் பற்றிய நுண்ணறிவுகளை வழங்குகிறது time.time_ns() முறை. அதிகாரப்பூர்வ குறிப்பைப் பார்க்கவும் பைதான் நேர தொகுதி .
Matplotlib ஐப் பயன்படுத்தி நேரத் தரவின் காட்சிப்படுத்தல் பற்றி விவாதிக்கிறது. வருகை Matplotlib Pyplot பயிற்சி .
விரைவான தேடல்களுக்கான தொகுப்புகள் போன்ற உகந்த தரவு கட்டமைப்புகளைப் பயன்படுத்துவதன் நன்மைகளை விளக்குகிறது. பாருங்கள் பைதான் செட் வகைகள் .

பைத்தானின் "இன்" ஆபரேட்டரின் செயல்திறனை பகுப்பாய்வு செய்தல்