പൈത്തൺ ഓപ്പറേറ്റർ മൊഡ്യൂൾ: ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിനായുള്ള ശക്തമായ യൂട്ടിലിറ്റികൾ

പ്രോഗ്രാമിംഗിന്റെ മണ്ഡലത്തിൽ, പ്രത്യേകിച്ചും ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃകകൾ സ്വീകരിക്കുമ്പോൾ, പ്രവർത്തനങ്ങൾ വൃത്തിയുള്ളതും സംക്ഷിപ്തവും വീണ്ടും ഉപയോഗിക്കാവുന്നതുമായ രീതിയിൽ പ്രകടിപ്പിക്കാനുള്ള കഴിവ് പരമപ്രധാനമാണ്. പൈത്തൺ, പ്രാഥമികമായി ഒരു ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ഭാഷയാണെങ്കിലും, ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ശൈലികൾക്ക് ശക്തമായ പിന്തുണ നൽകുന്നു. ഈ പിന്തുണയുടെ ഒരു പ്രധാന ഘടകം, ചിലപ്പോൾ അവഗണിക്കപ്പെടുന്ന ഒന്നാണ് operator മൊഡ്യൂൾ. ഈ മൊഡ്യൂൾ പൈത്തണിന്റെ உள்ளார் inherent ഓപ്പറേറ്റർമാർക്ക് അനുയോജ്യമായ കാര്യക്ഷമമായ ഫംഗ്ഷനുകളുടെ ഒരു ശേഖരം നൽകുന്നു, ഇത് ലാംഡ ഫംഗ്‌ഷനുകൾക്ക് മികച്ച ബദലായി വർത്തിക്കുകയും കോഡ് റീഡബിലിറ്റിയും പ്രകടനവും വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.

operator മൊഡ്യൂളിനെക്കുറിച്ച് മനസ്സിലാക്കുക

പൈത്തണിന്റെ അന്തർനിർമ്മിത ഓപ്പറേറ്റർമാർക്ക് തുല്യമായ പ്രവർത്തനങ്ങൾ ചെയ്യുന്ന ഫംഗ്ഷനുകളെ operator മൊഡ്യൂൾ നിർവചിക്കുന്നു. ഉദാഹരണത്തിന്, operator.add(a, b) എന്നത് a + b ന് തുല്യമാണ്, കൂടാതെ operator.lt(a, b) എന്നത് a < b ന് തുല്യമാണ്. ഈ ഫംഗ്‌ഷനുകൾ പലപ്പോഴും അവയുടെ ഓപ്പറേറ്റർ എതിരാളികളേക്കാൾ കാര്യക്ഷമമാണ്, പ്രത്യേകിച്ചും പ്രകടനം നിർണായകമായ സന്ദർഭങ്ങളിൽ, കൂടാതെ map(), filter(), functools.reduce() പോലുള്ള ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് നിർമ്മിതികളിൽ അവ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു.

ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുപകരം operator മൊഡ്യൂളിൽ നിന്നുള്ള ഒരു ഫംഗ്‌ഷൻ നിങ്ങൾ എന്തിന് ഉപയോഗിക്കണം? പ്രധാന കാരണങ്ങൾ ഇവയാണ്:

• ഫങ്ഷണൽ ശൈലിയിലുള്ള അനുയോജ്യത: പൈത്തണിലെ പല ഉയർന്ന ക്രമത്തിലുള്ള ഫംഗ്‌ഷനുകളും (functools-ലുള്ളവ പോലെ) വിളിക്കാവുന്ന ഒബ്ജക്റ്റുകളെ പ്രതീക്ഷിക്കുന്നു. ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുകൾ വിളിക്കാവുന്നവയാണ്, ഇത് ഒരു പ്രത്യേക ലാംഡ ഫംഗ്‌ഷൻ നിർവചിക്കാതെ തന്നെ ആർഗ്യുമെന്റുകളായി കൈമാറാൻ അവയെ മികച്ചതാക്കുന്നു.
• വായിക്കാനുള്ള എളുപ്പം: ചില സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ, പേരുള്ള ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്നത് ചിലപ്പോൾ സങ്കീർണ്ണമായ ലാംഡ എക്സ്പ്രഷനുകളേക്കാൾ കോഡിന്റെ വ്യക്തത മെച്ചപ്പെടുത്തും.
• പ്രകടനം: ചില പ്രവർത്തനങ്ങൾക്ക്, പ്രത്യേകിച്ചും ലൂപ്പുകൾക്കുള്ളിലോ ഉയർന്ന ക്രമത്തിലുള്ള ഫംഗ്‌ഷനുകൾക്കുള്ളിലോ ആവർത്തിച്ച് വിളിക്കുമ്പോൾ, C-യിലെ അവയുടെ ഇമ്പ്ലിമെന്റേഷൻ കാരണം ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുകൾക്ക് നേരിയ പ്രകടന നേട്ടം നൽകാൻ കഴിയും.

