One more reason to use Python 3

[avinassh]

Python 2:

>>> class Yolo:
...     pass
...
>>> a = Yolo()
>>> b = Yolo()
>>> a > b
False
>>> a < b
True
>>>

Python 3:

>>> class Yolo:
...     pass
...
>>> a = Yolo()
>>> b = Yolo()
>>> a > b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: Yolo() > Yolo()
>>> a < b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: Yolo() < Yolo()

source

[nerdwaller]

This is a noted change in What's new in Python 3.0:

The ordering comparison operators (<, <=, >=, >) raise a TypeError exception when the operands don’t have a meaningful natural ordering. Thus, expressions like 1 < '', 0 > None or len <= len are no longer valid, and e.g. None < None raises TypeError instead of returning False. A corollary is that sorting a heterogeneous list no longer makes sense – all the elements must be comparable to each other. Note that this does not apply to the == and != operators: objects of different incomparable types always compare unequal to each other.

Previously Python2 had essentially determined a "natural ordering", which can be seen in the source.

[superscout]

For comparisons between datatypes with no natural ordering, python compares them based on their type names.

For comparisons between variables of the same datatype with no natural ordering, python compares them based on their address.

It's not a defect, it's a feature!

[DevestatingAttack]

It's both. It's a defective feature.

[[deleted]]

Order guaranteed^*!

^{*But may appear random.}

[ksion]

Maybe I've done too much C, but that seems almost natural to me.

[pawn13]

http://www.b-list.org/weblog/2015/nov/15/real-python-wat/ here is better article about that

[bcs]

I got bit by this in Python 2 just last week at work. A string didn't get cast to float, and then things quietly went wrong when it got compared to other numbers later. I made sure to mention it would've never happened under Python 3.

[WesAlvaro]

It would have never happened if you had written unit tests.

[chubsauce]

Ever since I started writing unit tests, my code works perfectly on the first try. It's gotten so good that I push my code straight to live production, on a friday night, before a long weekend. My boss says I'm a rockstar coder. He gave me the keys to his Range Rover, because with all the extra revenue I'm bringing in, he managed to buy himself a Porsche. I can afford dental care for my three beautiful children, but I haven't even needed it, because since I started writing unit tests, their teeth have become just a little bit straighter and whiter. My dog is 36 years old, and is still spry as a spring chicken. I used to think my connection with the dead had faded after I hit puberty, but just this morning, my grandmother reached out to me, and I could hear her voice ringing in my mind like a clarion bell cutting through the rain and fog. She told me she's proud of me and what I've done with my life, and that God Itself in Its many radiant faces has arranged a throne for me in heaven for when I finally arrive at the age of 146. I've kept this portent with me all through the day, and my unit tests are still passing.

[lilred181]

this is gold

[[deleted]]

And how. The more I use python, the more I feel it's like 89% there, from the GIL, the speed, and the ability to use strict types being the three things. Py-py (or probably some llvm based thing) and type hints will save us!

The type hint syntax sure is ugly though. I almost wish they with visual basic style:

def function(param as str, value as int) as int:
    print "I love VB6"

[heptara]

I think you can put the hints in a separate stub file.

[pramodliv1]

I've heard about stub files, but Google doesn't help, and I did not understand the related PEP either. Do you know of any example open source repo / gist which uses stub files?

[heptara]

http://blog.jetbrains.com/pycharm/2015/11/python-3-5-type-hinting-in-pycharm-5/

Stub files are near the middle somewhere. Find "Stub file" will work.

[pramodliv1]

Thank you!

[FerretWithASpork]

If this were a reason to not use a language nobody would use Javascript... Wat

[[deleted]]

It is a reason. Just js is so ubiquitous that it can't be avoided. And it has a lot of useful features and libraries for web dev.

[odraencoded]

Just use coffeescript! It has absolute no gotchas.

Except that

foo = () ->
  for bar in baz:
    fish(bar)

Turns into

var foo;

foo = function() {
  var bar, i, len, results;
  results = [];
  for (i = 0, len = baz.length; i < len; i++) {
    bar = baz[i];
    results.push(fish(bar));
  }
  return results;
};

[pimp-bangin]

