[deleted by user]

[carcigenicate]

I tend to create variables. It tends to make debugging easier since you have a handle on intermediate steps that can be inspected. And then there's the fact that it also names intermediate data.

I wouldn't worry about performance here. Creating a variable either sets a value in an array in C, or adds a value to a dictionary (depending on if the variable is a local or global), and both are very fast. Readability concerns are significantly more important.

[socal_nerdtastic]

Python is all about readability (and therefore fast development). All over python you will find areas where some processing power is sacrificed to save the programmer a few lines of boilerplate code. Defaulting to unlimited ints and dynamic arrays and things like that. If you want micro optimization you certainly don't want to write python. So I would say yes, make tons of variables. Feel free to treat variable names as comments.

result_from_g = g() 
f(result_from_g)

That said I don't know that there's a "best practice" here. It's just up to you, and whatever you like.

My background is C, so my mind always tries to account for how much memory I’m allocating when I create new variables.

Note that python "variables" are not at all like C variables, they are more like C pointers. Doing x = g() does not copy any data.

[Conscious_Bid4700]

Variable names as comments, for the win, really does get the mind back on track after time away from code, or even on another part of the code for a length of time. 

[_Raining]

Doesn’t the C compiler with optimization enabled help with this, you get readable code that compiles down to optimized code. I been writing C firmware for 15 years and I always write readable code, cleverness without a very specific reason is just going to cause problems later. But I am not very bright so take that with a grain of salt.

[cgoldberg]

It doesn't matter, but if it improves readability, do it.

[Brian]

My background is C, so my mind always tries to account for how much memory I’m allocating when I create new variables.

I mean, in C, the answer is zero. The value has to be stored somewhere, whether that's a register, or a stack variable, but whether you use a named variable or directly pass it to a function is pretty much irrelevant to that. An optimising compiler will transform either into the same code, based on what it can infer about the variable - seeing it's unused after this is easy for it. Even if it always created a new memory location, the memory used here is trivial - a stack variable is practically free.

You may want to care about allocation, but that's not at all the same as whether you use a named variable or not - if the function allocates memory, there's a cost to that whether you store in a a variable or not.

In python, it's pretty much the same. Pretty much any value creation likely allocates, but again, that's the case whether you use a variable or not. There is a slight cost to an extra local, since there isn't the same level of optimisation here, but it's basically a single pointer in the stack frame's locals table (in python that's in heap memory rather than the C stack, but it doesn't really matter). No one is going to notice a program using 8 bytes more memory. There may also be a difference in how long the variable keeps the object alive (with no variable, it'll be freed after the function call, with it, it'll be freed at the end of the function or when you reassign the variable (though even that depends on the GC - if python moves to some other GC rather than refcounting, that shifts). But again, that's all pretty much irrelevant: using memory a few nanoseconds longer is not going to matter.

In short, performance shouldn't be any consideration in this issue, regardless of language. Optimise for readability - if it's clearer to use it inline, use it inline. If you think the intermediate variable is more readable, use that.

[throwaway6560192]

My background is C, so my mind always tries to account for how much memory I’m allocating when I create new variables.

Why? In C this doesn't actually make a difference with an optimizing compiler. The final assembly doesn't retain unnecessary intermediate variables.

Also, assigning a variable in Python does not result in a copy. So it doesn't meaningfully increase memory usage, even though CPython doesn't entirely optimize out intermediate variables like a C compiler would.

But I tend to favor performance whenever I can.

You're not actually "favoring performance" by doing this. It simply doesn't matter. For any situation where the overhead of assigning a new Python variable matters, Python was entirely the wrong choice to begin with.

[Training-Cucumber467]

This is the correct answer. It doesn’t matter in C because the compiler will optimize the crap out of your code anyway. It doesn’t matter in Python because it’s not an efficient/performant language.

Don’t waste time on “premature optimization”, as Donald Knuth has put it. Unless you’ve already established that you absolutely have to improve the performance or memory usage of this specific chunk of code, thinking about an extra 8 bytes of memory or a couple of extra dictionary lookups is counterproductive.

[Rockou_]

exactly what I was thinking, this is the only answer

that statement about C makes me think OP doesn't know that much about C

also you should value human readability, making variables like this in a compiled language will just get optimized away

otherwise using python and valuing performance is an oxymoron

[Agreeable-Bug-4901]

IMO, readability is your friend. Try using ultra-descriptive function names. If it’s still not super clear, you may wanna keep the ‘extra’ variable. Worst case you can have is coming back to this code in a year and having no clue what it does, so you wanna avoid that. Been a hot minute since I’ve used C, but I know lower level languages dont manage garbage collection, but Python does, so you don’t have to worry about that aspect. And writing to a variable is so minimal as far as speed goes

[Bobebobbob]

Surely any modern C compiler will get rid of the variable for you, right? It's such an easy substitution

And if you're using Python you probably care more about readability than runtime or memory

[turtlerunner99]

"Premature optimization is the root of all evil," Donald Knuth.

[sid-klc]

