Python Language
नक्शा समारोह

वाक्य - विन्यास

• नक्शा (कार्य, चलने योग्य [, * extra_iterables])
• future_builtins.map (फ़ंक्शन, चलने योग्य [, * extra_iterables])
• itertools.imap (फ़ंक्शन, iterable [, * extra_iterables])

पैरामीटर

टिप्पणियों

list(map(abs, [-1,-2,-3]))    # [1, 2, 3]
[abs(i) for i in [-1,-2,-3]]  # [1, 2, 3]

import operator
alist = [1,2,3]
list(map(operator.add, alist, alist))  # [2, 4, 6]
[i + j for i, j in zip(alist, alist)]  # [2, 4, 6]

मानचित्र, itertools.imap और future_builtins.map का मूल उपयोग

कार्यात्मक प्रोग्रामिंग के लिए उपयोग किए गए पायथन में निर्मित नक्शा फ़ंक्शन सबसे सरल है। map() एक तत्व में एक निर्दिष्ट फ़ंक्शन को लागू करने योग्य है:

names = ['Fred', 'Wilma', 'Barney']

map(len, names)  # map in Python 3.x is a class; its instances are iterable
# Out: <map object at 0x00000198B32E2CF8>

एक पायथन 3-संगत map future_builtins मॉड्यूल में शामिल है:

from future_builtins import map  # contains a Python 3.x compatible map()
map(len, names)                  # see below
# Out: <itertools.imap instance at 0x3eb0a20>

वैकल्पिक रूप से, अजगर 2 में से एक का उपयोग कर सकते हैं imap से itertools एक जनरेटर पाने के लिए

map(len, names)   # map() returns a list
# Out: [4, 5, 6]

from itertools import imap
imap(len, names)  # itertools.imap() returns a generator
# Out: <itertools.imap at 0x405ea20>

परिणाम को स्पष्ट रूप से अजगर 2 और 3 के बीच के अंतर को दूर करने के लिए एक list परिवर्तित किया जा सकता है:

list(map(len, names))
# Out: [4, 5, 6]

map() को समकक्ष सूची समझ या जनरेटर अभिव्यक्ति द्वारा प्रतिस्थापित किया जा सकता है:

[len(item) for item in names] # equivalent to Python 2.x map()
# Out: [4, 5, 6]

(len(item) for item in names) # equivalent to Python 3.x map()
# Out: <generator object <genexpr> at 0x00000195888D5FC0>

प्रत्येक मान को एक पुनरावृत्ति में मैप करना

उदाहरण के लिए, आप प्रत्येक तत्व का पूर्ण मूल्य ले सकते हैं:

list(map(abs, (1, -1, 2, -2, 3, -3))) # the call to `list` is unnecessary in 2.x
# Out: [1, 1, 2, 2, 3, 3]

किसी सूची को मैप करने के लिए अनाम फ़ंक्शन भी समर्थन करता है:

map(lambda x:x*2, [1, 2, 3, 4, 5])
# Out: [2, 4, 6, 8, 10]

या दशमलव मानों को प्रतिशत में परिवर्तित करना:

def to_percent(num):
    return num * 100

list(map(to_percent, [0.95, 0.75, 1.01, 0.1]))
# Out: [95.0, 75.0, 101.0, 10.0]

या डॉलर को यूरो में परिवर्तित करना (विनिमय दर दिया गया):

from functools import partial
from operator import mul

rate = 0.9  # fictitious exchange rate, 1 dollar = 0.9 euros
dollars = {'under_my_bed': 1000,
           'jeans': 45,
           'bank': 5000}

sum(map(partial(mul, rate), dollars.values()))
# Out: 5440.5

functools.partial कार्यों के ठीक मापदंडों के लिए एक सुविधाजनक तरीका इतना है कि वे साथ इस्तेमाल किया जा सकता है map उपयोग करने के बजाए lambda या इच्छित कार्यों का निर्माण।

विभिन्न पुनरावृत्तियों के मानचित्रण मान

उदाहरण के लिए कई पुनरावृत्तियों के प्रत्येक i -th तत्व के औसत की गणना:

def average(*args):
    return float(sum(args)) / len(args)  # cast to float - only mandatory for python 2.x

measurement1 = [100, 111, 99, 97]
measurement2 = [102, 117, 91, 102]
measurement3 = [104, 102, 95, 101]

list(map(average, measurement1, measurement2, measurement3))
# Out: [102.0, 110.0, 95.0, 100.0]

यदि अजगर के संस्करण के आधार पर map एक से अधिक चलने योग्य को पारित किया जाता है, तो अलग-अलग आवश्यकताएं होती हैं:

• समारोह में उतने ही पैरामीटर होने चाहिए जितने कि पुनरावृत्तियाँ हैं:

  def median_of_three(a, b, c):
      return sorted((a, b, c))[1]
  
  list(map(median_of_three, measurement1, measurement2))
  

  TypeError: median_of_three () 1 आवश्यक स्थिति संबंधी तर्क गायब है: 'c'

  list(map(median_of_three, measurement1, measurement2, measurement3, measurement3))
  

  TypeError: median_of_three () 3 स्थितिगत तर्क लेता है, लेकिन 4 दिए गए थे

मानचित्र के साथ ट्रांज़ोज़िंग: फ़ंक्शन तर्क के रूप में "कोई नहीं" का उपयोग करना (केवल अजगर 2.x)

from itertools import imap
from future_builtins import map as fmap # Different name to highlight differences

image = [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]

list(map(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
list(fmap(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
list(imap(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

image2 = [[1, 2, 3],
          [4, 5],
          [7, 8, 9]]
list(map(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8), (3, None, 9)]  # Fill missing values with None
list(fmap(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8)]                # ignore columns with missing values
list(imap(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8)]                # dito

list(map(None, *image))

def conv_to_list(*args):
    return list(args)

list(map(conv_to_list, *image))
# Out: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

श्रृंखला और समानांतर मानचित्रण

नक्शा () एक अंतर्निहित फ़ंक्शन है, जिसका अर्थ है कि यह 'आयात' कथन का उपयोग करने की आवश्यकता के बिना हर जगह उपलब्ध है। यह प्रिंट की तरह ही हर जगह उपलब्ध है () यदि आप उदाहरण 5 को देखते हैं तो आप देखेंगे कि मुझे सुंदर प्रिंट (आयात प्रिंट) का उपयोग करने से पहले आयात विवरण का उपयोग करना था। इस प्रकार प्रिंट एक अंतर्निहित कार्य नहीं है

श्रृंखला मानचित्रण

इस स्थिति में चलने योग्य के प्रत्येक तर्क को आरोही क्रम में मैपिंग फ़ंक्शन के तर्क के रूप में आपूर्ति की जाती है। यह तब होता है जब हमारे पास नक्शे के लिए सिर्फ एक चलने योग्य होता है और मानचित्रण फ़ंक्शन को एक ही तर्क की आवश्यकता होती है।

उदाहरण 1

insects = ['fly', 'ant', 'beetle', 'cankerworm']
f = lambda x: x + ' is an insect'
print(list(map(f, insects))) # the function defined by f is executed on each item of the iterable insects

का परिणाम

['fly is an insect', 'ant is an insect', 'beetle is an insect', 'cankerworm is an insect']

उदाहरण 2

print(list(map(len, insects))) # the len function is executed each item in the insect list

का परिणाम

[3, 3, 6, 10]

समानांतर मानचित्रण

इस मामले में मैपिंग फ़ंक्शन का प्रत्येक तर्क समानांतर में सभी पुनरावृत्तियों (प्रत्येक पुनरावृत्ति में से एक) से खींचा जाता है। इस प्रकार आपूर्ति किए गए पुनरावृत्तियों की संख्या फ़ंक्शन द्वारा आवश्यक तर्कों की संख्या से मेल खाना चाहिए।

carnivores = ['lion', 'tiger', 'leopard', 'arctic fox']
herbivores = ['african buffalo', 'moose', 'okapi', 'parakeet']
omnivores = ['chicken', 'dove', 'mouse', 'pig']

def animals(w, x, y, z):
    return '{0}, {1}, {2}, and {3} ARE ALL ANIMALS'.format(w.title(), x, y, z)

उदाहरण 3

# Too many arguments
# observe here that map is trying to pass one item each from each of the four iterables to len. This leads len to complain that
# it is being fed too many arguments
print(list(map(len, insects, carnivores, herbivores, omnivores)))

का परिणाम

TypeError: len() takes exactly one argument (4 given)

उदाहरण 4

# Too few arguments
# observe here that map is suppose to execute animal on individual elements of insects one-by-one. But animals complain when
# it only gets one argument, whereas it was expecting four.
print(list(map(animals, insects)))

का परिणाम

TypeError: animals() missing 3 required positional arguments: 'x', 'y', and 'z'

उदाहरण 5

# here map supplies w, x, y, z with one value from across the list
import pprint
pprint.pprint(list(map(animals, insects, carnivores, herbivores, omnivores)))

का परिणाम

 ['Fly, lion, african buffalo, and chicken ARE ALL ANIMALS',
 'Ant, tiger, moose, and dove ARE ALL ANIMALS',
 'Beetle, leopard, okapi, and mouse ARE ALL ANIMALS',
 'Cankerworm, arctic fox, parakeet, and pig ARE ALL ANIMALS']