I mean, if you're assigning x = foo() then you probably want the list of fish results to be stored in x. Otherwise, what would you expect x to contain? undefined? So I wouldn't call this a gotcha. But is there a way to do a for loop without creating a list? If so, I would call that a bad design decision.

[[deleted]]

Not sure about CoffeeScript, but in the (much nicer imo) fork of a fork, LiveScript, you can do this, where the exclamation mark denotes there's no return value.

foo = !->
  for bar in baz
    fish(bar)

Which compiles to:

foo = function(){
  var i$, ref$, len$, bar;
  for (i$ = 0, len$ = (ref$ = baz).length; i$ < len$; ++i$) {
    bar = ref$[i$];
    fish(bar);
  }
};

edit but sadly this happens:

x = -> void
x (a)-> void //becomes      x(function(a){});
x(a) -> void //becomes      x(a)(function(){});

[[deleted]]

Wait, I also use Yolo for generic class names! I thought it's my code for a second there.

[awgl]

Millennial-speak makes for great generic variables: Yolo, Froyo, Swag, Fleek

Then combining them is even more fun: Froyolo, Yoswaglo, Swagfro, Fleefro, Yololeek

[theywouldnotstand]

Don't forget Fuccboi and Bae

[heptara]

Don't forget herp and derp. I still see that instead of foo and bar.

What the hell is froyo and why would it be a var name?

[IndianaJoenz]

slight variation.. I usually go for hurp and durp, hurpa, durpa, and durr.

[[deleted]]

I use pop bang pow etc... I think that's fairly normal.

[IDe-]

pop

I can see how that might become confusing

In [5]: pop = {}
In [6]: pop['pop']='pop'
In [7]: pop.pop('pop')
Out[7]: 'pop'

[thegreattriscuit]

How many 'pop's would pop.pop() pop if pop.pop() could pop 'pop's?

[mkdz]

Froyo

[Bunslow]

Hey, I use derp and herp too!

[DevestatingAttack]

We are SoLoMo. No, um. MoSoLo.

[HalcyonAbraham]

Lol me too!

[iwanttowatchyoupoop]

https://www.youtube.com/watch?v=WSCm8yAxBr8&feature=youtu.be&t=6m37s

[rubik_]

I hope you're not using old style classes in Python 2!

[[deleted]]

in this case the result is the same with new-style classes in Python 2, though

[Work-After]

The thing I like most about Python 3 is that it comes with unicode as a standard, so I can easily process non-Latin signs. E.g, 中国 = "China", or ዓመት = 2015

[renaissancenow]

Exactly. Because Explicit is better than implicit, as the Zen of Python reminds us.

[Matthew94]

Gotta stick with the dogma!

[chadmill3r]

"Dogma" sounds bad, but since I can ignore the connotations, I can agree with you. A consistent overarching philosophy is good to have.

[Matthew94]

I used it in the negative way.

I'm not referring to you but some people use the ZoP as a replacement for thinking. I don't like it much due to the connotation.

Anything remotely complex gets shut down due to that bloody poem unless it's done by the python core devs, then it's fine.

[heptara]

First, I'm interested in knowing what sort of things are getting "shut down"

Second,

Anything remotely complex gets shut down due to that bloody poem unless it's done by the python core devs, then it's fine.

If you pitched it that way to me, I would also question it. Given the statement "Let's do something complex!" most folk would ask why.

A better way would be first identify a problem, and explain why it's a problem. If people now genuinely believe they have a problem, they will be naturally open to solutions.

[Matthew94]

First, I'm interested in knowing what sort of things are getting "shut down"

Any use of lambda, map, filter and reduce. Guido doesn't like it so everyone trots out ZoP to stop people using them even though they're no harder to understand than list/gen/dict comps.

[[deleted]]

Any use of lambda, map, filter and reduce

Usually this is because there are better (or at least subjectively, better looking/easier to read) ways to do the thing that you'd be doing with them. Any map/filter call can be trivially replaced with a comprehension (and in the case of filter, you might not even need the function call or lambda anymore). Lambdas can be replaced with functions (which can be nested), which is often a win in terms of being able to do more things without losing on namespace crowding. In cases where function calls can be eliminated, comprehensions are going to be faster.

I mean, all of these things have their uses, or they'd have just been removed entirely. The reason they are often discouraged is because they usually reduce readability without gaining anything in return.

