திரட்டுதலை திறப்பது: சக்திவாய்ந்த செயல்பாடுகளுக்கான Functools' reduce() தேர்ச்சி

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

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

மைய கருத்தைப் புரிந்துகொள்வது: திரட்டுதல் என்றால் என்ன?

reduce() இன் விவரக்குறிப்புகளுக்குச் செல்வதற்கு முன், திரட்டுதல் பற்றிய நமது புரிதலை வலுப்படுத்துவோம். சாராம்சத்தில், திரட்டுதல் என்பது பல தனிப்பட்ட தரவு புள்ளிகளை ஒரு ஒற்றை, உயர் மட்ட தரவு புள்ளியாக இணைப்பதன் மூலம் தரவை சுருக்குவதற்கான செயல்முறையாகும். ஒரு சிக்கலான தரவுத்தொகுப்பை அதன் மிக முக்கியமான கூறுகளாக குறைப்பதைப் பற்றி சிந்தியுங்கள்.

திரட்டுதலின் பொதுவான எடுத்துக்காட்டுகள் பின்வருமாறு:

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

திரட்டுதலின் முக்கிய பண்பு என்னவென்றால், இது தரவின் பரிமாணத்தைக் குறைக்கிறது, ஒரு தொகுப்பை ஒரு தனித்துவமான முடிவாக மாற்றுகிறது. இங்கேதான் functools.reduce() பிரகாசிக்கிறது.

functools.reduce() அறிமுகம்

functools.reduce() செயல்பாடு, functools தொகுதியில் கிடைக்கிறது, ஒரு தொடர்ச்சியின் உருப்படிகளுக்கு இரண்டு வாதங்களின் ஒரு செயல்பாட்டை ஒட்டுமொத்தமாகப் பயன்படுத்துகிறது (ஒரு பட்டியல், டூப்பிள் அல்லது சரம் போன்றவை), இடமிருந்து வலமாக, தொடர்ச்சியைக் குறைக்க ஒரு ஒற்றை மதிப்பு.

பொதுவான தொடரியல்:

            functools.reduce(function, iterable[, initializer])
            

              
                Copy
              
            
          

• function: இது இரண்டு வாதங்களை எடுக்கும் ஒரு செயல்பாடு. முதல் வாதம் இதுவரை திரட்டப்பட்ட விளைவாகும், இரண்டாவது வாதம் தொடர்ச்சியிலிருந்து வரும் அடுத்த உருப்படியாகும்.
• iterable: இது செயலாக்கப்பட வேண்டிய உருப்படிகளின் வரிசை.
• initializer (விரும்பினால்): வழங்கப்பட்டால், இந்த மதிப்பு கணக்கீட்டில் தொடர்ச்சியின் உருப்படிகளுக்கு முன் வைக்கப்படுகிறது, மேலும் தொடர்ச்சி காலியாக இருக்கும்போது இயல்புநிலையாக செயல்படுகிறது.

இது எவ்வாறு செயல்படுகிறது: ஒரு படிப்படியான விளக்கம்

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

எங்களிடம் [1, 2, 3, 4, 5] பட்டியல் இருப்பதாக வைத்துக்கொள்வோம், மேலும் reduce() ஐப் பயன்படுத்தி அவற்றைச் சுருக்க விரும்புகிறோம்.

எளிமைக்காக ஒரு லாம்ப்டா செயல்பாட்டைப் பயன்படுத்துவோம்: lambda x, y: x + y.

1. தொடர்ச்சியின் முதல் இரண்டு கூறுகள் (1 மற்றும் 2) செயல்பாட்டிற்கு அனுப்பப்படுகின்றன: 1 + 2, இதன் விளைவாக 3 கிடைக்கிறது.
2. விளைவாக வரும் (3) அடுத்த உறுப்புடன் (3) இணைக்கப்படுகிறது: 3 + 3, இதன் விளைவாக 6 கிடைக்கிறது.
3. இந்த செயல்முறை தொடர்கிறது: 6 + 4 10 ஆகிறது.
4. இறுதியாக, 10 + 5 15 ஆகிறது.

இறுதி திரட்டப்பட்ட மதிப்பு, 15, திரும்பப் பெறப்படுகிறது.

துவக்க மதிப்பு இல்லாமல், reduce() தொடர்ச்சியின் முதல் இரண்டு கூறுகளுக்கு செயல்பாட்டைப் பயன்படுத்துவதன் மூலம் தொடங்குகிறது. ஒரு துவக்க மதிப்பு வழங்கப்பட்டால், செயல்பாடு முதலில் துவக்க மதிப்பு மற்றும் தொடர்ச்சியின் முதல் உறுப்புக்கு பயன்படுத்தப்படும்.

