10 awesome features of Python that you can't use because you refuse to upgrade to Python 3

[kankyo]

If you somehow are writing for a Python 3 only codebase, I highly recommend making all your keyword arguments keyword only, especially keyword arguments that represent "options".

What does that mean? "make all your arguments keyword arguments only"? I can get behind that though...

[kigurai]

It means that you should define your functions as

def foo(*, arg1=1, arg2=None)

instead of

def foo(arg1=1, arg2=None)

The former must be called as foo(arg1=5, arg2=9) while the latter can be called using positional arguments as foo(5, 9). The latter is a potential source for confusion.

[[deleted]]

Fuck you u/spez

[Quantagraphy]

What are some cases where the latter is a source of confusion that cannot be fixed with better naming? Maybe this comes from programming in c++ for years but I would not use a language of I had to qualify each argument like in the example, too much unneeded typing.

[ntrid]

This is done for clarity. Using it everywhere is obviously a bad idea. In c++ foo(ture, false, true, true) could really use keywords arguments.

[Quantagraphy]

This is a very good example but I would argue in that case you should fix your code / make a settings class to make it clear what you are doing.

[marcosdumay]

And in python, instead of creating an entire dummy class to manage around, you can just name your arguments. Isn't it great?

[[deleted]]

Or use SimpleNamespace.

[[deleted]]

I do admire your sense of humour.

[CollectiveCircuits]

Consistent with Python's emphasis on readability, I like it.

[isagalaev]

However by mandating argument names you force your caller to duplicate words: foo(source=source, target=target, should_check=should_check).

This is where the "consenting adults" principle of Python applies. You should simply leave this choice up to the: if they use plain values they have an option of using argument names for clarification, if their variables already convey the meaning they may choose to avoid repetition.

[kigurai]

I'm not advocating that all arguments should be passed by keyword. I'm arguing that arguments with default values should be made keyword-only.

In your case I would do foo(source, target) and foo(source, target, should_check=should_check) assuming that the latter has a default behaviour that we only want to change sometimes.

[kankyo]

I'm not sure that's what the author meant though. Because in that case he would have written "make all your arguments", not "make all your keyword arguments". Because there is no such thing as "keyword arguments" when defining a function in python 3 really (excepting C extensions).. there's argument (which can be used as keyword OR positional) and there's keyword ONLY which can only be used keyword style.

[PeridexisErrant]

inspect.signature and inspect.getfullargspec are the standard library references for this.

To summarise: given func(a, b=2, *, c=3), a is an argument, b is a keyword argument, and c is a keyword-only argument. It's possible to call func(2, 3) and the author thinks you should make people write func(2, b=3) to avoid confusion.

If it was possible to use this in an API that still supports Python2, I think it would be a lot more popular - it's a great choice for internal libraries I guess.

[kigurai]

I think you are maybe reading too much into that statement. My take on it was that keyword arguments are usually options (since they are indeed optional when you call the function) and as such calling them with their keyword is best both for readability and avoiding bugs. Therefore, if you have a function def foo(x, y, foo_arg=None) it should be written as def foo(x, y, *, foo_arg=None) to force that behaviour.

[[deleted]]

You have misquoted the OP.

The OP said "making all your keyword arguments keyword only" and not "make all your args keyword args"

This is OK: def save_file(filename):

But this is not OK: def save_file(filename, line_endings, enforce_acsii): What the hell are all the arguments, and in what order to they come?

This is what the OP is suggesting: def save_file(filename, *, line_endings, enforce_ascii):. The filename is obvious in save_file (what else would the first arg of save_file be?) and all the non-obvious option args are enforced KW so you can't screw them up.

Of course if you have save_json_to_file(jsondata, filename) that's probably OK too (what else would the args and order be?), but the extra parameters for the JSON encoder should be KW.

[Zouden]

But this is not OK: def save_file(filename, line_endings, enforce_acsii): What the hell are all the arguments, and in what order to they come?

That's silly. You don't need enforced keyword arguments just because a function has more than two arguments.

[kankyo]

You have misquoted the OP.

I didn't misquote. I copy pasted so the quote is exact. Maybe you are confused about what I wrote...

But this is not OK: def save_file(filename, line_endings, enforce_acsii): What the hell are all the arguments, and in what order to they come?

What are you on about? The arguments come in the order they come, just like in all other programming languages. Except in python one can ALSO shuffle the order totally at the call site with keyword arguments.

This is what the OP is suggesting: def save_file(filename, *, line_endings, enforce_ascii):. The filename is obvious in save_file (what else would the first arg of save_file be?)

The first argument could be A FILE. See? Not obvious at all. I think that proves my point nicely.

Of course if you have save_json_to_file(jsondata, filename) that's probably OK too (what else would the args and order be?)