Core Operator Functions

operator മൊഡ്യൂളിനെ അവ പ്രതിനിധീകരിക്കുന്ന പ്രവർത്തനങ്ങളുടെ തരമനുസരിച്ച് വിശാലമായി തരം തിരിക്കാം. ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ചിലത് നമുക്ക് പര്യവേക്ഷണം ചെയ്യാം.

ഗണിത ഓപ്പറേറ്റർമാർ

ഈ ഫംഗ്‌ഷനുകൾ സാധാരണ ഗണിത കണക്കുകൂട്ടലുകൾ നടത്തുന്നു. മറ്റൊരു ഫംഗ്‌ഷനിലേക്ക് ഒരു ഗണിത പ്രവർത്തനം ആർഗ്യുമെന്റായി നൽകേണ്ടിവരുമ്പോൾ ഇവ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

• operator.add(a, b): a + b എന്നതിന് തുല്യം.
• operator.sub(a, b): a - b എന്നതിന് തുല്യം.
• operator.mul(a, b): a * b എന്നതിന് തുല്യം.
• operator.truediv(a, b): a / b എന്നതിന് തുല്യം (യഥാർത്ഥ ഡിവിഷൻ).
• operator.floordiv(a, b): a // b എന്നതിന് തുല്യം (ഫ്ലോർ ഡിവിഷൻ).
• operator.mod(a, b): a % b എന്നതിന് തുല്യം (മോഡുലോ).
• operator.pow(a, b): a ** b എന്നതിന് തുല്യം (എക്സ്പോണൻഷ്യേഷൻ).
• operator.neg(a): -a എന്നതിന് തുല്യം (യൂണറി നെഗേഷൻ).
• operator.pos(a): +a എന്നതിന് തുല്യം (യൂണറി പോസിറ്റീവ്).
• operator.abs(a): abs(a) എന്നതിന് തുല്യം.

ഉദാഹരണം: functools.reduce ഉപയോഗിച്ച് operator.add ഉപയോഗിക്കുന്നു

നിങ്ങൾ ഒരു ലിസ്റ്റിലെ എല്ലാ ഘടകങ്ങളും കൂട്ടിച്ചേർക്കണമെന്ന് കരുതുക. sum() ആണ് ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്ന പൈത്തോണിക് രീതി, ഒരു ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുള്ള reduce ഉപയോഗിക്കുന്നത് അതിന്റെ യൂട്ടിലിറ്റി വ്യക്തമാക്കുന്നു:

            import operator
from functools import reduce

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

# Using reduce with operator.add
total = reduce(operator.add, numbers)
print(f"The sum of {numbers} is: {total}") # Output: The sum of [1, 2, 3, 4, 5] is: 15

            

              
                Copy
              
            
          

ഇത് ഫങ്ഷണലായി ഇതിന് തുല്യമാണ്:

            total_lambda = reduce(lambda x, y: x + y, numbers)
print(f"Sum using lambda: {total_lambda}") # Output: Sum using lambda: 15

            

              
                Copy
              
            
          

operator.add പതിപ്പ് അതിന്റെ വ്യക്തതയ്ക്കും പ്രകടന സാധ്യതയുള്ള ആനുകൂല്യങ്ങൾക്കും പലപ്പോഴും ഇഷ്ടപ്പെടുന്നു.

താരതമ്യ ഓപ്പറേറ്റർമാർ

ഈ ഫംഗ്‌ഷനുകൾ രണ്ട് ഓപ്പറാൻഡുകൾ തമ്മിൽ താരതമ്യങ്ങൾ നടത്തുന്നു.

• operator.lt(a, b): a < b എന്നതിന് തുല്യം (കുറവ്).
• operator.le(a, b): a <= b എന്നതിന് തുല്യം (കുറവോ തുല്യമോ).
• operator.eq(a, b): a == b എന്നതിന് തുല്യം (തുല്യം).
• operator.ne(a, b): a != b എന്നതിന് തുല്യം (തുല്യമല്ല).
• operator.ge(a, b): a >= b എന്നതിന് തുല്യം (വലുതോ തുല്യമോ).
• operator.gt(a, b): a > b എന്നതിന് തുല്യം (വലുത്).