ஒரு துவக்க மதிப்புடன் இதைக் கவனியுங்கள்:

            import functools

numbers = [1, 2, 3, 4, 5]
initial_value = 10

# Summing with an initializer
result = functools.reduce(lambda x, y: x + y, numbers, initial_value)
print(result)  # Output: 25 (10 + 1 + 2 + 3 + 4 + 5)

            

              
                Copy
              
            
          

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

reduce() இன் நடைமுறை உலகளாவிய பயன்பாடுகள்

reduce() இன் சக்தி அதன் பல்துறையில் உள்ளது. இது எளிய தொகைகளுக்கு மட்டும் அல்ல; உலகளாவிய செயல்பாடுகளுக்கு பொருத்தமான பரந்த அளவிலான சிக்கலான திரட்டுதல் பணிகளுக்கு இது பயன்படுத்தப்படலாம்.

1. தனிப்பயன் தர்க்கத்துடன் உலகளாவிய சராசரிகளைக் கணக்கிடுதல்

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

காட்சி: ஐரோப்பா, ஆசியா மற்றும் வட அமெரிக்காவிலிருந்து வாடிக்கையாளர் திருப்தி மதிப்பெண்களை பகுப்பாய்வு செய்தல்.

            import functools

feedback_data = [
    {'score': 85, 'region': 'Europe'},
    {'score': 92, 'region': 'Asia'},
    {'score': 78, 'region': 'North America'},
    {'score': 88, 'region': 'Europe'},
    {'score': 95, 'region': 'Asia'},
]

def aggregate_scores(accumulator, item):
    total_score = accumulator['total_score'] + item['score']
    count = accumulator['count'] + 1
    return {'total_score': total_score, 'count': count}

initial_accumulator = {'total_score': 0, 'count': 0}

aggregated_result = functools.reduce(aggregate_scores, feedback_data, initial_accumulator)

average_score = aggregated_result['total_score'] / aggregated_result['count'] if aggregated_result['count'] > 0 else 0

print(f"Overall average score: {average_score:.2f}")
# Expected Output: Overall average score: 87.60

            

              
                Copy
              
            
          

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

2. புவியியல் தகவல்களை ஒருங்கிணைத்தல்

பல நாடுகளை உள்ளடக்கிய தரவுத்தொகுப்புகளை கையாளும் போது, நீங்கள் புவியியல் தரவை ஒருங்கிணைக்க வேண்டியிருக்கலாம். உதாரணமாக, உங்களிடம் அகராதிகளின் பட்டியல் இருந்தால், ஒவ்வொன்றிலும் 'country' மற்றும் 'city' விசை இருந்தால், குறிப்பிடப்பட்டுள்ள அனைத்து நாடுகளின் தனித்துவமான பட்டியலை உருவாக்க விரும்புகிறீர்கள்.

காட்சி: ஒரு உலகளாவிய வாடிக்கையாளர் தரவுத்தளத்திலிருந்து தனித்துவமான நாடுகளின் பட்டியலைத் தொகுத்தல்.

            import functools

customers = [
    {'name': 'Alice', 'country': 'USA'},
    {'name': 'Bob', 'country': 'Canada'},
    {'name': 'Charlie', 'country': 'USA'},
    {'name': 'David', 'country': 'Germany'},
    {'name': 'Eve', 'country': 'Canada'},
]

def unique_countries(country_set, customer):
    country_set.add(customer['country'])
    return country_set

# We use a set as the initial value for automatic uniqueness
all_countries = functools.reduce(unique_countries, customers, set())

print(f"Unique countries represented: {sorted(list(all_countries))}")
# Expected Output: Unique countries represented: ['Canada', 'Germany', 'USA']

            

              
                Copy
              
            
          

ஒரு set ஐ துவக்கியாகப் பயன்படுத்துவது தானாகவே நகல் நாட்டு உள்ளீடுகளைக் கையாளுகிறது, இது தனித்துவத்தை உறுதி செய்வதற்கான திரட்டலை திறமையாக்குகிறது.

3. விநியோகிக்கப்பட்ட அமைப்புகள் முழுவதும் அதிகபட்ச மதிப்புகளைக் கண்காணித்தல்

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

காட்சி: உலகெங்கிலும் உள்ள வானிலை நிலையங்களிலிருந்து அதிகபட்ச வெப்பநிலை வாசிப்பைக் கண்டறிதல்.

            import functools

