1.1M views · Mar 21, 2013 · 48:51 · 9 HN recommenders · 13 mentions · discussed 2014–2022
Raymond Hettinger's PyCon 2013 talk on transforming code into idiomatic Python through a series of before-and-after refactorings. It shows how to use iterators, dictionaries, named tuples and other language features well.
Why Hacker News points people here: HN treats it as a must-watch classic for writing Pythonic code, though somewhat dated for modern Python.
“the excellent talk "Transforming Code into Beautiful, Idiomatic Python".”HN comment, 2021
“Must watch”
Idiomatic Python talk relevant to comprehensions versus filter.
Must watch: this video I believe that the list comprehension will be faster than filter, but as always, any time you replace readable code with unreadable code for performance reasons, you damn well better time it.
“I'm currently watching one of his videos [1] and it's amazing.”
Hettinger talk on writing idiomatic Python.
I've never heard of Raymond Hettinger before but I'm currently watching one of his videos [1] and it's amazing. Thanks for sharing your list, I'll definitely look up some more of these people. [1] this video
“the excellent talk "Transforming Code into Beautiful, Idiomatic Python".”
Excellent talk on simple, clean, thoughtful code with broad applicability.
Your mention of simple and clean code makes me think of the excellent talk "Transforming Code into Beautiful, Idiomatic Python". Although it relates to Python programming, if the ideas and principles (and thoughtfulness and pace) from it could be applied to much more written code, then (I think) we as an industry and all our users would be in a better place. [1] - this video
“Halfway through and this one seems great so far”
Great Python talk with enjoyable style
Great suggestion. Just searched for him on youtube and a couple of excellent looking talks popped up. Halfway through and this one seems great so far: this video Really enjoy his style as well :)
“Great talk on avoiding some of the common pitfalls new python developers step in.”
Avoiding pitfalls and using nice language features
Check out Raymond Hettingers Transforming Code into Beautiful, Idiomatic Python talk on youtube [1]. Great talk on avoiding some of the common pitfalls new python developers step in. Exposes some nice language features. [1]: this video
“Topics include: 'looping' with iterators to avoid creating new lists, dictionaries, named tuples and more”
Hettinger's PyCon talk on iterators, dicts, named tuples and idiomatic Python.
If you were underwhelmed by this blog post have a look at: Transforming code into Beautiful, Idiomatic Python by Raymond Hettinger at PyCon 2013 link and this video Topics include: 'looping' with iterators to avoid creating new lists, dictionaries, named tuples and more
“Raymond Hettinger's talks are great.”
Classic 2013 Hettinger talk, though somewhat dated for modern Python.
Raymond Hettinger's talks are great. I know it's not a succint blog post, but they are out there are watching a video is very approachable. Maybe link (Dataclasses! We could cheekily say Python gets better at something Rust does - dataclasses makes Python better at records.) And link This talk (2013): this video Unfortunately this video is now a bit out of touch with modern Python. Another (2013) classic: link it is very well known, and it has the very memorable advice: what's a class that only has one method? That should be a function!
“they are example-heavy and give a good insight to a very Pythonic mind.”
Example-heavy insight into Pythonic style.
These are a few videos which present Pythonic style. They do not form a proper curriculum, but they are example-heavy and give a good insight to a very Pythonic mind. 1. Beyond PEP 8 link 2. Transforming Code into Beautiful, Idiomatic Python this video
“some classic talks from Raymond Hettinger.”
Generic tips for writing pleasant Python code.
For an alternative perspective, allow me to present some classic talks from Raymond Hettinger. First, some generic tips on how to write Python code that's pleasant to work with: this video And then this one digs more specifically into how not to write Python like it's Java, starting at 12:40 (with talking about why leading up to that): link
“I came to the comments to post the same thing[1]”
Explains loop else clause
Glad you posted this. I came to the comments to post the same thing[1] because thinking of it as "notfound" makes remembering (and comprehending it) easier. :) [1] this video
1) There's certainly not "one way" to iterate in Python[1], and they're not even consistently named (xrange is the iterator version of range, but izip is the iterator version of zip). 2) You can use Python in the browser[2][3][4 sort of]. 1. this video 2. link 3. link 4. link
“He says if he had a time machine he could tell Guido in the future we’re all using structured programming”
Hettinger explains why for-else should have been called nobreak.
Here’s why (Hettinger): > In 1991, “else” was the obvious choice because of the traditional way compilers implemented while-loops: pastebin.com/tY35CTJ4 That is, “if I haven’t finished the loop, GOTO the body.” He says if he had a time machine he could tell Guido in the future we’re all using structured programming so no one will find “else” intuitive; call it “nobreak” instead: this video Guido says if he had a time machine he would not have included the feature at all: link This whole thing was Knuth’s idea, not Guido’s: link
“Link to the talk”
Hettinger traces for-else to Knuth and goto, suggests naming it nobreak.
Raymond Hettinger has a good section on this, tracing it back Knuth's discourse on structured programming in the face of 'goto'. He suggests calling the keyword 'nobreak', rather than 'else'. Inside any loop are a conditional and a jump. In pseudocode: if not <loop end condition> then <do loop things> <jump to top of loop> else //loop is done <do things in the case that the loop has terminated naturally> If we 'break' in the body of the loop for some reason, we will never hit the 'else' in this chunk of code. As Mr. Hettinger explains, this is obvious to anyone reading Knuth or coming from a 'goto' style of control flow. This is not an insult, but an observation. (Un)Fortunately, structured programming is the absolute norm now, and we learn looping constructs directly, rather than learning 'goto' and then building to looping constructs. Especially in a language with rich iteration protocols, such as Python, it is very much unapparent that the looping constructs are fancy wrappers around 'goto'. Link to the talk: this video
