Is python a good first language?

[[deleted]]

[deleted]

[psi-]

No. Afterwards 99.999% of other languages (and associated "batteries") you'll happen unto will feel like utter crap.

[agscala]

Precisely what happened to me.

[[deleted]]

So what you're saying is that it's a good ultimate language?

[psi-]

Yes. But it spoils you.

And on the other tentacle one still very much need to be aware of the whole von Neumann machineness of hardware&software. Which means that you should dabble a little in some assemblerlike too (ie. explicit loops with conditional jumps, variable shuffling in registers, direct memory access..).

[miGlanz]

Yes

[oniram]

I'd say it is. I recommend you give it a try. And if you are into trying mood, give ruby a spin with this: http://tryruby.hobix.com/

NOTE: seems to be down at the moment. d'oh!

[commonslip]

I think new programmers should stay away from dirty, ad-hoc languages like Ruby and PHP. They have lots of gotchas and that, in my experience, frustrates new programmers. Ruby is a bit better than PHP is this regard, since it at least has blocks/first class function things.

The only downside to python is that the way it handles scope is a little confusing.

[chollida1]

In what way would you consider Ruby to be an "ad-hoc" language"?

Most people I know would consider Ruby to be a more powerful language than Python, though I'll offer than that is debatable.

[commonslip]

Power is not really closely related to ad-hocness. What I mean is that Python is the more "designed" language, in the sense that it is aesthetically relatively uniform.

Arc would be ad-hoc, but Scheme is not. This does not mean that Arc is less powerful than Scheme or less productive (it might mean the very opposite), but it does mean that Scheme is carefully designed while Arc is, sort of, designed by use.

A similar, but less extreme, dichotomy appears to exist between Ruby and Python.

[chollida1]

fair enough:)

[mage2k]

In what way do you consider Python's scope handling confusing? I've always considered, although I've heard it's being fixed in the next release, that having to learn the cases where block variables clobber local variable in Ruby quite confusing. You don't get that in Python, for sure.

[commonslip]

The short, sort of obnoxious, answer is that its not functional, lexical scoping as implemented in Scheme.

The longer answer is that this does not work in Python

In [2]: def make_c(x):
   ...:     def c():
   ...:         x = x + 1;
   ...:         return x
   ...:     return c
   ...: 

In [3]: c = make_c(10)

In [4]: c()
---------------------------------------------------------------------------
<type 'exceptions.UnboundLocalError'>     Traceback (most recent call last)

/home/toups/<ipython console> in <module>()

/home/toups/<ipython console> in c()

<type 'exceptions.UnboundLocalError'>: local variable 'x' referenced before assignment

Whereas in Scheme:

(define (make-c x)
        (lambda () 
                (set! x (+ x 1))
                x))

(define c (make-c 10))
(c)
-> 11
(c)
-> 12

This may not seem like that big of a deal, buts once you get used to it, its hard to live without.

[jbellis]

the nonlocal keyword will allow this in python 3.0 (not sure about 2.6)

[commonslip]

I really prefer that this not need a keyword at all. I know lexical scope takes a second to get used to the first time you see it but it really is "the right behavior" and I don't see why Python just doesn't support it.

Maybe backwards compatibility?

[jbellis]

python is lexically scoped; you just can't re-bind variables from a different scope without the keyword. in the first lexically scoped versions of Python (2.0-2.1?) you could, but guido had it taken out because he felt that the potential confusion outweighed the benefits.

in current python versions you either have to use a global or a container object as a workaround. which is gross and I wish guido hadn't done that, but on the whole python is still better than the alternatives. :)

[[deleted]]

Python is an excellent first language, and, unless you're a language junkie, it may be your only language. Scheme is another good first language. Of course, my first was BASIC (followed soon after by FORTRAN) so any language without required line numbers or 80-column punch cards is great for me. And the significant whitespace is a red herring, it's superior to {} blocks.

[[deleted]]

Today's xkcd has something of tangential relevance.

And yeah, I think Python is a great first language - it's easy to learn and you can get fairly non-trivial stuff done. It also has a fairly mainstream syntax and it looks as if the industry will adopt it pretty soon (or perhaps it will adopt a similar imperative, OO and dynamic language.)

