"""Three vars (one in a sub-module) and compute method."""

  def __init__(self):
    self.x = variables.Variable(1.0, name="variable_x")
    self.y = variables.Variable(2.0, name="variable_y")
    self.child = module.Module()
    self.child.z = variables.Variable(3.0, name="child_variable")
    self.child.c = ops.convert_to_tensor(5.0)

  @def_function.function(input_signature=[

        then:
        directories.size() == 2
        directories[0].location == jdk8
        directories[0].source == "environment variable 'JDK8'"
        directories[1].location == jdk9
        directories[1].source == "environment variable 'JDK9'"
    }

    Set<InstallationLocation> consistentOrder(Set<InstallationLocation> s) {
        s.sort { it.location.absolutePath }
    }

    effects.emplace_back(MemoryEffects::Read::get(), value,
                         ResourceEffects::Variable::get());
    effects.emplace_back(MemoryEffects::Write::get(), value,
                         ResourceEffects::Variable::get());
  }
}

void MarkResourceAsReadOnly(
    Value value,
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>&

#### Listas

Por ejemplo, vamos a definir una variable para que sea una `list` compuesta de `str`.

De `typing`, importa `List` (con una `L` mayúscula):

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial006.py!}
```

Declara la variable con la misma sintaxis de los dos puntos (`:`).

Pon `List` como el tipo.

                return "using environment variable"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.withEnvironmentVars(variables)
            }
        }
    }

    static void checkEnvironmentVariableUnset(String key) {

 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

package test

import (
	"context"
	"os"

	"go.uber.org/atomic"
)

// SetForTest sets a variable for the duration of a test, then resets it once the test is complete.
func SetForTest[T any](t Failer, vv *T, v T) {
	old := *vv
	*vv = v
	t.Cleanup(func() {
		*vv = old
	})
}

// SetEnvForTest sets an environment variable for the duration of a test, then resets it once the test is complete.

 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code