LoL’s comprehension

List comprehension kunnen ook gebruikt worden met meer dan 1 lijst.

Zelfde waarden in twee lijsten

• input: Y en W, twee lijsten met “loterij” getallen (integers)

• output: de getallen in Y dat ook in W voorkomt

Voorbeeld:

lingo([5, 7, 42, 47], [3, 4, 5, 7, 44, 47]) == 3

def same_numbers(Y, W):
    LC = [x for x in Y if x in W]
    return LC

Met een kleine aanpassing kunnen we ook tellen hoeveel getallen in Y ook voorkomt in W.

def lingo(Y, W):
    LC = [1 for x in Y if x in W]
    return sum(LC)

Paar gewijs optellen

• input: Y en W, twee lijsten met evenveel getallen (integers)

• output: De elementen zijn paarsgewijs bij elkaar opgeteld. Met andere woorden. [Y[0] + W[0], Y[1]+W[1], …]

Voorbeeld:

pairwise([1, 2, 3, 4], [5, 6, 7, 8]) == [6, 8, 10, 12]

def pairwise(Y, W):
    LC = [Y[i] + W[i] for i in range(0, len(Y))]
    return LC

print(pairwise([1, 2, 3, 4], [5, 6, 7, 8]) )

[6, 8, 10, 12]

Tweedimensionale arrays

Zijn overal! (en zijn LoL’s)

def mul_table(n):
    """Returns a multiplication table for n
    """
    return [[x * y for x in range(1, n + 1)] for y in range(1, n + 1)]

Voor alle y in de range van 1 tot n+1 wordt

[x * y for x in range(1, n + 1)] 

uitgevoerd. Het wordt dus n keer uitgevoerd en dit creeert n lijsten binnen de list rn. Dit creëert dus een LoL.

mul_table(5)

[[1, 2, 3, 4, 5],
 [2, 4, 6, 8, 10],
 [3, 6, 9, 12, 15],
 [4, 8, 12, 16, 20],
 [5, 10, 15, 20, 25]]

def mul_table(n):
    """Returns a multiplication table for n
    """
    table = []                     # start with an empty table
    
    for x in range(1, n + 1):      # for every row in this table ...
        row = []                   # start with an empty row
        
        for y in range(1, n + 1):  # for every column in this row ...
            row += [x * y]         # add the column value to the row
            
        table += [row]             # add the row to the table
        
    return table                   # return table

Gegeven een LoL

L = [
    [3, 2, 6, 8],
    [9, 2, 5, 7],
    [0, 3, 2, 3],
    [1, 2, 3, 4]
]

Wat als we willen tellen hoeveel getallen er in de LoL zijn.

def sum_2D(lol):
    LC = [len(row) for row in lol]
    return sum(LC)

print(sum_2D(L))

16

De expressie mag dus een lijst bevatten. for row in lol gaat elke rij langs en len(row) telt hoeveel elementen er in de rij staan. sum(LC) telt vervolgens alle lengtes van alle rijen bij elkaar op.

Nu willen we alle getallen in de LoL verdubbelen.

def double(lol):
    LC = [[x * 2 for x in row] for row in lol]
    return LC

print(double(L))

[[6, 4, 12, 16], [18, 4, 10, 14], [0, 6, 4, 6], [2, 4, 6, 8]]

for row in lol gaat elke rij af in de LoL.
[x * 2 for x in row] gaat elk element af binnen de gegeven rij en verdubbelt deze. Zo worden dus alle elementen per rij verdubbelt.

Op deze manier kunnen we ook afbeeldingen bewerken. Ter herinnering, een afbeelding bestaat uit rijen met pixels

afbeelding = [
    [[r, g, b], [r, g, b], [r, g, b], ...]
    [[r, g, b], [r, g, b], [r, g, b], ...]
    [[r, g, b], [r, g, b], [r, g, b], ...]
    ...
]

We zouden dus elke pixel kunnen bewerken met behulp van een List comprehension.

LC = [[change(pix) for pix in row] for row in afbeelding] 

Opdrachten

Opdracht 1

In het werkcollege van week 6, Fraaie plaatjes, gebruikte we for loops om alle pixels binnen een afbeelding aan te passen

def invert():
    """ run this function to read in the in.png image,
        change it, and write out the result to out.png
    """
    im_pix = get_rgb('in.png')  # lees het bestand in.png in
    print("De eerste twee pixels van de eerste rij zijn", im_pix[0][0:2])
    #
    # Onthoud dat im_pix een lijst (de afbeelding) van
    # lijsten (elke rij) van lijsten (elke pixel is [R,G,B]) is
    #
    new_pix = []
    for row in im_pix:
        new_row=[]
        for pixel in row:
            new_pixel = change(pixel)
            new_row+= [new_pixel]
        new_pix += [new_row]
    # sla nu het bestand 'out.png' op
    save_rgb(new_pix, 'out.png')

Vervang de nested loops met een list comprehension zodanig dat alle pixels worden aangepast met behulp van de functie change(pixel)

Opdracht 2

• input: row en colums, waarbij row aangeeft hoeveel rijen er zijn en colums hoe lang de rijen moeten zijn.

• output: een LoL met row aantal list van colums lang gevuld met 0-en.

Input: empty_board(5, 3):
output:
[[0,0,0]
[0,0,0]
[0,0,0]
[0,0,0]
[0,0,0]]

Opdracht 3

• input: Een LoL

• output: Een LoL waarbij alle oneven getallen zijn verwijderd.

In: [[2,3,4][4,5,6][6,7,8]]
Out: [[2,4][4,6][6,8]]