# [Python] lambda Vs. def

Recently, while solving math problems for many hours I ended up getting sick of solving simple calculation at the end of one problem, so I tried making a simple python automation programme for calculations. It was mostly about putting multiple values into a function and finding the values that make the function return 0. In the code, I was overusing lambda expression for every function I had to define.
However, some of those lambda functions I used were inside a for loop, which makes the code smelly! (Needs to be Refactored!)

This is the part of the code that smells a lot.

nominator = [1, 2, 3, 4]
denominator = [1, 3]
for d in denominator:
for u in nominator:
frac = nominator/denominator
func = lambda x: 3*(x**4) -29*(x**2) + 8

if not func(frac):
print(nominator, denominator)
print("no solution found")


Yes I’m telling you. I was pretty dumb at the moment :(

After figuring that out, I became quite curious about the performance between lambda and def, and how they behaviour differently in the back side of the high level programming language, python. What I meant by its performance is mainly as to time it takes to perform a certain task and user-usability (which one is easy to use).

### Measuring Time

I have recorded their time taken to complete one task for 100 iterations

import time
import matplotlib.pyplot as plt
import numpy as np

lambda_function = lambda x: 3*(x**4) -29*(x**2) + 8

def def_function(x):
return 3*(x**4) -29*(x**2) + 8

lambdaTime = []
defTime = []
for _ in range(100):
start1 = time.time()
lambda_function(123)
end1 = time.time()
lambdaTime.append(end1-start1)

start2 = time.time()
def_function(123)
end2 = time.time()
defTime.append(end2-start2)

#  Graph
fig, ax = plt.subplots()

x = np.array(lambdaTime)
y = np.array(defTime)

plt.scatter(np.arange(100), x, marker='o', label='lambda')
plt.scatter(np.arange(100), y, marker='^', label='def')

ax.set_xlabel("iteration")
ax.set_ylabel("def time & lambda time")

ax.set_xlim(0, 100)
ax.set_ylim(min(min(defTime, lambdaTime))-np.mean(defTime), max(max(defTime, lambdaTime))+np.mean(defTime))

ax.legend(
loc='best',
fancybox=True,
)

plt.show()


This Image shows that they have the same time-wise performance.

### Bytecode disassembling

import dis

lambda_function = lambda x: 3*(x**4) -29*(x**2) + 8

def def_function(x):
return 3*(x**4) -29*(x**2) + 8

# bytecode disassemble
print("Lambda")
dis.dis(lambda_function)
print("def")
dis.dis(def_function)


Terminal output:

Lambda
6 BINARY_POWER
8 BINARY_MULTIPLY
16 BINARY_POWER
18 BINARY_MULTIPLY
20 BINARY_SUBTRACT
26 RETURN_VALUE
def
6 BINARY_POWER
8 BINARY_MULTIPLY
16 BINARY_POWER
18 BINARY_MULTIPLY
20 BINARY_SUBTRACT