Introduction

TensorFlow assignment operations mutate the value stored in a variable, but many developers also want to know what the assignment expression itself evaluates to. The answer depends on which TensorFlow execution model you are using: old graph-style TensorFlow 1 or eager-style TensorFlow 2.

The short version is that an assign operation updates the variable and gives you the updated value in a form you can use in later computation. The details become clearer once you separate mutation from graph execution.

In TensorFlow 1 Graph Mode

In TensorFlow 1, tf.assign created a graph node. That node represented the act of assigning a new value to the variable, and when the node was executed in a session it yielded the variable’s new value.

1import tensorflow as tf
2
3tf.compat.v1.disable_eager_execution()
4
5x = tf.Variable(3)
6assign_op = tf.compat.v1.assign(x, 10)
7
8with tf.compat.v1.Session() as sess:
9    sess.run(tf.compat.v1.global_variables_initializer())
10    result = sess.run(assign_op)
11    current = sess.run(x)
12    print(result)
13    print(current)

Both printed values are 10. That is why older TensorFlow examples often chained assignment ops into other graph expressions.

In TensorFlow 2 Eager Execution

In TensorFlow 2, variables are executed eagerly by default. assign updates the variable immediately and returns the variable object after the new value has been written.

1import tensorflow as tf
2
3x = tf.Variable(3)
4returned = x.assign(10)
5
6print(returned.numpy())
7print(x.numpy())
8print(returned is x)

The important points are:

• the variable is updated immediately
• the returned object reflects the new value
• in eager code you usually inspect it with .numpy()

So while the exact representation differs from TF1 graph nodes, the practical meaning is similar: the returned result corresponds to the updated value.

Why Returning the Updated Value Is Useful

Returning the new value lets TensorFlow compose variable updates with later computation. For example, you can update a counter and then immediately read the result.

1import tensorflow as tf
2
3step = tf.Variable(0)
4new_step = step.assign_add(1)
5print(new_step.numpy())
6print(step.numpy())

This is why assignment APIs do not return None. The updated value is often part of the computation you care about.

Mutation Versus Pure Tensors

A common source of confusion is that tensors are immutable values, while variables are mutable containers. assign does not create a brand-new independent variable. It updates the existing variable and returns a handle or tensor-like result that represents the new state.

That distinction matters in training code. If you write to a variable inside tf.function, TensorFlow still tracks the variable mutation as part of the function execution, but conceptually you are mutating state, not performing a pure tensor transformation.

Use assign, assign_add, and assign_sub Intentionally

TensorFlow exposes a few closely related APIs:

• 'assign replaces the variable value'
• 'assign_add increments it'
• 'assign_sub decrements it'

1import tensorflow as tf
2
3value = tf.Variable(5)
4print(value.assign(8).numpy())
5print(value.assign_add(2).numpy())
6print(value.assign_sub(4).numpy())

These methods are clearer than reading the variable, computing a separate tensor, and then reassigning in multiple steps.

Common Pitfalls

• Mixing TensorFlow 1 graph-mode explanations with TensorFlow 2 eager code.
• Expecting assign to return None like a typical in-place Python list method.
• Forgetting that variables are mutable state while ordinary tensors are not.
• Reading the returned object incorrectly in eager code instead of using .numpy().
• Using assignment for logic that would be clearer as a pure tensor computation.

Summary

• In TensorFlow 1, assign created a graph op that evaluated to the variable’s new value.
• In TensorFlow 2, Variable.assign mutates immediately and returns the updated variable result.
• The returned value is useful because follow-up computation often needs the updated state.
• Variables are mutable containers, unlike ordinary tensors.
• Keep the TensorFlow version and execution model in mind when reading examples about assignment behavior.