# HG changeset patch # User Atul Varma # Date 1212700906 25200 # Node ID 027bea439a5589f7b9ff7a7deaa0b5c95d88823f Origination. diff -r 000000000000 -r 027bea439a55 PythonForJsProgrammers.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/PythonForJsProgrammers.txt Thu Jun 05 14:21:46 2008 -0700 @@ -0,0 +1,226 @@ +================================= +Python for JavaScript Programmers +================================= + +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`_. + +.. _`borrowed directly from Python`: http://weblogs.mozillazine.org/roadmap/archives/2006/02/js_and_python_news.html + +Interactive Shell +================= + +Python, when executed with no parameters, just presents an interactive +shell. It's similar to the SpiderMonkey shell and xpcshell if you're +familiar with those. The 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. + +The shell is also a useful way to explore Python's functionality; feel +free to just use it as a desk calculator to get used to it. + +No Brackets +=========== + +Python doesn't have brackets; instead, indentation alone is used to +lay out blocks of code. For instance: + + >>> if 1 == 2: + ... print "Something very strange is going on." + ... print "Right now." + ... else: + ... print "The world is fine." + The world is fine. + +No Semicolons +============= + +As with JavaScript, semicolons are actually optional. Whereas always +using semicolons is the accepted stylistic standard in JS, however, +it's the reverse in Python: don't ever use them. + +Functions +========= + +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 + +As in Javascript, they're first-class citizens and can be passed +around as parameters to other functions and so forth. + +Closures +======== + +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. + +Lists +===== + +Lists are a lot like JavaScript arrays. Iterating through them is +easy: + + >>> mylist = ["hello", "there"] + >>> for i in mylist: + ... print i + hello + there + +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 not possible for there to be "holes" in Python arrays like there +are in Javascript ones, though: + + >>> a = [1, 2, 3] + >>> del a[1] # Deletes '2' + >>> a + [1, 3] + +Indexing and Slicing +==================== + +Any item that is a sequence can be indexed as expected, but unlike +Javascript, negative indexes may be used to denote items from the end +of the sequence: + + >>> ["hello", "there", "dude"][-1] + 'dude' + +Any indexable item can generally also be sliced; this is similar to +``String.slice`` 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' + +Dictionaries +============ + +Dictionaries are a lot like Object literals in JavaScript: + + >>> d = {"foo" : 1, "bar" : 2} + >>> d["foo"] + 1 + +Their properties can't be referenced using dot notation, though: + + >>> d.foo + Traceback (most recent call last): + ... + AttributeError: 'dict' object has no attribute 'foo' + +Dictionaries generally aren't used to create arbitrary objects like +they are in Javascript, though; they don't have prototypes, nor do +they have meta-methods. Instead, classes are used to do that sort of +thing. + +Classes +======= + +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 ``Foo`` is a subclass of ``object``, which is the root object +class that any class should ultimately descend from. The constructor +is always called ``__init__()`` and is invoked like so: + + >>> f = Foo(1) + Foo created. + +So you don't need to use a ``new`` operator or anything as is the case +with JS. Calling methods and accessing attributes is straightforward +too: + + >>> f.a + 1 + >>> f.doThing() + 2 + +Classes in Python get inheritance for free, but because they're not +really prototype-based, it's not easy to dynamically add or remove +methods to existing objects on-the-fly. + +An object's methods are also bound to the object itself, so--unlike in +Javascript--if they're "disconnected" from the object, they still work: + + >>> f = Foo(5) + Foo created. + >>> doThing = f.doThing + >>> doThing() + 6 + +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`_. + +.. _`PEP 8`: http://www.python.org/dev/peps/pep-0008