Python Bad Practices¶

l = [1, 2, 3, 4, 5]
i = 0
while i < len(l):
    print(l[i])
    i += 1

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

for v in l:
    print(v)

for i in range(len(l) - 1, -1, -1):
    print(l[i])

for i in reversed(l):
    print(i)

l = [1, 2, 3, 4, 5]
>>> l[len(l) - 1]
5

>>> l[-1]
5

>>> l[-2]
4
>>> l[-3]
3

l1 = l[0]
l2 = l[1]
l3 = l[2]

l1, l2, l3 = [1, 2, 3]

>>> l1
1
>>> l2
2
>>> l3
3

under_18_grades = []
for grade in grades:
    if grade.age <= 18:
        under_18_grades.append(grade)

under_18_grades = [grade for grade in grades if grade.age <= 18]

for i in range(len(menu_items)):
    menu_items = menu_items[i]
    print("{}. {}".format(i, menu_items))

for i, menu_items in enumerate(menu_items):
    print("{}. {}".format(i, menu_items))

foo = [1, 2, 3]
for i, item in zip(range(len(foo)), foo):
    print i, item

foo = [1, 2, 3]
for i, item in enumerate(foo):
    print i, item

people = [Person('John', 30), Person('Peter', 28), Person('Joe', 42)]

def compare_people(p1, p2):
    if p1.age < p2.age:
        return -1
    if p1.age > p2.age:
        return 1
    return 0

sorted(people, cmp=compare_people)

[Person(name='Peter', age=28), Person(name='John', age=30), Person(name='Joe', age=42)]

sorted(people, key=lambda p: p.age)

[Person(name='Peter', age=28), Person(name='John', age=30), Person(name='Joe', age=42)]

def all_true(lst):
    for v in lst:
        if not v:
            return False
    return True

all([True, False])
>> False

any([True, False])
>> True

all([person.age > 18 for person in people])

# or generator

all(person.age > 18 for person in people)

for k in d.keys():
    print(k)

for k in d:
    print(k)

for k in d:
    v = d[k]
    print(k, v)

for k, v in d.items():
    print(k, v)

d = {}
for person in people:
    d[person.name] = person

d = {person.name: person for person in people}

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])

>>> Point(1, 2)
Point(x=1, y=2)
>>> Point(1, 2) == Point(1, 2)
True

d = {}
for v in lst:
    if v not in d:
        d[v] = 1
    else:
        d[v] += 1

>>> d = defaultdict(lambda: 42)
>>> d['key']
42

from collections import defaultdict
d = defaultdict(int)
for v in lst:
    d[v] += 1

from collections import Counter

>>> counter = Counter(lst)
>>> counter
Counter({4: 3, 1: 2, 2: 1, 3: 1, 5: 1})

>>> odd = lambda x : bool(x % 2)
>>> numbers = [n for n in range(10)]
>>> for i in range(len(numbers)):
...     if odd(numbers[i]):
...         del numbers[i]  # BAD: Deleting item from a list while iterating over it
...
Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
IndexError: list index out of range

>>> odd = lambda x : bool(x % 2)
>>> numbers = [n for n in range(10)]
>>> numbers[:] = [n for n in numbers if not odd(n)]  # ahh, the beauty of it all
>>> numbers
[0, 2, 4, 6, 8]

def foo(bar=[]): # bar is optional and defaults to [] if not specified
    bar.append("baz")
    return bar

>>> foo()
["baz"]
>>> foo()
["baz", "baz"]
>>> foo()
["baz", "baz", "baz"]

def foo(bar=None):
    if bar is None:  # or if not bar:
        bar = []
    bar.append("baz")
    return bar

>>> foo()
["baz"]
>>> foo()
["baz"]
>>> foo()
["baz"]

swap = lambda a, x, y:
        lambda f = a.__setitem__:
        (f(x, (a[x], a[y])),
        f(y, a[x][0]), f(x, a[x][1]))()

