Pythonuppgifter 2 - Sekvenser

Skriv lösningarna till uppgifterna i en och samma fil och testa koden själv innan du använder rättningsskriptet. Att kunna testa sin kod är en viktig del av att programmera!

För att göra det här kapitlet lite lättare att komma igång med har vi förberett ett så kallat kodskelett. Detta hittar ni i kurskatalogen /courses/729G46/kursmaterial/pyuppg/2_sekvenser.py. Kopiera kodskelettet till någon av era hemkataloger och utgå från det när ni skriver era lösningar.

Den här gången finns inga tester i kodskelettet utan bara header-raden för varje funktionsdefinition. Det är upp till er att skriva lämpliga tester utifrån uppgiftsbeskrivningarna.

Att lära dig från uppgifterna

• Förstå vad en sekvens är med särskilt fokus på listor, tupler och strängar.
• Förstå access av element i sekvenser med indexering.
• Förstå hur utsnitt fungerar.

Man kan få max 95 poäng och för att få godkänt krävs 55 poäng (85 för väl godkänt). Försök dock att lösa alla uppgifter då inte alla fel upptäcks av rättningsskriptet. Om ni har lite marginal kan ni kanske bli godkända även om assistenten som rättar hittar något sådant fel.

Uppgift 2.1

Subskriptnotationen för index

Sekvenser i Python har per definition en ordning och vi kan komma åt element på olika platser med hjälp av index och subskriptnotation. Vi kommer titta särskilt på strängar, listor och tupler i de här uppgifterna men andra sekvenstyper kan dyka upp längre fram i kursen.

För att testa uppgifterna nedan kan du använda strängen "abcdef", listan [1, 2, 3, 4, 5] och tupeln (1, 2, 3, 4, 5).

Strängar är som vi sett ett sätt att representera text i Python (och andra programmeringsspråk) medan tupler och listor är så kallde behållare (eng. containers) eller samlingar (eng. collections), dvs en typ av värden som “innehåller” och “samlar” andra värden. Vi kommer stöta på flera samlingar längre fram i kursen.

Det är viktigt att veta att en lista, eller en tupel, kan innehålla vilka datatyper som helst, även blandat, som i [1, "b", 3.0]. Vi kommer till vad som skiljer en lista från en tupel längre fram i kursen. För vad vi gör i det här avsnittet är det ingen skillnad mellan dem, annat än att listor skrivs med hakparenteser, [ och ], medan tupler skrivs med vanliga parenteser ( och ) (eller inga parenteser alls, vilket går bra ibland).

Överkurs: Ska man vara riktigt strikt är många kommaseparerade sekvenser av värden i Python-kod tupler. T.ex. argumenten till en funktion. Detta kan man utnyttja på olika intressanta sätt som vi kommer tillbaka till längre fram i kursen.

2.1.1 (5p)

Skriv en funktion second_element(seq) som tar in en sekvens som argument och returnerar det andra elementet i sekvensen.

2.1.2 (5p)

Skriv en funktion last_element(seq) som tar in en sekvens som argument och returnerar det sista elementet i sekvensen.

2.1.3 (5p)

Skriv en funktion second_last_element(seq) som tar in en sekvens som argument och returnerar det näst sista elementet i sekvensen.

2.1.4 (5p)

Skriv en funktion nth_element(seq, n) som tar in en sekvens och ett heltal som argument och returnerar elementet på index n i sekvensen

Uppgift 2.2

Subskriptnotationen för utsnitt

Ofta är man intresserad av mer än att bara plocka ut ett enskilt värde i en sekvens. Istället vill man plocka ut delar av sekvensen, delsekvenser. I Python kan vi komma åt sådana utsnitt (eng. slice) med hjälp av subskriptnotationen som vi tidigare använde för index. Använd utsnitt för att lösa nedanstående uppgifter. Se Common Sequence Operations.

Använd samma testsekvenser som i den föregående uppgiften för att testa dina lösningar.

2.2.1 (5p)

Skriv en funktion three_first_in_sequence(seq) som tar in en sekvens som argument och returnerar delsekvensen med de tre första elementen i sekvensen.

2.2.2 (5p)

Skriv en funktion three_last_in_sequence(seq) som tar in en sekvens som argument och returnerar de tre sista elementeten i sekvensen.

