Python - Idioms + Tricks

Question 1

Loop over dictionary

Answer 1

for key in dict:

print(key)

Question 2

Loop over dictionary and delete something in dictionary

Answer 2

for key in dict.keys()
if key.startswith(‘some letter’):
del dict[key]

Question 3

Loop over dictionary and access both keys and values

Answer 3

for key, value in dict.items():

print(key, value)

Question 4

Loop over dictionary and access both keys and values (in a memory efficient way)

Answer 4

for key, value in dict.iteritems():

print(key, value)

Question 5

Construct a dictionary from pairs (memory efficient way)

Answer 5

mydict = dict( izip( firstlist, secondlist) ) )

Question 6

Counting with dictionaries

From this:
colors = {‘red’, ‘green’, ‘red’, ‘blue’….}

You want this:
{‘blue’: 1, ‘green’: 2, ‘red’: 3}

Answer 6

d = {}
for color in colors:
d[color] = d.get(color, 0) + 1

Question 7

Grouping with dictionaries

We want to group by number of letters:
names = [‘mary’, ‘matt’, ‘rachel’, ‘mellissa’, ‘betty’, ‘raymond’]

Answer 7

d = defaultdict(list)
for name in names:
key = len(name)
d[key].append(name)

Question 8

Clarify the readability of your function calls with keyword arguments

Try to make this better:
my_function( ‘somestring’, False, 20, True )

Answer 8

my_function( name=’somestring’, nameofcondition=False,

somenumber=20, nameofcondition2=True )

Question 9

Unpacking sequences

mylist = [ ‘mundy’, ‘reimer’, 28, …]

Answer 9

firstname, lastname, age = mylist

Question 10

Updating multiple state variables at once

Make the below better:

def fibonacci(n):
    x = 0
    y = 1
    for i in range(n):
       print(x)
       temp = y
       y = x+y
       x = temp

Answer 10

def fibonacci(n):
    x, y  = 0, 1
    for i in range(n):
        print(x)
        x, y = y, x+y

Question 11

Simultaneous state variable updates (especially when doing a differential equation where the variables in a equation update at time steps)

Make the below better (get rid of temp variables):

temp_x = x + dx * t
temp_y = y + dy * t
x = temp_x
y = temp_y

Answer 11

x, y = ( x + dx * t, y + dy * t )

Question 12

Concatenating strings (the efficient way)

Rewrite the following:

names = ['mundy', 'bob', 'alice', 'bill']
s = names[0]
for name in names[1:]:
    s+= ', ' + name
print(s)

Answer 12

print( ‘, ‘.join(names) )

Question 13

How to open and close files (the efficient way)

Rewrite the following:

f = open('data.txt')
try:
    data = f.read()
finally:
    f.close()

Answer 13

with open('data.txt') as f:
    data = f.read()

Question 14

Turn List expressions into Generator Expressions (so it doesn’t have to create the whole list at once and be memory intensive)

Rewrite the following:

