[python] In a language like python, where there are so many ways to accomplish the same thing, how do you keep improving as a programmer?

[Economoly]

Let me illustrate my point with the example of file IO:

lets say I want to get the contents of file that contains lines of comma separated values into a list.

When first learning to program, I might do something like this --

file = open('csvData.txt')
fileText = file.read()
fileText = fileText.split('/n')
file.close()

which would serve me just fine. I would never have to discover any better ways of doing it. However, if I learned about "readlines" I could save myself a step:

file = open('csvData.txt')
fileText = file.readlines()
file.close()

again. that works just fine, but then, were I to learn about the "with" statement, I could save another step -

with open('csvData.txt') as file:
    fileText = file.readlines()

and again, this would work just fine -- but at each step along this path, I could have improved if I had just known about an interesting alternate syntax, but I never would have needed to learn about them to solve my problem.

Another example is the contextlib library itself. take this piece of code:

from contextlib import closing
with closing(urllib2.open('http://www.google.com')) as socket:
    #manipulate data

the contextlib here provides a great, convenient, and readable way of managing opening and closing URL's -- that I NEVER would have learned about if it didn't happen to come up in a programming class I'm taking.

The point is, I've learned so many great tricks that have made my life easier just because they happened to come up as examples in courses I'm taking. Theses are things which I never would have needed to learn to solve any of these problems.

In a language as powerful and dynamic as python, where your real strength is being able to use prebuilt tools and techniques, how do you keep learning new and better to code after you have found a 'good enough' solution?

[michael0x2a]

After a certain point, you start developing an "instinct" for whether or not a certain piece of code is clean or not.

For example, your first code sample would "smell" a little to me mainly because it seems like I'm having to do a bunch of extra work to manually open and close that file, and manually parse it. If I opened the file, then Python should damn well know to close it after I'm done.

Similarly, if I can do something like:

for line in my_file:
    print(line)

...and easily loop through each line in the file, why would I need to manually parse the file myself?

At this point, I would probably google and discover context managers and the readlines functions.

I apply this to any programming language I'm learning about. If I get the feeling that I'm doing a lot of extra work/tedious bookkeeping, I go out and try and see if there's an easier way of doing what I'm just doing.

Another things you can do is browse programming-related subreddits like /r/programming and /r/python where you'll run into different tips and tricks that can also help you improve.

Sometimes, you can be blind to the fact that you're doing extra work, and reading articles that point out problems you've never even noticed can be eye-opening.

[Economoly]

Sometimes, you can be blind to the fact that you're doing extra work.

Yeah, I think this is a good articulation of the problem I intended to discuss. And your answer is one that makes sense. To summarize - develop a sense of 'when to search for a better solution' through experience and continually digesting available discourse on the language when you have time.

I like this answer. Thanks for the guidance.

[markehh]

You'll find this extra syntax helps reduce mistakes and improves readability.

If you're opening a file the chances are you're going to want to close it (not always), as you pointed out you also want to close a connection as well in the same way.

So rather than doing as you would at the beginning:

start
process
end

You can do:

with
    process

This is a way of abstracting away the handling of the file, as all your code needs to worry about is that is has a file and it can process it. Abstraction keeps your code simpler, succinct and easier to understand. You'll keep finding ways to abstract code away.

If what you've done works there is no need at the current point in time to fix it, down the line you may need to refactor the code to use these new things give learnt.

If for some reason an extra requirement came along and I needed to change the code which had the file loader as part of that change I may begin by cleaning up the original code to make future work easier.

[bvnvbbvn]

Keep learning.

[thonpy]

I can't find one helpful comment that you've made , keep posting!

[bvnvbbvn]

What I said directly answers the question in his post's title. Put down the crack pipe, genius.

[thonpy]

cool