Function composition is the process of combining two or more functions so that the output of one function becomes the input of another function. தமிழில்: ஒரு function return செய்யும் value-ஐ இன்னொரு function argument-ஆக எடுத்துக்கொண்டு pro…
Tamil + English Mixed | Concept First | Inch by Inch | TRB / NET / SET / Interview Style
Function Composition என்பது ஒரு function-ன் output-ஐ மற்றொரு function-க்கு input-ஆக கொடுத்து functions-ஐ ஒன்றாக combine செய்து பயன்படுத்துவது.
One function's result becomes another function's input.
Function composition is the process of combining two or more functions so that the output of one function becomes the input of another function.
ஒரு function return செய்யும் value-ஐ இன்னொரு function argument-ஆக எடுத்துக்கொண்டு process செய்வதுதான் Function Composition.
நம்மிடம் இரண்டு functions இருக்கிறது
return x * 2
return x * x
5 × 2
=
10
10
10 × 10
=
100
இதுதான் function composition.
print(square(double(5)))
100
Function composition ஏன் தேவை?
ஒரு பெரிய task-ஐ small-small functions-ஆக பிரித்து எழுதலாம்.
ஒவ்வொரு வேலைக்கும் தனித்தனி function.
பிறகு அவற்றை combine செய்யலாம்.
Suppose:
1def f(x): 2 return ...
1def g(x): 2 return ...
g(f(x))
First → f(x)
Then → g(result of f(x))
g(f(x))
எந்த function first execute ஆகும்?
f(x)
Inner function first execute ஆகும்.
g(...)
outer function execute ஆகும்.
Inside First → Outside Next
1def add_five(x): 2 return x + 5
1def multiply_two(x): 2 return x * 2
1result = multiply_two(add_five(10))
1print(result)
30
30
add_five(10)
10 + 5
=
15
multiply_two(15)
15 × 2
=
30
30
| Step | Action |
|---|---|
| 01Iteration 1 | add_five(10) → ↓ → 10 + 5 → ↓ → 15 |
| 02Iteration 2 | multiply_two(15) → ↓ → 15 × 2 → ↓ → 30 |
| 03Final | 30 |
Outer(Inner(value))
Inner first
Outer second
square(double(5))
(f ∘ g)(x)
f(g(x))
f composed with g
f(x) = x + 2 g(x) = x × 3
(f ∘ g)(x) = f(g(x))
x = 5
g(5) =
= 15
f(15) =
= 17
(f ∘ g)(5) = 17
1def f(x): 2 return x + 2
1def g(x): 2 return x * 3
1print(f(g(5)))
17
17
Function composition-ல் order மிகவும் முக்கியம்.
f(g(5))
g(f(5))
இரண்டும் same result தர வேண்டிய அவசியமில்லை.
1def f(x): 2 return x + 2
1def g(x): 2 return x * 3
1print(f(g(5))) 2print(g(f(5)))
17 21
17 21
f(g(5))
g(5)
=
15
f(15)
=
17
g(f(5))
f(5)
=
7
g(7)
=
21
f(g(x)) ≠ g(f(x))
generally.
Function composition generally not commutative.
f(g(x))
g(f(x))
may produce different outputs.
return value
Function composition வேலை செய்ய முக்கியமானது:
1def double(x): 2 return x * 2
மூலம் output கொடுக்கிறது.
return
அந்த output தான் next function-க்கு input.
print(x * 2)
return x * x
print(square(double(5)))
இது problem தரும்.
Why?
10
print செய்கிறது.
None
square(None)
None * None
invalid.
Function composition-க்கு:
First function should normally return a value compatible with the next function's parameter.
Suppose:
1def get_length(text): 2 return len(text)
1def double(number): 2 return number * 2
double(get_length("Python"))
Works.
1def get_length(text): 2 return len(text)
1def double(number): 2 return number * 2
1print(double(get_length("Python")))
12
12
"Python"
↓
get_length()↓
6
↓
double()↓
12
return mark / 100 * 100
return "A"
return "B"
return "Pass"
return "Fail" print(grade(percentage(82)))
B
return mark / 500 * 100
return "A"
return "B"
return "C"
return "Fail" print(grade(percentage(400)))
A
grade(80)↓
AFunction composition numbers மட்டும் இல்லை.
Strings-லையும் செய்யலாம்.
return text.strip()
return text.upper()
print(upper(clean(" python ")))
PYTHON
" python "
First:
clean()
"python"
Then:
upper()
"PYTHON"
Two functions மட்டும் அல்ல.
பல functions compose செய்யலாம்.
1def add_two(x): 2 return x + 2
1def double(x): 2 return x * 2
1def square(x): 2 return x * x
1result = square(double(add_two(3)))
1print(result)
100
100
| Step | Action |
|---|---|
| 01Expression | square(double(add_two(3))) |
| 02First | add_two(3) → = → 5 |
| 03Then | double(5) → = → 10 |
| 04Then | square(10) → = → 100 |
| 05Flow | 3 → ↓ → add_two() → ↓ → 5 → ↓ → double() → ↓ → 10 → ↓ → square() → ↓ → 100 |
f(g(h(x)))
Deepest function executes first.
Same code two ways.
Without direct composition
a = add_two(3)
b = double(a)
c = square(b)
print(c)
With composition
print(square(double(add_two(3))))
Both same result.
square(double(add_two(3)))
easy.
f(g(h(k(m(x)))))
readability குறையலாம்.
அப்போது intermediate variables use செய்வது better.
1step1 = add_two(3) 2step2 = double(step1) 3result = square(step2)
Built-in functions-யும் compose செய்யலாம்.
1print(len(str(12345)))
1str(12345) 2↓ 3"12345" 4↓ 5len("12345") 6↓ 75 8↓ 9print(5)
5
5
str()
len()
print()
மூன்றும் functions.
print(len(str(12345)))
print(abs(int("-25")))
Lambda functions-லையும் composition concept பயன்படுத்தலாம்.
double = lambda x: x * 2 square = lambda x: x * x
print(square(double(5)))
100
நாமே ஒரு generic compose() function எழுதலாம்.
return lambda x: f(g(x))
Then
return x * 2
return x * x
combined = compose(square, double)
print(combined(5))
100
compose(square, double)
square(double(x))
functions-ஐ arguments-ஆக receive செய்கிறது.
def compose(f, g):
So இது Higher-Order Function concept-உடன் தொடர்புடையது.
function-ஐ argument-ஆக receive செய்யலாம்
அல்லது function-ஐ return செய்யலாம்
Function composition functional programming-ல் முக்கிய concept.
இரண்டையும் confuse செய்யக்கூடாது.
Function Composition
f(g(x))
ஒரு function result மற்ற function input.
Nested Function
pass
ஒரு function definition மற்ற function-க்குள் இருக்கும்.
இரண்டும் different concepts.
| Function Composition | Nested Function |
|---|---|
| Functions combine outputs/inputs | Function inside function definition |
| f(g(x)) | def inner() inside outer |
| Data flows between functions | Function structure |
| Functions separate-ஆக இருக்கலாம் | Inner function enclosed |
Composition
Function A calls Function B/result
f(g(x))
Recursion
Function calls itself
1def count(n): 2 count(n - 1)
becomes next function:
Function Composition encourages single responsibility.
Wrong execution order
f(g(x))
Don't think f() first.
First function doesn't return value
print(x + 1)
return x * 2
b(a(5))
a() returns None.
Composition fails if b() expects a number.
Incompatible return/input types
return "Python"
return x * x
square(get_name())
"Python" * "Python"
invalid.
So function types must be compatible.
Assuming order doesn't matter
f(g(x))
and:
g(f(x))
are generally different.
Too much nesting
a(b(c(d(e(f(x))))))
technically possible.
But readability becomes difficult.
Use intermediate variables when needed.
Output → Input
becomes next function:
Easy Tamil:
ஒரு function கொடுப்பதை அடுத்த function வாங்கும்.
For:
f(g(x))
Goes Inside First
g() is inside.
g first
f next
1. Function composition means?
One function's output is passed to another function as input.
1. In f(g(x)), which executes first?
g(x)
1. Is f(g(x)) always equal to g(f(x))?
No
1. Function composition mainly depends on?
Return values
1. First function's return value should be?
Compatible with the next function's expected input.
1. Can built-in functions be composed?
Yes
1. Can lambda functions be composed?
Yes
1. Is function composition same as recursion?
No
1. Is function composition same as nested function definition?
No
1. Mathematical notation for composition?
(f ∘ g)(x) = f(g(x))
What is function composition?
Function composition combines functions by passing the return value of one function as the argument to another function.
1result = square(double(5)) 2Which function executes first in f(g(x))?
1The inner function g(x) executes first.
25 30
Its result is passed to f().
is return important in function composition?
the output from one function must be available to pass as input to another function.
Is function composition order-sensitive?
Yes.
f(g(x)) ≠ g(f(x))
What is the advantage of function composition?
It helps create reusable, modular, testable, and easier-to-maintain code.
a(4) = 6
b(6) = 18
Answer: 18
f(g(h(x)))
B
A. Always same
B. Different concepts
B
def add10(x):
return x + 10
def double(x):
return x * 2
print(double(add10(5)))Find output.
Step:
add10(5) = 15
double(15) = 30
Answer:
30
def square(x):
return x * x
def minus_one(x):
return x - 1
print(minus_one(square(4)))Step:
square(4) = 16
minus_one(16) = 15
Answer:
15
Find difference:
def f(x):
return x + 5
def g(x):
return x * 2
print(f(g(10)))
print(g(f(10)))First:
g(10) = 20
f(20) = 25
Second:
f(10) = 15
g(15) = 30
25 30
Function Composition என்பது ஒரு function return செய்யும் output-ஐ மற்றொரு function-க்கு argument/input-ஆக கொடுத்து functions-ஐ combine செய்வது. f(g(x)) என்ற composition-ல் முதலில் g(x) execute ஆகும்; அதன் return value f()-க்கு input ஆகும். இது modular, reusable மற்றும் clean programming-க்கு மிகவும் முக்கியமான concept.