return _instance;
 public function Singleton() {
Python.
Implémentation simple.
 class Singleton(object):
 _instance = None # Attribut statique de classe
 def __new__(cls): # __new__ classmethod implicite: la classe 1e paramètre
 "méthode de construction standard en Python"
 if cls._instance is None:
 cls._instance = object.__new__(cls)
 return cls._instance
mon_singleton1 = Singleton()
mon_singleton2 = Singleton()
assert mon_singleton1 is mon_singleton2
Les deux variables référencent ici la même instance. Cette solution ne nécessite pas de méthode spécifique pour accéder à l'instance de classe (comparativement à d'autres langages, où il est d'usage d'implémenter une méthode codice_1, par exemple).
Considérations "avancées".
D'après le développeur Python Alex Martelli, "le patron de conception Singleton a un nom élégant mais trompeur, car il met l'accent sur l'identité plutôt que sur l'état de l'objet." D'où l'apparition d'un patron alternatif, appelé "Borg" , pour lequel toutes les instances partagent le même état. Il est généralement accepté par la communauté de développeurs Python que le partage d'état entre instances est plus élégant que la mise en cache de la création d'instances identiques lors de l'initialisation de la classe. 
L'implémentation de cet état partagé est quasiment transparente en Python : 
class Borg:
 __shared_state = {} # variable de classe contenant l'état à partager
 def __init__(self):
 # copie de l'état lors de l'initialisation d'une nouvelle instance
 self.__dict__ = self.__shared_state 
 # suivi de ce qui est nécessaire à la classe, et c'est tout !
L'implémentation ci-dessus peut être améliorée en tirant partie du nouveau type de classe de Python , ne nécessitant ainsi qu'une seule instance :
class Singleton (object):
 instance = None 
 def __new__(classe, *args, **kargs): 
 if classe.instance is None:
 classe.instance = object.__new__(classe, *args, **kargs)
 return classe.instance
monSingleton1 = Singleton()
monSingleton2 = Singleton()
assert monSingleton1 is monSingleton2
class InheritableSingleton (object):
 # Dictionnaire Python référencant les instances déjà créés
 def __new__(cls, *args, **kargs): 
 if InheritableSingleton.instances.get(cls) is None:
 InheritableSingleton.instances[cls] = object.__new__(cls, *args, **kargs)
 return InheritableSingleton.instances[cls]
Ruby.
Le patron Singleton existe dans la librairie standard du langage Ruby. C'est un mixin qu'il suffit d'inclure dans la classe qui doit être un singleton.
require 'singleton'
class Config
 include Singleton
 def foo
 puts 'foo'
 end
end
config = Config.instance
config.foo
Ce script affiche "codice_2".
PHP 5.
Voici une solution écrite en PHP :
class Singleton {
 private $instance;
 /**
 * Empêche la création externe d'instances.
 * Empêche la copie externe de l'instance.
 * Renvoi de l'instance et initialisation si nécessaire.
 public static function getInstance() {
 static $instance;
 if ($instance === null) {
 $instance = new self();

return $instance;
 * Méthodes dites métier
// Utilisation
Singleton::getInstance()->uneAction();
Avant PHP 5.3 : Difficultés liées à l'héritage d'une classe Singleton.
Il faut noter qu'avant PHP 5.3, il n'est pas possible d'hériter une classe de type Singleton. En effet, l'accesseur codice_3 se réfère toujours à la classe dans laquelle il est écrit. L'exemple ci-dessous illustre ce problème.
class Singleton {
 ... // Voir ci-dessus (remplacer la visibilité private par protected)
 /**
 * Méthodes dites métier
 public function uneAction() {
 echo "Singleton";
class AnotherSingleton extends Singleton {
 public function uneAction() {
 echo "AnotherSingleton";
echo AnotherSingleton::getInstance()->uneAction(); // Affiche "Singleton" au lieu de "AnotherSingleton"
Ce problème ne peut être résolu qu'en dupliquant la méthode codice_4 dans la classe héritée.
class AnotherSingleton extends Singleton {
 public static function getInstance() {
 static $instance;
 if ($instance === null) {
 $instance = new self();
 return $instance;

... // Voir ci-dessus
echo AnotherSingleton::getInstance()->uneAction(); // Affiche bien "AnotherSingleton"
Depuis PHP 5.3 : le mot-clé codice_5 et le Late Static Bindings.
Avec PHP 5.3, l'apparition du Late Static Bindings sous la forme d'un accesseur codice_6 semblable à codice_3 résout ce problème. En effet, l'accesseur codice_6 se réfère à la classe dans laquelle il est appelé. Il peut donc être hérité. C'est pourquoi l'on parle de Late Static Bindings (Résolution statique à la volée), par opposition à une résolution statique au moment de la compilation du script.
class Singleton {
 ... // Voir ci-dessus (remplacer la visibilité private par protected)
 final public static function getInstance() {
 static $instance;
 if ($instance === null) {
 $instance = new static();
 return $instance;

... // Voir ci-dessus
echo AnotherSingleton::getInstance()->uneAction(); // Affiche bien "AnotherSingleton"
Perl.
Pour les versions de Perl à partir de 5.10, une variable d'état fait l'affaire.
package MySingletonClass;
use strict;
use warnings;
use 5.10;
sub new {
 my ($class) = @_;
 state $the_instance;
 if (! defined $the_instance) {
 $the_instance = bless { }, $class;
 return $the_instance;
Pour les versions plus anciennes, c'est une fermeture ("closure" en anglais) qui fera l'affaire.
package MySingletonClass;
use strict;
use warnings;
my $THE_INSTANCE;
sub new {
 my ($class) = @_;
 if (! defined $THE_INSTANCE) {
 $THE_INSTANCE = bless { }, $class;
 return $THE_INSTANCE;
Si le module Moose est utilisé, il y a l'extension MooseX::Singleton