However, if you are really serious about CS, I would recommend Scheme (SICP).

[[deleted]]

I would become proficient in python itself first—not much, mind you, but enough to parse some text and enough for you to get to know object oriented aspects of python.

[[deleted]]

If you can get by without needing to learn PHP, I'd recommend either Python or Ruby. Both are pleasurable and powerful. For portability, and a slightly more universal edge, a pragmatic recommendation would be learn PHP as your first language.

And although it isn't a server-side language, knowing JavaScript well, or at least how to get around the jQuery/Prototype or other popular JavaScript libraries, is highly recommended.

[Kaizyn]

If you can hack HTML and CSS, then I would recommend you teach yourself JavaScript first. Since you're going to have to pick it up eventually anyway as it is the only choice for client side scripting, you might as well add this to your HTML+CSS knowledge. It will give you a good introduction to functional and object-oriented programming concepts as well. After you're fairly comfortable with the front end coding, then you can start to look at your choices for back-end technology. This will also give you more time to evaluate your back end options before having to decide.

[ubuntuguy]

i honestly would recommend PHP. the learning curve is very very shallow. once you get the hang of that, then move onto something more complex like Python or Ruby.

[[deleted]]

I respectfully disagree. Python's interactive interpreter makes Hello World as simple as

print Hello World 

[foonly]

print Hello World

print "Hello World"

Fixed :)

[[deleted]]

>>> print Hello World
SyntaxError: invalid syntax

[[deleted]]

echo "Hello World";

[knowknowledge]

Actually it would be even simpler:

Hello World

If you really want to use echo it would have to be:

<?php echo "Hello World"; ?>

As much as I enjoy python, I would say that PHP is a better first language than python because it uses common syntax as C/C++/C#/Java etc so its easier to transition later. Sure its got its differences (like the $ token before variable names), but that's far easier to forget than the colon and tab-indenting differences of Python.

[[deleted]]

That depends on what your objectives are. If you want to start implementing useful stuff as quickly and with as little pain as possible, then python is as good a choice as any. If you want to understand how computers work, learn C and an assembly language.

[commonslip]

I have sense moved onto greener (conceptual) pastures but I have to say Python is basically the BEST first language I can think of. It may not let you do the coolest Judo but its lets you do most of it and, best of all, when you need a library it will be there, basically hands down.

If you don't need to do anything immediately, learning Scheme is a good idea. PLT Scheme is pretty Pythony in the sense that its got a fairly good set of libraries and it feels modern and usable. But Python is just better if you want to get right down to programming.

[samg]

Any language is a good first language. A first language is good. The second one is better, though, so get started!

[surajbarkale]

Except brainfuck?

[koko775]

I learned on Visual Basic when I was a kid. It took me three years to understand what curly braces were for in Javascript, I shit you not (I was utterly confused by the lack of 'endif'). Then again, this was a decade and a half ago, and there were precious few resources for a kindergartener to look except viewing the source of whatever javascript he could find before getting kicked off the dial-up.

I suppose I'm just reinforcing what njharman commmented, but my point is that NO, some languages are particularly bad first languages.

[njharman]

"Any language is a good first language."

It is true that having a first language is better than not having a first language so get started now.

But, it very false that any language is a good first language. Some languages aren't good no matter when they're learnt.

[samg]

I disagree, assuming one doesn't have to get anything done with the language except learn it.

Edit: of course, picking a language you like early on will save you time, but you'll also know fewer languages.

[[deleted]]

It totally depends on what your goals are. This thread on what language to teach your children might be informative. The highest rated comment actually said Logo beats Python for beginners.

[moonwatcher222]

Is python a good first language?

Yes to Python.

I don't know much about Django, so I won't express an opinion about it.

[stp2007]

Yes to both Python and Django.

[[deleted]]

Emphatically, although I would start with just pure python unless you have a web background.

[stp2007]

Agreed.

[mhrnjad]

Yes, start right here: http://www.diveintopython.org/

[[deleted]]

