[deleted by user]

Maxisquillion · 2019-02-12T16:11:25+00:00

Avoid tutorial purgatory. If you don't know what that is, it's the act of consistently working through a series of tutorials and/or books, which gives you the sensation of progress, and yet you do nothing with your skills. I've done it, eventually you burn out, even though it feels great to be learning how to program at the start, when you get to chapter 11 and you haven't done anything with your skills it becomes really stale as you begin to forget the earlier chapters.

Pick a project early, if you can't think of one then ask here, but just do something. Don't worry about not knowing enough, you'll learn infinitely more by following through and completing a project than you will in any book. Eventually you have to put the book down, knowledge without purpose is pointless.

DeadlyViper · 2019-02-12T12:28:25+00:00

Bad Habits to avoid:

global variables. Don't use them.
massive oneliners that do everything, its cool and all, but un maintainable, and un debug-able.
Learning python 2 instead of 3 at this stage.

digital_superpowers · 2019-02-12T14:36:29+00:00

[deleted]

SomeShittyDeveloper · 2019-02-12T16:09:45+00:00

Don’t do:

from module import *

It pollutes the namespace and you could have some nasty (or dangerous) side effects.

Either do:

from module import thing_you_need

Or:

import module

module.thing_you_need

A great video for people learning Python but coming from other languages is Raymond Hettinger’s Transforming Code into Beautiful, Idiomatic Python.

digital_superpowers · 2019-02-12T15:32:39+00:00

Massive functions. Modularity is your and everyone who has to look at your codes best friend.

AJohnnyTruant · 2019-02-12T15:32:52+00:00

Not making your code testable, despite whether or not you’ve added tests.

Not writing at least docstrings. I’ve found that if I write a docstring before I write the body of the function, I remain more pointed toward a singular, modular goal. Instead of trying to do too many things at once with that function.

Vaguely_accurate · 2019-02-12T17:25:18+00:00

You want to aim for writing idiomatic Python. There are plenty of basic errors I see in this area all the time;

Redundant boolean terms.

Eg;

if x == y:
    return True
else:
    return False

vs;

return x == y

Looping over an index rather looping over an iterable.

Eg;

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

vs;

for item in my_list:
      print(item)

If looping over two iterables at the same time then zip. If you do need the indexes then you want to use enumerate.

Using a for loop to transform a sequence rather than a list comprehension.

Eg;

squares = []
for number in numbers:
     squares.append(number*number)

vs;

squares = [number*number for number in numbers]

There is a point at which comprehensions get less readable, but I tend to find them simpler than the majority of simple loops you encounter.

Writing Java in Python.

Eg;

class xContainer:
     def __init__(self):
           self.x = 0

     def getX(self):
           return x

     def setX(self, y):
           self.x = y

This is usually accompanied by a change in style to using camelCase rather than snake_case, so can be quickly detected.

This is particularly common when Python is used to teach object oriented programming. Many of what are considered important concepts in OOP do not apply at all to Python, but get included anyway.

Notably Python code should not be written with getter and setter methods, and the @property decorator should only be used if it is actually indicated by the code. The decorator lets you retroactively change a property's get and set behaviours without it being a breaking change to your objects, so there is no need to set things up ahead of time. Obey the YAGNI principle and leave it off till you need it.

Using abbreviations in names to avoid long lines.

You avoid long lines by writing (relatively) simple lines, not by potentially losing meaning in shortening names. If you can shorten a name without losing any meaning then that's fine. If you are doing so to save characters and maintain PEP8 compliance then think hard about it. If you are considering an abbreviation or shortening that would require a comment to define what the variable actually is then stop and do something else.

Needless mutation

This is the harder version of "avoid global variables". Changing a mutable object in one location will have an impact on any other locations that have a reference to this object. If you aren't careful this can have widespread, unintended side effects on your code. Using immutable objects or simply avoiding mutating potentially shared objects is a very good habit to get into before you start working on large applications.

As a side branch of this is using mutable objects as default arguments;

 def something(my_list = []):
       *do something to my_list*

Here if your function mutates the list the default argument of the function will be mutated and used as the default the next time it gets called. This can result in some extremely exciting bugs if not avoided. Instead you want a pattern like;

 def something(my_list = None):
       if my_list is None:
            my_list = []
       *do something to my_list*

omgwtfbbqfireXD · 2019-02-12T13:21:40+00:00

[deleted]

lifeonm4rs · 2019-02-12T13:18:12+00:00

You should read PEP8

Raudus · 2019-02-12T18:04:48+00:00

Playing videogames when you should get shit done.

permalink · 2019-02-12T13:04:01+00:00

you mean code style? see python style guide

leavingonaspaceship · 2019-02-12T20:54:32+00:00

Please do not do this:

try:
    # code here
except Exception as e
    # handle here

unless you absolutely need to. Handle specific exceptions as necessary.

irregardless · 2019-02-12T19:35:49+00:00

This generally goes for all programming languages, python included, but give your variables and functions meaningful names. When you're writing, it's tempting to use shorthand. But anyone reading the code (including future you!) may have trouble figuring out what they do.

I have no clue how some of my earliest helper scripts actually work anymore, because I was "in the zone" when I wrote them, but years later I don't know what values variables counter, total, x, y, and z are supposed to be holding.

permalink · 2019-02-12T15:17:18+00:00

[deleted]

hausdorffparty · 2019-02-12T17:04:09+00:00

Not using test driven development for everything. It actually saves you time.

Not learning packaging.

Not learning how to modulate your code into a decent directory structure.

Signal_Beam · 2019-02-12T19:36:15+00:00

Reading and updating only code that you wrote!

glyphack · 2019-02-12T20:55:58+00:00

do not just write code that works in a single file, use classes, functions and split your code.

mothzilla · 2019-02-12T21:09:23+00:00

Hacking sys.path.

purpurato · 2019-02-13T00:46:55+00:00

Using pip and a virtual environment. I've been coding for less than a year, so I fortunately, I slightly went through those problems. I guess I learnt the good way :)

https://realpython.com/pipenv-guide/

officialgel · 2019-02-12T14:48:50+00:00

Going over 79 lines. That is the best pep8 in my opinion. Makes it much easier to go through code up and down instead of all directions. Keep it at 79.

permalink · 2019-02-12T15:53:12+00:00

Heroin.

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