Implementation of semantic matters not syntax or naming.

If you do call python's function variables lexical, I surely wouldn't call them "lexical my", as you can't limit a variable to a scope except function (so a variable in a loop can be used outside of that loop). And the condition for using a variable in perl is that it has been declared before lexically, while in python it must have been defined before chronologically. Also in perl one distinction is that non lexicals can be accessed by name (symref or symbols table) while lexicals can't. Python doesn't have that distinction.

Python has closures, closures require lexicals.

Edit: (after yours):

the first assignment in a "scope" is an implicit declaration in Python.

> while in python it must have been defined before chronologically.

not sure what you mean. Example?

> Also in perl one distinction is that non lexicals can be accessed by name (symref or symbols table) while lexicals can't. Python doesn't have that distinction.

AFAIK does Python have namespaces - well classes - like __BUILTINS__ or globals()['var'] to access such non-lexicals.

> Are you saying the names of elements in a language must match their implementation and not their behaviour?

I'm saying it has to match the semantic of the definition. From what I know have "lexical vars" been invented in lambda calculus.

I suppose they where first implemented in lisp.

> as you can't limit a variable to a scope except function (so a variable in a loop can be used outside of that loop)

Scoping rules are different, but please keep in mind that you need an extra "form" in lisp to build a lexical scope. (at least in elisp). So scopes are language depended.

But what matters here is the visibility of lexicals (or rather non-visibility outside a scope)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

> Example?

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
  if x == "banana":
      print(y)
  if x == "apple":
      y=1
[download]

whips himself

map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

I've edited my post after seeing your update FYI.

> while in python it must have been defined before chronologically.

not sure what you mean. Example?

This was what my example above was meant to demonstrate. The print(a) is fine because a=x has been executed first chronologically, although it was done after lexically (ie, below).

I'm saying it has to match the semantic of the definition

But definition are different between language aren't they? Like a closure can just be an anonymous function in some languages. Or do you consider that there is one true definition, and incorrect uses? You say that "Scoping rules are different", but you might just consider that the definition of a scope is different between languages. I could then argue that python doesn't have a definition for lexical variables. But I see it's a very poor argument, as you can't say that a language doesn't have a feature simply because the feature has another name :).

But what matters here is the visibility of lexicals

That makes sense. And IMHO it's an argument for calling our variable lexical aliases rather than just package variables :D.

I still don't think calling python variables lexical is really helpful, especially when comparing it to perl. But I see your points and accept them as valid. I won't discuss much further, or at all, because who cares about python anyway?

Another disturbing thing is that Python does hoisting like JS.

if it encounters a (implicit) declaration of a var somewhere at the end of a function, it will bind all var to the same private storage.

see demo of the mess in fun2()

>>> a=666       # global
>>> def fun1():
...    print a  # global
... 
>>> def fun2():
...    print a  # privat
...    a = 33   # declaration
... 
>>> fun1()
666
>>> fun2()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in fun2
UnboundLocalError: local variable 'a' referenced before assignment
>>>
[download]