ഉദാഹരണം: ഒരു പ്രത്യേക കീ ഉപയോഗിച്ച് നിഘണ്ടുക്കളുടെ ഒരു ലിസ്റ്റ് അടുക്കുന്നു

ഓരോ ഉപയോക്തൃ പ്രൊഫൈലും ഒരു നിഘണ്ടുവിൽ പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ നിങ്ങളുടെ 'സ്കോർ' അനുസരിച്ച് അവയെ അടുക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു എന്ന് കരുതുക.

            import operator

users = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]

# Sort users by score using operator.itemgetter
sorted_users = sorted(users, key=operator.itemgetter('score'))
print("Users sorted by score:")
for user in sorted_users:
    print(user)
# Output:
# Users sorted by score:
# {'name': 'Charlie', 'score': 78}
# {'name': 'Alice', 'score': 85}
# {'name': 'Bob', 'score': 92}

            

              
                Copy
              
            
          

ഇവിടെ, operator.itemgetter('score') എന്നത് ഒരു നിഘണ്ടു നൽകുമ്പോൾ, 'score' എന്ന കീയുമായി ബന്ധപ്പെട്ട മൂല്യം നൽകുന്ന ഒരു കോളെബിൾ ആണ്. ഇത് key=lambda user: user['score'] എഴുതുന്നതിനേക്കാൾ വൃത്തിയുള്ളതും കാര്യക്ഷമവുമാണ്.

ബൂളിയൻ ഓപ്പറേറ്റർമാർ

ഈ ഫംഗ്‌ഷനുകൾ ലോജിക്കൽ പ്രവർത്തനങ്ങൾ നടത്തുന്നു.

• operator.not_(a): not a എന്നതിന് തുല്യം.
• operator.truth(a): a ശരിയാണെങ്കിൽ True നൽകുന്നു, അല്ലെങ്കിൽ False നൽകുന്നു.
• operator.is_(a, b): a is b എന്നതിന് തുല്യം.
• operator.is_not(a, b): a is not b എന്നതിന് തുല്യം.

ഉദാഹരണം: തെറ്റായ മൂല്യങ്ങൾ ഫിൽട്ടർ ചെയ്യുന്നു

ആവർത്തിക്കാവുന്നതിൽ നിന്ന് എല്ലാ തെറ്റായ മൂല്യങ്ങളും (0, None, ശൂന്യമായ സ്ട്രിംഗുകൾ, ശൂന്യമായ ലിസ്റ്റുകൾ പോലെ) നീക്കം ചെയ്യാൻ നിങ്ങൾക്ക് filter() ഉപയോഗിച്ച് operator.truth ഉപയോഗിക്കാം.

            import operator

data = [1, 0, 'hello', '', None, [1, 2], []]

# Filter out falsy values using operator.truth
filtered_data = list(filter(operator.truth, data))
print(f"Original data: {data}")
print(f"Filtered data (truthy values): {filtered_data}")
# Output:
# Original data: [1, 0, 'hello', '', None, [1, 2], []]
# Filtered data (truthy values): [1, 'hello', [1, 2]]

            

              
                Copy
              
            
          

ബിറ്റ്‌വൈസ് ഓപ്പറേറ്റർമാർ

ഈ ഫംഗ്‌ഷനുകൾ പൂർണ്ണ സംഖ്യകളുടെ വ്യക്തിഗത ബിറ്റുകളിൽ പ്രവർത്തിക്കുന്നു.

• operator.and_(a, b): a & b എന്നതിന് തുല്യം.
• operator.or_(a, b): a | b എന്നതിന് തുല്യം.
• operator.xor(a, b): a ^ b എന്നതിന് തുല്യം.
• operator.lshift(a, b): a << b എന്നതിന് തുല്യം.
• operator.rshift(a, b): a >> b എന്നതിന് തുല്യം.
• operator.invert(a): ~a എന്നതിന് തുല്യം.

ഉദാഹരണം: ബിറ്റ്‌വൈസ് പ്രവർത്തനങ്ങൾ നടത്തുന്നു

            import operator

a = 10 # Binary: 1010
b = 4  # Binary: 0100

print(f"a & b: {operator.and_(a, b)}") # Output: a & b: 0 (Binary: 0000)
print(f"a | b: {operator.or_(a, b)}")  # Output: a | b: 14 (Binary: 1110)
print(f"a ^ b: {operator.xor(a, b)}") # Output: a ^ b: 14 (Binary: 1110)
print(f"~a: {operator.invert(a)}")     # Output: ~a: -11

            

              
                Copy
              
            
          

സീക്വൻസും മാപ്പിംഗ് ഓപ്പറേറ്റർമാരും

