खोज…


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

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

पैरामीटर

पैरामीटर विवरण
समारोह मानचित्रण के लिए कार्य (पुनरावृत्तियों के रूप में कई मापदंडों को लेना चाहिए) ( स्थिति-केवल )
iterable समारोह चलने योग्य ( केवल स्थितीय ) के प्रत्येक तत्व पर लागू होता है
* additional_iterables यह देखने योग्य है, लेकिन आप की तरह के रूप में कई ( वैकल्पिक , केवल स्थिति )

टिप्पणियों

map साथ किया जा सकता है कि सब कुछ भी comprehensions साथ किया जा सकता है:

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

यदि आपके पास कई पुनरावृत्तियाँ हैं, तो आपको zip आवश्यकता होगी:

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]

सूची की समझ कुशल है और कई मामलों में map तुलना में तेज हो सकती है, इसलिए यदि आपके लिए गति महत्वपूर्ण है, तो दोनों दृष्टिकोणों के समय का परीक्षण करें।

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

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

names = ['Fred', 'Wilma', 'Barney']
अजगर 3.x 3.0
map(len, names)  # map in Python 3.x is a class; its instances are iterable
# Out: <map object at 0x00000198B32E2CF8>

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

पायथन 2.x 2.6
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 एक जनरेटर पाने के लिए

पायथन 2.x 2.3
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 2.0.1
  • map : मैपिंग के रूप में iterates के रूप में लंबे समय के रूप में एक iterable अभी भी पूरी तरह से भस्म None है, लेकिन पूरी तरह से भस्म iterables से None मानता है:

    import operator
    
    measurement1 = [100, 111, 99, 97]
    measurement2 = [102, 117]
    
    # Calculate difference between elements
    list(map(operator.sub, measurement1, measurement2))
    

    TypeError: असमर्थित ऑपरेंड प्रकार (ओं) के लिए -: 'int' और 'noneType'

  • itertools.imap और future_builtins.map : जैसे ही एक future_builtins.map बंद हो जाता है, मैपिंग बंद हो जाती है:

    import operator
    from itertools import imap
    
    measurement1 = [100, 111, 99, 97]
    measurement2 = [102, 117]
    
    # Calculate difference between elements
    list(imap(operator.sub, measurement1, measurement2))
    # Out: [-2, -6]
    list(imap(operator.sub, measurement2, measurement1))
    # Out: [2, 6]
    
अजगर 3.x 3.0.0
  • जैसे ही एक चलना बंद हो जाता है, मैपिंग बंद हो जाती है:

    import operator
    
    measurement1 = [100, 111, 99, 97]
    measurement2 = [102, 117]
    
    # Calculate difference between elements
    list(map(operator.sub, measurement1, measurement2))
    # Out: [-2, -6]
    list(map(operator.sub, measurement2, measurement1))
    # Out: [2, 6]
    

मानचित्र के साथ ट्रांज़ोज़िंग: फ़ंक्शन तर्क के रूप में "कोई नहीं" का उपयोग करना (केवल अजगर 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
अजगर 3.x 3.0.0
list(map(None, *image))

TypeError: 'noneType' ऑब्जेक्ट कॉल करने योग्य नहीं है

लेकिन समान परिणाम प्राप्त करने के लिए वर्कअराउंड है:

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']


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow