Programmeringskanon

Programmeringskanon för 729G46

Den här sidan agerar kanon (som i religiös eller litterär kanon, inte en sådan man skjuter med) för vilka koncept som introduceras i respektive tema. Det är inte tillåtet för vare sig examinator, assistenter eller studenter att använda koncept utanför denna kanon eller längre fram i denna kanon än där användandet sker. Dvs. det är till exempel inte tillåtet att använda sig av loopar för att lösa uppgifter som tillhör Tema 1 eftersom dessa introduceras först under Tema 2, osv. Varje tema bygger dock vidare på vad som kommit tidigare och det är alltså självklart tillåtet att använda koncept från Tema 1 i Tema 2, och så vidare.

Denna begränsning är till för att stegvis utöka din konceptuella verktygslåda och dina språkkunskaper i Python. Detta har två huvudsakliga syften:

1. Det begränsar mängden nya koncept du behöver lära dig för att angripa uppgifterna du ska lösa utan att bli allt för överväldigad. Det kommer vara väldigt mycket nytt ändå men detta begränsar “sökmängden” av möjliga saker du kan göra i de inledande delarna av kursen.
2. Det tvingar dig att lösa problem med de verktyg du har till hands, och inte sträcka dig efter mer avancerade verktyg förrän du behärskar de mer grundläggande verktygen. Ingen spikpistol förrän du behärskar hammaren, så att säga.

Tema 1

Programflöde

• Ett python-program utförs rad för rad, uppifrån och ned.
• Funktionsanrop innebär ett hopp till funktionskroppen, som körs rad för rad, men vi återvänder sedan till samma plats i koden där funktionsanropet skedde, och funktionsanropet omvandlas till funktionens returvärde (substitution).
• Villkorssatsen if låter programmet välja en av flera olika vägar. Villkoren för if och eventuella elif-klausuler testas uppifrån och ned, och den första klausulen vars villkor är sant kommer utföras, och inga andra. En eventuell else-klausul fångar de fall där inget villkor var sant.
• Kommentarer inleds med # och ignoreras av programmet, används för förklaringar och minnesanteckningar i koden. (Nej, det är INTE hashtags.)

Värden, datatyper och literaler

Alla program bearbetar någon form av värden, och alla värden i Python måste ha en datatyp. Vi kan representera värden i vår kod som literaler, som är den “bokstavliga” representation av värdet.

Literaler kommer i texten på den här sidan alltid uttryckas i ett monospace-typsnitt medan när jag refererar till motsvarande värde använder jag det vanliga typsnittet. Vi kan nästan alltid tänka på dessa som samma sak, men det är viktigt att komma ihåg att en literal bara är en textuell representation av det underliggande värdet. Ett sätt att säga till python att använda motsvarande värde.

• Heltal (integer) torde vara självförklarande.
  • 2 är en heltalsliteral och representerar heltalet 2.
• Flyttal (floating point number) är det vanligaste sättet att representera decimaltal i en dator.
  • 3.141592 är en flyttalsliteral och representerar en approximation av talet $\pi$.