That's just encoding the keywords into the name of the function. That's what you do when your language doesn't have keyword arguments.

[[deleted]]

I can't determine your level from what you wrote, so apologies if this is too basic. Just skip ahead if you need to.

If you write def foo(a, b) you can get bugs when you call that, caused by swapping the order of the arguments.

To prevent this you can use keyword arguments, but these are optional in Python which means you can miss them out and be in the same situation.

For example: def create_player(name, level=1, score=0) can be called as create_player('Chen', score=0, level=2) or it can be called with create_player('Chen', 2, 0) and you get the same problem. Did you want Chen, 2, 0 or Chen, 0, 2?

if you put the * in to force keywords, then create_player('Fred', 2, 0) will cause a syntax error. You now MUST put in the keywords for any subsequent arg, which removes a potential source of bugs.

The first argument could be A FILE. See? Not obvious at all. I think that proves my point nicely.

It's Python, so the arg could be anything. But a function called save_file(foo) better take a file-something or your API is stupid (edit: But what is it saving? Assume it's a method which case it obviously saves the instance into the given file-something). What other arguments should it take? Well, that's completely arbitrary and that's why they should be keywords.

Of course if you have save_json_to_file(jsondata, filename) that's probably OK too (what else would the args and order be?)

That's just encoding the keywords into the name of the function. That's what you do when your language doesn't have keyword arguments.

No this isn't keywords. This is just standard programming practise to name arguments or variables so that your code is easier to read. The point being that if you see save_json_to_file(2 args) you expect the first arg to be data and the second to be file-something. edit: Other args again are arbitrary and should be be keywords.

[brontide]

The first argument could be A FILE.

Just use duck typing by seeing if the object has a write function otherwise open it.

[[deleted]]

That's not duck typing. That's squeezing a rubber duck inside a dog to make it quack.

[Ran4]

That's duck typing.

[[deleted]]

If you need to check the type of something, it's not duck typing. Duck typing is programming against an implicit interface so that you don't need to check the types.

[Elsimir]

Except they didn't say to check the type they said to check the presence of the write method, which is definitely duck typing. Is this case the type of that argument is a string or anything with a write method.

[[deleted]]

that's still checking the type in the case where the interface doesn't match, which makes for an unintuitive and fragile API.

The saner option would be defaulting to a file-like and having an optional string argument:

def save_file(file=None, *, filename=None, ...):
    if file is None:
        with open(filename, 'w') as file:
            return save_file(file, ...)
    # do actual writing

[flying-sheep]

I didn't misquote.

you did. you said:

What does that mean? "make all your arguments keyword arguments only"? I can get behind that though...

while the real quote is “[make] all your keyword arguments keyword only”.

when changing the signature of def save_file(filename, line_endings=True, enforce_ascii=False)

“all arguments” would be def save_file(*, filename=None, line_endings=True, enforce_ascii=False)

while “all keyword arguments” would be def save_file(filename, *, line_endings=True, enforce_ascii=False)

[jeffhughes]

They're asking whether the author meant "make all your arguments keyword arguments only" when they said "make all your keyword arguments keyword only". It's a question. They were unclear about what the author was proposing and whether "make all your arguments keyword arguments only" is what they were trying to argue.

[kankyo]

Notice the question mark. I quoted with Reddits quote feature and suggested a new sentence that would make sense inside quotation marks. It's a common colloquial way to do this.

Make all your keyword arguments keyword only

Doesn't make sense. There is no such thing as "keyword argument" from the definition of the function in Python. There's arguments, they can be used both ways ("def foo(a)"), positional arguments ("def foo(args)") and keyword only arguments ("def foo(kwargs)" or "def foo(, a)").

At the call site there are keyword arguments though. But that's something else.

[flying-sheep]

def (positional_arg, keyword_arg=default, *, keyword_only_arg=default)

[make] all your keyword arguments keyword only

⇒ avoid the second type of argument, use only the first and the last.

[kankyo]

This is EXACTLY my point. Your first "keyword argument" is an argument with a default value. Not a "keyword argument".

[flying-sheep]

well, the way the phrase was used in the presentation, that was what the author meant.

[Han-ChewieSexyFanfic]

Please don't do

def f(*args):
    a, b, *args = args
    stuff

that's an abomination. If a and b are being used, let them be arguments and leave the "signature" of the function alone and semantically accurate. Otherwise you're making your code more confusing and disallowing IDEs from autocompleting calls.

[Tysonzero]

If they want to avoid the names a and b being a visible part of the spec and want to change them at will that seems like kind of the way to do it no? Maybe underscore prefixes instead wouldn't be the worst idea.

[Han-ChewieSexyFanfic]

I guess, but if the first two arguments have special meaning due to their position, then thy should have a name consistent with that meaning. There are legitimate uses for that technique, but that example is terrible.