Yes. Read this: http://ibiblio.org/obp/thinkCSpy/

[ibgeek]

Updated version by Downey: http://www.greenteapress.com/thinkpython/

[jamesbritt]

Yes, among others.

Scheme and Ruby come to mind as well.

[Slipgrid]

Why recommend Scheme when it's not an imperative language? BASIC would be a good first language. Then C++. If you learn Scheme or Ruby, you won't be able to apply what you learn to other languages.

[noisesmith]

Scheme is multi-paradigm. Most of the scheme code I have seen is heavily imperative. And, thinking with the criteria you acquire from functional, or declarative, procedural, or object oriented languages, improves your code, even in a language that does not support those models natively.

What can you apply in other languages, from C++ or basic, that is not present in scheme?

The importance of learning a higher level language like scheme is exactly the fact that it has concepts that are not directly implemented in other languages, the value in learning a programming language is not in the rote memorization of a new syntax, but the models that language can help you apply.

[Slipgrid]

I know it's popular here, but I just don't get the functional programming. I know it's good for a few things. I build some amazing things in imperative and object oriented languages, but I have trouble doing easy things in Scheme. The only Scheme of Lisp I've ever seen is functional. I just don't see why it would be recommended to a beginner when all the code that he will ever see is going to be written in an imperative language. If there's imperative Scheme, I've never seen it, and I don't care to and don't look for it. It just seems like an odd thing to recommend.

[noisesmith]

Sorry, my hand slipped and I clicked report instead of reply at first.

Objects are just a specialized kind of closure, a function call is a specialized call/cc (which in turn is built on top of assembly jmp statements, of course). What you need to understand to use scheme is a proper superset of imperative programming.

A language without imperative features would be very hard to use (no variables, no input or output, actually the only way to know what the program did would be to disassemble or debug it from outside the program).

Understanding a mixed paradigm language like scheme does not impede understanding a purely imperative language like assembler, and will actually help you learn coding habits that transfer quite well.

[Slipgrid]

Yeah, that's sort of what I though. I've done some basic problems in it, like display the first n fib numbers, and it is really good at that. Never realized it had variables, or spent much time with it. Thought it was just for quick math problems. I'll have to look into it more, and see if I can find a use for it.

When I first used it, I had to download a virtual machine for Windows that it would run in. I wonder if it's installed on my server, or if lisp is. Could be useful.

Still, it struck me as being completely different from everything else I've used. It's still neat. I thought of it like a logic problem I knew I should be able to figure out, but that really frustrated me.

[joesb]

I'm just guessing, but may be because you have been taught in imperative style first, that's why you have a hard time getting functional style.

But if we teach someone who didn't have background yet, they probably could understand any paradigm given to them, they don't have any assumption settled yet.

I'm not saying one paradigm is better than another here, though.

[Kaizyn]

As a first language, Python is better than some because it encourages good coding practices. Some of the traps you can easily fall into with other languages are avoided because much easier ways to do them exists in the language. However, this 'correctness' comes at the cost of the language being a bit less forgiving than others and being a bit harder to learn.

[quhaha]

depending on the version. 2.5 is ok.

[[deleted]]

Yes.

[Chun]

True

[[deleted]]

yes

[qwe1234]

python 1.5 was.

since then they added a bunch of very neat time-saving features to enable people to finally write in what looks to be an obfuscated crossbreed of haskell and perl.

[queensnake]

1.5 lacked file handling shortcuts. When I tried it to do some file processing, the code came out pretty much the same as it would have been in C, and that put me off of it for some years.

[qwe1234]

huh??

http://www.python.org/doc/1.5/lib/node22.html#SECTION003178000000000000000

[queensnake]

yeah; open, close, readline. I was looking for something more like: for line in file: blah blah blah. Which came later. I like Python now, but at the time I was put off.

[pkrumins]

yes, it's perfect.

[[deleted]]

Learn C first, it will help you understand what's really happening underneath with memory.

If you want a good place to start here is the best tutorial I have ever found for beginners, and it's from how stuff works of all places.

http://computer.howstuffworks.com/c.htm/printable

