Cad iad lambdas agus na huirlisí feidhmiúla map/filter/reduce?

Question

Accepted Answer

Is **lambda** ná feidhm bheag, gan ainm, le gealadh amháin inti. **`map`**, **`filter`**, agus **`reduce`** ná uirlisí feidhmiúla a chuireann feidhm i bhfeidhm ar feadh inite. Le chéile, tugann siad stíl feidhmiúil ar fáil — ach is fearr le Python go minic na comprehenisions don obair chéanna.

## Lambda — feidhmeanna gan ainm inlíne

```python
# a lambda is a one-line function with no name
square = lambda x: x ** 2
square(5)                      # 25

# equivalent named function:
def square(x): return x ** 2
```

Tá lambdas an-bhreá mar **argóintí inlíne** do fheidhmeanna eile, go háirithe mar eochracha sort/filter:

```python
people.sort(key=lambda p: p.age)            # sort by an attribute
sorted(words, key=lambda w: len(w))          # sort by length
max(items, key=lambda x: x.score)            # find max by a criterion
```

## map — feidhm a chur i bhfeidhm ar gach eilimint

```python
nums = [1, 2, 3, 4]
list(map(lambda x: x ** 2, nums))   # [1, 4, 9, 16]
# more Pythonic alternative — a comprehension:
[x ** 2 for x in nums]               # [1, 4, 9, 16]
```

## filter — eilimintí a choimeád a bhíonn rathúil ar thástáil

```python
list(filter(lambda x: x % 2 == 0, nums))   # [2, 4]
# comprehension equivalent:
[x for x in nums if x % 2 == 0]             # [2, 4]
```

## reduce — an inite a fhilleadh i luach amháin

```python
from functools import reduce
reduce(lambda acc, x: acc + x, nums, 0)     # 10 (sum)
# but built-ins are clearer when they exist:
sum(nums)                                    # 10
```

## An rogha Pythonic

```text
For map/filter, COMPREHENSIONS are usually more readable and idiomatic:
  map(f, xs)            →  [f(x) for x in xs]
  filter(pred, xs)      →  [x for x in xs if pred(x)]
Lambdas are best for short inline keys (sort/max/filter), NOT complex logic.
```

I gcoitinne, is fearr le Guido (cruthaitheoir Python) agus an pobal comprehenisions a úsáid seachas `map`/`filter` ar mhaithe le soiléireacht; bhog siad `reduce` as na builtins fiú. Ach fanainn lambdas mar fheidhmeanna `key=` ina ngnatúsach agus coitianta.

## Cén fáth a bhíonn tábhacht ann

Tugann na huirlisí feidhmiúla seo deis duit claochluithe agus scagadh a chur in iúl go gonta.

Is féidir Python a scríobh go feidhmiúil, ach is é an rogha idiomaúil de ghnáth **comprehension** a úsáid seachas `map`/`filter` ar mhaithe le soiléireacht, agus builtín (`sum`, `max`, `min`) seachas `reduce`.

Is féidir lambdas a chaitheamh ar an spéir mar fheidhmeanna beaga inlíne a chuirtear ar `sort`/`max`/`min`/`filter` mar `key`.

Bheith tuiscint agat ar an dá dhóigh — agus bheith ar eolas agat ar an rogha Pythonic ar comprehenisions agus builtíns — cabhraíonn sin leat cód soiléir, idiomaúil a scríobh agus an cód stíle feidhmiúil a léamh a bhíonn ann i dtionscadail fhíora.