assign variables before or in loops statement performance - performance

Question

In many programming languages, assignments are legal in loops statement like this.
while(variable1 = someFunction()){
...
}
although it would be more clear code to assign variables like this I am wondering if someFunction function has a computational process in it's, it would be a better way to assign variable before loops like this
variable1 = someFunction()
while(variable1){
...
}
or no matter and compilers can detect this to do not compute it again

Answer 1

I tested this in Java,JavaScript and Python that are popular languages.
in every language first I have a function that sums from number 1 to 1000.
first I assign this value before the loop and see how many second take-ups to finish, then I assign this sum in a loop condition and see the result again
Java
public class Main {
public static void main(String args[]){
//assign variable before loop
long startTime= System.currentTimeMillis();
int counter = sum();
for (int i = 0; i < counter; i++) {
//some code
}
long finishTime = System.currentTimeMillis();
System.out.println("duration for assign before loop : "+(finishTime-startTime));
//assign variable in loop
startTime = System.currentTimeMillis();
for (int i = 0; i < sum(); i++) {
//some code
}
finishTime = System.currentTimeMillis();
System.out.println("duration for assign in loop : "+(finishTime-startTime));
}
public static int sum(){
int sum = 0;
for (int i = 1; i < 1000; i++) {
sum+=i;
}
return sum;
}
}
Then write this code in javascript:
function sum(){
let sum = 0;
for (let i = 1; i < 1000; i++) {
sum+=i;
}
return sum;
}
(function(){
//assign variable before loop
let startTime= Date.now();
let counter = sum();
for (let i = 0; i < counter; i++) {
//some code
}
let finishTime = Date.now();
console.log("duration for assign before loop : "+(finishTime-startTime))
//assign variable in loop
startTime = Date.now();
for (let i = 0; i < sum(); i++) {
//some code
}
finishTime = Date.now()
console.log("duration for assign in loop : "+(finishTime-startTime));
})()
and finally, I write this code in python
import time
def current_milli_time():
return int(round(time.time() * 1000))
def sum():
sum = 0
for i in xrange(1,1000):
sum += i
return sum
if __name__=="__main__":
#assign before loop
startTime = current_milli_time()
counter = sum()
for i in xrange(1,counter):
pass
finishTime = current_milli_time()
print("duration for assign before loop : "+str(finishTime-startTime))
#assign in loop
startTime = current_milli_time()
for i in xrange(1,sum()):
pass
finishTime = current_milli_time()
print("duration for assign in loop : "+str(finishTime-startTime))
the result was interesting.I got this result in every language
Java :
duration for assign before loop : 2
duration for assign in loop : 326
JavaScript :
duration for assign before loop : 4
duration for assign in loop : 1846
but in python I got
duration for assign before the loop : 66
duration for assign in a loop : 67
as we can see in Java and JavaScript we absolutely should not use assign variable in loops if it results is the same during loop but in python, we got almost very close duration.
Conclusion
as a conclusion, I think it's no matter what programming language we use but it's better to don't assign variables in loops if it results remain the same during the loop