Écrivez quelques lignes de code Python,, Xqui ne référencent aucune variable globale, telles que

def method():
    X
    print(a)

method()

imprime 1mais

def method():
    X
    X
    print(a)

method()

impressions 2.

Donc, je déteste être pointilleux, mais il semble que varset localssont en fait des variables globales en Python:

def test_global_1():
    global vars, locals
    vars = lambda: 2
    locals = lambda: 3

def test_global_2():
    print(vars())
    print(locals())

test_global_1()
test_global_2()

En outre, il semble que les gens aimeraient voir des critères de victoire objectifs pour des puzzles comme celui-ci. La longueur du code ne se sent pas vraiment ici, alors peut-être pourrions-nous créer un système de points brownie pour diverses nouvelles fonctionnalités du code? Je ne sais pas exactement ce que cela pourrait être, mais voici un début:

• +1 pour vraiment vraiment pas de globaux (non varsou locals)
• +1 pour avoir été le premier à publier une technique particulière
• +1 pour la solution la plus courte publiée
• +1 pour une solution n'impliquant qu'une seule instruction Python
• +1 pour des "hacks" intéressants comme rejoindre des non-frontières lexicales
• +1 pour ne pas utiliser d'exceptions

Et si vous pouvez penser à plus, vous pouvez modifier cette question pour l'ajouter à la liste.

Ce problème peut-il être résolu sans utiliser d'exceptions et sans utiliser des globaux comme varset locals? Je soupçonne que c'est possible, même si je n'ai pas encore compris exactement comment ...

def method():
    if 'a' not in vars():a=0
    a+=1
    if 'a' not in vars():a=0
    a+=1
    print(a)

Initialise la variable aà 0seulement si elle est pas déjà initialisé dans le tableau des variables. Ensuite, l'incrémente.

Plus brièvement (merci à l'histocrate pour len):

def method():
    a=len(vars())+1
    a=len(vars())+1
    print(a)

Si les deux copies de Xpouvaient être sur la même ligne, nous pourrions faire

a=0;a+=1;a

qui double à

a=0;a+=1;aa=0;a+=1;a

avec "l'agneau sacrificiel" aadévorant la deuxième affectation variable.

Python

La pensée de cette solution, car tryet excepta été la première façon dont je pensais de déterminer si une variable existe encore ou non.

def method():
    try:a+=1
    except:a=1
    print(a)

Python 2

def method():
    exec'';locals()['a']=locals().get('a',0)+1
    exec'';locals()['a']=locals().get('a',0)+1
    print a

method()

Fondamentalement, lorsqu'il execest rencontré dans Python 2, il provoque la 0x01suppression d' un indicateur spécial ( ) method.func_code.co_flags, ce qui fait que les localsaffectations ont un effet. J'ai exploité cela pour implémenter le nonlocalsupport en Python 2 (voir la ligne 43 pour le xor qui modifie le drapeau).

Ma première idée (puis la faire naître) a été:

def method():
    a=2if'a'in vars()else 1 
    a=2if'a'in vars()else 1 
    print(a)

Mais la réponse de l'histocrate semble optimale.

Ma tentative. Utilise le module mathématique pour suivre si X est exécuté une ou deux fois.

def module():
  import sys
  if 'math' in sys.modules:
    a+=1
  else:
    a=1
  import math

  import sys
  if 'math' in sys.modules:
    a+=1
  else:
    a=1
  import math

  print(a)

module()

def method(a=[]):  
  a.append(a)  
  print len(a)

Modifié en réponse au commentaire: a est une liste de listes vides de longueur n, où n est le nombre de fois que vous avez appelé la méthode. L'appel de cette méthode imprime deux fois 1 puis 2.

def method():
    #### X-block
    try:a
    except NameError:a=1
    else:a=2
    ####
    print(a)

Le trybloc vérifie si la variable a est définie.
Si la variable n'est pas définie (c'est uniquement lorsque le bloc X est présent une fois), une NameErrorexception est déclenchée.
Si une variable est définie, (c'est lorsque le bloc X est présent deux fois), alors elsesera entré.