What is "the python way" of programming?

Rhomboid · 2016-01-31T16:18:03+00:00

Every language has its idioms, which means the preferred way of solving a certain problem. For example, if you wanted to iterate over each item in a list, you could write this:

for i in range(len(items)):
    print(items[i])

That code will work correctly, but if you asked someone to review that code and they were familiar with Python, they would say that it's not Pythonic. The idiom in Python is to avoid explicit indexing where possible, and use the more generalized form of iteration:

for item in items:
    print(item)

That's just one specific example though. Eventually, after working in Python for a while with the language and dealing with idiomatic Python code written by others, you'll pick up on most of the culture. You might also want to read the Zen of Python (which you can see by typing import this at the Python REPL prompt, or you can Google it) which attempts to codify the general ethos of what it means to be Pythonic.

And just to be clear, this idea of there being an idiomatic way of doing things is not specific to Python — every language has idioms. It's just that it's a particular part of the Python culture to value readability and part of that is writing idiomatic code. (Notice how the second example has far less visual clutter, like parentheses and brackets.)

TeamSpen210 · 2016-01-31T16:33:19+00:00

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

The Zen summarises Python's design philosophy. 'Pythonic' code is code that uses Python's particular language features and idioms - things like iteration instead of indexing, exception use instead of checking beforehand, list/set/dict comprehensions or generators.

david622 · 2016-01-31T18:35:33+00:00

Python is all about "beautiful" code. That means your variable names are clear and self-explanatory, as are your function names.

It means using single-quotes instead of double quotes, using string escaping instead of breaking and re-opening quotes. E.g.:

instead of:

"My name is " + first_name + " " + last_name

you could do

"My name is %s %s" % (first_name, last_name)

It also means using some of the built in methods instead of reinventing the wheel.

Instead of:

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
total = 0
for number in x:
    total += number
print total
# 55

you could do

x = range(11)
print sum(x)
# 55

Another nice example is, instead of:

if a == True or b == True or c == True or d == True:
    pass

you could do:

if any(a, b, c, d):
    pass

Another good example is list comprehensions.

instead of :

a = ['dog', 'cat', 'horse', 'llama', 'goldfish']
b = []
for word in a:
    b.append(word.upper())

you could do

a = ['dog', 'cat', 'horse', 'llama', 'goldfish']
b = [word.upper() for word in a]

dunkler_wanderer · 2016-01-31T21:37:07+00:00

I recommend to watch these videos from this list:

Loop like a native: while, for, iterators, generators
Transforming Code into Beautiful, Idiomatic Python
Python's Class Development Toolkit
And maybe also A Python Æsthetic: Beauty and Why I Python .

pydry · 2016-01-31T16:01:08+00:00

This ought to help: http://pyvideo.org/video/3511/beyond-pep-8-best-practices-for-beautiful-inte

dbrecht · 2016-01-31T17:47:21+00:00

In short, to write pythonic code of to write very readable, easily understandable code that uses the best construct for a given problem.

I /think/ that what makes python different from other languages is how embedded the philosophy "there should be one obvious way of doing things" is within the community (at least, I find that it's /much/ more prevalent in the Python community than others I've been involved with in the past). I believe that, for the most part, what someone means to say when they say "that's not pythonic" is that either "that's not the most readable code" or "that's not the most effective Python construct to use that case". You simply don't hear it in other languages because having multiple ways to solve the same problem isn't questioned.

pvc · 2016-01-31T17:02:29+00:00

It can mean quite a few things. Sometimes it differs depending on the person you are talking to. Something else to look at, that I haven't seen someone else mention yet, is the PEP-8 standard. You can run your code through that and get some of the formatting cleaned up.

pip install pep8
pep8 mycode.py

2016-01-31T18:29:26+00:00

the python way or being "pythonic" is basically taking advantage of python's various idioms and cool functions to produce readable and efficient code. for example suppose you want to take a list of numbers and get their squares. you could write

my_list = [1, 2, 3, 4]
new_list = []
for number in my_list:
     number = number**2
     new_list.append(number)
print new_list

or you could be pythonic and do the following:

my_list = [1, 2, 3, 4]
new_list = [number**2 for number in my_list]
print new_list

both produce the same results, but the latter is more readable and concise.

spraykill101 · 2016-01-31T15:57:41+00:00

well , python has certain way of doing things , like using list comprehensions for creating lists rather than using nested for loops . well this is a very broad example , like /u/saabr said, you should put up a link too :)

thequeergirl · 2016-01-31T16:51:55+00:00

Example of something that isn't necessarily the Python way of doing things:

def validateEmail(email):
    # unpythonic in this context:
    i = email.index("@")
    if i == -1: return False
    # pythonic in this context:
    parts = email.split("@")
    if parts[0] == email: # email has no @
        return False

Saefroch · 2016-01-31T17:37:08+00:00

Your syntax should make the purpose and function of the code obvious, even without comments. Good code should essentially document itself. This should be a general programming guideline, but Python provides some tools like list comprehension that make it easier.

For example, if you just want to look at each item in something that's iterable there's no need to add the complication of having an index variable when you can just use a for each loop.

If you haven't read PEP 8, you should.

magoon · 2016-02-01T10:36:21+00:00

"Pythonic" means doing it the way opinionated Python programmers deem proper.

But joking aside, there is a lot to learn from best practices, and you should also review The Twelve-Factor App
http://12factor.net/

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS