দরকারী কোড যা ব্যবহার করে হ্রাস ()? [বন্ধ]

Question

এখানে কারও কাছে এমন কোনও দরকারী কোড রয়েছে যা অজগরটিতে () ফাংশন হ্রাস ব্যবহার করে? সাধারণ + এবং * ব্যতীত অন্য কোনও কোড রয়েছে যা আমরা উদাহরণগুলিতে দেখি?

পড়ুন পাইথন 3000 অদৃষ্টের কমাতে () GVR দ্বারা

Comments

from functools import reduceপাইথন 2 এবং 3 উভয় ক্ষেত্রে একই

— কোডটিকে

Answer 1

+ এবং * এর পাশাপাশি আমি অন্যান্য ব্যবহারগুলি এর সাথে পেয়েছি এবং এবং বা ছিলাম, তবে এখন আমাদের কাছে আছে anyএবং allসেই কেসগুলি প্রতিস্থাপন করতে হবে।

foldlএবং foldrস্কিমে প্রচুর আসে ...

এখানে কিছু সুন্দর ব্যবহার রয়েছে:

একটি তালিকা সমতল করুন

গোল: চালু [[1, 2, 3], [4, 5], [6, 7, 8]]মধ্যে [1, 2, 3, 4, 5, 6, 7, 8]।

reduce(list.__add__, [[1, 2, 3], [4, 5], [6, 7, 8]], [])

একটি সংখ্যার অঙ্কের তালিকা

গোল: চালু [1, 2, 3, 4, 5, 6, 7, 8]মধ্যে 12345678।

কুরুচিপূর্ণ, ধীর পথ:

int("".join(map(str, [1,2,3,4,5,6,7,8])))

সুন্দর reduceউপায়:

reduce(lambda a,d: 10*a+d, [1,2,3,4,5,6,7,8], 0)

Comments

একটি তালিকা চ্যাপ্টা করার জন্য, আমি তালিকাটি পছন্দ করি (itertools.chain (* নেস্টেড_লিস্ট))

— রবার্তো বনভোলেট

যোগফল ([[1, 2, 3], [4, 5], [6, 7, 8]], [])

— গর্ডন রাইগলে

এটি বিটওয়াইজ অপারেশনের জন্যও দরকারী। আপনি যদি বিটওয়াইস বা সংখ্যার একগুচ্ছ নিতে চান, উদাহরণস্বরূপ, যদি আপনাকে তালিকা থেকে বিটমাস্কে পতাকা রূপান্তর করতে হয়?

— এন্টিমোনি

কিছু মানদণ্ড করা, 'কুশ্রী' উপায়টি বৃহত তালিকার জন্য দ্রুত। timeit.repeat('int("".join(map(str, digit_list)))', setup = 'digit_list = list(d%10 for d in xrange(1,1000))', number=1000)০.০৯ সেকেন্ড সময় timeit.repeat('reduce(lambda a,d: 10*a+d, digit_list)', setup = 'digit_list = list(d%10 for d in xrange(1,1000))', number=1000)লাগে যখন 0.36 সেকেন্ড লাগে (প্রায় 4 গতি ধীর)। মূলত 10 টি দ্বারা গুণন ব্যয়বহুল হয়ে যায় যখন তালিকাটি বড় হয়, যখন ইন্ট টু স্টার এবং কনটেনটেশন সস্তা থাকে।

— ডাঃ জিম্বব

মঞ্জুরিপ্রাপ্ত, হ্যাঁ ছোট তালিকার জন্য (আকার 10) তারপরে হ্রাস করার পদ্ধতিটি 1.3 গুণ বেশি দ্রুত। তবে, এক্ষেত্রে, সাধারণ লুপটি হ্রাস এবং এড়াতে আরও দ্রুত timeit.repeat('convert_digit_list_to_int(digit_list)', setup = 'digit_list = [d%10 for d in xrange(1,10)]\ndef convert_digit_list_to_int(digits):\n i = 0\n for d in digits:\n i = 10*i + d\n return i', number=100000)0.06 সেকেন্ড timeit.repeat('reduce(lambda a,d: 10*a+d, digit_list)', setup = 'digit_list = list(d%10 for d in xrange(1,10))', number=100000)লাগে, 0.12 গুলি লাগে এবং অঙ্কগুলি স্ট্রিং পদ্ধতিতে রূপান্তর করতে 0.16 এস লাগে।

— ডাঃ জিম্বব

Answer 2

reduce()3 বা ততোধিক সংখ্যার জন্য কমপক্ষে সাধারণ একাধিক খুঁজে পেতে ব্যবহার করা যেতে পারে :

#!/usr/bin/env python
from fractions import gcd
from functools import reduce

def lcm(*args):
    return reduce(lambda a,b: a * b // gcd(a, b), args)

উদাহরণ:

>>> lcm(100, 23, 98)
112700
>>> lcm(*range(1, 20))
232792560

Comments

কি lcmদ্বিতীয় লাইন কি?

— দাড়ি

@ বার্ডজাগুয়ারআইভিও: উত্তরের লিঙ্কটি অনুসরণ করুন । lcm()দুটি সংখ্যার মধ্যে সর্বনিম্ন সাধারণ একাধিক প্রদান করে।

— jfs

Answer 3

reduce()বিন্দুযুক্ত নামগুলি সমাধান করতে ব্যবহার করা যেতে পারে (যেখানে eval()ব্যবহার করা খুব নিরাপদ নয়):

>>> import __main__
>>> reduce(getattr, "os.path.abspath".split('.'), __main__)
<function abspath at 0x009AB530>

Answer 4

প্রদত্ত এনগুলির তালিকাগুলির ছেদটি সন্ধান করুন:

input_list = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]]

result = reduce(set.intersection, map(set, input_list))

আয়:

result = set([3, 4, 5])

মাধ্যমে: পাইথন - দুটি তালিকার ছেদ

Comments

সংশ্লিষ্ট উত্তরে আমার মন্তব্য দেখুন

— jfs

Answer 5

আমি মনে করি হ্রাস একটি নির্বোধ আদেশ। অত: পর:

reduce(lambda hold,next:hold+chr(((ord(next.upper())-65)+13)%26+65),'znlorabggbbhfrshy','')

Comments

আমি এখানে

— রোমান

Answer 6

reduceআমার কোডটিতে আমি যে ব্যবহারটি পেয়েছি তার ব্যবহারের সাথে যুক্তিটি প্রকাশের জন্য আমার কিছু শ্রেণি কাঠামো ছিল এবং আমি এই অভিব্যক্তিগুলির একটি তালিকাকে প্রকাশের সংমিশ্রণে রূপান্তর করতে পারি। আমি make_andদুটি অভিব্যক্তি দেওয়া একটি সংযোগ তৈরি করতে ইতিমধ্যে আমার একটি ফাংশন ছিল , তাই আমি লিখেছিলাম reduce(make_and,l)। (আমি জানতাম যে তালিকাটি খালি নয়; অন্যথায় এটি এমন কিছু হত reduce(make_and,l,make_true))

ঠিক এই কারণেই (কিছু) ফাংশনাল প্রোগ্রামারগুলি পছন্দ করে reduce(বা ভাঁজ ফাংশন, যেমন ফাংশন সাধারণত বলা হয়)। সেখানে প্রায়ই মত ইতিমধ্যে অনেক বাইনারি ফাংশন হয় +, *, min, max, সংযুক্তকরণের আমার ক্ষেত্রে, এবং make_andএবং make_or। একটি থাকার reduceকারণে তালিকাগুলিতে এই ক্রিয়াকলাপগুলি উত্থাপিত করা (বা গাছ বা আপনি যা পেয়েছেন, সাধারণভাবে ভাঁজ ফাংশনের জন্য) তুচ্ছ করে তোলে।

অবশ্যই, যদি নির্দিষ্ট কিছু ইনস্ট্যান্টেশন (যেমন sum) প্রায়শই ব্যবহৃত হয়, তবে আপনি লিখতে চান না reduce। তবে sumকিছু ফর-লুপের সাহায্যে সংজ্ঞা না দেওয়ার পরিবর্তে আপনি এটিকে সহজেই সংজ্ঞায়িত করতে পারেনreduce ।