ഈ ഫംഗ്‌ഷനുകൾ സീക്വൻസുകൾക്കുള്ളിലെ ഘടകങ്ങളെ (ലിസ്റ്റുകൾ, ട്യൂപ്പിളുകൾ, സ്ട്രിംഗുകൾ പോലെ) മാപ്പിംഗുകളും (നിഘണ്ടുക്കൾ പോലെ) ആക്സസ് ചെയ്യാൻ ഉപയോഗപ്രദമാണ്.

• operator.getitem(obj, key): obj[key] എന്നതിന് തുല്യം.
• operator.setitem(obj, key, value): obj[key] = value എന്നതിന് തുല്യം.
• operator.delitem(obj, key): del obj[key] എന്നതിന് തുല്യം.
• operator.len(obj): len(obj) എന്നതിന് തുല്യം.
• operator.concat(a, b): a + b എന്നതിന് തുല്യം (സ്ട്രിംഗുകൾ അല്ലെങ്കിൽ ലിസ്റ്റുകൾ പോലുള്ള സീക്വൻസുകൾക്ക്).
• operator.contains(obj, item): item in obj എന്നതിന് തുല്യം.

operator.itemgetter: ഒരു ശക്തമായ ഉപകരണം

സോർട്ടിംഗ് ഉദാഹരണത്തിൽ സൂചിപ്പിച്ചതുപോലെ, operator.itemgetter എന്നത് വളരെ ഉപയോഗപ്രദമായ ഒരു പ്രത്യേക ഫംഗ്‌ഷനാണ്. ഒന്നോ അതിലധികമോ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ, അത് അതിന്റെ ഓപ്പറാൻഡിൽ നിന്ന് ആ ഇനങ്ങൾ എടുക്കുന്ന ഒരു കോളെബിൾ നൽകുന്നു. ഒന്നിലധികം ആർഗ്യുമെന്റുകൾ നൽകിയിട്ടുണ്ടെങ്കിൽ, അത് എടുത്ത ഇനങ്ങളുടെ ഒരു ട്യൂപ്പിൾ നൽകുന്നു.

            import operator

# Fetching a single item
get_first_element = operator.itemgetter(0)
my_list = [10, 20, 30]
print(f"First element: {get_first_element(my_list)}") # Output: First element: 10

# Fetching multiple items
get_first_two = operator.itemgetter(0, 1)
print(f"First two elements: {get_first_two(my_list)}") # Output: First two elements: (10, 20)

# Fetching items from a dictionary
get_name_and_score = operator.itemgetter('name', 'score')
user_data = {'name': 'Alice', 'score': 85, 'city': 'New York'}
print(f"User info: {get_name_and_score(user_data)}") # Output: User info: ('Alice', 85)

            

              
                Copy
              
            
          

ഒരു കീ ഫംഗ്‌ഷൻ സ്വീകരിക്കുന്ന സോർട്ടിംഗിലോ മറ്റ് ഫംഗ്‌ഷനുകളിലോ operator.itemgetter കീ ആർഗ്യുമെന്റായി ഉപയോഗിക്കുമ്പോൾ വളരെ കാര്യക്ഷമമാണ്.

operator.attrgetter: ആട്രിബ്യൂട്ടുകൾ ആക്സസ് ചെയ്യുന്നു

itemgetter-ന് സമാനമായി, operator.attrgetter അതിന്റെ ഓപ്പറാൻഡിൽ നിന്ന് ആട്രിബ്യൂട്ടുകൾ എടുക്കുന്ന ഒരു കോളെബിൾ നൽകുന്നു. ഒബ്ജക്റ്റുകളുമായി പ്രവർത്തിക്കുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

            import operator

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

products = [
    Product('Laptop', 1200),
    Product('Mouse', 25),
    Product('Keyboard', 75)
]

# Get all product names
get_name = operator.attrgetter('name')
product_names = [get_name(p) for p in products]
print(f"Product names: {product_names}") # Output: Product names: ['Laptop', 'Mouse', 'Keyboard']

# Sort products by price
sorted_products = sorted(products, key=operator.attrgetter('price'))
print("Products sorted by price:")
for p in sorted_products:
    print(f"- {p.name}: ${p.price}")
# Output:
# Products sorted by price:
# - Mouse: $25
# - Keyboard: $75
# - Laptop: $1200

            

              
                Copy
              
            
          

