Patrón Singleton

class Configuracion:
    """Solo puede haber una configuración en toda la aplicación."""
    _instancia = None                             # la única instancia, compartida

    def __init__(self):
        # Python no tiene constructores privados: se impide crear una segunda a mano
        if Configuracion._instancia is not None:
            raise RuntimeError("Usa Configuracion.get_instance()")
        self._valores = {"idioma": "es"}
        print("(se crea la configuración)")

    @classmethod
    def get_instance(cls):
        """Punto de acceso global: la crea la primera vez que se pide (inicialización perezosa)."""
        if cls._instancia is None:
            cls._instancia = cls()
        return cls._instancia

    def get(self, clave):
        return self._valores.get(clave)

    def set(self, clave, valor):
        self._valores[clave] = valor


a = Configuracion.get_instance()
b = Configuracion.get_instance()
a.set("idioma", "en")
print("¿a y b son el mismo objeto?", "sí" if a is b else "no")
print("Idioma visto desde b:", b.get("idioma"))

/** Solo puede haber una configuración en toda la aplicación. */
class Configuracion {
    static #instancia = null;                     // la única instancia, compartida
    #valores = new Map([["idioma", "es"]]);

    constructor() {
        // JavaScript no tiene constructores privados: se impide crear una segunda a mano
        if (Configuracion.#instancia) throw new Error("Usa Configuracion.getInstance()");
        console.log("(se crea la configuración)");
    }

    /** Punto de acceso global: la crea la primera vez que se pide (inicialización perezosa). */
    static getInstance() {
        if (Configuracion.#instancia === null) Configuracion.#instancia = new Configuracion();
        return Configuracion.#instancia;
    }

    get(clave) { return this.#valores.get(clave); }
    set(clave, valor) { this.#valores.set(clave, valor); }
}

const a = Configuracion.getInstance();
const b = Configuracion.getInstance();
a.set("idioma", "en");
console.log("¿a y b son el mismo objeto? " + (a === b ? "sí" : "no"));
console.log("Idioma visto desde b: " + b.get("idioma"));

using System;
using System.Collections.Generic;

// Solo puede haber una configuración en toda la aplicación.
class Configuracion {
    private static Configuracion? instancia;              // la única instancia, compartida
    private readonly Dictionary<string, string> valores = new();

    private Configuracion() {                             // privado: nadie más puede hacer new
        valores["idioma"] = "es";
        Console.WriteLine("(se crea la configuración)");
    }

    // Punto de acceso global: la crea la primera vez que se pide (inicialización perezosa).
    public static Configuracion GetInstance() {
        instancia ??= new Configuracion();
        return instancia;
    }

    public string Get(string clave) => valores[clave];
    public void Set(string clave, string valor) => valores[clave] = valor;
}

class Program {
    static void Main() {
        Configuracion a = Configuracion.GetInstance();
        Configuracion b = Configuracion.GetInstance();
        a.Set("idioma", "en");
        Console.WriteLine("¿a y b son el mismo objeto? " + (ReferenceEquals(a, b) ? "sí" : "no"));
        Console.WriteLine("Idioma visto desde b: " + b.Get("idioma"));
    }
}

<?php
/** Solo puede haber una configuración en toda la aplicación. */
class Configuracion {
    private static ?Configuracion $instancia = null;       // la única instancia, compartida
    private array $valores = ["idioma" => "es"];

    private function __construct() {                        // privado: nadie más puede hacer new
        echo "(se crea la configuración)\n";
    }

    /** Punto de acceso global: la crea la primera vez que se pide (inicialización perezosa). */
    public static function getInstance(): Configuracion {
        if (self::$instancia === null) self::$instancia = new Configuracion();
        return self::$instancia;
    }

    public function get(string $clave): ?string { return $this->valores[$clave] ?? null; }
    public function set(string $clave, string $valor): void { $this->valores[$clave] = $valor; }
}

$a = Configuracion::getInstance();
$b = Configuracion::getInstance();
$a->set("idioma", "en");
echo "¿a y b son el mismo objeto? " . ($a === $b ? "sí" : "no") . "\n";
echo "Idioma visto desde b: " . $b->get("idioma") . "\n";

# configuracion.py
# Un módulo de Python solo se ejecuta la primera vez que se importa (y la importación está
# protegida por un cerrojo): una variable del módulo ya es una instancia única y segura con hilos.
class _Configuracion:
    def __init__(self):
        self.idioma = "es"


configuracion = _Configuracion()

# En cualquier otro módulo:
#     from configuracion import configuracion

// configuracion.js
// Un módulo ES se evalúa una sola vez, y cada hilo (worker) tiene su propia memoria:
// el objeto exportado ya es único y no hay carreras que evitar.
class Configuracion {
    idioma = "es";
}

export const configuracion = new Configuracion();

// En cualquier otro módulo:
//     import { configuracion } from "./configuracion.js";

// Perezosa y segura con hilos: Lazy<T> crea la instancia una sola vez aunque la pidan
// varios hilos a la vez, y solo cuando alguien la usa por primera vez.
public sealed class Configuracion {
    private static readonly Lazy<Configuracion> instancia = new(() => new Configuracion());

    private Configuracion() { }

    public static Configuracion Instancia => instancia.Value;
}

<?php
// En PHP cada petición tiene su propia memoria y un solo hilo: nadie compite por crear la
// instancia, así que basta la propiedad estática (y se impide también clonarla).
final class Configuracion {
    private static ?Configuracion $instancia = null;

    private function __construct() { }
    private function __clone() { }

    public static function getInstance(): self {
        return self::$instancia ??= new self();
    }
}

from enum import Enum


class Configuracion(Enum):
    """Los miembros de un Enum son únicos: no se puede crear otro, ni copiándolo."""
    INSTANCIA = "instancia"

    def __init__(self, _):
        self.idioma = "es"


# Uso: Configuracion.INSTANCIA.idioma = "en"

// En JavaScript un objeto literal ya es único: no hay ninguna clase de la que crear otro.
const Configuracion = Object.seal({     // seal: no se le pueden añadir ni quitar propiedades
    idioma: "es",
    getIdioma() { return this.idioma; },
    setIdioma(idioma) { this.idioma = idioma; },
});

// Uso: Configuracion.setIdioma("en");

// En C# lo más corto es una clase static: no se puede instanciar ni heredar, y el runtime
// la inicializa una sola vez, de forma segura con hilos.
public static class Configuracion {
    public static string Idioma { get; set; } = "es";
}

// Uso: Configuracion.Idioma = "en";

<?php
// Los enum de PHP 8.1 no pueden guardar estado: para algo único y con datos se usa una
// clase final que no se puede instanciar, con todo estático.
final class Configuracion {
    private static string $idioma = "es";

    private function __construct() { }

    public static function getIdioma(): string { return self::$idioma; }
    public static function setIdioma(string $idioma): void { self::$idioma = $idioma; }
}

// Uso: Configuracion::setIdioma("en");