পঠনযোগ্যতা, যেমন অন্যেরা উল্লিখিত হয়েছে, আসলেই এটি একটি সমস্যা। আপনি তর্ক করতে পারেন, তবে লোকেরা reduceকম "পরিষ্কার" হওয়ার কারণ হ'ল কারণ এটি এমন কোনও ফাংশন নয় যা অনেক লোক জানে এবং / অথবা ব্যবহার করে।

Comments

খালি তালিকার বিরুদ্ধে রক্ষা করতে আপনি andঅপারেটরের শর্ট সার্কিট আচরণটি কাজে লাগাতে L and reduce(make_and, L)পারেন : যদি খালি তালিকায় ফিরে আসা এই ক্ষেত্রে উপযুক্ত

— jfs

Answer 7

ফাংশন রচনা : আপনার যদি ইতিমধ্যে ক্রমাগত প্রয়োগ করতে চান এমন ফাংশনগুলির একটি তালিকা থাকে যেমন:

color = lambda x: x.replace('brown', 'blue')
speed = lambda x: x.replace('quick', 'slow')
work = lambda x: x.replace('lazy', 'industrious')
fs = [str.lower, color, speed, work, str.title]

তারপরে আপনি এগুলির সাথে একটানা সমস্ত প্রয়োগ করতে পারেন:

>>> call = lambda s, func: func(s)
>>> s = "The Quick Brown Fox Jumps Over the Lazy Dog"
>>> reduce(call, fs, s)
'The Slow Blue Fox Jumps Over The Industrious Dog'

এই ক্ষেত্রে, পদ্ধতি শৃঙ্খলা আরও পঠনযোগ্য হতে পারে। তবে কখনও কখনও এটি সম্ভব হয় না, এবং এই জাতীয় রচনাটি এক f1(f2(f3(f4(x))))ধরণের সিনট্যাক্সের চেয়ে বেশি পঠনযোগ্য এবং রক্ষণাবেক্ষণযোগ্য হতে পারে ।

Comments

একটি সুবিধা হ'ল আপনি কোডটিতে প্রয়োগ করার জন্য ফাংশনগুলির তালিকা পরিবর্তন করতে পারেন।

— হ্যাঙ্কক

Answer 8

আপনি এর value = json_obj['a']['b']['c']['d']['e']সাথে প্রতিস্থাপন করতে পারেন:

value = reduce(dict.__getitem__, 'abcde', json_obj)

আপনার যদি ইতিমধ্যে a/b/c/..একটি তালিকা হিসাবে পথ থাকে । উদাহরণস্বরূপ, তালিকার আইটেমগুলি ব্যবহার করে নেস্টেড ডিক্টের ডিকের মানগুলি পরিবর্তন করুন ।

Answer 9

@ ব্লেয়ার কনরাড: আপনি নিজের গ্লোব বাস্তবায়ন করতে / যোগফলটি কমিয়ে ব্যবহার করতে পারেন:

files = sum([glob.glob(f) for f in args], [])

এটি আপনার দুটি উদাহরণের তুলনায় কম ভার্বোজ, পুরোপুরি পাইথোনিক, এবং এখনও কোডের একটি লাইন।

সুতরাং আসল প্রশ্নের উত্তর দেওয়ার জন্য, আমি ব্যক্তিগতভাবে হ্রাস ব্যবহার এড়াতে চেষ্টা করি কারণ এটি কখনই সত্যই প্রয়োজন হয় না এবং এটি অন্যান্য পদ্ধতির চেয়ে কম পরিষ্কার বলে আমি মনে করি। তবে কিছু লোক কমার জন্য অভ্যস্ত হয়ে যায় এবং তা বোঝার তালিকাগুলি (বিশেষত হাস্কেল প্রোগ্রামারস) তালিকাতে পছন্দ করতে আসে। তবে আপনি যদি হ্রাসের দিক থেকে কোনও সমস্যা নিয়ে ইতিমধ্যে চিন্তা না করে থাকেন তবে সম্ভবত এটি ব্যবহারের জন্য আপনার চিন্তা করার দরকার নেই।

Comments

উভয় sumএবং reduceচতুর্ভুজ আচরণের নেতৃত্ব। এটা তোলে রৈখিক সময়ের মধ্যে সম্পন্ন করা যেতে পারে: files = chain.from_iterable(imap(iglob, args))। যদিও এটির কারণে সম্ভবত ডিসক অ্যাক্সেস করতে গ্লোব () লাগে।