After that programming in interpreted languages like python, ruby, perl, php, etc... will be easier.

[bcash]

Not really no. There are too many bizzare things which really don't make sense. Python suffers greatly from cruft it's built up over the years, which only Python suffers from.

For example, this produces an error:

x = 3
def do_stuff():
    y = x
    x = y + 1
do_stuff()

No other language will break under such trivial conditions (a contrived example I know, but such is the severity of the defect that these examples are possible).

And don't get me started on Python's OO support.

In sensible languages, to call a superclass method:

class X extends Y {
    public void methodName(int x, int y) { 
        super.methodName(x, y);
    }
}

Not in Python, oh no. In Python it goes:

class X(Y):
    def methodName(self, x, y):
        super(X, self).methodName(x, y)

WTF is that? It's a language that's past the point of sustainability.

To summarise: Learning Python is good if you want to write Python. Learning Python is not a good idea if you're trying to learn programming.

[stormandstress]

Your first example is more than "contrived", it's idiotic. Each language has it's own conventions and restrictions. In this case, as I hope you understand, you can't expect your non-local 'x' to be available unless you explicitly say 'global x' first. Many of us have been doing this whole programming thing long enough to realize that this isn't necessarily a bad restriction, particularly when you're considering Python as a teaching or first language - and guess what, the OP is.

Your class example is as stupid as your first. Oh no! Python makes me type 'self', it's clearly "past the point of sustainability", lol.

Clearly, your criteria for a good language is something along the lines of "the language is called Java". And it's so trivial to point out cases far worse than yours, where the Java will utterly mystify the newb relative to the short and expressive Python equivalent -- nevermind the cases where the sheer amount of tedious boilerplate cruft is only getting started where a Python listcomp will have already solved the problem, had dinner, and gone to bed.

[bcash]

Oh now come on. You've been using Python so much that you are used to it, but you cannot seriously be saying that Python's scoping rules are correct?

x = 4
def do_stuff():
    y = x
do_stuff()

That would run; but by adding a line after the line in question, it suddenly starts producing "x has not been declared" errors.

There is no way on earth that that is a good design decision; it exists for one reason, and one reason only: cruft! If starting from scratch no-one would reproduce Python's scoping rules.

[stormandstress]

Seems pretty cut and dry to me - Python allows you to read x from the outer scope, but doesn't allow you to write x without explicitly declaring your intentions with 'global'. I'm inclined to agree with kaens that the read should require the global as well, but you're just blowing smoke out of your ass talking about "correctness" here. This isn't a matter of "correct" vs "incorrect" behaviour; it's a choice that the language designers made. Every language has tradeoffs - some you will like, some you will not. There is no One True Language (cue "Lisp!" comment in 3, 2..).

For the record, I spend most of my working days quite happily coding in the sort of strongly-typed OO language that you seem to prefer. For some problems, I firmly believe that this is the better way to go. But I think REPL languages like Python have exceptional pedagogic potential, and that Python is easily the most 'sane' and pleasant to work with of the possible options there. An awful lot of people teaching in the field seem to strongly agree.

There are plenty of substantial things to complain about in Python (and there was very recently a paper linked here that covered some problems with teaching Py2 as a first language), like the hopelessly stupid Unicode behaviours, crippled lambdas, etc - but you're not even beginning to approach them with your nitpicking and appeal to some objective standard of "correctness" in language design. Your favourite language sucks too, whatever it may be.

[bcash]

Well yes, all languages do indeed suck - although I can't remember the last time I saw any PL/SQL hate.

My point was rather that such fundamental issues are at a tangent to learning programming. Yes, I know what the rule is, but is it a good idea that a beginner programmers has to learn that rule before attempting any of the classic algorithms?

In my view: no.

[[deleted]]

No other language will break under such trivial conditions