2.2.3 (5p)

Skriv en funktion but_five_last_in_sequence(seq) som tar in en sekvens som argument och returnerar allting förutom de 5 sista elementen i sekvensen.

2.2.4 (5p)

Skriv en funktion every_other_in_sequence(seq) som tar in en sekvens som argument och returnerar vartannat element i sekvensen (det vill säga elementen på index 0, 2, 4, 6, …).

Tips: Du kommer behöva ett utsnitt med två kolon.

2.2.5 (5p)

Skriv en funktion five_around_n_in_sequence(seq, n) som tar in en sekvens och ett heltal som argument och returnerar den delsekvens som innehåller de två elementen före index n, följt av elementet på index n och sist de två elementen efter index n. Anropet five_around_n_in_sequence("abcdefg", 3) ska alltså returnera "bcdef".

2.2.6 (5p)

Skriv en funktion reverse_sequence(seq) som tar in en sekvens som argument och returnerar sekvensen i omvänd ordning. Använd utsnittsnotation.

Uppgift 2.3 (10p)

Skriv en funktion get_n_from_pos(seq, start, n) som tar en sekvens (seq) och två heltal (start och n) som argument. Funktionen ska returnera en sekvens som innehåller n element från och med index start ur sekvensen.

Exempel:

1
2
3
4
5
6

>>> get_n_from_pos("Ett ytterligare exempel", 4, 11)
'ytterligare'
>>> get_n_from_pos("Ett ytterligare exempel", 4, 7)
'ytterli'
>>> get_n_from_pos("Ett ytterligare exempel", 8, 11)
'rligare exe'

Uppgift 2.4 (5p)

Skriv en funktion concatenate_sequences(seq1, seq2) som tar två sekvenser som argument och returnerar en ny sekvens som är en samanslagning av seq1 och seq2. Det vill säga först alla element i sekvens 1 följt av alla element i sekvens 2. Att sammanfga sekvenser på detta sätt kallas för att konkatenera (eng. concatenate).

Exempel:

I exemplet använder vi tupler men prova med strängar och listor också. Vad händer om man försöker konkatenera två sekvenser av olika datatyp, t.ex. en lista och en sträng?

1
2
3
4
5
6
7
8

>>> tup1 = (1, 2, 3)
>>> tup2 = (4, 5, 6)
>>> concatenate_sequences(tup1, tup2)
(1, 2, 3, 4, 5, 6)
>>> print(tup1)
(1, 2, 3)
>>> print(tup2)
(4, 5, 6)

Uppgift 2.5 (10p)

Skriv en funktion list_append(seq, val) som tar in en lista och ett värde och returnerar en ny lista som innehåller samma element som seq men där val lagts till i slutet.

Den ursprunliga listan får inte modifieras.

Exempel

1
2
3
4
5

>>> values = [1, 2, 3]
>>> list_append(values, "hej")
[1, 2, 3, 'hej']
>>> print(values)
[1, 2, 3]

Tips: Använd operatorn +.

Vad händer om seq är en sträng? Även om sekvenser har mycket gemensamt, så finns det situationer där olika sekvenstyper inte kan hanteras på exakt samma sätt.

Uppgift 2.6 (10p)

Python har en modul som innehåller färdiga funktioner som man kan använda när man vill ha med slumpen på något sätt i sin kod.

Importera modulen random. Skriv funktionen select_random(values) som väljer ut ett slumpmässigt värde bland de som finns i sekvensen values och returnera det. Använd funktionen random.choice().

Testa med alla tre sekvenstyper som vi introducerat.

Uppgift 2.7 (10p)

I denna uppgift ska du skriva en funktion som returnerar slumpmässigt valda pokemon-namn. Vi ska skicka in två tupler till den

• en tupel med förled som "Bulba", "Pika" och "Ivy", dvs strängar som börjar med en versal och slutar med en vokal.
• en tupel med efterled som "mon", "chu", och "saur", dvs strängar som börjar med en gemen konsonant.

Skriv funktionen generate_pokemon_name(prefixes, suffixes) som tar in dessa två sekvenser som argument. Slumpa fram ett värde från vardera tupel. Konkatenera sedan dessa två värden och returnera resultatet.