print( sum( [ i**2 for i in range(10) ] )

Answer 14

Take out the square brackets to turn it into a generator expression!

print( sum( i**2 for i in range(10) )

Question 15

In the following function definition, how would we use an ASSERT statement to help us debug in the case something goes wrong? What does the ASSERT statement return if it is true/false?

def apply_discount (price, discount):
    price_after_discount = price * (1.0 - discount)

return price_after_discount

Answer 15

def apply_discount (price, discount):
    price_after_discount = price * (1.0 - discount)
    assert 0 <= price_after_discount <= price
    return price_after_discount
\_\_\_\_\_\_
If the assert statement is TRUE, nothing happens.  If it is FALSE (and the price after discount happens to be lower than 0 dollars or higher than the original price), then the assert statement raises an AssertionError as an exception, along with an optional error message.  Use ASSERT statements for debugging (in case things go wrong) only!  Don't ever use them as an alternative for an if statement or anything logic or program flow wise.  Debugging only!

Question 16

How would we use an assert statement to check if an IF-statement or chunk in code is not working?

if condition == x:
do_blah()
else:
do_blah2()

Answer 16

if condition == x:
do_blah()
elif: condition == y
do_blah2()
else:
assert False, (‘Printing this should not happen
but if it does, the error is here’)

Question 17

What’s good style for comma placement in lists with respect to catching diffs in line changes in some version control software? Fix the below code:

names = [‘Alice’, ‘Bob’, ‘Dilbert’}

Answer 17

Make sure you put list elements on separate lines and always end in a comma so you can add or subtract an element on the fly and only highlight that line as a diif in code:

names: = [
                'Alice',
                'Bob',
                'Dilbert',
                ]

Question 18

What the benefit of using with statements in opening files, and how do we use it? Fix the below:

f = open(‘hello.txt’, ‘w’)

f. write(‘hello world’)
f. close()

Answer 18

The benefit is that WITH automatically closes a file after the interpreter exits that indentation of code, so if any error occurs when the file is open, then it still gets closed automatically afterwards no matter what.

with open('hello.txt', 'w') as f:
    f.write('hello world')

Question 19

What does a single leading underscore in python mean? Example:

_var

Answer 19

It’s convention only, but it’s a hint to tell the programmer that the variable or method is for internal use only. That means that that variable or method stays within the module and is never used outside of it when imported.

It is interesting to note that wildcard imports (eg - from some_module import * ), will NOT import the names of methods or variables with a leading underscore.

Question 20

What does a single trailer underscore in python mean?
Example:

var_

Answer 20

This is used just in case you have a name conflict and want to use that name. For example, if you want to have a variable named ‘class’, we can’t because that is a reserved word, but instead we can use ‘class_’ to use it. This is just a convention.

Question 21

What does a double leading underscore (dunder) in python mean?
Example:

__var

Answer 21

A double underscore prefix causes the python interpreter to rewrite the attribute name in order to avoid naming conflicts/collisions in subclasses. This is called name mangling.
For example:

class Test:
    def \_\_init\_\_(self):
        self.foo = 11
        self._bar = 23
        self.\_\_baz = 42

t = Test()
dir(T)
_____
If we call the dir() function to look at all the attributes of a class, we will notice that the variable got renamed to _Test__baz, and will not show up to be able to be accessed in the subclasses.

Question 22

What does the double leading+trailing underscore (dunder) in python mean?
Example:

__var__

Answer 22

Name mangling does NOT occur and the interpreter leaves these alone. These are called dunder methods or magic methods and are reserved for special use in the language, like __init__

Question 23

What does a single underscore by itself in python mean?
Example:

_

Answer 23

Per convention, a single stand-alone underscore is sometimes used to indicate that a variable is temporary or insignificant or not used (like in loops or unpacking).
Example:

for _ in range(32):
print(‘Hello World’)

Question 24

Sort a list of dictionaries, by a specific key-value pair.

ex) Sort animals by age:

> > > animals = [
… {‘type’: ‘penguin’, ‘name’: ‘Stephanie’, ‘age’: 8},
… {‘type’: ‘elephant’, ‘name’: ‘Devon’, ‘age’: 3},
… {‘type’: ‘puma’, ‘name’: ‘Moe’, ‘age’: 5},
… ]

Answer 24

It’s worth knowing about the optional keyword argument key that lets you specify a function that will be called on every element prior to sorting. Adding a function allows custom sorting rules, which are especially helpful if you want to sort more complex data types:

sorted(animals, key=lambda animal: animal[‘age’])

By passing in a lambda function that returns each element’s age, you can easily sort a list of dictionaries by a single value of each of those dictionaries. In this case, the dictionary is now sorted in ascending order by age.

Question 25

What’s a quick way to turn a list expression into a generator expression? Why would you do this?

Change the below into a generator expression:
\_\_\_\_\_
# find the sum of the first 1000 perfect squares

sum( [ i * i for i in range(1, 1001) ] )

Answer 25

Generator expressions save on memory resources. Just replace the brackets with parentheses to easily create a generator expression!

sum( ( i * i for i in range(1, 1001) ) )

Generator expressions are perfect for when you know you want to retrieve data from a sequence, but you don’t need to access all of it at the same time.

Instead of creating a list, the generator expression returns a generator object. That object knows where it is in the current state (for example, i = 49) and only calculates the next value when it’s asked for.

So when sum iterates over the generator object by calling .__next__() repeatedly, the generator checks what i equals, calculates i * i, increments i internally, and returns the proper value to sum. The design allows generators to be used on massive sequences of data, because only one element exists in memory at a time.