weather_stations = [
    {'location': 'London', 'temperature': 15},
    {'location': 'Tokyo', 'temperature': 28},
    {'location': 'New York', 'temperature': 22},
    {'location': 'Sydney', 'temperature': 31},
    {'location': 'Cairo', 'temperature': 35},
]

def find_max_temperature(current_max, station):
    return max(current_max, station['temperature'])

# It's crucial to provide a sensible initial value, often the temperature of the first station
# or a known minimum possible temperature to ensure correctness.
# If the list is guaranteed to be non-empty, you can omit the initializer and it will use the first element.

if weather_stations:
    max_temp = functools.reduce(find_max_temperature, weather_stations)
    print(f"Highest temperature recorded: {max_temp}°C")
else:
    print("No weather data available.")

# Expected Output: Highest temperature recorded: 35°C

            

              
                Copy
              
            
          

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

4. உலகளாவிய அறிக்கைகளுக்கான தனிப்பயன் சரம் இணைப்பு

பல்வேறு மூலங்களிலிருந்து சரங்களை இணைப்பதை உள்ளடக்கிய அறிக்கைகள் அல்லது தகவல்களைப் பதிவு செய்யும் போது, இதைக் கையாள reduce() ஒரு நேர்த்தியான வழியாக இருக்கும், குறிப்பாக இணைப்பின் போது பிரிப்பான்களைச் செருகவோ அல்லது மாற்றங்களைச் செய்யவோ வேண்டும் என்றால்.

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

            import functools

product_listings = [
    {'region': 'EU', 'product': 'WidgetA'},
    {'region': 'Asia', 'product': 'GadgetB'},
    {'region': 'NA', 'product': 'WidgetA'},
    {'region': 'EU', 'product': 'ThingamajigC'},
]

def concatenate_products(current_string, listing):
    # Avoid adding duplicate product names if already present
    if listing['product'] not in current_string:
        if current_string:
            return current_string + ", " + listing['product']
        else:
            return listing['product']
    return current_string

# Start with an empty string.
all_products_string = functools.reduce(concatenate_products, product_listings, "")

print(f"Available products: {all_products_string}")
# Expected Output: Available products: WidgetA, GadgetB, ThingamajigC

            

              
                Copy
              
            
          

திரட்டல் எவ்வாறு தொடர்கிறது என்பதைக் கட்டுப்படுத்த நிபந்தனை தர்க்கத்தை function வாதம் எவ்வாறு சேர்க்கலாம் என்பதை இந்த எடுத்துக்காட்டு காட்டுகிறது, தனித்துவமான தயாரிப்பு பெயர்கள் பட்டியலிடப்படுவதை உறுதி செய்கிறது.

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

reduce() இன் உண்மையான சக்தி நீங்கள் எளிய எண்கணிதத்தைத் தாண்டி செல்லும் திரட்டல்களைச் செய்ய வேண்டியிருக்கும்போது வெளிப்படுகிறது. சிக்கலான திரட்டி நிலைகளை நிர்வகிக்கும் தனிப்பயன் செயல்பாடுகளை உருவாக்குவதன் மூலம், அதிநவீன தரவு சவால்களை நீங்கள் சமாளிக்க முடியும்.

5. வகை மூலம் கூறுகளை வகைப்படுத்துதல் மற்றும் எண்ணுதல்

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

காட்சி: ஒவ்வொரு நாட்டிலிருந்தும் பயனர்களின் எண்ணிக்கையை எண்ணுதல்.

            import functools

user_data = [
    {'user_id': 101, 'country': 'Brazil'},
    {'user_id': 102, 'country': 'India'},
    {'user_id': 103, 'country': 'Brazil'},
    {'user_id': 104, 'country': 'Australia'},
    {'user_id': 105, 'country': 'India'},
    {'user_id': 106, 'country': 'Brazil'},
]

def count_by_country(country_counts, user):
    country = user['country']
    country_counts[country] = country_counts.get(country, 0) + 1
    return country_counts

# Use a dictionary as the accumulator to store counts for each country
user_counts = functools.reduce(count_by_country, user_data, {})

print("User counts by country:")
for country, count in user_counts.items():
    print(f"- {country}: {count}")

# Expected Output:
# User counts by country:
# - Brazil: 3
# - India: 2
# - Australia: 1

            

              
                Copy
              
            
          