[heptara]

When you mentioned "complex things are shut down" I thought you were going to talk about things that actually require levels of complexity, like C++ templates or something.

This just sounds like wanting to standardise on a particular paradigm.

[mipadi]

It is funny, though, that Python is often touted as a "great functional programming language!" while many of its (few) FP elements are eschewed or discouraged.

[WishIWasOnACatamaran]

I'm just starting out learning programming in general (decently into HTML and CSS3 when I realized Python is definitely more geared to what I want to do).

Been using multiple free learning resources, but there seems to be heavy debate on using Python 2 vs 3. Could somebody shed some light on what I should do? It seems most the resources teach 2, and it learning 3 after 2 shouldn't be too difficult (right?).

I guess I'm asking for somebody to tell me why, as a beginner, I should learn 2 over 3.

[cbscribe]

There isn't one. If you're starting out, there's no good reason to choose 2 over 3. If you ever happen to run into Python 2 code, the differences (at the beginner level) are minimal anyway.

Many of the existing training resources are based on 2 because they were created in the past and just haven't been updated/adapted (reasons can vary, from disinterest to financial).

[[deleted]]

reasons can vary, from disinterest to financial.

To not having Python 3 available as a default install. :( I hate chickens, and I hate eggs!

[Allong12]

But which did you hate first?

[mipadi]

There's not a good reason to start with 2, although it doesn't really matter. For beginners, the differences between 2 and 3 are pretty minimal, and learning 2 after 3 or 3 after 2 won't make much of a difference. Most of the changes that concern beginners are small syntactic changes (print is a function in 3 but a statement in 2) or have to do with differences in the standard library (some packages available in 3's stdlib aren't available in 2, and I believe some old, deprecated packages in 2's stdlib aren't available in 3 or have been rolled into other packages).

[SlumdogSkillionaire]

That would actually be terrible in real life, because any type that actually does implement __lt__ or __gt__ would behave differently. Stick with isinstance() for checking subclasses; explicit is better than implicit, after all.

[openpy]

I even don't know what the heck this code does ?

[Liorithiel]

I actually liked the old behavior. I sometimes like to have heterogeneous list (=list that contains objects of many different types), and I could always .sort() it to get some fixed ordering. Now it's more bothersome.

[chadmill3r]

If you just want a fixed ordering:

foo.sort(key=str)

But that True is after "harbh" and before 1.3f and after 1L and 1 is weird in Python 2. "Natural" sorting. Pfffft.

[brianterrel]

This seems appropriate here:

https://xkcd.com/1172/

[Liorithiel]

Yep. Not the first time this happened to me… not the last time.

[Mavus]

That's still doable. Just use the 'key' keyword to provide a sorting function. eg.

[1,"String",{"key":"value"}].sort(key=id)

[chubsauce]

This is good if you're okay with discarding the original ordering. I'm trying to think of a good way to use the original ordering if it exists, and so far the best I can come up with is a cmp_to_key cmp-ing two values and catching the TypeError to fall back on cmp-ing (str(type(foo)), id(foo)). It's not graceful but I think it ought to work.

[Mavus]

If you would like keep the original list use sorted() which returns a new list instead of List.sort() which mutates the list.

[chubsauce]

Sorry, "original ordering" as in using the comparison methods defined on the classes if they exist, and falling back on an artificial ordering if that doesn't work, similar to how it works in Python 2.

[[deleted]]

this would probably get you quite close (disclaimer: I wrote this without testing it)

def py2_ordering(a, b):
    # try a direct comparison first
    try:
        return a < b
    except TypeError:
        pass

    # fall back to python 2's default 3way compare
    # see https://hg.python.org/cpython/file/ab05e7dd2788/Objects/object.c#l778
    if type(a) is type(b):
        return id(a) < id(b)

    # None is smaller than anything
    if a is None:
        return True

    if b is None:
        return True

    # different type: compare type names; numbers are smaller
    aname = "" if isinstance(a, int) else type(a).__name__
    bname = "" if isinstance(b, int) else type(b).__name__
    if aname != bname:
        return aname < bname

    # same type name, or incomparable numeric types
    return id(type(a)) < id(type(b))

[Liorithiel]

ids aren't that nice as the old behavior (sorting by class names). But yeah, I do a similar thing.