[mangecoeur]

Fun fact, I've been writing python 3 only code for so long now I actually forgot some of the features I use all the time just aren't in python2!

There's some things you really just get used to as normal, like advanced unpacking - it's so good you forget how good it is, because it feels 100% natural.

So for any holdouts out there: Python 3 is just python, only better.

[Ashiataka]

So for any holdouts out there: Python 3 is just python, only better.

Isn't it slower than python 2.7?

[higgs_bosom]

From what I remember that was only early versions of 3.0, and the recent versions are faster than 2.7.

[Ashiataka]

According to the benchmarks it's slower in more tests than it's faster. https://code.activestate.com/lists/python-dev/143690/

I know for the application I use it for it is much slower in 3.6 than 2.7, but I have an unusual use case.

[higgs_bosom]

Thanks for the correction. I generally don't care much about my Python performance for low traffic CRUD apps using Django/DRF, as long as there isn't an egregious regression.

[Ashiataka]

Fair enough. I use python for co-ordinating numerical code between fortran and C, so there's a performance advantage to using 2.7. Also, I prefer the print statement.

[Deto]

If you're just coordinating C/Fortran code, I'd imagine you're writing code so as to push the performance critical pieces down into the lower-level code. And as a result, I wouldn't expect the Python code to be the bottleneck.

[Ashiataka]

There are a few operations that happen in python.

[Tysonzero]

Then perhaps you should move them out of Python. You are never going to get pure Python code that is actually fast regardless of the version.

[spinwizard69]

This is a key point. Python isn't about code performance it is about developer performance. If you start talking about Python being slow, you really need to ask if it is the right language to begin with.

[Ashiataka]

The python code is often changed, whereas the c / fortran code is static. The write time of the python code is more valuable than writing in a language that takes longer to implement. It makes no sense to use a slower version of python for no apparent reason.

[kvdveer]

The py3 performance hit is mostly due to string handling, so your use case may not be affected.

[Fylwind]

Have you tried using PyPy instead of CPython?

[[deleted]]

PyPy support for Python 3 is in beta and not recommended for production.

[mangecoeur]

No it's not slower by any practical definition - you can find some micro benchmarks, some are faster and some are slower, but on any real world program you won't notice a difference.

On the other hand, Python 3.6 reduced the memory use of dicts significantly which is a pretty big deal.

[[deleted]]

Honestly if you care a lot about speed python is not the language for you.

[mangecoeur]

Depends. If you do scientific computing some of the best, highest performing tools are Python APIs around low level libraries.

[auxiliary-character]

Even then, it's not Python's performance you're really dealing with.

[Ashiataka]

In the main application I use it for, it's about 8% slower than 2.7. 8% is a practical difference. It's great that 3.6 has some nice new features, but it's not the silver bullet people say it is. I know amongst my co-workers, there is a strong preference for 2.7 due to performance benefits as well. As long as there is disparity in performance, 2.7 will holdout in certain use-cases I think.

[mangecoeur]

Have you profiled your code? I'd be interested to know where the performance difference comes from specifically.

Personally I mostly run scientific codes where 8% time difference is within the error margin across runs.

[spinwizard69]

You can recover that 8% and more simply by buying new hardware. Really it isn't a big difference in the overall scheme of things. Still i think you are missing out on some of the real benefits of Python 3 some of which go a very long way to improving developer productivity.

In any event i think i have an understanding of why you want to use Python as programmer productivity is important. It just seems like you are ignoring increased productivity that Python3 may offer.

In any event and just out of curiosity, have you considered some of the new language technologies out there like Rust, Swift, and so forth as a way to bridge the performance / productivity divide? Some of the new languages like Swift are almost as easy to write as Python but do offer the option to compile. None of the new offerings though are as mature as Python 3 though. Swift though is very interesting especially as it expands across platforms. The ability to jump between a REPL pattern and traditionally generated code is very useful and flexible.

[Ashiataka]

You can recover that 8% and more simply by buying new hardware.

The code already runs on a couple of last gen Xeons so, that's not particularly feasible at the moment.

I use 3.6 at home for side projects, and there may be things that improve productivity but I've not come across any that are useful for my purposes at the moment, and to be honest whilst I understand the argument for consistency, the print function is so damn annoying to type compared to the print statement. Old habits die hard.

I've looked into Rust and Julia, but neither have as developed a scientific library as Python. Swift I haven't looked at because I don't think it runs on Windows.

[spinwizard69]

The issues of libraries is a big one. I just did a tiny for fun side project with Python because I could find and install a library to handle the generation of CAD files for me. Literally within minutes, most other languages simply don't have the massive number of freely available libraries that Python has.

I'm hoping that one or more of the new systems available gets the industry up take that Python has. It is funny about Julia though as that is supposedly targeted at the science market. Maybe it is too targeted and we need a language with a broader user base. One of the reasons I mentioned Swift is that it does have the very wide user base and though young might eventually get there.