இந்த வழக்கில், திரட்டி ஒரு அகராதி. ஒவ்வொரு பயனருக்கும், அவர்களின் நாட்டை அணுகி அகராதியில் உள்ள நாட்டின் எண்ணிக்கையை அதிகரிக்கிறோம். dict.get(key, default) முறை இங்கே விலைமதிப்பற்றது, நாடு இன்னும் சந்திக்கப்படாவிட்டால் 0 என்ற இயல்புநிலை மதிப்பை வழங்குகிறது.

6. முக்கிய-மதிப்பு ஜோடிகளை ஒரு ஒற்றை அகராதியாக திரட்டுதல்

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

காட்சி: நாடு சார்ந்த நாணய குறியீடுகளை உலகளாவிய வரைபடமாக இணைத்தல்.

            import functools

currency_data = [
    ('USA', 'USD'),
    ('Canada', 'CAD'),
    ('Germany', 'EUR'),
    ('Australia', 'AUD'),
    ('Canada', 'CAD'), # Duplicate entry to test robustness
]

def merge_currency_map(currency_map, item):
    country, code = item
    # If a country appears multiple times, we might choose to keep the first, last, or raise an error.
    # Here, we simply overwrite, keeping the last seen code for a country.
    currency_map[country] = code
    return currency_map

# Start with an empty dictionary.
global_currency_map = functools.reduce(merge_currency_map, currency_data, {})

print("Global currency mapping:")
for country, code in global_currency_map.items():
    print(f"- {country}: {code}")

# Expected Output:
# Global currency mapping:
# - USA: USD
# - Canada: CAD
# - Germany: EUR
# - Australia: AUD

            

              
                Copy
              
            
          

அகராதிகள் போன்ற சிக்கலான தரவு கட்டமைப்புகளை reduce() எவ்வாறு உருவாக்க முடியும் என்பதை இது நிரூபிக்கிறது, அவை பல பயன்பாடுகளில் தரவு பிரதிநிதித்துவம் மற்றும் செயலாக்கத்திற்கு அடிப்படை.

7. ஒரு தனிப்பயன் வடிகட்டி மற்றும் ஒருங்கிணைந்த குழாய் வரிசையை செயல்படுத்துதல்

பைத்தானின் பட்டியல் புரிந்துணர்வு மற்றும் ஜெனரேட்டர் வெளிப்பாடுகள் பெரும்பாலும் வடிகட்டுவதற்கு விரும்பப்பட்டாலும், தர்க்கம் சிக்கலானதாக இருந்தால் அல்லது நீங்கள் கண்டிப்பாக செயல்பாட்டு நிரலாக்க பாணியை கடைபிடித்தால், வடிகட்டுதல் மற்றும் திரட்டலை ஒரு ஒற்றை reduce() செயல்பாட்டிற்குள் இணைக்க முடியும்.

காட்சி: 'RegionX' இலிருந்து வரும் அனைத்து உருப்படிகளின் 'மதிப்பை' ஒரு குறிப்பிட்ட வரம்புக்கு அதிகமாகக் கூட்டுதல்.

            
import functools

data_points = [
    {'id': 1, 'region': 'RegionX', 'value': 150},
    {'id': 2, 'region': 'RegionY', 'value': 200},
    {'id': 3, 'region': 'RegionX', 'value': 80},
    {'id': 4, 'region': 'RegionX', 'value': 120},
    {'id': 5, 'region': 'RegionZ', 'value': 50},
]

def conditional_sum(accumulator, item):
    if item['region'] == 'RegionX' and item['value'] > 100:
        return accumulator + item['value']
    return accumulator

# Start with 0 as the initial sum.
conditional_total = functools.reduce(conditional_sum, data_points, 0)

print(f"Sum of values from RegionX above 100: {conditional_total}")
# Expected Output: Sum of values from RegionX above 100: 270 (150 + 120)

            

              
                Copy
              
            
          

ஒட்டுமொத்த செயல்பாடு நிபந்தனை தர்க்கத்தை எவ்வாறு இணைக்க முடியும் என்பதைக் காட்டுகிறது, இது ஒரு நேரத்தில் வடிகட்டுதல் மற்றும் திரட்டுதல் இரண்டையும் திறம்பட செய்கிறது.

reduce() க்கான முக்கிய கருத்தில் கொள்ளல்கள் மற்றும் சிறந்த நடைமுறைகள்

functools.reduce() ஒரு சக்திவாய்ந்த கருவியாக இருக்கும்போது, அதை விவேகத்துடன் பயன்படுத்துவது முக்கியம். இங்கே சில முக்கிய கருத்தில் கொள்ளல்கள் மற்றும் சிறந்த நடைமுறைகள் உள்ளன:

படிக்கக்கூடிய தன்மை vs. சுருக்கம்

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

எடுத்துக்காட்டு: எளிய தொகை

            # Using a loop (often more readable for beginners)
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
    total += num

# Using functools.reduce() (more concise)
import functools
numbers = [1, 2, 3, 4, 5]
total = functools.reduce(lambda x, y: x + y, numbers)

            

              
                Copy
              
            
          

தர்க்கம் சிக்கலானதாக இருக்கும்போது மிகவும் சிக்கலான திரட்டுதல் செயல்பாடுகளுக்கு, reduce() குறியீட்டை கணிசமாகக் குறைக்கும், ஆனால் உங்கள் செயல்பாட்டு பெயர் மற்றும் தர்க்கம் தெளிவாக இருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.

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

initializer வாதம் பல காரணங்களுக்காக முக்கியமானது:

• வெற்று தொடர்ச்சிகளைக் கையாளுதல்: தொடர்ச்சி காலியாக இருந்தால் மற்றும் துவக்கி வழங்கப்படாவிட்டால், reduce() ஒரு TypeError ஐ அதிகரிக்கும். துவக்கியை வழங்குவது இதைத் தடுக்கிறது மற்றும் கணிக்கக்கூடிய முடிவை உறுதி செய்கிறது (எ.கா., தொகைகளுக்கு 0, சேகரிப்புகளுக்கான வெற்று பட்டியல்/அகராதி).
• தொடக்க புள்ளியை அமைத்தல்: ஒரு இயற்கை தொடக்க புள்ளியைக் கொண்ட திரட்டல்களுக்கு (ஒரு தளத்திலிருந்து தொடங்கும் நாணய மாற்றம் அல்லது அதிகபட்சங்களைக் கண்டறிதல் போன்றவை), துவக்கி இந்த அடிப்படை வரியை அமைக்கிறது.
• திரட்டி வகையை நிர்ணயிப்பது: துவக்கியின் வகை பெரும்பாலும் செயல்முறை முழுவதும் திரட்டியின் வகையை கட்டளையிடுகிறது.

செயல்திறன் தாக்கங்கள்

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

கூட்டுதல் போன்ற செயல்பாடுகளுக்கு, பைத்தானின் உள்ளமைக்கப்பட்ட sum() செயல்பாடு பொதுவாக மேம்படுத்தப்பட்டு reduce() ஐ விட விரும்பப்பட வேண்டும்:

            # Recommended for simple sums:
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)

# functools.reduce() also works, but sum() is more direct
# import functools
# total = functools.reduce(lambda x, y: x + y, numbers)

            

              
                Copy
              
            
          

மாற்று அணுகுமுறைகள்: லூப்ஸ் மற்றும் பல

reduce() பணிக்கு எப்போதும் சிறந்த கருவி அல்ல என்பதை அங்கீகரிப்பது அவசியம். கருத்தில் கொள்ளுங்கள்:

• லூப்ஸிற்காக: நேரடியான, தொடர்ச்சியான செயல்பாடுகளுக்கு, குறிப்பாக பக்க விளைவுகள் சம்பந்தப்பட்டிருக்கும்போது அல்லது தர்க்கம் தொடர்ச்சியாகவும், படிப்படியாகப் பின்பற்ற எளிதாகவும் இருக்கும்போது.
• பட்டியல் புரிந்துணர்வு / ஜெனரேட்டர் வெளிப்பாடுகள்: ஏற்கனவே உள்ளவற்றின் அடிப்படையில் புதிய பட்டியல்கள் அல்லது மறு செய்கையாளர்களை உருவாக்குவதற்கு சிறந்தது, பெரும்பாலும் மாற்றங்கள் மற்றும் வடிகட்டுதலை உள்ளடக்கியது.
• உள்ளமைக்கப்பட்ட செயல்பாடுகள்: பைத்தானில் sum(), min(), max() மற்றும் all(), any() போன்ற மேம்படுத்தப்பட்ட செயல்பாடுகள் உள்ளன, அவை பொதுவான திரட்டுதல் பணிகளுக்காக வடிவமைக்கப்பட்டுள்ளன, மேலும் அவை பொதுவாக ஒரு பொதுவான reduce() ஐ விட படிக்கக்கூடியவை மற்றும் திறமையானவை.

எப்போது reduce() நோக்கி சாய வேண்டும்:

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

முடிவுரை

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

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

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