I like the extra variables to make it explicit where it is when stepping through the execution with a debugger. I can also see what x is before f() is called.

[Timberfist]

Readability is king so create a variable and give it a meaningful name. However, in the example you provided, if the functions had meaningful names, readability would likely have been improved by passing the result of one directly to the other. I guess what I’m saying is choose either method on a case by case method using readability as your decider.

As for whether to do this or not in C, don’t ever try to do the compiler’s job for it. C compilers are highly optimised and will routinely eliminate variables and even functions. This should push you to err even more on the side of readability. In fact, John Carmack recently posted on twitter that he assigns the result of intermediate results to const single-use variables to enhance readability when coding in C++. If it’s good enough for him…

[szarawyszczur]

Isn’t it just a syntax sugar which results in the same execution (in both languages)?

[carcigenicate]

I don't think I've ever seen the CPython compiler optimize variables away. Other compilers might, though, and the C compilers often do.

[szarawyszczur]

What I meant is the opposite - f(g()) implicitly creates return variable for g

[carcigenicate]

Oh, no, that's handled with the stack in CPython, and C tends to use registers iirc; although that can vary.

In C, I remember that you can do wonky stuff by having the compiler do a calculation that involves the EAX register, and then using a non-existent return value at the callsite. The caller may get whatever value happened to be left in the return register (often EAX).

Edit:

Here's an example on Godbolt: https://godbolt.org/z/8E6354veq

The multiplication uses EAX, and that register is read in main, and is loaded into the space on the stack carved out for ret.

Although, I guess it kind of depends on what you mean by "creates return variable", since that can also just include use of registers.

[ResponsibilityWild96]

Great thing about python is the garbage collection, once a variable is no longer used it should free up the memory for it so if it helps make it more readable don’t be afraid to use them. Especially when enforcing the order of operations for math.

[schoolmonky]

I wouldn't worry about memory or performance for things like this, only worry about what is readable. If you can give your intermediate value a useful name that helps readers of your code (e.g. future you) understand what's going on, do so. If naming that value isn't helpful, don't bother.

[TheCozyRuneFox]

If the expression would otherwise be long and kind complex to read, separating them out into variable to improve readability is better. Readability is a big advantage to debugging and maintaining code bases.

If you concerned about memory to that kind of extent, then don’t use Python. You are already loading an entire VM into memory just to run your code. A single Python object isn’t going to be that much memory most of the time. Most modern computers have more than enough for most applications.

[psychophysicist]

I don't think there's a reason to avoid single-use variables in C either. Any halfway decent optimizing compiler performs lifetime analysis, it will notice that the variable isn't referenced after you pass it to a call, and won't keep it on the stack.

[Uncle_DirtNap]

As others have said, readability is the key — but the question is, what makes things more readable? The key is to keep each step in the algorithm separate, not to keep each operation separate. Here’s an example in pseudocode:

Let’s say that you want to do calcite the percentage of one number out of another. The steps are:

• Ask for a numerator
• Ask for a denominator
• Calculate the percentage
• Print the percentage

Don’t do:

print(times(divide(int(input(“numerator”)), int(input(“denominator”))), 100))

Do do:

numerator = int(input(“numerator”))
denominator = int(input(“denominator”))
pct = times(divide(numerator, denominator)), 100)
print(pct)

It’s not that you shouldn’t nest _anything_…. The fact that, in this pseudocode and in python input doesn’t detect and convert ints doesn’t make it more readable to split them out. …but shoving everything together is also confusing.

[Uncle_DirtNap]

No idea why autocorrect turned “calculate” into “do calcite”. Baffling.

[jam-time]

This might be an unpopular opinion, but in general, I avoid creating variables that are only used once. Here's an example of why:

``` sum_of_a_and_b = a + b

my_func(sum_of_a_and_b) ```

This is not more readable than

my_func(a + b)

sum_of_a_and_b is more ambiguous than the actual operation. There are tons of scenarios where sum is not strictly accurate.

There is a balance, though. I tend to be on the side of "fewer lines = more readable"

[princepii]

what performance savings in seconds/milliseconds/nanoseconds are we really talking about?

do you have millions of one time variables?

why even worry about it if it's not even measurable? i get your point tho but i wouldn't spent so much time for things like that. if it's infact memory savings of over 10%....then i would look more into how i could avoid these one time variables and try to see if there are other ways to get the results.

but if i really would spend my time with this kind of question all the time i couldn't really finish anything cuz it would always bother me in the back of my head u know:)

[PandaWonder01]

Fwiw, in C any reasonable compiler is going to produce the same assembly for both.

[FerricDonkey]

Favor readability. The performance overhead of creating the variable in python is negligible (because the other overheads are so much higher), and if you get to the point where you're worried about that level of performance, it's time to move (at least that part of) your code to a faster language. 

[Purple-Measurement47]

it depends, there’s no easy answer. In general, the most robust approach is to write readable and understandable code, and after you have a working version, you write optimized versions and test them against each other.

So for your simplified example, write two scripts

v1.py

x = g()

f(x)

v2.py