ഡോട്ട് നൊട്ടേഷൻ ഉപയോഗിച്ച് നെസ്റ്റഡ് ഒബ്ജക്റ്റുകളിലൂടെ attrgetter-ന് ആട്രിബ്യൂട്ടുകൾ ആക്സസ് ചെയ്യാനും കഴിയും. ഉദാഹരണത്തിന്, operator.attrgetter('address.city') ഒരു ഒബ്ജക്റ്റിന്റെ 'address' ആട്രിബ്യൂട്ടിൽ നിന്ന് 'city' ആട്രിബ്യൂട്ട് എടുക്കും.

മറ്റ് ഉപയോഗപ്രദമായ ഫംഗ്‌ഷനുകൾ

• operator.methodcaller(name, *args, **kwargs): അതിന്റെ ഓപ്പറാൻഡിൽ name എന്ന് പേരുള്ള രീതിയെ വിളിക്കുന്ന ഒരു കോളെബിൾ നൽകുന്നു. ഇത് itemgetter-ന്റെയും attrgetter-ന്റെയും രീതിക്ക് തുല്യമാണ്.

ഉദാഹരണം: ഒരു ലിസ്റ്റിലെ ഒബ്ജക്റ്റുകളിൽ ഒരു രീതിയെ വിളിക്കുന്നു

            import operator

class Greeter:
    def __init__(self, name):
        self.name = name

    def greet(self, message):
        return f"{self.name} says: {message}"

greeters = [Greeter('Alice'), Greeter('Bob')]

# Call the greet method on each Greeter object
call_greet = operator.methodcaller('greet', 'Hello from the operator module!')

greetings = [call_greet(g) for g in greeters]
print(greetings)
# Output: ['Alice says: Hello from the operator module!', 'Bob says: Hello from the operator module!']

            

              
                Copy
              
            
          

ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് കോൺടെക്സ്റ്റുകളിൽ operator മൊഡ്യൂൾ

operator മൊഡ്യൂളിന്റെ യഥാർത്ഥ ശക്തി map(), filter(), കൂടാതെ functools.reduce() പോലുള്ള പൈത്തണിന്റെ അന്തർനിർമ്മിത ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ടൂളുകളുമായി ചേർന്ന് ഉപയോഗിക്കുമ്പോൾ പ്രകാശിക്കുന്നു.

map() ഉം operator ഉം

map(function, iterable, ...)` ഒരു ആവർത്തിക്കാവുന്നതിലെ എല്ലാ ഇനത്തിനും ഒരു ഫംഗ്‌ഷൻ പ്രയോഗിക്കുകയും ഫലങ്ങളുടെ ഒരു ഇറ്ററേറ്റർ നൽകുകയും ചെയ്യുന്നു. ഓപ്പറേറ്റർ ഫംഗ്‌ഷനുകൾ ഇതിന് അനുയോജ്യമാണ്.

            import operator

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

# Square each number using map and operator.mul
squared_numbers = list(map(lambda x: operator.mul(x, x), numbers)) # Can be simpler: list(map(operator.mul, numbers, numbers)) or list(map(pow, numbers, [2]*len(numbers)))
print(f"Squared numbers: {squared_numbers}") # Output: Squared numbers: [1, 4, 9, 16, 25]

# Add 10 to each number using map and operator.add
added_ten = list(map(operator.add, numbers, [10]*len(numbers)))
print(f"Numbers plus 10: {added_ten}") # Output: Numbers plus 10: [11, 12, 13, 14, 15]

            

              
                Copy
              
            
          

            import operator

salaries = [50000, 65000, 45000, 80000, 70000]

# Filter salaries greater than 60000
high_salaries = list(filter(operator.gt, salaries, [60000]*len(salaries)))
print(f"Salaries above 60000: {high_salaries}") # Output: Salaries above 60000: [65000, 80000, 70000]

# Filter even numbers using operator.mod and lambda (or a more complex operator function)
even_numbers = list(filter(lambda x: operator.eq(operator.mod(x, 2), 0), [1, 2, 3, 4, 5, 6]))
print(f"Even numbers: {even_numbers}") # Output: Even numbers: [2, 4, 6]

            

              
                Copy
              
            
          

            import operator
from functools import reduce

numbers = [2, 3, 4, 5]

# Calculate the product of numbers
product = reduce(operator.mul, numbers)
print(f"Product: {product}") # Output: Product: 120

# Find the maximum number
maximum = reduce(operator.gt, numbers)
print(f"Maximum: {maximum}") # This doesn't work as expected for max, need to use a lambda or custom function for max: 
# Using lambda for max:
maximum_lambda = reduce(lambda x, y: x if x > y else y, numbers)
print(f"Maximum (lambda): {maximum_lambda}") # Output: Maximum (lambda): 5
# Note: The max() built-in function is generally preferred for finding the maximum.

            

              
                Copy