Fördelning av mandat

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)