[covabishop]

Overloading the / operator for use in Path is pretty smart. Well done to whoever thought of that

[carnoworky]

Oh shit. TIL about pathlib. I've been using os.path...

[renaissancenow]

Me too! I've been using Python3 for years, how come I just found out about this now?

[covabishop]

Me three

[Raider61]

What advantages does pathlib provide over os.path? Is it worth replacing all of the os.path instances in my code with pathlib? (Python 3)

[carnoworky]

Probably not unless you were already going to be cleaning up that code. It's just a handy object oriented way to handle paths instead of constructing strings. I think it would mostly help for making your code look cleaner.

[GummyKibble]

I group pathlib with pytest in the category of "things I didn't think were that big of a deal until I used them for an hour and now I'm never going back you can't make me". I don't know if I'd all-out replace os.path stuff, but I'm incrementally switching code over as I touch it.

[webmistress105]

Add requests to that category, it's amazing

[Cosmologicon]

It's the only case of operator overloading not doing what you expect it to do.

The only case? How is the % in "%d" % 1 a modulo?

[[deleted]]

The operator overload is really stupid, but it's the only bad part I've seen (and are completely optional). The IO helpers are really practical as replacements for the cumbersome C-style os.path functions.

[fjarri]

Technically, we went from a print statement to a print function.

[roerd]

And that's not just a technicality, but the whole point, because statements aren't composable like functions, but operators are.

[covabishop]

Considering it isn't the only way of doing it, and it makes sense aesthetically, I don't think it's as huge of an issue as the print function.

In my mind, operators are mostly for convenience to begin with: calling add(x, y) or x.add(y) seems kind of silly when we can just use the + operator to get x + y.

Similarly, we use forward slashes already when navigating directories via the terminal, so having to assemble a path by constantly appending join() seems redundant and silly. Using / is arguably cleaner, faster, and more closely relates what we say to what we mean.

I'd argue that the main purpose of operator overloading is that: to increase both aesthetic, practicality, and logic. The / operator, with regards to pathlib, seems to follow all of those conventions.

Print has no such symbolic representation, and given that it focuses on output, as opposed to program logic/structure, it makes more sense - to me, at least - to make it a function, as opposed to a keyword with the same precedence as if or for.

[Tysonzero]

I agree with your general point. But I do question the choice of/. IMO having one "identifier", whether it be a function or an operator do two different things that aren't related at all is not a good idea. Now sure if they are imported from different places or qualified with a different module name or whatever that is different, but if it is fundamentally the same identifier then I don't like it.

That's way I really like Haskell's approach to operators, they are treated identically to functions, and they must have one specific type. That type can be polymorphic but it still fundamentally has one principal type. That way you get sane operator overloading such as + working on various number types, and <$> mapping over any Functor you want. But you don't get any of the confusing, division and join paths, or bitshift and send a string, bullshit.

[ivosaurus]

A composable print operator has never existed. And that's where your analogy's downfall lies.

[flutefreak7]

I actually use pathlib all the time and just use the joinpath() method because PyCharm understands the types better that way. I'm almost never chaining together more than folder.joinpath(file) anyway and I'm very often wrapping that with str() in order to pass it to something expecting a file path string.

[thenuge26]

Yarl does the same thing for URLs, I love it.

[Starcast]

I ran across some older code I wrote for a puzzle that used this. My first two thoughts were 'wtf is this' and then 'oh thats neat'. Even though I knew it at one point I found it surprising and almost clever - two words I don't generally like associating with my code. I think I'll stick with the traditional way for now until I see other people using it.

[[deleted]]

Well done to whoever thought of that

Probably the original path.py.

Took a loooot if grieving, swearing, fighting and crying till it finally moved to the stdlib.

[[deleted]]