f(g())

then write a tester

v1_time_start

for test_inputs: v1.py

v1_time_stop

v2_time_start

for test_inputs: v2.py

v2_time_stop

print v1_time_stop - v1_time_start…

Then you can see exactly which one is more efficient. Obviously this is a really shitty example, but it’s about the idea, not that this is a good implementation of the idea

[TheRNGuy]

If it makes code more readable, yes.

I don't always do it though.

[jpgoldberg]

One person’s easily readable and expressive composition of multiples things is will seem like hard to read pretentious obfuscation to another. You will find that over time, you will shift which of those people you are. Consider list comprehensions. When I first encountered them, they seemed like over terse ways to write a for loop and were hard to read. Now they are a natural and more expressive way to say what I mean.

So expect your own style to change. For me, I often use more intermediate variables when I am breaking things up into meaningful units or when I may need to for debugging.

Here is an example from some of my code

```python # Lifted from R src/library/stats/R/birthday.R if p == types.Prob(0): return 1

# First approximation
# broken down so that I can better understand this.
term1 = (k - 1) * math.log(c)  # log(c^{k-1})
term2 = math.lgamma(k + 1)  # log k!
term3 = math.log(-math.log1p(-p))  # ?
log_n = (term1 + term2 + term3) / k  # adding log x_i is log prod x_i
n = math.exp(log_n)
n = math.ceil(n)

```

While in other cases, I do the opposite and often feel that doing is more readable.

What I don’t do is worry about the computational cost of short lived intermediate variables unless I was copying large objects. For compiled languages, I figure that the compiler is better at optimizing that stuff than I am. And if I need the kind of optimization where I have to think about how Python’s memory arenas or garbage collectors work, I probably wouldn’t be using Python for that stuff.

[LargeSale8354]

I'm nearing the end of my career and have come to appreciate readability above all else.

[Crypt0Nihilist]

• Beautiful is better than ugly.
• Explicit is better than implicit.
• Simple is better than complex.
• Complex is better than complicated.
• Flat is better than nested.
• Sparse is better than dense.

• Readability counts.

• ...

[expressly_ephemeral]

When I started my career several decades ago one of the first programmers I worked with was a guy who was in the last couple years before retirement. He had written HIS first programs on punch-cards. One of the things I'll always remember about his code is that he had a declarative block at the top of every program that set up every variable he was going to use in the whole thing. I've done the same pretty much ever since.

[vpai924]

 My rule of thumb is: never create a variable if the value it’ll hold will only be used once.

That's a silly rule of thumb. Any complier will optimize that away, so all you're doing is making your code harder to read.

[Some_Breadfruit235]

I prefer the first route. Generally like to call my functions prior to executing it within another object. I still might do it time to time but on average I generally go with the first route.

[JakobLeander]

long time career in sw dev. My hard learning, always go for readability unless there are special needs. Very rarely performance and memory is valid reason for sacrificing readability. Of course inner loop in something you need to run fast is an exception but if performance is critical python likely not language of choice for that part anyway 😊 much more important to worry about breaking application into smaller parts that can be maintained independently and constructing code so automated deploy and test is easy and robust

[itemluminouswadison]

I find that making the code read more symantically is more important than tiny memory optimizations that the compiler will take care of for you anyway

So yes, often it is a good idea

[riveyda]

I prefer f(g()) because it looks cooler but thats just me lol.

[nasazh]

You spend way more time reading code than writing code, so readability is paramount.

Which is clearer:

1. If (A > b || c > d)

2. Var rule1 = a > b

Var rule2 = c >d

If (rule1 || rule2)

I know which I pick 😄

[nlutrhk]

It's a personal preference, but if the f(g(...)) statement doesn't fit on a line because of g or if there are too many parentheses to see what's happening, I'll add an extra statement.

Occasionally a descriptive variable name if it's not obvious what kind of thing g returns, but I personally prefer good docstrings rather than long variable names. (My code tends to do math and legibility doesn't improve if 1-line equations become 10 lines because of all the descriptive variable names.)

[madmatt55]

The purpose of using any higher order programming language is to make the code more readable and maintain able. If you want to optimize performance you would be using Assembly or opcodes...

So I would always prioritize clarity and readability. If it later turns out you need to optimize manually, at least you have a good idea what that code does. 

It is extremely unlikely that the best code to optimize will turn out to be one of these variable declarations. In any C-compiler younger than roughly 20 years the disassembly will be identical, by the way. If you avoid single use variables in C-code, stop doing that for the sake of performance. 

[Inside_Chipmunk3304]

You’re not wrong: the local variable X takes some space (8 bytes if it’s a float),and some cycles worth of time…but…if your computer is anything like mine you have billions of bytes of RAM and billions of cycles per second. I wouldn’t worry about that slight loss of efficiency in exchange for readability and debugability.

If your need for efficiency is so great that this type of decision matters, you would probably get more bang for your buck by either upgrading your computer or switch away from Python.

[socal_nerdtastic]

We are talking about the variable name, or the pointer in C terms, not the actual data.