Fördelning av mandat

Från Wikiskola
Hoppa till navigering Hoppa till sök
Python logo and wordmark.svg
Programmeringsuppgift

Python-hjälp - Fler exempel

Target 10 points.svg
Mål för undervisningen Kom igång med programmering i matematiken.

Målet är att du ska använda ett färdigt program för att fördela mandat i ett val. Du bör läsa koden och skaffa dig en förståelse för hur programmet fungerar. Sedan ska du jämföra programmet med den algoritm som egentligen används vid fördelning av mandat.

Målet är inte att du ska lära dig programmering på matematiklektionen men det är oundvikligt att du ändå lär dig lite Python-kod.


Undersök hur ett Pythonprogram fördelar mandat

Det här kodexemplet passar till ett tematiskt arbete inför skolval och riksdagsval och är lämpligt att ha i kurserna Ma1a, Ma1b och Ma1c. Det kräver inga förkunskaper i programmering.

Koden

Lista: (klicka expandera till höger)

#Val-program, inputs antalet röster för de åtta riksdagspartierna

V = input("V:")
V = int(V)
S = input("S:")
S = int(S)
M_P = input("MP:")
M_P = int(M_P)
C = input("C:")
C = int(C)
L = input("L:")
L = int(L)
M = input("M:")
M = int(M)
K_D = input("KD:")
K_D = int(K_D)
S_D = input("SD:")
S_D = int(S_D)

R = V + S + M_P + C + L + M + K_D + S_D
R = int(R)

#Förra valet var k=5/7
k = 5/6
k= float(k)

JT_V = k*V
JT_V = float(JT_V)

JT_S = k*S
JT_S = float(JT_S)

JT_M_P = k*M_P
JT_M_P = float(JT_M_P)

JT_C = k*C
JT_C = float(JT_C)

JT_L = k*L
JT_L = float(JT_L)

JT_M = k*M
JT_M = float(JT_M)

JT_K_D = k*K_D
JT_K_D = float(JT_K_D)

JT_S_D = k*S_D
JT_S_D = float(JT_S_D)

mandat = 349
mandat = int(mandat)

#Korrigeringarna efter ett mandat blivit fördelat
kV = 1
kV = float(kV)

kS = 1
kS = float(kS)

kM_P = 1
kM_P = float(kM_P)

kC = 1
kC = float(kC)

kL = 1
kL = float(kL)

kM = 1
kM = float(kM)

kK_D = 1
kK_D = float(kK_D)

kS_D = 1
kS_D = float(kS_D)

#Varje partis mandat

mV = 0

mS = 0

mM_P = 0

mC = 0

mL = 0

mM = 0

mK_D = 0

mS_D = 0

while mandat > 0:

    if JT_S == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mS += 1
        mandat -= 1
        kS = kS + 2
        JT_S = S/kS

        
    elif JT_M == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mM += 1
        mandat -= 1
        kM = kM + 2
        JT_M = M/kM

    elif JT_S_D == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mS_D += 1
        mandat -= 1
        kS_D = kS_D + 2
        JT_S_D = S_D/kS_D      
        
    elif JT_V == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mV += 1
        mandat -= 1
        kV = kV + 2
        JT_V = V/kV
        
    elif JT_M_P == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mM_P += 1
        mandat -= 1
        kM_P = kM_P + 2
        JT_M_P = M_P/kM_P
        
    elif JT_C == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mC += 1
        mandat -= 1
        kC = kC + 2
        JT_C = C/kC
        
    elif JT_L == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mL += 1
        mandat -= 1
        kL = kL + 2
        JT_L = L/kL

    elif JT_K_D == max(JT_V, JT_S, JT_M_P, JT_C, JT_L, JT_M, JT_K_D, JT_S_D):
        mK_D += 1
        mandat -= 1
        kK_D = kK_D + 2
        JT_K_D = K_D/kK_D

    
print("Totalt antal röster:",R)
print("Mandat till V:", mV)
print("Mandat till S:", mS)
print("Mandat till MP:", mM_P)
print("Mandat till C:", mC)
print("Mandat till L:", mL)
print("Mandat till M:", mM)
print("Mandat till KD:", mK_D)
print("Mandat till SD:", mS_D)



Credit

Tomaas Westman skapade programmet.

Uppgift

Uppgift
Hur fungerar programmet

1. Studera koden. Vad gör programmet?

Tips: koden är lång men eftersom det finns nio riksdagspartier upprepas varje moment nio gånger i koden.

2. Kör programmet och jämför resultatet med den befintliga mandatfördelningen. Stämmer det? Om inte, varför?

Tips: Du behöver mata in de antal röster som partierna fick i förra valet.


Förädlad kod

Victors program med listor

Lista: (klicka expandera till höger)

# Listan kommer vara fylld med alla mandat i slutet av programet
Mandat = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

# Röstetal för respektive partier som blev röstde på
Röstetal = [ 516119, 1822691, 284931, 555567, 354562, 1279192, 408061, 1130832 ];

# Delnings nummer
DelningsNummer = 6/5;

# Först delar man röstetalet med 1.2
RöstetalDelad = [x / (DelningsNummer) for x in Röstetal];

Iter = 0
while Iter < 349:
    Iter += 1;
    
    # Hitta det största talet
    StörstaTalet = max(RöstetalDelad);

    # Hitta vart det nummeret är i listan
    Index = RöstetalDelad.index(StörstaTalet);

    # Lägg till en mandat till det våran index
    Mandat[Index] += 1;

    # Nu måste vi dela röstetalet med antal mandat * 2 + 1
    RöstetalDelad[Index] = Röstetal[Index] / (Mandat[Index] * 2 + 1);

    # Jag vet inte varför men här så avrundar jag till 2 decimaler
    RöstetalDelad = [float("{0:.2f}".format(x)) for x in RöstetalDelad];
    
    # print(RöstetalDelad);
#

# Här skriver jag de mandater som vart fördelade
for Val in Mandat:
    print("Mandat", Val);
#

print(Mandat);



Gustaf Haglunds kod

Programmet använder sig av Sainte-Laguë-metoden

Lista: (klicka expandera till höger)

# Sainte-Lague in Python
# Copyright (C) Gustaf H.

seated = 0
parties = [
        {'name':'S', 'votes': 1347950, 'seats': 0},
        {'name':'M', 'votes': 848739, 'seats': 0},
        {'name':'KD', 'votes': 286175, 'seats': 0},
        {'name':'C', 'votes': 389672, 'seats': 0},
        {'name':'L', 'votes': 225220, 'seats': 0},
        {'name':'MP', 'votes': 180215, 'seats':0},
        {'name':'SD', 'votes': 848503, 'seats':0},
        {'name':'V', 'votes': 345378, 'seats':0}
];

while (seated != 39):
    record = []
    keepbig = 0
    keepindex = 0

    for party in parties:
        if party['seats'] == 0:
            record.append((party['votes'] / 1.2) / ((2 * party['seats']) + 1))
        else:
            record.append((party['votes']) / ((2 * party['seats']) + 1))

    for index, check in enumerate(record):
        if check > keepbig:
            keepbig = check
            keepindex = index
    parties[keepindex]['seats'] += 1
    seated += 1

print(parties)