— jfs

Answer 10

reduce শৃঙ্খলযুক্ত অ্যাট্রিবিউট লুকআপ সমর্থন করতে ব্যবহার করা যেতে পারে:

reduce(getattr, ('request', 'user', 'email'), self)

অবশ্যই এটি সমান

self.request.user.email

তবে এটি কার্যকর যখন আপনার কোডগুলিতে গুণাবলীর একটি স্বেচ্ছাসেবী তালিকা গ্রহণ করা দরকার।

(জ্যাঙ্গো মডেলগুলির সাথে কাজ করার সময় নির্বিচারে দৈর্ঘ্যের শৃঙ্খলযুক্ত বৈশিষ্ট্যগুলি সাধারণ)

Answer 11

reduceযখন আপনাকে setপছন্দসই বস্তুর সিকোয়েন্সের ইউনিয়ন বা ছেদ খুঁজতে হবে তখন দরকারী ।

>>> reduce(operator.or_, ({1}, {1, 2}, {1, 3}))  # union
{1, 2, 3}
>>> reduce(operator.and_, ({1}, {1, 2}, {1, 3}))  # intersection
{1}

(প্রকৃত setগুলি ব্যতীত এর একটি উদাহরণ জ্যাঙ্গোর কিউ অবজেক্ট ।

অন্যদিকে, আপনি যদি boolএর সাথে ডিল করছেন , আপনার ব্যবহার করা উচিত anyএবং all:

>>> any((True, False, True))
True

Answer 12

আমার কোডটি গ্রেপ করার পরে, ফ্যাক্টরিয়ালটি গণনা করা কেবলমাত্র এটিই আমি হ্রাস ব্যবহার করেছি বলে মনে হচ্ছে:

reduce(operator.mul, xrange(1, x+1) or (1,))

Comments

তারপরে এটি ম্যাথ.ফ্যাক্টোরিয়াল ডকস.প্যাথন.আর.

— ২

Answer 13

আমি একটি ভাষার জন্য একটি রচনা ফাংশন লিখছি, তাই আমি আমার প্রয়োগ অপারেটরের সাথে হ্রাস ব্যবহার করে রচনা ফাংশনটি তৈরি করি।

সংক্ষেপে, রচনা একটি একক ফাংশন রচনা করতে ফাংশনগুলির একটি তালিকা নেয়। যদি আমার কোনও জটিল অপারেশন থাকে যা পর্যায়ক্রমে প্রয়োগ করা হয়, তবে আমি এটির মতো সমস্ত কিছু একসাথে রাখতে চাই:

complexop = compose(stage4, stage3, stage2, stage1)

এইভাবে, আমি তারপরে এটির মতো অভিব্যক্তিতে এটি প্রয়োগ করতে পারি:

complexop(expression)

এবং আমি এটির সমতুল্য হতে চাই:

stage4(stage3(stage2(stage1(expression))))

এখন, আমার অভ্যন্তরীণ বস্তুগুলি তৈরি করতে, আমি এটি বলতে চাই:

Lambda([Symbol('x')], Apply(stage4, Apply(stage3, Apply(stage2, Apply(stage1, Symbol('x'))))))

(লাম্বদা শ্রেণি একটি ব্যবহারকারী-সংজ্ঞায়িত ফাংশন তৈরি করে এবং প্রয়োগ একটি ফাংশন অ্যাপ্লিকেশন তৈরি করে))

এখন, হ্রাস করুন, দুর্ভাগ্যক্রমে, ভুল উপায়ে ভাঁজ হয়, তাই আমি মোটামুটিভাবে:

reduce(lambda x,y: Apply(y, x), reversed(args + [Symbol('x')]))

কী কী উত্পাদন হ্রাস করে তা নির্ধারণের জন্য, আরএপিএলে এগুলি ব্যবহার করে দেখুন:

reduce(lambda x, y: (x, y), range(1, 11))
reduce(lambda x, y: (y, x), reversed(range(1, 11)))

Comments

