Javascript Variable Assignment In Python

I haven't used Django, but to my eyes it looks like your problem is with the concept of an AJAX call.

Using jQuery's is an asycnhronous operation, so you can't work with it using a synchonous programming style (i.e. assigning the function's ouput to a variable).

Instead, you must supply a callback function which is exectued after the client recieves the server's response. Depending on how you want to display the data, you have a few different options.

Option 1

if you don't need to use the value for other operations in JavaScript, is to drop the value into your HTML with jQuery.

Option 2

If you want to use you can, but it's bad UX and I wouldn't reccommend it.

Option 3

Finally, if you need to actually work with the variable you can initialize a variable on page load, then assign the new value to that variable in the callback. This is probably more complicated than you need.

Option 4

The NEW best option (because I was bored) is probably to just use the Leaflet popup.

With some help from the jQuery docs:

I would also suggest that you take a look at this SE post on returning AJAX responses from Django using JSON.

Hope this helps!

Python for JavaScript Programmers

By Atul Varma

I couldn't find anything on the web that attempted to teach Python to readers who already knew JavaScript, so I thought I'd give it a shot, since a number of my friends at Mozilla don't know much about Python but know JavaScript incredibly well. The languages actually aren't that dissimilar--in fact, some of JavaScript's latest features have been borrowed directly from Python.

Many thanks to those who have commented in my blog post about this tutorial; this rendition of it contains a number of changes as a result of that feedback.


This is a good time to explain a bit about Python's design philosophy; hopefully it will give you a better idea of whether this is a language you'd like to use.

While not syntactically enforced by many languages, whitespace is semantically meaningful during the reading and writing of code. Take the following example of C-like code:

if (someVar == 1) doSomething();

The line is indented after the statement to indicate that it should only be done if the statement above it is true. Given this, consider what the following code does:

if (someVar == 1) doSomething(); doSomethingElse();

It's clear from the use of whitespace that should also only be executed if the statement it's indented under is true, but this is not the case for C-like languages. Indeed, the programmer must add additional code to tell the compiler what he or she means:

if (someVar == 1) { doSomething(); doSomethingElse(); }

Why does the programmer have to write more code to tell the computer something it should already be able to infer from the use of whitespace?

This is actually a violation of the Don't Repeat Yourself (DRY) principle popularized by Andy Hunt and Dave Thomas. Because extra work is required when moving from a single-line clause to a multiple-line clause, it's a constant source of errors in C-like languages, and stylistic rules and arguments have been spawned as a result of this mistake in language design.

Python is one of the few languages that takes the simpler and more humane approach: whitespace has a consistent semantic meaning to the humans who write code, so the computer should take this into account when it processes the code. This reduces the burden on the programmer from having to repeat their intent in multiple different ways.

So, you won't see any brackets in Python. Instead, if a statement ends with a colon, the next statement needs to be indented and begins a new block. The block ends as soon as an unindented line is encountered, like so:

if someVar == 1: doSomething() doSomethingElse() else: doOtherThing()

Python is technically like JavaScript in that semicolons are optional, but its community prescribes the opposite convention: that is, semicolons should never be used to delimit statements unless absolutely necessary. This is yet another decision that reduces the cognitive burden on the programmer; indeed, many of the language features covered below were designed with a very careful eye towards readability, reducing cognitive load, and making the process of programming as enjoyable as possible.

The Interactive Shell

Python, when executed with no parameters, just presents an interactive interpreter. It's similar to the SpiderMonkey/Rhino shell and if you're familiar with those. All following code examples in this tutorial will be displayed as though they're being executed in it, like so:

>>> 1 + 2 3 >>> # Here's a comment that does nothing. >>> print "hi!" hi! >>> print "This is a long " \ ... "statement that spans multiple lines." This is a long statement that spans multiple lines.

One built-in function in particular that helps explore things in the built-in shell is , which returns a list of all the attributes attached to an object:

>>> dir("a string") ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

If there's a function you're interested in learning more about, you can look at the built-in documentation metadata associated with the object--known as the docstring--by calling the built-in function on the object. For instance, here's how to get help on the string object's method:

>>> help("a string".join) Help on built-in function join: <BLANKLINE> join(...) S.join(sequence) -> string <BLANKLINE> Return a string which is the concatenation of the strings in the sequence. The separator between elements is S. <BLANKLINE>

This makes it easy and fun to explore the language and its environs.

Batteries Included

Python comes with a standard library that provides a great deal of functionality, from enhanced introspection to serialization, logging, XML processing, database access, testing, networking, data archiving, and more. Extensive documentation for it all is contained in the Python Library Reference.

To use the functionality of a module, you'll use Python's statement, like so:

>>> import sha

This particular line imports the sha module, which provides access to the SHA-1 message digest algorithm. At this point, is an object in your namespace and can be used, for instance, to create a object from which to generate a hex digest:

>>> sha.sha("hello").hexdigest() 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d'

It's not hard to create your own modules; you can learn how to do it in the Modules section of the official Python Tutorial.


Strings in Python work a lot like they do in JavaScript, but with some added benefits.

Strings--or any sequence-like object in Python, for that matter--can be indexed by character like they can in JavaScript, with the addition that negative indexes may be used to denote items from the end of the sequence:

>>> "Hello"[-1] 'o'

Any indexable item can generally also be sliced; this is similar to in JavaScript, only built-in to the language:

>>> "hello"[2:4] # Just like "hello".slice(2,4) in JS 'll' >>> "hello"[2:] # Just like "hello".slice(2) in JS 'llo' >>> "hello"[:4] # Just like "hello".slice(0,4) in JS 'hell'

It's also easy to format strings in Python. If you're familiar with C's function, Python's string interpolation operator, , behaves a bit like it:

>>> "Hello %s, I need %d dollars." % ("bob", 5) 'Hello bob, I need 5 dollars.'

You can find out more in the String Formatting Operations section of the Python Library Reference.


Python's expression syntax is much like that of JavaScript, or any C-like language for that matter:

>>> 9 & 1 # Bitwise operations 1 >>> 2 << 2 # Shifting 8 >>> 5 >= 3 # Comparisons True >>> 8 + 2 * (3 + 5) # Arithmetic 24 >>> 1 == 1 # Equivalence True

Some C-like expression constructs have been substituted for more readable alternatives:

>>> not True # 'not' instead of '!' False >>> True and True # 'and' instead of '&&' True >>> True or False # 'or' instead of '||' True

But there's some elements of C-like expressions that aren't supported, because they tend to be more trouble than they're worth. For instance, some constructs that can be used in expressions in C-like languages can only be used in statements in Python:

>>> a = 5 # Assignment works in statements. >>> a += 1 # Add-assignment does too. >>> if a = 1: # But you can't assign in an expression. ... pass Traceback (most recent call last): ... SyntaxError: invalid syntax

The and unary assignment operators aren't part of the Python language.


Unlike JavaScript, Python doesn't have a concept of . Instead, things that would normally cause to be returned by JavaScript simply end up raising an exception in Python:

>>> "a string".foo Traceback (most recent call last): ... AttributeError: 'str' object has no attribute 'foo'

In most cases, this is for the best, as it makes debugging easier.

Python also has an analog to JavaScript's : it's called .


There are some differences between Python and JavaScript when it comes to equality; when using the operator, for instance, Python compares the value of objects rather than their locations in memory:

>>> a = [1, 2, 3] >>> b = [1, 2, 3] >>> a == b True

The above expression is valid JavaScript code, but it would evaluate to . Python's operator compares object identity:

>>> a is b False


Functions are defined like so:

>>> def foo(x): ... print "foo called with parameter: %s" % x

They are called as you'd expect:

>>> foo(5) foo called with parameter: 5

Unlike JavaScript, though, it's not possible to call them with fewer or more arguments than they'd expect:

>>> foo() Traceback (most recent call last): ... TypeError: foo() takes exactly 1 argument (0 given)

Though it is possible to provide defaults for arguments:

>>> def bar(x, y=1, z=5): ... return x + y + z

And it's also possible to specify arguments using keywords:

>>> bar(1, z=6) 8

You can also write documentation for functions by providing a string immediately following the function signature:

>>> def foo(): ... "Does something useless" ... pass

As mentioned earlier, this string is called the docstring; it's actually attached to the function object as its attribute. Creating docstrings for your functions not only helps document your code, but also makes it easier for Python users to interactively explore your code, too.

It's also possible for Python functions to have arbitrary argument lists, which is similar to JavaScript's array. And as in JavaScript, functions are first-class citizens and can be passed around as parameters to other functions, returned by functions, and so forth.


Python, like JavaScript, is lexically scoped when it comes to reading variables.

However, Python's scoping rules for assignment to undefined variables works opposite to JavaScript's; instead of being global by default, variables are local, and there is no analog to or . Rather, the keyword is used to specify that a variable be bound to global instead of local scope:

>>> a = 1 # Define our global variable. >>> def foo(x): ... a = x + 1 # 'a' is a new local variable. >>> def bar(x): ... global a # Bind 'a' to the global scope. ... a = x + 1 >>> foo(5) >>> a 1 >>> bar(5) >>> a 6

This is for the best: as it's well-known that global variables should be used as sparingly as possible, it's better for a language interpreter to assume that all new assignments are local unless explicitly told otherwise.


Lists are a lot like JavaScript arrays:

>>> mylist = ["hello", "there"]

Iterating through them is easy:

>>> for i in mylist: ... print i hello there

Strings are just sequences of single-character strings, so they can be used similarly:

>>> for c in "boof": ... print c b o o f

Tuples are just like lists, only they're immutable and differentiated from lists by using parentheses instead of brackets:

>>> mytuple = ("hello", "there") >>> mytuple[0] = "bye" Traceback (most recent call last): ... TypeError: 'tuple' object does not support item assignment

Tuples with a single item look a little weird, though:

>>> mytuple = ("hello",) # Without the comma, it'd just be a string.

It's also not possible for there to be "holes" in Python lists like there are in Javascript arrays:

>>> a = [1, 2, 3] >>> del a[1] # Deletes '2' >>> a [1, 3]

It's also possible to index and slice lists and tuples, just like you can with strings:

>>> ["hello", "there", "dude"][-1] 'dude' >>> [1, 2, 3][1:2] [2]

In fact, if the datatype is mutable like lists are, you can even assign to slices:

>>> a = [1, 2, 3, 4] >>> a[1:3] = [5] >>> a [1, 5, 4]

Control Flow

You've already seen examples of , , and . Python also supports :

>>> if 1 == 2: ... pass ... elif 1 == 1: ... print "Hooray!" ... else: ... print "Boo." Hooray!

It also supports :

>>> while False: ... print "This should never display."

However, Python does not have a loop.

To loop through a range of numbers, you can use the built-in function, which returns a list of numbers in the range you specify:

>>> for i in range(3): ... print i 0 1 2

Python also has and statements, which work as expected.


Dictionaries are a bit like Object literals in JavaScript:

>>> d = {"foo" : 1, "bar" : 2} >>> d["foo"] 1

Their properties can't be referenced using dot notation, though:

>>> Traceback (most recent call last): ... AttributeError: 'dict' object has no attribute 'foo'

Since Python doesn't have a notion of , the easiest way to check whether a dictionary has a key is through the keyword:

>>> "a" in {"a" : 1, "b" : 2} True

Dictionaries can also be used as operands for string formatting operations:

>>> d = {"name" : "bob", "money" : 5} >>> "Hello %(name)s, I need %(money)d dollars." % d 'Hello bob, I need 5 dollars.'

Keys for dictionaries can actually be any immutable type; this means that, for instance, tuples can be used as keys:

>>> a = {(1,2) : 1}

But lists can't:

>>> b = {[1,2] : 1} Traceback (most recent call last): ... TypeError: list objects are unhashable

Python dictionaries generally aren't used to create arbitrary objects like they are in Javascript; they don't have prototypes, nor do they have meta-methods. Instead, classes are used to do that sort of thing. In some ways, this is unfortunate, since the simplicity of conflating objects with dictionaries, as JavaScript and Lua do, makes understanding and using them easier. But in exchange, dictionaries do come pre-packaged with a bevy of useful methods.


Classes are pretty straightforward:

>>> class Foo(object): ... def __init__(self, a): ... self.a = a ... print "Foo created." ... def doThing(self): ... return self.a + 1

Here is a subclass of , which is the root object class that any class should ultimately descend from. The constructor is always called and is invoked like so:

>>> f = Foo(1) Foo created.

So you don't need to use a operator or anything as is the case with JS. Calling methods and accessing attributes is straightforward too:

>>> f.a 1 >>> f.doThing() 2

An object's methods are also bound to the object itself once it's created; that is, the parameter that's passed to them is always the same, unlike the parameter in JavaScript which changes based on the object the function is attached to:

>>> f = Foo(5) Foo created. >>> doThing = f.doThing >>> doThing() 6

Do make sure that you always remember to include as an explicit parameter in class methods, though; failure to do so can lead to some strange results:

>>> class Foo(object): ... def bar(x): ... return x + 1 >>> f = Foo() >>> Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'Foo' and 'int' >>> Traceback (most recent call last): ... TypeError: bar() takes exactly 1 argument (2 given)

As you can see, classes in Python aren't particularly elegant; it's hard to understand exactly why things work the way they do unless you understand how classes are implemented "under the hood", which is unfortunate.

Because classes in Python aren't really prototype-based, it's not easy to dynamically add or remove methods to existing objects on-the-fly--though some will probably tell you that doing such a thing isn't a good idea in the first place. In practice, all of Python's built-in types come with a well-designed retinue of methods, so there's little need for one to want to add methods to them on-the-fly, which certainly isn't the case in JavaScript.

Another advantage of Python's class mechanism is that you get inheritance for free:

>>> class A(object): ... def foo(self): ... print "In" >>> class B(A): ... def bar(self): ... print "In" >>> b = B() >>> In >>> In

Overriding superclass methods is a bit odd syntactically, though:

>>> class C(B): ... def foo(self): ... super(C, self).foo() ... print "In" >>> c = C() >>> In In


You can achieve the equivalent of JavaScript's getters and setters by creating a in a class definition:

>>> class Foo(object): ... def _get_bar(self): ... print "getting bar!" ... return 5 ... bar = property(fget = _get_bar)

Not quite as elegant as JavaScript's keyword in an object initializer, but it gets the job done:

>>> f = Foo() >>> getting bar! 5

Note that since we didn't define a setter, we've effectively created a read-only attribute:

>>> = 5 Traceback (most recent call last): ... AttributeError: can't set attribute


They work as expected, and there's a number of built-in ones.

Python prefers the term to JavaScript's , and to JavaScript's . Given this, the following code is fairly self-explanatory:

>>> try: ... raise Exception("Oof") ... except Exception, e: ... print "Caught an exception: %s" % e Caught an exception: Oof


Function closures are available in Python:

>>> def myfunc(): ... a = 1 ... def wrapped(): ... return a ... return wrapped >>> myfunc()() 1

Unlike Javascript, however, the variable bindings in the closure are "read-only":

>>> def myfunc(): ... a = 1 ... def wrapped(): ... a += 1 # Doesn't work! ... return a ... return wrapped >>> myfunc()() Traceback (most recent call last): ... UnboundLocalError: local variable 'a' referenced before assignment

This means that closures can't be used to access private variables like they can in JavaScript; instead, everything is visible, and implementation-specific variables are conventionally preceded with one or two underscores.


As with any language, there's a few wrinkles in Python's design and history that any newcomer should be aware of. I'll try to outline the most important ones below.


Sometimes, strings are the bane of Python programming. Unlike JavaScript, in which every string is unicode, strings in Python are really more like immutable arrays of bytes. Unicode strings are an entirely different type, and unicode literals must be prepended with a , like so:

>>> u"I am a unicode string." u'I am a unicode string.' >>> "I am a non-unicode string." 'I am a non-unicode string.'

The non-intuitiveness of this is due to historical reasons: Python is an older language than JavaScript and dates back to 1991, so the language didn't originally support unicode. When support was added, it was added in a way that didn't break backwards compatibility. This situation will be resolved in Python 3000, the first version of Python to break backwards compatibility with previous versions.

A string with a character encoding may be converted to a object through the method, like so:

>>> "Here is an ellipsis: \xe2\x80\xa6".decode("utf-8") u'Here is an ellipsis: \u2026'

Conversely, you can convert a object into a string via the method:

>>> u"Here is an ellipsis: \u2026".encode("utf-8") 'Here is an ellipsis: \xe2\x80\xa6'

An exception will be raised if there are characters that aren't supported by the encoding you specify, though:

>>> u"hello\u2026".encode("ascii") Traceback (most recent call last): ... UnicodeEncodeError: 'ascii' codec can't encode character u'\u2026' in position 5: ordinal not in range(128)

As such, it's a good idea to optionally specify an algorithm to deal with characters that aren't supported by the encoding:

>>> u"hello\u2026".encode("ascii", "ignore") 'hello' >>> u"hello\u2026".encode("ascii", "xmlcharrefreplace") 'hello&#8230;'

Old-Style Classes

There are also some bumps in the history of Python's class mechanism: until version 2.2, Python's built-in types weren't part of the class heirarchy, and there was no root class; these kinds of classes were known as old-style classes, and are being mentioned here solely because you may run across them when reading old code. They don't support a lot of the things that new-style classes do, and should be avoided if at all possible. You can tell that an object is an instance of an old-style or new-style class by using the built-in function:

>>> class OldStyle: # No superclass means it's old-style. ... pass >>> class NewStyle(object): ... pass >>> type(OldStyle()) <type 'instance'> >>> type(NewStyle()) <class 'NewStyle'>

A number of the class mechanisms outlined in this tutorial, such as the and built-in functions, don't work with old-style classes. Fortunately, as with the string/unicode schism, this confusion will be resolved in Python 3000, which abandons old-style classes to their well-deserved fate.

Coding Style

Python has a coding convention that's generally been embraced throughout the community; almost all libraries use it. It's contained in PEP 8.

Documentation Testing

One of the most useful features of Python is one of its standard library modules. The doctest module allows you to test interactive interpreter excerpts embedded either in the docstrings of your Python code or separate files to verify their correctness. It's an excellent way to turn your documentation into your unit tests, and it's also how the document you're reading right now is tested for accuracy.

More Resources

If you like what you've seen of the language, I highly recommend reading David Beazley's Python Essential Reference, which features a much more thorough and concise overview of the language.

It's also a good idea to become involved with the Python community; it's very friendly and helpful. In particular, you may want to join the tutor mailing list, and a local user group if your area has one.


If you have any suggestions or comments regarding this tutorial, please feel free to post them to the blog post. Thanks!

0 thoughts on “Javascript Variable Assignment In Python

Leave a Reply

Your email address will not be published. Required fields are marked *