• Sträng (string) är en typ av sekvens som används för att representera text, inklusive enskilda tecken (python har till skillnad från många andra programmeringsspråk ingen separat datatyp för enskilda tecken).
  • "hej" och 'tjenare' är strängliteraler och vi kan använda antingen enkla eller dubbla citattecken, men vi måste välja samma tecken för en sträng ('tja" är alltså inte en tillåten strängliteral). Notera att "2" och '3.141592' är strängar, inte tal, eftersom de omges av citattecken.
• Lista (list) är en typ av sekvens och en typ av samling som innehåller flera andra värden av vilken datatyp som helst.
  • Hakparenteserna [ och ] används för att skapa listliteraler och är speciella eftersom vi kan ha andra literaler mellan hakparenteserna.
• True och False är de två enda sanningsvärdesliteralerna. Notera att de inte är strängar och att de måste skrivas med versal i början.
  • Alla andra värden i python har ett motsvarande sanningsvärde, och det är nästan alltid sant. För datatyperna vi sett hittills är de enda undantagen heltalet 0 (motsv. literalen 0), flyttalet 0 (motsv. literalen 0.0), tomma strängen (motsv. literalen '' eller "") och tomma listan (motsv. literalen []).

Variabler och tilldelning

Variabler kan ses som lådor i vilka vi lagt ett visst värde och de flesta värden vi bearbetar ligger oftast i sådana variabler. I verklig kod använder vi förhållandevis få literaler, utan vi jobbar oftast med variabler.

Vi “lägger ett värde i en låda” genom att använda tilldelningsoperatorn =. Variabeln som tilldelas står alltid till vänster om =-tecknet, och värdet som lagras i variabeln står till höger. Värdet kan representeras av literaler, andra variabler, eller uttryck.

1

var1 = 5

Uttryck och substitution.

Ett uttryck är något som kan beräknas och omvandlas till ett värde. Vi kan tänka att när uttrycket beräknas så ersätts, substitueras, det av sitt värde. Uttrycket 1 + 1 kan t.ex. substitueras av värdet 2. Uttryck kan vara hur långa som helst och vi kan indikera ordningen av beräkningarna med vanliga parenteser, ( och ), precis som i matematiken, och vi kan substituera sådana deluttryck “inifrån och ut”. T.ex. 10 - (7 - 3) kan substitueras av 10 - 4 som i sin tur kan substitueras av 6. En av de vanligaste typerna av uttryck i praktiken är funktionsanrop.

Funktioner

Funktionsdefinition, parametrar och returvärde:

1
2
3

def funktionsnamn(parameter1, parameter2):
    ... funktionskropp ...
    return returvärde

Parametrar är en typ av variabler som tilldelas när funktionen anropas och som bara existerar inne i funktionskroppen.

Funktionsanrop och argument:

1
2
3

variabel = funktionsnamn(argument1, argument2)
# via substiution samma sak som:
variabel = returvärde

Först binds argumenten, argument1 och argument2, till parametrarna parameter1 respektive parameter2. Vi kan tänka på det som tilldelningar där parameter1 = argument1 osv. Själva argumentet kan vara vilket uttryck som helst, t.ex. en literal, en variabel, ett aritmetiskt uttryck eller till och med ett annat funktionsanrop.

Funktionskroppen utförs sedan uppifrån och ned, och vi kan tänka på det som att funktionsanropet omvandlas till funktionens returvärde.

Konstruktorer

Vi kan också skapa värden med hjälp av konstruktorer, som är en typ av funktioner.

Konstruktorn int skapar ett nytt heltal och anropet int() returnerar heltalet 0. Genom att skicka med ett argument kan vi skapa andra heltal. Vi kan skapa t.ex. heltalet 1 genom att skriva int(1), men eftersom heltalsliteralen 1 redan representerar heltalet 1 så skippar vi normalt sett konstruktorn i dessa fall. Mer relevant är att konvertera värden av andra datatyper till heltal. T.ex. int('5') tar strängen som uttrycks av strängliteralen '5' och returnerar heltalet 5.

Vi kan också konstruera:

• Flyttal med konstruktorn float
  • float() utan argument returnerar flyttalet 0, motsv. flyttalsliteralen 0.0.
• Strängar med str
  • str() utan argument returnerar den tomma strängen, motsv. flyttalsliteralerna '' och "".
• Listor med list
  • list() utan argument returnerar den tomma listan, motsv. listliteralen [].
• Sanningsvärden med bool()
  • bool() utan argument returnerar falskt, motsv. sanningsvärdesliteralen False

Inte alla datatyper och värden kan konverteras hur som helst, och python kommer säga ifrån om vi försöker göra en förbjuden konvertering.

Operatorer

• Aritmetiska operatorer:
  • De fyra räknesätten: +, -, *, /
    • Fungerar som man förväntar sig för taltyper, bortsett från lite kluriga typkonverteringar som man ibland kan snubbla på. T.ex. är kvoten av två heltal alltid ett flyttal, även om divisionen “går jämt ut”, 4 / 2 blir alltså flyttalet 2.0.
    • + och * kan också användas för konkatenering, sammanfogning, av sekvenser.
  • Ytterligare tre räknesätt:
    • **, potensoperatorn, dvs. “upphöjt till”. 2**3 är alltså hur vi skriver $2^3$ i python.
    • //, “nedrundningsdivision”, ofta felaktigt kallat heltalsdivision (t.ex. av Skansholm) eftersom den beter sig som heltalsdivision för positiva värden. Fungerar som vanlig division avrundat nedåt och är ofta den första typen av division man lär sig i grundskolan innan man lär sig räkna med decimaler. 14 // 4 blir alltså heltalet 3.
    • %, modulo eller resten vid en nedrundningsdivision, 14 % 4 blir alltså heltalet 2.
    • Den matematiskt lagde kan tänka sig att // och % förhåller sig till varandra enligt formeln b * (a // b) + a % b == a.
• Jämförelseoperatorer:
  • ==, !=, <, <=, >=, >
  • ==, testar om två värden är lika
  • !=, testar om två värden är olika
  • <, <=, >=, >, mindre än, mindre än eller lika med, större än eller lika med, och större än eller lika med
  • En jämförelse är alltid ett uttryck och beräknas alltid till, och kan substitueras av, ett sanningsvärde, sant eller falskt (motsv. literalerna True och False).
  • Fungerar mestadels som man tänker sig, men man kan behöva hålla tungan i rätt mun med datatyperna ibland, t.ex. är 1 == 1.0 sant, men 1 == '1' är falskt.
• Logiska operatorer:
  • or, and, not
  • Opererar på andra sanningsvärden (dvs. på alla andra värden eftersom dessa kan tolkas som sanningsvärden) och beräknas alltid till, och kan substitueras av, ett sanningsvärde.
  • Uttrycket a or b är sant om minst ett av värdena i a och b är sant, annars falskt.
  • Uttrycket a and b är sant endast då både a och b innehåller sanna värden, annars falskt.
  • Uttrycket not a är sant då a är falskt och falskt då a är sant.
• in-operatorn kontrollerar om ett visst värde finns i en samling eller i en sekvens

Villkorssatser och klausuler

1
2
3
4
5
6
7
8
9

if villkor1:
    # klausulkropp som utförs om villkor1 är sant
    ...
elif villkor2:
    # klausulkropp som utförs om villkor1 är falskt men villkor2 är sant
    ... 
else:
    # klausulkropp som utförs om både villkor1 och villkor 2 är falska
    ...

Själva villkoren kan vara vilka uttryck som helst eftersom alla värden i Python kan konverteras till, och alltså substitueras av, antingen sant eller falskt.

Specialfunktioner

Funktionen print returnerar ingenting och substitueras därför bara av det speciella värdet None som representerar just “inget värde” (som dock kan tolkas som sanningsvärdet falskt, eftersom alla värden kan tolkas som ett sanningsvärde, sista gången jag säger det, jag lovar). Funktionen print används för att skriva ut något i terminalen medan programmet körs. Det är dock väldigt viktigt att inse att en sådan utskrift bara är till för programmeraren eller användaren, för python är en utskrift lika betydelselös som en kommentar.

Funktionen random.randint, som vi får tillgång till genom att skriva import random längst upp i filen eller i pythons interaktiva läge, används för att generera slumpade heltal. Anropet random.randint(0, 1) kommer att returnera antingen heltalet 0 eller heltalet 1. Anropet random.randint(3, 6) kommer att returnera något av heltalen 3, 4, 5 eller 6.

Tema 2

Rekursion, upprepning med funktionsanrop

Generell iteration med while

Iteratorer och sekvenser med for

Filer och kontexthanterare

Mängder och mängdoperationer

Strikt nästlade strukturer

Tema 3

Muterbarhet, föränderliga värden

Objekt och metoder

Namespaces och scope

Associationstabeller, dict

Godtyckligt nästlade strukturer och multirekursion