আমি পারফরম্যান্স পরীক্ষার জন্য সমস্ত কার্যকারিতা সংমিশ্রণগুলি তৈরিcompose = lambda *func: lambda arg: reduce(lambda x, f: f(x), reversed(funcs), arg) করতে ব্যবহার করেছি ।

— jfs

Answer 14

সর্বাধিক নবম উপাদান সহ তালিকাটি পেতে ব্যবহার হ্রাস করা যাবে

reduce(lambda x,y: x if x[2] > y[2] else y,[[1,2,3,4],[5,2,5,7],[1,6,0,2]])

[৫, ২, ৫,]] ফিরে আসবে কারণ এটি সর্বোচ্চ তৃতীয় উপাদান + এর তালিকা রয়েছে

Comments

সর্বাধিক (lst, কী =

— ল্যাম্বদা

Answer 15

হ্রাস কেবল স্কেলারের অপারেশনে সীমাবদ্ধ নয়; এটি বালতিতে জিনিসগুলিকে বাছাই করতেও ব্যবহার করা যেতে পারে। (এটি আমি প্রায়শই হ্রাস ব্যবহার করি)।

এমন কোনও ক্ষেত্রে কল্পনা করুন যাতে আপনার কাছে অবজেক্টগুলির একটি তালিকা রয়েছে এবং আপনি বস্তুতে সমতলভাবে সঞ্চিত বৈশিষ্ট্যের উপর ভিত্তি করে এটিকে স্তরক্রমিকভাবে পুনরায় সংগঠিত করতে চান। নিম্নলিখিত উদাহরণে, আমি articlesফাংশন সহ একটি এক্সএমএল-এনকোডেড সংবাদপত্রে নিবন্ধ সম্পর্কিত মেটাডেটা অবজেক্টগুলির একটি তালিকা প্রস্তুত করি । articlesএক্সএমএল উপাদানগুলির একটি তালিকা তৈরি করে এবং তারপরে একে একে ম্যাপ করে এমন বস্তু তৈরি করে যা তাদের সম্পর্কে কিছু আকর্ষণীয় তথ্য রাখে। সামনের প্রান্তে, আমি ব্যবহারকারীকে বিভাগ / উপশাখা / শিরোনাম দ্বারা নিবন্ধগুলি ব্রাউজ করতে দিতে চাইছি। সুতরাং আমি reduceনিবন্ধগুলির তালিকা গ্রহণ করতে এবং একটি একক অভিধান ফেরত দিতে ব্যবহার করি যা বিভাগ / উপশাখা / নিবন্ধক্রমক্রমকে প্রতিফলিত করে।

from lxml import etree
from Reader import Reader

class IssueReader(Reader):
    def articles(self):
        arts = self.q('//div3')  # inherited ... runs an xpath query against the issue
        subsection = etree.XPath('./ancestor::div2/@type')
        section = etree.XPath('./ancestor::div1/@type')
        header_text = etree.XPath('./head//text()')
        return map(lambda art: {
            'text_id': self.id,
            'path': self.getpath(art)[0],
            'subsection': (subsection(art)[0] or '[none]'),
            'section': (section(art)[0] or '[none]'),
            'headline': (''.join(header_text(art)) or '[none]')
        }, arts)

    def by_section(self):
        arts = self.articles()

        def extract(acc, art):  # acc for accumulator
            section = acc.get(art['section'], False)
            if section:
                subsection = acc.get(art['subsection'], False)
                if subsection:
                    subsection.append(art)
                else:
                    section[art['subsection']] = [art]
            else:
                acc[art['section']] = {art['subsection']: [art]}
            return acc

        return reduce(extract, arts, {})

আমি এখানে উভয় ফাংশন দিয়েছি কারণ আমি মনে করি এটি মানচিত্র এবং হ্রাস কীভাবে একে অপরের সাথে সুন্দরভাবে পরিপূরক করতে পারে তা অবজেক্টের সাথে কাজ করার সময় দেখায়। লুপের জন্য একই জিনিসটি সম্পন্ন করা যেতে পারে, ... তবে কার্যকরী ভাষার সাথে কিছুটা গুরুতর সময় ব্যয় করা আমাকে মানচিত্রের দিক থেকে ভাবতে এবং হ্রাস করার প্রবণতা তৈরি করেছে।

যাইহোক, আমি যেভাবে কাজ করছি তার মতো সম্পত্তি নির্ধারণের জন্য যদি কারওর আরও ভাল উপায় থাকে তবে extractযেখানে আপনি সেট করতে চান সেই সম্পত্তিটির পিতামাতারা এখনও থাকতে পারেন না, দয়া করে আমাকে জানান।

Answer 16

আপনার পরে কী তা নিশ্চিত কিনা তবে আপনি গুগলে সোর্স কোডটি অনুসন্ধান করতে পারেন ।

গুগল কোড অনুসন্ধানে 'ফাংশন: কমিয়ে () ল্যাং: অজগর' অনুসন্ধানের জন্য লিঙ্কটি অনুসরণ করুন

প্রথম নজরে নিম্নলিখিত প্রকল্পগুলি ব্যবহার করে reduce()

• মঈন মঈন
• Zope
• সাংখ্যিক
• ScientificPython

ইত্যাদি ইত্যাদি তবে এগুলি বিস্ময়কর নয় কারণ এগুলি বিশাল প্রকল্প huge

হ্রাস কার্যকারিতা ফাংশন পুনরাবৃত্তি ব্যবহার করে করা যেতে পারে যা আমার অনুমান যে গুডোর ধারণা আরও স্পষ্ট ছিল।

হালনাগাদ:

যেহেতু গুগলের কোড অনুসন্ধানটি 15-জানুয়ারী -2012 এ বন্ধ ছিল, নিয়মিত গুগল অনুসন্ধানগুলিতে ফিরে আসার পাশাপাশি কোড স্নিপেটস সংগ্রহ নামেও কিছু রয়েছে যা আশাব্যঞ্জক বলে মনে হচ্ছে। গুগল কোড সন্ধানের প্রতিস্থাপন এই (বদ্ধ) প্রশ্নের উত্তরে অন্যান্য সংখ্যক সংস্থানসমূহ উল্লেখ করা হয়েছে ? ।

আপডেট 2 (29-মে-2017):

পাইথন উদাহরণগুলির জন্য একটি ভাল উত্স (ওপেন সোর্স কোডে) হ'ল নুল্লেজ অনুসন্ধান ইঞ্জিন ।

Comments

"হ্রাস কার্যকারিতা ফাংশন পুনরাবৃত্তি ব্যবহার করে করা যেতে পারে" ... বা একটি forলুপ।

— জেসন ওরেডরফ

এছাড়াও, হ্রাসের জন্য অনুসন্ধান করা () তাদের কোডের মধ্যে ফাংশন হ্রাস করার সংজ্ঞা দেয় এমন প্রকল্পগুলি দেয়। অন্তর্নির্মিত ফাংশনের প্রকৃত ব্যবহারগুলি খুঁজে পেতে

— অজগরটি

@ শিউন ওসোয়া: এমনকি অনুসন্ধানে উত্স কোড কোডিং শৈলীর উপর নির্ভর করে lang:python "reduce("সংজ্ঞা পাওয়া যাবে reduce।

— মার্টিনিউ

Answer 17

import os

files = [
    # full filenames
    "var/log/apache/errors.log",
    "home/kane/images/avatars/crusader.png",
    "home/jane/documents/diary.txt",
    "home/kane/images/selfie.jpg",
    "var/log/abc.txt",
    "home/kane/.vimrc",
    "home/kane/images/avatars/paladin.png",
]

# unfolding of plain filiname list to file-tree
fs_tree = ({}, # dict of folders
           []) # list of files
for full_name in files:
    path, fn = os.path.split(full_name)
    reduce(
        # this fucction walks deep into path
        # and creates placeholders for subfolders
        lambda d, k: d[0].setdefault(k,         # walk deep
                                     ({}, [])), # or create subfolder storage
        path.split(os.path.sep),
        fs_tree
    )[1].append(fn)

print fs_tree
#({'home': (
#    {'jane': (
#        {'documents': (
#           {},
#           ['diary.txt']
#        )},
#        []
#    ),
#    'kane': (
#       {'images': (
#          {'avatars': (
#             {},
#             ['crusader.png',
#             'paladin.png']
#          )},
#          ['selfie.jpg']
#       )},
#       ['.vimrc']
#    )},
#    []
#  ),
#  'var': (
#     {'log': (
#         {'apache': (
#            {},
#            ['errors.log']
#         )},
#         ['abc.txt']
#     )},
#     [])
#},
#[])

Comments

এখানে কী চলছে সে সম্পর্কে আপনি কিছুটা ব্যাখ্যা যোগ করতে পারেন? অন্যথায়, উপযোগটি সত্যই স্পষ্ট নয়।

— জোড়ান পাভলভিক

Answer 18

def dump(fname,iterable):
  with open(fname,'w') as f:
    reduce(lambda x, y: f.write(unicode(y,'utf-8')), iterable)

Answer 19

আমি ব্যবহৃত reduce পোস্টগ্রি অনুসন্ধান ভেক্টর একটি তালিকা কনক্যাটেনেট করার সঙ্গে ||sqlalchemy-অনুসন্ধানযোগ্য মধ্যে অপারেটর:

vectors = (self.column_vector(getattr(self.table.c, column_name))
           for column_name in self.indexed_columns)
concatenated = reduce(lambda x, y: x.op('||')(y), vectors)
compiled = concatenated.compile(self.conn)

Answer 20

আমার কাছে পাইপগ্রিপের পুরানো পাইথন বাস্তবায়ন রয়েছে যা প্রসেসের জন্য ফাইলগুলির একটি তালিকা তৈরি করতে হ্রাস এবং গ্লোব মডিউল ব্যবহার করে:

files = []
files.extend(reduce(lambda x, y: x + y, map(glob.glob, args)))

আমি এটিকে খুব সহজেই দেখতে পেলাম, তবে এটি সত্যিই প্রয়োজনীয় নয়, কারণ অনুরূপ কিছু ঠিক তত ভাল, এবং সম্ভবত আরও পাঠযোগ্য

files = []
for f in args:
    files.extend(glob.glob(f))

Comments

কিভাবে একটি তালিকা বোঝার সম্পর্কে? এটি এর জন্য নিখুঁত প্রয়োগের মতো বলে মনে হচ্ছে: files = [glob.glob(f) for f in args]

— স্টিভাহ

আসলে, @ ধীরে ধীরে, আপনার উদাহরণটি গ্লোবগুলির সাথে মেলে এমন সমস্ত আইটেমের সমতল তালিকার চেয়ে প্রসারিত গ্লোবগুলির তালিকার তালিকা তৈরি করবে, তবে আপনি @ [এলি কোর্টরাইট] (# 16198) হিসাবে একটি তালিকা বোঝার + সমষ্টি ব্যবহার করতে পারেন ) পয়েন্ট আউট।

— ব্লেয়ার কনরাড

ঠিক আছে, আপনি সঠিক, সে সম্পর্কে দুঃখিত। আমি এখনও প্রসারিত / হ্রাস / ল্যাম্বদা / মানচিত্রের সংমিশ্রণটি খুব পছন্দ করি না! আমি ডকস.পিথন.আর.এলথার.আই.আর.লিটরি / সাইটোরলস.চ.টি.এম.এল থেকে রেসিপিটি itertoolsব্যবহার করে আমদানি করার পরামর্শ দেব এবং তারপরে লিখব: (এবং এবার, আমি কোডটি পোস্ট করার আগে কোডটি পরীক্ষা করেছি এবং আমি এটি সঠিকভাবে জানি))flatten()files = flatten(glob.glob(f) for f in args)

— স্টিভেহা

files = chain.from_iterable(imap(iglob, args))যেখানে chain, মডিউল imapথেকে রয়েছে itertoolsএবং glob.iglobদরকারী যদি কোনও প্যাটার্ন argsথেকে বিভিন্ন ডিরেক্টরি থেকে ফাইল পাওয়া যায়।

— jfs

Answer 21

ধরা যাক যে কিছু বার্ষিক পরিসংখ্যান তথ্য কাউন্টারগুলির একটি তালিকা সঞ্চিত আছে। আমরা বিভিন্ন বছরে প্রতিটি মাসে এমআইএন / ম্যাক্স মান খুঁজে পেতে চাই। উদাহরণস্বরূপ, জানুয়ারীর জন্য এটি 10 ​​হবে এবং ফেব্রুয়ারির জন্য এটি 15 হবে We আমাদের ফলাফলগুলি একটি নতুন কাউন্টারে সংরক্ষণ করতে হবে।

from collections import Counter

stat2011 = Counter({"January": 12, "February": 20, "March": 50, "April": 70, "May": 15,
           "June": 35, "July": 30, "August": 15, "September": 20, "October": 60,
           "November": 13, "December": 50})

stat2012 = Counter({"January": 36, "February": 15, "March": 50, "April": 10, "May": 90,
           "June": 25, "July": 35, "August": 15, "September": 20, "October": 30,
           "November": 10, "December": 25})

stat2013 = Counter({"January": 10, "February": 60, "March": 90, "April": 10, "May": 80,
           "June": 50, "July": 30, "August": 15, "September": 20, "October": 75,
           "November": 60, "December": 15})

stat_list = [stat2011, stat2012, stat2013]

print reduce(lambda x, y: x & y, stat_list)     # MIN
print reduce(lambda x, y: x | y, stat_list)     # MAX

Answer 22

আমার কাছে কিছু ধরণের ওভারল্যাপিং অন্তরগুলি (জিনোমিক এক্সোনস) উপস্থাপন করে এবং তাদের ছেদগুলি ব্যবহার করে এই ব্যবহার করে নতুন সংজ্ঞা দেওয়া হয়েছে __and__:

class Exon:
    def __init__(self):
        ...
    def __and__(self,other):
        ...
        length = self.length + other.length  # (e.g.)
        return self.__class__(...length,...)

তারপরে যখন আমি সেগুলির একটি সংগ্রহ করব (উদাহরণস্বরূপ, একই জিনে), আমি ব্যবহার করি

intersection = reduce(lambda x,y: x&y, exons)

Answer 23

আমি স্রেফ এর দরকারী ব্যবহার পেয়েছি reduce: ডিলিমিটারটি সরিয়ে না দিয়ে বিভক্ত স্ট্রিং । কোডটি পুরোপুরি প্রোগ্রামারিক স্পিকিং ব্লগের। কোডটি এখানে:

reduce(lambda acc, elem: acc[:-1] + [acc[-1] + elem] if elem == "\n" else acc + [elem], re.split("(\n)", "a\nb\nc\n"), [])

ফলাফল এখানে:

['a\n', 'b\n', 'c\n', '']

নোট করুন যে এটি প্রান্তের কেসগুলি পরিচালনা করে যা জনপ্রিয় উত্তরটি তাই দেয় না। আরও গভীরতার ব্যাখ্যার জন্য, আমি আপনাকে মূল ব্লগ পোস্টে পুনর্নির্দেশ করছি।

Answer 24

তারিখগুলির তালিকা পরপর রয়েছে কিনা তা জানতে () হ্রাস ব্যবহার করে:

from datetime import date, timedelta


def checked(d1, d2):
    """
    We assume the date list is sorted.
    If d2 & d1 are different by 1, everything up to d2 is consecutive, so d2
    can advance to the next reduction.
    If d2 & d1 are not different by 1, returning d1 - 1 for the next reduction
    will guarantee the result produced by reduce() to be something other than
    the last date in the sorted date list.

    Definition 1: 1/1/14, 1/2/14, 1/2/14, 1/3/14 is consider consecutive
    Definition 2: 1/1/14, 1/2/14, 1/2/14, 1/3/14 is consider not consecutive

    """
    #if (d2 - d1).days == 1 or (d2 - d1).days == 0:  # for Definition 1
    if (d2 - d1).days == 1:                          # for Definition 2
        return d2
    else:
        return d1 + timedelta(days=-1)

# datelist = [date(2014, 1, 1), date(2014, 1, 3),
#             date(2013, 12, 31), date(2013, 12, 30)]

# datelist = [date(2014, 2, 19), date(2014, 2, 19), date(2014, 2, 20),
#             date(2014, 2, 21), date(2014, 2, 22)]

datelist = [date(2014, 2, 19), date(2014, 2, 21),
            date(2014, 2, 22), date(2014, 2, 20)]

datelist.sort()

if datelist[-1] == reduce(checked, datelist):
    print "dates are consecutive"
else:
    print "dates are not consecutive"