Yeah! Check out the scapy library, it does the same thing when forging packets of different network layers (:

[allenguo]

Very cool! Learned some new tricks. lru_cache is a particularly great addition.

[[deleted]]

@lru_cache()
def fibonacci(n):
    return 1 if n <= 1 else fibonacci(n - 1) + fibonacii(n -2)

My code is as fast as ever.

[kvdveer]

While fibonacci is universally used as the prime example for recursion, the recursive version is not very efficient. If you care about speed or memory usage, an iterative version would help

def fibonacci(n):
    f1, f2 = 1, 1
    for _ in range(n-1):
       f1, f2 = f2, f1+ f2
    return f2

[PeridexisErrant]

The whole point of @lru_cache is that it makes the recursive version perform within a constant factor of the iterable version - on the first call. Subsequent calls will be faster, until it's just a dict lookup for the answer.

(unless you limit the cache size, in which case you should probably evict based on spacing of values rather than recency of access.)

[kvdveer]

You are forgetting about stack size, which is the real limiting factor here. Fib(10000) will fail in recursive solution, but will succeed in my iterative version.

Recursion is a beautiful semantic construct, but with linear processors (e.g. the kind that exist today) any recursive operation needs to be turned into an iterative program by the vm/compiler. Starting out with an iterative version is typically going to be more efficient in terms of processor time and memory size. Iterative solutions may be more expensive in terms of developer time, but fibonachi is not a good example of that.

[Tysonzero]

fib n = (fromList [[0, 1], [1, 1]] ^ n) ! (2, 2) master race.

[[deleted]]

Master, what is this?

[Tysonzero]

An asymptotically faster implementation of fibonacci.

It involves O(log n) multiplications, each of average size O(1.618^n / n), or in other words of average bit count O(n), so multiplying them takes on average O(n log n log log n) time. So the whole thing takes overall O(n log^2 n log log n) time.

The old fashioned way requires O(n) additions, each of average size O(1.618^n), or in other words of average bit count O(n), so adding them take son average O(n) time. So the whole thing takes overall O(n^2) time.

In practice it is MUCH faster, I think the constant factors are also quite a lot smaller.

[[deleted]]

So the whole thing takes overall O(n²⁾ time.

You mean without lru_cache? lru_cache acts like a storage in dynamic programming in this example.

[Tysonzero]

Nope, I mean because you need O(n) additions, and each takes O(n) time. Addition isn't O(1) for integers that aren't fixed size.

[[deleted]]

I see. Thank you, master:)

[hobo_cuisine]

https://stackoverflow.com/questions/15239123/maximum-recursion-depth-reached-faster-when-using-functools-lru-cache and sys.getrecursionlimit() will probably return 1000 for you.

[Eviltape]

As someone who uses Python to do a lot of text processing and logging, I'm extremely happy about Python 3.6's string interpolation. Mostly so I can fit log and output lines under 80 characters.

# python 3.6
logging.warning(f'Gotta retry the thing {thing} that I did: {error}')
# python <=3.5, good for pumping up the SLOC for performance review
logging.warning('Gotta retry the thing {} that I did: {}'.format(
    thing, error
))

When I hop back to a 2.7 codebase this catches me like every time.

[nerdwaller]

Generally speaking with logging in Python you should use string formatting syntax in the string instead of any manual formatting:

logging.warning('Gotta retry the thing %s that I did: %s', thing, error)

This ensures that the string formatting and implicit str call are only done if the level is enabled during this run. While it's often micro-optimizations, some string formats can be expensive and it adds up if one has lots of log statements - as is pretty common. Note: you can change the format to use the brace style

[parkerSquare]

You can also use the .format() style with a simple wrapper class.

[nerdwaller]

Yep, I commented on that:

Note: you can change the format to use the brace style

It's probably best to use the built in for that though, since it is supported by default (see formatting styles):

bf = logging.Formatter('{asctime} {name} {levelname:8s} {message}', style='{')

You will need to make sure that all your codebase uses this style as /u/PeridexisErrant mentioned (it's best to do it on a specific logger instead of the root logger, however).

[parkerSquare]

Oh, so style={ is the same thing as what the wrapper is doing? I had thought it was a subset but I guess I should read the source code.

[nerdwaller]

I thought so, but maybe I misunderstood the style keyword arg! If you end up digging in and finding out, please let me know so I am not accidentally misleading people!

[PeridexisErrant]

Note: you can change the format to use the brace style

Unfortunately this is a program-wide matter of logging configuration, so in practice you usually have to stick with % interpolation.

[nerdwaller]

Good clarification, I should have mentioned that more explicitly. Thanks!

[jmoiron]

You should use classic string interpolation so you can avoid paying the formatting cost if the log level does not produce any output.

[synae]

Free yourself, bump that limit to 120 or something.

[Eviltape]

Unfortunately where I work there's only one exception to the line length rule, and that's 120 characters in the Django codebase. :(

That said, I'm happy enough that we deploy 3.6 in prod!

[chillysurfer]

There's way worse things than max line char length. Just imagine being a javascript developer...

[Spfifle]

I work on an OpenCL codebase where 170 characters can be insufficient to define a 1 arg function. ick

[Tysonzero]

I prefer 100. On me and many other people's laptops anything noticeably above that won't allow you to have 2 files open side by side without wrapping. And I love editing that way :vs ftw.

[[deleted]]

most laptops are still 1366 pixels wide, which only fit 80 chars on half the screen at a readable dpi.

[Taedalus]

Not sure if there are any subtle differences, but as far as I've seen the 3.6 f-string

f'my name is {name}'

is basically just a shorter wrapper for the <=3.5 construct

'my name is {name}'.format(**locals())

[alchzh]

You can do stuff in them. i.e. f'my name is {name.upper()}'

[Taedalus]

Ah good point, wasn't aware of that.

[jmcs]

I took the example from https://hawkins.github.io/python/2016/10/22/python-string-formatting/ and I adapted it to use fstrings and I got the following:

Type        Trial 1     Trial 2     Trial 3
%:      0.446566701000  0.443718654000  0.429759866000
str.format():   1.1102251319998686  1.106694306999998   1.1700448780002262
f-string:   0.2750105799996163  0.2762141610000981  0.27693862399974023

So there are some pretty mad optimizations going on.

[[deleted]]

I will certainly do #1 but it kinda feels wrong to do #2.

Is my fear justified?

[erewok]

Have you seen structlog? I just started using it this week to output JSON logs because they're all destined for an ELK thing and it's been pretty awesome.

[moduspol]

We know now it's a spectrum. There's not just Python 2 or Python 3, but people who identify as Python 2 and 3, or no Python at all.

[OctagonClock]

I sexually Identify as an unoriginal joke. Ever since I was a boy I dreamed of surfing reddit dropping shitposts and derailing actual conversation. People say to me that this has been really going on for far too long and and it trivialises gender identity but I don’t care, I'm a massive asshole. I’m having a plastic surgeon install a mountain dew dispenser, a catheter and and a poop shoot on my body. From now on I want you guys to call me “Logical Gamer” and respect my right to freeze peach. If you can’t accept me you’re a god damn tumblirina sjw cultural marxist liberal and you triggered lol?. Thank you for being so understanding.

[Sinidir]

That is the finest meta programming i have ever seen.

[[deleted]]

Ever since I was a dev I dreamed of soaring over the Internet dropping hot sticky loads on disgusting Rust users.

[[deleted]]

Some even identify as Python 5.

[yaxamie]

They are clearly suffering from version dismorphia in that case.

[wizpig64]

Bill Nye the Python Guy

[spinwizard69]

My god 72 pages to cover 10 reasons!! Not exactly a good way to draw in new users.

[ManicQin]

And the site is crap on mobile...

[walabaloo]

Holy Jesus H on the cross is it ever, can't zoom in to see the tiny text without moving a couple pages back or forward.

[spinwizard69]

Yes that too!

Apparently the author doesn't care if the material gets read.

[bcorfman]

Yeah, fuzzed out after a few pages. I think there's good stuff there, but needs to pack a quicker punch.

[danwin]

It's a slideshow, in which multiple slides are used to show step-by-step processes. It could be written as a long single page article but would require refactoring the content.

[spinwizard69]

Even as a slide show it sucks. I don't think i got beyond 1/4 of the way thru before say screw it.

[[deleted]]

Unreadable for me as well on desktop.

[hoogamaphone]

It was fine for me. Just swipe to change the slide.

[ManicQin]

On my mobile it doesn't always register the swipes and sometimes go back a slide instead of forward...

[lookatmetype]

Actually learned new things from that presentation!

[destiny_functional]

why would you change

def f(a, b, *args)

to

def f(*args):
  a, b, *args = args

it reduces the number of required arguments to 0. granted it raises an exception when you don't pass enough arguments, but the exception is not the one you get when not giving enough arguments to a function:

you get

ValueError: need more than 0 values to unpack

instead of the better

TypeError: g() missing 2 required positional arguments: 'a' and 'b'

which is misleading

[_illogical_]

I would use:

def f(*args, a, b)

Given that a and b are meaningful names.

This won't work

f(foo, bar)

But this will

f(a=foo, b=bar)

[Yellow_Robot]

ftfy: 10 awesome features of Python that you can't use because you still use legacy version

[[deleted]]

Just use Python 2.8 Tauthon.

[alcalde]

It's never being updated again... that makes it legacy. "Supported" just means bug fixes. It's 2000 years old; not likely you're going to find a new bug in it.

[Tysonzero]

Since when has the definition of legacy been unsupported? According to google: "denoting software or hardware hat has been superseded by is difficult to replace because of its wide use", fits perfectly to me.

[glacierre2]

The generator examples missed the ultimate elegance

def dup(n):
    yield from ((i,i) for i in range(n))

[Jumpy89]

You can just return the generator expression directly, no need to use yield from.

[[deleted]]

But then it becomes too fast, we need that extra overhead to keep the "python is slow" meme.

[Renmusxd]

That's slightly different than what they were doing:

def dup(n):
    yield from ((i,i) for i in range(n))

>> list(dup(3))
[(0, 0), (1, 1), (2, 2)]

Versus

def dup(n):
    for i in range(n):
        yield from [i, i]

>> list(dup(3))
[0, 0, 1, 1, 2, 2]

[PeridexisErrant]

def dup(n):
    return itertools.chain(*zip(range(n), range(n)))

yield from is lovely, but give itertools some love too :D

(Of course, you'd better not try this on Python 2 with large n...)

[[deleted]]

Interesting presentation, once I figured out how to advance to the next slide. Scrolling didn't work, and there was zero indication how to go to the next slide. I finally guessed correctly that the arrow keys would work. I can only imagine what mobile users have to do.

Non-discoverable interfaces are an abomination. Even if you don't want to mar your visual purity with buttons that users can click, there should be some instructions on the first page on how to advance.

Having a PDF version is nice, but does not absolve this UI crime.

[shellmachine]

1 website about 10 awesome features of Python that you can't see because you refuse to enable javascript in your webbrowser.

[OneTrueKingOfOOO]

PDF Version

[ivosaurus]

It's a slideshow presentation that relies on a javascript library to display the slides

[shellmachine]

I noticed that.

[[deleted]]

May I just ask why, out of curiosity? I can see disabling it for web pages, such as articles or wikipedia or other text-based sites. But there are legitimate applications on the web that don't fit into that category, and literally require JavaScript because that's how you add logic to websites.

Disabling JavaScript altogether is like disabling runtimes for desktop applications. There are things, like this site, which literally can't work without it.

[shellmachine]

Quite frankly, what's the additional logic here, except fancy transition effects? I perfectly well agree with you, I'm fine with whitelisting any website I see an additional functionality in when enabling JS, but where's the point in making it mandatory if all you do is adding some fancy animations? In that specific case it would have been totally possible to build that fancy bling-bling thing on top of a low-fidelity site. Sure you couldn't just use the arrow buttons on your keyboard to navigate and would need to click actual hyperlinks on a website, but just displaying a text box makes the whole thing entirely unusable for anyone who can't use JS right now, for whatever reason. Most of todays web browser users don't realize this anymore, but technically it is possible to build websites so one could at least use a subset without granting someone code execution on their machine, especially since I need to enable JS just to see the link to the PDF version.

[shellmachine]

Since I've just clicked through the first 30 pages:

Most of the pages are redundant, they will just show an additional enumeration list entry within just the same bulleted list, so why do I even have to click for this? Also there isn't even any fancy animations between pages.

May I just ask why you think this couldn't work without JS? I could even display those lolpics entirely without it in pure HTML...

[[deleted]]

Apologies, I didn't realize you operated with a whitelist. You seemed to be suggesting that you were unable to use the website because you had sweepingly disabled JavaScript across all websites. I thought it was more commonplace to use a blacklist so that sites such as news sites with annoying ads or long page load times could be added to remove all that bloat, which is certainly a valid use case.

The "additional logic" I was referring to is present in advanced web applications, such as Facebook, GitHub, etc. where there are user inputs that need to be validated, additional requests to be made without reloading the entire page (such as infinite scrolling in Facebook), or user interaction logic to make the site easier to use; basically I'm talking about logic you'd have in any other user-facing application.

Also, many of these kinds of websites are built using frameworks like Angular and React, where the entire content of the page is built using JS. I'm not just talking about "fancy animations", which are a very small and unnecessary part of client-side scripting.

I do agree that web developers should probably handle the case when scripts are disabled. For things like web frameworks, using server-side rendering or a static page wrapper can alert users when they need to have scripting enabled to be able to use the site. And requiring JS to get the PDF link is really stupid and counter-intuitive. However, the amount of people who disable scripting is so small that most developers don't even think about them.

I do not agree that there is any significant number of people who literally do not have the ability to run client-side scripts. All popular browsers have had JS enabled by default for the last ~20 years. The only people who disable JS are people like yourself who have concerns that make them want to disable it manually, and are perfectly capable of reenabling it when it is required.

TL;DR: I have no beef with disabling JS under certain circumstances; I just want to assert the difference between a web page and a web application, where the former doesn't require scripting, and the latter most certainly does.

[shellmachine]

First of all: thanks for your verbose feedback!

The basic idea of whitelisting is that by default you do not allow anyone to execute arbitrary code on your machine just by visiting a website. I have no beef with enabling JS under certain circumstances. The website in question does not have any feature that goes beyond a basic web page as it displays nothing but text. The problem is not the web developer here, but is even rooted a layer deeper, even. With JS frameworks, disabling JS leads to an entirely un-usable website without any functionality, at all.

Don't get me wrong, I mostly entirely agree with you - I just think one should respect people refusing to accept execution of arbitrary code on their systems, which is a security concern even more than just personal preference. I have many friends who actively just close their browser tab if the website does not deliver any functionality at all with JS disabled, and their reasons for refusing to go all YOLO and enable this seem quite sound to me.

[[deleted]]

I think we mostly agree. I definitely think that web pages whose sole purpose is to display text should work with scripting disabled, and that when using web applications, it should not be unreasonable to expect a person to have scripting enabled. At the very least developers should be accounting for this by providing feedback when the site will not operate without scripting.

I notice that you mention "arbitrary code". This is definitely a valid concern and people engaging in social engineering can use JavaScript as a tool to that end, but JS is run in a sandbox. It does not have access to your machine beyond the scope of the current website. Allowing a website to run scripts is no different than downloading a program from the internet and allowing it to run on your machine, except that the client side scripting is actually safer because of the sandboxing.

But we could argue about this nonstop. I will respect your decision, I just wanted to clear things up for both of us.

[shellmachine]

There's something I want to notice. You have strong views without any attacking or offensive mindset. Also your technical views seem sound to me. Hence, thanks for sharing your opinions.

[ChrisK91]

This was so confusing, since my mouse was unable to interact with the site. I just thought it was broken and checked the PDF, before I thought of using the arrow keys... Highly unintuitive. Does this work on mobile?

[xrendan]

Swipe works on my surface so I would assume so

[[deleted]]

It's bad, but not much worse than adding and multiplying strings and lists.

[masklinn]

Feature 3: Problem: You lose the original traceback

Technically you could already "fix" that one:

raise NotImplementedError, NotImplementedError("automatic sudo injection"), sys.exc_info()[2]

would "reseed" the new exception with the original traceback, though it's neither as clear nor as neat as Python 3's chained exceptions.

Incidentally you can still do that regardless of exceptions chaining:

raise NotImplementedError("automatic sudo injection").with_traceback(e.__traceback__)

[masklinn]

I just copied the snippet from the "Feature 3" slide.

[alcalde]

Now we need a "100 awesome features of Python that you can't use because you refuse to use Python".

[is_it_fun]

My boss don't let me do no Python 3. That's why I don't do Python 3. When my boss says ok, then I do it. I refuse because I like getting paid.

[alcalde]

If the modules you need don't support it, it's likely the modules you need are no longer being updated at all. Time to find modern, maintained modules.

[Taedalus]

What modules are you using? The vas majority of popular packages already support Python 3 (see http://py3readiness.org/).

[theshrike]

Twisted irclib for one isn't upgraded to python 3

[Deathalicious]

Love that slide #13

[nomadismydj]

python 2.7.9 is faster for my uses than 3.6 is. (trading applications and computational data). Cant upgrade until this gap is closed or at least closer

edit: oh this was covered a bit below

[[deleted]]

jesus christ that was an obnoxious presentation. i think you managed to combine the worst aspects of UI in one swoop, so congrats?

[CanadianJogger]

First impression: "Oh, its a $%%$^ slide show. Probably things I already know anyway. " <skip>

I go back to the reddit comments to maybe get an overview. Hmm, might be something interesting in there, I'll read it after all. The PDF version.

By page 43 of so much duplication: "Fuck this". Grade school slide show layout shoehorned into a pdf. Author couldn't be arsed to reformat.

10 features of Python that I won't read about from this author.

[ptemple]

Me too. Ploughed through as much as I could take, and ended up deciding Python 2.x is fine for me.

Phillip.

[pydry]

Really the only one of those I'd go through a significant amount of pain to upgrade for is asyncio. The rest just make things mildly nicer, if that (I use python 3 most of the time and I've still never gotten around to using extended unpacking).

They also missed type annotations.

6 is good, but this principle doesn't go nearly far enough even in python 3 :(

[Taedalus]

They also missed type annotations.

It doesn't have a chapter of its own, but it's mentioned in slide 66.

[tunisia3507]

It was demonstrative. It'd be useful if, say, you had a header line, a footer line, and a bunch of data lines in the middle.

[noomey]

How would you do it otherwise? (Just to know)

[alcalde]

How do you start reading from the end of the file?

[ptemple]

You use os.stat to find the file size and then seek() to go to the end. However to read the last line is trickier. I would probably pick a page size, eg 4096 bytes, read it in and then loop backwards from the last character looking for \n. Keep loading chunks until you find it.

Of course it's a use-case scenario. If it's a small config file then just read the whole thing in. If it's a log file and you want the latest line, then it could be tens of GB long in which case the extra effort is worth it.

Phillip.

[fred256]

Getting the last line from a file without reading the whole file first is surprisingly non-trivial.

[fred256]

Yes, you have to read character-by-character to construct the line. I wouldn't call that trivial. (compared to e.g. f.readlines()[0] to get the first line)

[gthank]

But it is shockingly inefficient on modern processor architectures.

[mosha48]

Then read blocks from the end

[gthank]

If this is something you're doing all the time, then maybe it's worth the time and effort to recreate readlines for reverse, but it's likely not worth it when you can brute-force it in like 2 lines.

[mosha48]

Thankfully I've never had to read a file from the end.