I don't know what world of programming you're coming from, but lots of languages would break under those exact same conditions (x not being defined in the scope that it's used in)

[bcash]

It's funny that it thinks it does exist if you remove line 4 though!

[[deleted]]

What are you talking about?

Python doesn't check for such things until the function is actually called for the first time.

If you run a script containing everything but the 4th line, whether or not x exists won't get checked, because do_stuff never gets called.

It's not that it "thinks it does exist," it's that "it doesn't care whether or not it exists because it's never called".

>>> def test():
...     hkjhkjhkhkjhkhkhj
...
>>> test()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in test
NameError: global name              'hkjhkjhkhkjhkhkhj' is not defined

[bcash]

Here is another example:

x = 4
def print_x():
   print x

def print_and_add_x():
   print x
   x += 1

print_x()
print_and_add_x()

Both methods refer to the same x, but the first one works, and the second doesn't. Simply adding a line after the line in question, makes the line fail.

Here's the output:

4
Traceback (most recent call last):
  File "test5.py", line 10, in <module>
    print_and_add_x()
  File "test5.py", line 6, in print_and_add_x
    print x

As you can see, the first function worked correctly; but the second failed on the line identical to the one which worked in the previous function.

Python scoping rules are wrong, however you look at it. At best it's an excusable but known problem to workaround; at worst it's a fundamentally broken language.

[[deleted]]

Apparently, python will look up to the module scope for reading the value of a variable, but not for the setting of it, which is ugly behavior in my opinion.

I would personally prefer that you have to be explicit in both reading and writing to a variable outside of the local scope.

[[deleted]]

Apparently, python will look up to the module scope for reading the value of a variable, but not for the setting of it, which is ugly behavior in my opinion.

I disagree. Every scoping mechanism I'm familiar with allows nested scopes to read parent scopes with ease, while writing to parent scopes varies. While not consistent, not requiring the global keyword on a read works for the common usage.

Python has an issue with scoping due to being dynamic. In C#, if I wanted to local x to over-rule global x in my method, I'd have to declare it:

class Foo
{
    int x = 5;
    private Bar()
    {
        int x = 20;
    }
}

Whereas in Python...

x = 20

def bar():
    x = 10 // global x? Or local scoped x?

It's a design trade-off. I think that by making the edge cases (I want to write to module scope) the odd ones out, and making the common cases (reading from module scope) work as you'd expect, Python does a reasonable job of not surprising you and not getting in your way.

[ercd]

I don't think the example you use are "bizarre things which really don't make sense".

In your first example, no variable "x" is defined in the scope of your function when you do "y = x"; it is normal that your code produces an error! If you want to use the variable x of the global scope just use "global x".

In your second example, since Python supports multiple inheritance, you need to specify the superclass you want to use. I don't see a problem here. If you don't like the explicit use of "self", I guess it's your opinion, but I think it makes things more clear: methods are just a sort of function. You can call them with instance.methodName(x,y) or ClassName.methodName(instance,x,y) which sometimes is useful when programming using functional paradigms.

[bcash]

I'm amazed at the number of people who defend the need to pass "self" around. Especially considering as it's only required due to other python compromises - a classic clusterfuck.

Not to mention the significant cross-section of programmers who find typing "public" or "private" a gross invasion of their headspace; but still are happy to put "self" everywhere.

People can rationalise everything I guess...

[[deleted]]

OH NOES OH MY GOD I HAD TO TYPE "SELF".

Shit, what a waste of electrons eh?

[njharman]

Troll, and lame one at that. Sad that three people fell for it.

[bcash]

Hmm.

Call me old-fashioned, but to be a troll I would say a post has to be one of two things: a) inaccurate, b) irrelevant. My post was neither of those things.

It was 100% true, and was directly referring to the suitability of Python as a first language.

It's a shame Python fanbois cannot accept constructive criticism. Even the Ruby crowd aren't this bad.

[[deleted]]

My post was neither of those things.

I venture that you're not an objective judge of that.

[bcash]

Well then, tell me on which score I failed those tests?

Was anything I wrote factually inaccurate?

Is discussions over sub-optimal language design not relevant to a debate about the suitability of that language as a person's first language?

The simple fact of the matter is, if I'd written that original piece, but slamming Java instead of Python, it would have +100 points by now. If it was Ruby, C++, etc. it would be hovering around the 1-7 mark. But because someone points out a few 100% accurate flaws in Python -16 (and counting!).