def swap(a, x, y):
    """ Swap two position values in a list """
    a[x],a[y] = a[y],a[x]

def func1(param=None):
    def func2():
        if not param:
            param = 'default'
        print param
    # Just return func2.
    return func2


if __name__ == '__main__':
   func1('test')()

$ python test.py 
Traceback (most recent call last):
  File "test.py", line 11, in 
    func1('test')()
  File "test.py", line 3, in func2
    if not param:
UnboundLocalError: local variable 'param' referenced before assignment

def func1(param=None):
    def func2(param2=param):
        if not param2:
            param2 = 'default'
        print param2
    # Just return func2.
    return func2

>>> x = 10
>>> def foo():
...     x += 1
...     print x
...
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'x' referenced before assignment

>>> lst = [1, 2, 3]
>>> def foo1():
...     lst.append(5)   # This works ok...
...
>>> foo1()
>>> lst
[1, 2, 3, 5]

>>> lst = [1, 2, 3]
>>> def foo2():
...     lst += [5]      # ... but this bombs!
...
>>> foo2()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'lst' referenced before assignment

>>> def create_multipliers():
...     return [lambda x : i * x for i in range(5)]
>>> for multiplier in create_multipliers():
...     print multiplier(2)
...

0
2
4
6
8

8
8
8
8
8

>>> def create_multipliers():
...     return [lambda x, i=i : i * x for i in range(5)]
...
>>> for multiplier in create_multipliers():
...     print multiplier(2)
...
0
2
4
6
8

object = MyObject()
map = Map()
zip = 90213 # common US developer mistake
id = 34 # I still fight this one

obj = MyObject() # necessary abbreviation
object_ = MyObject() # Underscore so we don't overwrite

map_obj = Map() # combine name w/necessary abbreviation
map_ = Map()

zip_code = 90213 # Explicit name with US focus
postal_code = 90213 # i18n explicit name
zip_ = 90213

pk = 34 # pk is often synonymous with id
id_ = 34

c = "green"
a = False
p = 20
t = "04/20/2011"

clr = "green"
ctv = False
pythnYrs = 20
pthnFrstSd = "04/20/2011"

strColor = "green"
boolActive = False
intPythonYears = 20
dtPythonFirstUsed = "04/20/2011"

color = "green"
active = False
python_years = 20
python_first_used = "04/20/2011"

import logging
log = logging.getLogger()

class JavaStyle:
    """ Quiz: what else am I doing wrong here? """

    def __init__(self):
        self.name = ""

    def get_name(self):
        return self.name

    def set_name(self, name):
        log.debug("Setting the name to %s" % name)
        if isinstance(name, str):
            self.name = name
        else:
            raise TypeError()

    if __name__ == "__main__":
        j = JavaStyle()
        j.set_name("pydanny did this back in 2006!")
        print(j.get_name())

import logging
log = logging.getLogger()

class PythonStyle(object):

    def __init__(self):
        self._name = ""

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        """ Because name is probably a string we'll assume that we can
            infer the type from the variable name"""
        log.debug("Setting the name to %s" % value)
        self._name = value

    if __name__ == "__main__":
        p = PythonStyle()
        p.name = "pydanny doing it the right way"
        print(p.name)

class WebService:

    @property
    def connect(self):
        self.proxy = xmlrpc.Server("http://service.xml")

if __name__ == '__main__':
    ws = WebService()
    ws.connect

class WebService:

    def connect(self):
        self.proxy = xmlrpc.Server("http://service.xml")

if __name__ == '__main__':
    ws = WebService()
    ws.connect()

try:
    do_akshun(value)
except:
    pass

class AkshunDoesNotDo(Exception):
    """ Custom exceptions makes for maintainable code """
    pass

try:
    do_akshun(value)
except AttributeError as e:
    log.info("Can I get attribution for these slides?")
    do_bakup_akshun(vlue)
except Exception as e:
    log.debug(str(e))
    raise AkshunDoesNotDo(e)