Koda med TI: TI-84 Plus Python Edition
Korta övningar som lär dig grunderna i programmering med stöd av grafräknaren TI-84 Plus Python Edition.
Välj bland olika övningar och lär dig i steg för steg grunderna i programmering med Python.
Kapitel 1: Starta de första progammeringsförsöken
Övning 1: Beräkningar i Python
LärarkommentarerI den första övningen från kapitel 1 kommer du att upptäcka grundläggande egenskaper hos TI-Python och de vanligaste matematiska funktionerna som ingår i TI-84 Premium CE-T-räknaren.
Syfte:
- Använda TI Python-modulen
- Upptäck de matematiska funktionerna i Python
- Skilja programeditor och konsol (Shell)
- Använda en programmerings-instruktion i konsolen
Steg 1
För att komma åt Python-appen så trycker du på knappen <prgm> och väljer sedan Python App. Du kan också komma åt Pythonappen via tangenten . Sök sedan i listan med olika appar.
Lärarkommentar: För att använda TI-Python-appen måste räknarens operativsystem uppdateras till version 5.35 eller senare. Vi rekommenderar också att TI-Connect-CE-programvaran uppda- teras så att du direkt kan överföra Python-utformade program till en IDLE (Integrated Development Environment) direkt till TI-84 Plus CE-T-räknaren.Steg 2
Välj nu 2:Python App. Då öppnas filhanteraren. Längst ner i fönstret finns olika funktioner som du når med räknarens vita tangenter. Den lilla gröna rutan längst upp till höger på skärmen visar att Python är ”på”.
Lärarkommentar: Pythonspråket är baserat på ett skript som utförs i konsolen (shell). Emellertid är det möjligt att där också
- Göra beräkningar, definiera variabler för att integrera dem i beräkningar.
- Skriva och köra ett program.
- Köra ett program som anges i editorn och be om de värden som tas av variablerna i det programmet.
Steg 3
Först kommer vi att använda konsolen även kallad "Shell" Tryck nu på f4-tangenten för att komma åt konsolen (Shell). Du kan rensa fönstret och i detta fall ta bort listan med filer genom att trycka på f4 (Tools och välja 5:Clear screen. Det har vi gjort här på skärmen.
Steg 4
Några grundläggande kommandon.
Variabler namnges vanligtvis med små bokstäver. a ←5 skrivs i Python a = 5 och erhålls på räknaren genom att skriva: a 5. Den här satsen innebär att 5 har tilldelats variabeln a.
För att testa a-värdet av variabeln c: skriver man a == 5 eller c>=5. Du får då svaret True eller False
För åtkomst samt grundläggande kontroller kan du alltså trycka på f2 och får då en palett med vanliga bokstäver och en massa symboler. De flesta tecken når du dock från räknarens tangentbord. Trycker du [A] så får du a. Trycker du på alpha-tangenten två gånger får du A. Pröva nu själv.
Steg 5
Några specialberäkningar
- Resten vid division av a med b skrivs a%b
- Heltalsdelen vid division av a med b skrivs a//b
- x upphöjt till n kan skrivas x**n. Man kan också skriva pow(x,n).
För att kunna utföra beräkningar med kvadratrötter och bråk måste man ladda biblioteksmodulen ”math import”. För att infoga modulen så trycker du på f1-tangenten (Fns..) och väljer Modul och sedan 1:math. Roten ur x skrivs nu som sqrt(x) och talet π skrivs på skärmen som pi. Du kan också trycka på tangenten för att nå olika mate- matiska funktioner.
Steg 6
Lärarkommentar: Om du trycker en gång på tangenten så konfi- gureras tangentbordet för att skriva bokstäver som gemener (”små bokstäver”). Om du trycker på två gånger så skrivs bokstäverna som versaler (stora bokstäver). Sekvensen y gör att du låser tangentbordet i alfanumeriskt läge. Trycker du på igen ändar du inställning från aktuellt läge till det tidigare.
Obs: För att tömma en konsol från tidigare aktiviteter så trycker du på f3 (Tools) och väljer 5: Clear Screen eller 6: New shell om du inte vill behålla variablerna.
Steg 7
Teckensträngar definieras med dubbla eller enkla citattecken, ’Python’ eller ”Python”.
- Längden hos en teckensträng fås med kommandot len(c). (Välj f1 (Fns…) och sedan List.
- c[k] returnerar element k-1 hos kedjan c
- För att sätta samman två strängar så adderar man dem
Steg 8
Ett litet trick:
Vid tilldelning av flera variabler så kan man göra det på en gång, vilket visas på skärmen här
Steg 9
Använda en programinstruktion i Shell-fönstret
I Pythonspråket har man möjlighet att observera en viss funktion oberoende av ett skript. Så på skärmen till höger kan du analysera funktionen av en s.k. for-loop. Du kommer åt instruktionen genom att trycka på f1 (Fns…) och sedan välja menyalternativet 5:Ctl For i in range (start, slut). Vi återkommer till loopar i en senare övning.
Steg 10
Nu till en enkel tillämpning
Den kinetiska energin hos en kropp i rörelse ges av uttrycket
Ek = (1/2)·mv2
Där m är massan i kg och v är hastigheten i m/s. Beräkna nu den kinetiska energin för en kropp som har massan 50 kg och hastigheten 12 m/s.
Lärarkommentar: Ett datorprogram innehåller instruktioner som använder variabler. En variabel är en ”låda” som gör att du kan behålla programdata (tal, användarens indatavärden, teckensträngar, etc.) genom att lagra den i datorns minne. För tilldelningen av ett värde till en variabel används tangenten som kopieras in som = i Shell-fönstret.
Steg 11
Om du trycker på [ catalog ] så får du en lista med alla Python-funktioner som finns hos räknaren.
Övning 2: Beräkningar i Python
LärarkommentarerI denna andra övning i kapitel 1 så ska du upptäcka hur man använder olika typer av data i Python
Syfte:
- Känna till olika typer av data i Pythonspråket
- Forma formatet hos digitala data
Steg 1
Känna till vilken typ av kvantitet som används
När du använder ett Pythonspråk-skript kan det vara nödvändigt att känna till vilken typ av variabel som används, eller att ändra dessa vari- abler för senare användning. Om kvantiteten som returneras av ett Python-skript till exempel returnerar en magnitud som motsvarar ett mått ifrån naturvetenskaperna, är det oftast inte lämpligt att behålla ett resultat med 6 decimaler.
Du ska skapa ett skript i Python-appen för att skilja mellan de typer av kvantiteter som används.
- En kedja av tecken
- Ett reellt tal
- Ett irrationellt tal, till exempel √2
Du visar namnet liksom typen under instruktionen Type.
Steg 2
- Importerna modulen Math (Tryck Fns och välj därefter 1:Modul. Tryck sedan 1:math… och till sist from math import *)
- Alla kommandon kan nås genom att trycka på f1-tangenten (Fns…) och sedan välja undermenyerna I/O och Type.
- Typkommandot som låter dig känna till variabelns typ skrivs för hand.
Steg 3
Till höger här har vi en teckensträng. Citattecknen (dubbla och enkla) kan man nå genom att trycka resp. .
Steg 4
Tips: Med piltangenten kan du kopiera en rad när man arbetar i Shell-fönstret (konsolen).
- Operatorn int() extraherar där så är möjligt, hela kedjan av tecken och returnerar heltalsdelen av ett tal.
- Operatorn str() omvandlar ett tal till en teckensträng.
- Operatorn float extraherar om så är möjligt flyttalet (tal med decimaltecken) från en teckensträng.
Steg 5
Ett annat tips:
Man kan skriva variabler som man vill använda på samma rad
Steg 6
För att öka värdet av en variabel med ett räkneverk så finns det två möjligheter. Skriv till exempel enligt skärmarna till höger och be sedan om att variabeln ska visas.
Steg 8
Lärarkommentar:
- Tänk på att man kan använda det alfanumeriska tangentbordet och skriva gemener genom att trycka på y . Trycker du sedan på en gång till kan du skriva versaler.
- Använd "klistra in"-funktionen från f3-menyn (Tools). Här kan man klistra in text som man kopierat i editorn.
- När du skriver in text så kan du trycka på tangenten om du skrivit in tecken som du vill ta bort.
- Se till att räknaren har svenska som lokaliseringsspråk. Då får man med å, ä och ö i teckenpaletten. Se skärmbilden till höger. För att ställa in språk trycker man på och välj sedan språk längst ner i listan för olika inställningar.
- Man kan lägga in kommentarer i sina skript genom att lägga till tecknet # innan kommentaren. Placeringen först på raden indikerar att det som står efter tecknet# inte tolkas. Man når # genom att trycka på f2-knappen (a A #).
Övning 3: Funktionerna i Python
LärarkommentarerI den tredje lektionen i enhet 1 ska du använda programeditorn (skriptet) för att skapa funktioner och sedan köra dem, och obser- vera resultaten i konsolen (Shell-fönstret)
Syfte:
- Upptäck begreppet funktion i Python
- Skapa en funktion
Steg 1
Begreppet funktion i Python.
Implementera följande algoritm:
x←3
y←2*x + 3
I en konsol görs detta enkelt. Se skärmbilden till höger. Men om du vill upprepa den här typen av beräkning för ett annat x-värde måste du skriva om hela sekvensen. För ett mindre trivialt exempel blir detta både tidskrävande och väldigt tråkigt. Så vi leds nu att skapa en funktion som gör det möjligt för oss att enkelt kopiera processandet av algoritmen.
Steg 2
def funktionsnamn(argumentlista):
..block med instruktioner
..return (resultat)
Algoritmiskt kan en funktion betraktas som en sekvens av instruktioner som utför en viss uppgift med hjälp av ett eller flera argument.
Den här funktionen får ett namn.
- Programmeringen av en funktion börjar alltid med def följt av namnet på funktionen och sedan följt av argumenten för funktionen. Raden slutar med symbolen:
- Kolontecknet : markerar början på det funktionsdefinierande blocket med instruktioner. Alla dessa instruktioner har indrag, dvs. i början av varje rad läggs samma antal blanksteg till.
Funktionen returnerar bara ett resultat via kommandot return. Resultatet kan bestå av en lista med resultat, en sträng med tecken...osv.
Indrag som erhållits med tabbtangenten eller med blanksteg är av största vikt: allt som är indraget efter def() kommer att utföras som ett block. Storleken på indragen bör inte variera inom ett block.
Steg 3
Lärarkommentar: En funktion gör det möjligt att dela upp problem i subproblem och på så sätt undvika upprepning av instruktioner. När den är definierad kan den "anropas" så många gånger som det behövs. En funktion behöver inte ha något argument. Den kan också anropas från ett annat program. Man behöver bara infoga den i en instruktion genom att mata in namnet på funktionen och värdena på argumenten.
Genomförande av ett första exempel.
- Öppna Python-appen och välj att skapa ett nytt skript genom att trycka på f3 "New"
Steg 4
- Ge ditt skript ett namn. Välj till exempel CALC och bekräfta genom att trycka på . Det maximala antalet tecken är 8.
- Namnet på skriptet visas sedan högst upp i det grå fältet: name=CALC. Tryck sedan Ok.
Steg 5
Tryck sedan på f1 (Fns) och välj def function():. Tryck sedan på enter.
Steg 6
Skriv sedan enligt skärmen till höger. Observera indragen på rad 2 och 3. Det kallas för indentering. Den sker automatiskt och gör det möjligt att definiera programblocken. Man kan säga att indentering är en del av själva Pythonspråket.
Instruktionen return finns också under fliken Fns… Vi återkommer till betydelsen av instruktionen return senare.
Steg 7
Tryck nu på f4 (Run) för att köra programmet. Du får nu ett meddelande att programmet är uppladdat i konsolen (Shell).
För att beräkna funktionsvärdet för x = 6 kan du skriva in t.ex. f(6). Ett annat sätt är att trycka på tangenten 0ch sedan trycka Ok. Du fyller sedan i x-värdet. Vi har här beräknat funktionsvärdet för tre olika värden på x.
Steg 8
Inom funktionsblocket kan man ha flera rader. Här ska vi nu beräkna funktionsvärden för
(2x - 3) · (2x + 3) = 4x2- 9
Du kan också plotta denna funktion och se om de beräknade funktionsvärdena stämmer.
Steg 9
I en senare övning ska vi skriva ett program som gör en tabell där vi har matat in start- och slutvärde. Se nedan.
>Avsluta nu Python genom att trycka på [ quit ].
Tillämpning: Olika typer av Pythondata
LärarkommentarerAtt skriva skript som repetition på de tre första övningarna i kapitel 1.
- Pythons språkfunktion
- Skapa en lista
Syfte:
- Skapa en temperaturomvandlare
- Skapa ett skript som utformar ett algebraiskt uttryck
Steg 1
Exempel 1: Omvandla temperatur
För att mäta temperatur använder vi i Sverige och de flesta andra länder Celsiusskalan (OC). I anglosaxiska länder använder man Fahrenheitskalan.
Din uppgift nu är att programmera en funktion som utför temperaturomvandling i båda riktningarna, Celcius till Fahrenheit och tvärtom!
Finns det någon temperatur där mätetalet är lika i båda skalorna.
Sambandet är
t(°F) = (9/5) · t(°C) + 32 som kan skrivas t(°F) = 1,8 · t(°C) + 32
Steg 2
- Öppna Pythonappen och starta ett nytt skript genom att trycka på f3 (New)
- Döp skriptet till TEMP t.ex. Tryck sedan på f5 (Ok).
- Tryck på tangenten och välj sedan modulen 1:math och till sist 1:from math import. Raden ”from math import *” kopieras in i editorn.
Steg 3
- Skapa nu den första omvandlingsfunktionen genom att trycka f1 och välja 1:def function():. Tryck sedan på .
- På nästa rad skriver du return f. Du kan antingen mata in return från räknarens tangenttbord eller trycka på f1 och välja 2:return.
- Kör nu skriptet (Run) och skriv f(30). Du får resultatet 86.
Steg 4
- Slutför nu redigeringen av skriptet genom att lägga till de nödvändiga instruktionerna för omvandlingen från grader Fahrenheit till grader Celsius.
- Vi ser att man automatiskt får indrag på funktionsblocket efter definitionen av c(f). Indentering finns med bland editeringsverktygen om du trycker på f3 (Tools).
Steg 5
- Om du nu kör detta skript och beräknar Fahrenheit-temperaturen vid 30 °C får vi resultatet 86. Vi beräknar sedan Celsiustemperaturen vid 86 °F. Då får vi tillbaka värdet 30.
Lärarkommentar: Fråga eleverna om det finns någon temperatur
där mätvärdet är lika i båda skalorna?
Enklast sättet att lösa problemet är att lösa ekvationen
x =1,8.x +32. För att visst värde på x är vänstra och högra ledet lika.
x =1,8.x +32
x - 1,8.x = 32
-0,8x = 32
0,8x = -32
x = -32/0,8 = -40
Om man +skriver f(-40) så ska man få ut -40.
Steg 6
Till höger här visar vi nu ett skript där man kan få ut en tabell med värden i båda skalorna. Man ska här vid körningen av programmet mata in startvärde, slutvärde och steg. Kan du förklara de olika stegen i programmet. De instruktioner som förekommer i programmet har vi bara tagit upp ytligt i de tidigare övningarna. Utförliga förklaringar kommer i senare övningar.
Lärarkommentar: Be eleverna att skriva in programmet och sedan exekvera det i Shell-fönstret. Man kan också skriva programmet så att man går från Celsius till Fahrenheit.- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 2: Starta programmering på riktigt
Övning 1: Instruktioner med villkor
LärarkommentarerI den första övningen i kapitel 2 får du lära dig att skriva och använda en villkorsinstruktion i Python.
Syfte:
- Skriva och använda en villkorsinstruktion
- Återanvända begreppet funktion i Python
Steg 1
If villkor
Instruktion A
else
Instruktion B
I ett program är det särskilt vanligt att behöva styra genomförandet efter villkor som påverkar de olika variablerna. Ett villkor är en sats som kan vara sann eller falsk. Till exempel: a = b eller a ≥ b men också n är ett villkor som verifieras med de värden som tilldelats dessa variabler. I ett program kan ett villkor testas och beroende på om det är sant eller falskt, utföra ett processande eller inte. Detta kallas villkorligt processande.
Lärarkommentar: I Pythonspråket finns det ingen instruktion för att ange slutet på en instruktion med villkor. Det visas av indragen (inden- teringen) för instruktionerna A och B. elif är sammandragning av else och If. För att testa likheten mellan två värden i Pythonspråket används två likhetstecken ”==”.
Steg 2
Exempel: Ett biluthyrningsföretag erbjuder sina kunder följande avtal: Ett weekendpris för 66 euro plus 0,25 euro per kilometer över 70 km. Ditt jobb är att konstruera ett skript som automatiskt beräknar kost- naden för avtalet baserat på den tilltänkta sträckan.
Genomförande:
- Starta Python-appen genom att trycka på tangenten .
- Starta sedan ett nytt -skript genom att trycka på f3(New) och döp det till "BILHYRA". Validera genom att trycka på f5-tangenten (Ok).
- Startas skriptet genom att definiera en funktion. Tryck då på f1 (Fns…) och tryck sedan på 1:def function():. Namnge funktionen till kostnad(s). s står här för sträckan i km.
Steg 3
- Tryck nu på f1-tangenten (Fns…) och välj sedan Ctl, som står för Kontroll. Här finns nu ett antal val för olika villkorssatser plus ett antal alternativ för s.k. loopar. Välj nu 2:if .. else. Detta kan översättas till svenska som ”om .. annars”.
På nästa sida ser vi resultatet.
Steg 4
Vi ser strukturen på skärmen med nödvändiga indrag för villkorsblocket. I Python-språket så hör kommandon med samma antal indrag ihop. Detta är en del av själva språket. Man får då en bra bild av programstrukturen.
Steg 5
Du kan se intill hur funktionen kan se ut, till exempel. Om sträckan s är 70 eller mindre blir resultatet 66. I det andra fallet beräknar funktionen först antalet kilometer över 70 och sedan kostnaden. I det här exemplet kan du se att ett block kan bestå av flera regler. Du infogar symbolen ≤ med f1(Fns...) och sedan Ops eller också kan du trycka på .
Steg 6
Nu kan vi köra programmet för några olika värden på sträckan s. Du får fram kostnadsfunktionen genom att trycka på tangenten
Steg 7
Lärarkommentar: Till höger har vi ett skript som ser lite annorlunda ut än skriptet Bilhyra. Be eleverna att skriva in skriptet i editorn och göra några körningar vid olika värden på sträckan s. Be dem förklara vad det är för beräkningar som utförs. Förklara också användandet av villkorssatsen if .. elif .. else.
Lärarkommentar: Hur plottar man nu denna kostnadsfunktion på räknaren. Den kallas för en styckvis funktion eftersom den består av olika bitar som är definierade för olika intervall. Vi ska här visa ett sätt att plotta funktionen som handlar om hur räknaren utvärderar jämförelser när man använder s.k. relationsoperatorer. Se nästa sida
Räknaren utvärderar påståenden och ger ett av två möjliga sannings- värden: 1 = Sant och 0 = Falskt. När är A < 2 sant?
Steg 8
Räknaren returnerar 1 för sant och 0 för falskt när A är mindre än 2.
Se skärmbilden till höger.
Om du delar en funktion med ett påstående divideras funktionen med 1 när påståendet är sant och funktionen divideras med 0 när påståendet är falskt. Nu kan man ju inte dividera med 0 och då kan man heller inte plotta funktionen.
Steg 9
Den funktion vi nu ska plotta kan skrivas så här:
Ett sätt att mata in detta i Y=-editorn blir då som i skärmen här bredvid. Här måste man se till att man ställt in visningen som MATHPRINT (tryck på för att ställa in). I Y-editorn trycker man sedan på för att få inmatning som bråk. Sedan skriver man enligt skärmen till höger
Övning 2: Upprepade beräkningar
LärarkommentarerI den andra övningen i enhet 2 får du lära dig hur du upprepar en process eller en uppsättning instruktioner med hjälp av en förbestämd for-loop.
Syfte:
- Utforska och implementera for-loopar
- Använda for-loopar i enkla exempel
Steg 1
Det är ibland användbart i ett program att upprepa en eller flera instruktioner ett antal gånger. Om antalet repetitioner av processen är känt i förväg används en förbestämd for-loop. Syntaxen för en for-loop är följande:
Naturligt språk
För variabler som sträcker sig från lägsta till högsta instruktioner.
Python-språk
for variabel i intervall ():
Instruktioner
Steg 2
För funktionen range() kan du ange antalet steg i den förbestämda loopen. Det kan kallas på flera sätt:
for i in range(size): tar heltalsvärden från 0 till range-1. range(4)==[0, 1, 2, 3]
for i in range:(start,stop): tar heltalvärden från start till stop-1
for i in range:(strt,stp,step): tar heltalsvärden från start till stop-1 med steglängden step.
for i in list: Variabeln använder listvärdena från det första värdet till det sista.
Det finns ingen end-i en loop-sats. Det är indenteringen, dvs indraget till höger som gör det möjligt att markera slutet på loopen.
Steg 3
Genomförande
Implementering: Du ska skapa ett skript för att förstå vad en loop är och en iterationsprocess.
- Starta ett nytt skript och namnge det "LOOP"
- Starta en tom lista med satsen b=[ ]. I Python-språket placeras elementen i en lista mellan [ ], åtskilda av kommatecken.
- Tryck på f1 (Fns...) och välj från Ctl-menyn, alternativ 4: for i in range (size)
- append-satsen gör att du kan slutföra en lista. b.append (i**2) stegar b-listan med i2. För varje värde på i så placeras värdet på i2 i slutet av i2-listan.
- Variabeln varierar från 0 till och med 4 vilket motsvarar 5 värden.
Steg 4
Lärarkommentar: Tänk på att, loopräknare alltid startas från 0. Instruktionen gäller för listorna. För att nå den, så trycker man på F1 (Fns ...),och väljer sedan listmenyn och slutligen 6: .append (x).
Tryck nu f4 för att köra skriptet.
I konsolen (shell) ber du sedan om visning av b.
Lärarkommentar: I en loop eller instruktion med en indentering är alla indenterade inmatningar ”för hand” ett kommando som är en del av loopen. Slutet av loopen markeras med avslutningen på indenteringen.Steg 5
Låt oss tillämpa vår kunskap:
Här kommer nu en liten berättelse.
Inuti ett slott finns en kista full av guldmynt. För att komma ut från slottet måste du ta dig igenom fem dörrar, var och en skyddad av en vakt. De låter dig passera så länge du uppfyller deras krav. Här är vakternas krav:
”För att kunna gå ut genom dörren måste du ge mig hälften av dina mynt plus ett halvt mynt”
Vad är det minsta antalet mynt du borde ta med dig från kistan, så att du kan behålla minst ett för dig själv när du kommer ut från slottet?
Steg 6
När man har gått igenom 5 dörrar ska man alltså ha 1 mynt kvar. Det måste ju betyda att man ska ha 3 mynt innan man passerar den sista dörren. Man ska ju ge bort hälften av 3 mynt + ett halvt mynt och det blir ju 2 mynt och då har man ett mynt kvar.
Så här kan man fortsätta och räkna ut antalet mynt man ska ha innan man passerar dörr 4, dörr 3 osv. Vi räknar här baklänges!
Här är ett algebraiskt uttryck som beskriver relationen mellan antalet mynt an man ska ha vid en dörr och den föregående dörren. Vi kallar antalet mynt för a.
an = 2·an-1 + 1
Så här då vårt skript ut. Se till att du har indrag enligt skärmen
Steg 7
Ska du ha ett mynt kvar efter 5 dörrar så måste du ha 63 mynt från början. Vi visar också körningar när man passerat 1, 2, och 3 dörrar.
Ändra nu i skriptet och gör nu körningar när antalet kvarvarande mynt efter passage av 5 dörrar ska vara 2 respektive 0! Vad får du för resultat?
Steg 8
Den här uppgiften finns som en särskild aktivitet för TI-NspireTM. Här finns också ett antal andra bra tillämpningar med upprepade beräkningar.
Gå till https://ti-resurser.com/materialdatabas och sök på upprepade beräkningar. De flesta beräkningar (utom de rent algebraiska) kan du utföra med TI-84 Plus CE-räknaren också.
Övning 3: Upprepade beräkningar
LärarkommentarerI den tredje övningen i enhet 2 får du lära dig hur du på ett enkelt sätt kan upprepa tilldelningar.
Syfte:
- Hur man använder kommandot while
- Exempel på hur man använder while i enkla situationer
Steg 1
Antag att du vill upprepa en serie kommandon ett antal gånger men du vet inte i förväg hur ofta. Då kan du använda kommandot while.
Här är vad kommandot gör:
Så länge ett visst villkor gäller, fortsätt att upprepa
Vi ska nu skapa ett program för följande problem:
Kasta en tärning och upprepa tills en sexa kommer upp.
Steg 2
Det går inte i förväg att veta hur många gånger du måste kasta tärningen. Öppna nu ett nytt pythonprogram och ge det ett namn. Eftersom vi ska använda slumptal, behöver vi först slumptalsmodulen ”from random import”. Den ska vi sätta in i programmet först. Välj F1 (Fns...) sedan Modul och därefter 2: random. Du kan också trycka på tangenten och sedan 2:random.
Steg 3
Vi kommer att behöva två variabler i programmet. Variabeln n som håller reda på antalet kast och variabeln x som håller reda på vad som kastas (1 t.o.m. 6). Vi ger båda variablerna värdet 0 från början.
Därefter lägger vi till mallen för while. Tryck på f1 (Fns…) och välj alternativ 8:while condition. Villkoret blir ”inte lika med 6” vilket kan skrivs som != i Pythonspråket. Upprepning ska alltså ske tills d får värdet 6.
while-blocket innehåller två tilldelningar. Först ska vi ha ett slumptal d mellan 1 och 6 och sedan ska vi öka räkneverket n med 1. Får vi nu 6 som resultat vid alstringen av slumptalet avslutas körningen och vi får en utskrift av hur många gånger vi fick kasta tills en sexa kom upp. Om vi nu kör programmet ett antal gånger så får vi lite olika värden på n. Om du ska köra programmet flera gånger så kan du trycka på f3 (Tools) och välja 1:Rerun last Program.Steg 4
- Vi ska nu bygga på programmet så att vi inte bara gör ett kast utan ett stort antal kast och där vi sedan beräknar medelvärdet från de många kasten.
- Först så att själva kastet läggs i en funktion ”tills en sexa kommer upp”. Vi kallar denna funktion tärning(). Om du anropar denna funktion så kommer den att rapportera antalet kast.
- Om vi sedan t.ex. anropar denna funktion 500 gånger, adderar resultatet och dividerar denna summa med 500 så får vi ett medelvärde.
Steg 5
- Vi lägger alltså till en for-loop som gör denna upprepning 500 gånger.
- Då måste vi först lägga till en ny variabel, summa, som har startvärdet 0 från början.
- I programmet så körs for-loopen 500 gånger och summan uppdateras efter varje kast. Till sist så beräknas medelvärdet som summan/500.
Steg 6
Lärarkommentar: Vi människor och programmerade datamaskiner har minne och vet att det t.ex. ska bli ungefär lika många sexor som ettor om vi kastar en tärning många gånger. Det vet inte tärningen eller kronan när den hänger i luften. I ett äkta slumpförsök finns det ingen- ting som heter minne. Allt börjar om igen när vi kastar tärningen nästa gång.
Räknaren kan alltså egentligen inte generera riktiga slumptal. Den an- vänder faktiskt en formel för att generera en sekvens av tal som verkar vara helt slumpmässiga. Varje tal i sekvensen beror på det föregående talet. Detta betyder då att hela sekvensen av tal beror på det första talet. Detta tal kallas för en kärna. Om du låter två räknare få samma kärna, t.ex. talet 273, så genereras samma sekvens. Det kan väl knap- past kallas slumpen.
Steg 7
Använda en känd formel
LärarkommentarerFör denna tillämpningsaktivitet i kapitel 2 ska vi skriva ett program som löser en allmän andragradsekvation. Det finns tre möjliga lösningar till en ekvation som skrivs på formen:
a · x2 + b · x + c = 0
och vi ska använda olika villkor för de tre olika lösningarna. Vi börjar med lite teori.
Syfte:
- Använda If… elif… else-kommandon i två program som båda löser andragradsekvationer.
Steg 1
Den allmänna andragradsekvationen a · x2 + b · x + c = 0 kan skrivas om som
Omskrivning och första kvadreringsregeln ger nu
Vi drar roten ur båda leden
Vi subtraherar nu till sist både leden med b / 2a :
Steg 2
Uttrycket ovan kan skrivas om genom att först sätta termerna under rottecknet på gemensam nämnare.
Uttrycket under rottecknet, b2 - 4ac kallas för diskriminanten och det ska vi använda i programmet.
- Om diskriminanten är mindre än noll finns det ingen lösning i reella tal eftersom man inte kan dra kvadratroten ur ett negativt tal.
- Om diskriminanten är noll finns det bara en lösning, nämligen - (b / 2 · a). Vi har då en dubbelrot.
- Om diskriminanten är större än noll har vi två lösningar enligt formeln ovan.
Steg 3
from math import*
print("lösa a*x**2+b*x+c=0")
def lösandra(a,b,c):
diskr=b**2-4*a*c
if diskr<0:
print("diskriminant =",diskr)
print("inga reella rötter")
return
elif diskr==0:
print("diskriminant =",diskr)
print("en reell rot")
rot1=-b/(2*a)
return rot1
else:
print("diskriminant =",diskr)
print("två reella rötter")
rot1=(-b+sqrt(diskr))/(2*a)
rot2=(-b-sqrt(diskr))/(2*a)
return rot1,rot2
Detta kan vi utnyttja på ett smart sätt genom att använda if…elif…else. Vi definierar funktionen lösandra med argumenten a, b och c som är koefficienterna i andragradsekvationen.
Vi skapar också variabeln diskr för att vid utskrift av ev. rötter också skriva ut värdet på diskriminanten.
Eftersom programmet inte får plats på en enda skärm (19 rader) har vi här gjort en utskrift via datorn och programmet TI Connect.
Några kommentarer till koden:
Du ser att vi använder dubbla likhetstecken (==) i koden när vi ska göra jämförelser. Se raden ”elif diskr==0”. När man har ett likhetstecken så ska man tilldela ett värde till en variabel. Två helt olika operationer alltså.
Steg 4
När man befinner sig i editorn och ska göra en körning så trycker du på tangenten . Överst i fönstret så står det då lösandra(). Tryck på Ok och fyll sedan i argumenten i funktionen, t.ex. lösandra(1,2,1). Tryck sedan på . Då får vi en utskrift på tre rader. Överst diskriminantens värde, sedan antalet rötter och till sist rötterna värde.
Steg 5
Vi ska nu titta på ett annat program som också beräknar rötterna till en andragradsekvation. Det innehåller också if…elif…else för ingen, en respektive två lösningar till ekvationen. Här har vi dock ingen funktion utan istället tre inputsatser.
Steg 6
I input-satser vill programmet hämta in information från användaren. Input-satser läser in allt som text. Vi tar ett exempel:
Vi skriver in det korta programmet till höger och kör det. Du skriver in talet 5.7 t.ex. Du kommer att få svaret 5.75.7 och inte 10. Det beror på att input läser in allt som text.
Steg 7
För att verkligen få multiplikationen utförd så kan du skriva
a = float(input("Mata in…)).
Steg 8
Alltså: Genom att omge input() med float() eller int(), så omvandlas svaret till ett decimaltal eller heltal.
På nästa sida kommer nu det andra programmet som löser andragradsekvationer.
Steg 9
Här är nu programmet, som inleds med tre input-satser. Float som vi använder här är den datatyp som används för decimaltal. På svenska säger man flyttal. Precis som det föregående programmet använder vi här if…elif…else.
from math import *
print("lösa a*x**2+b*x+c=0")
a=float(input("vad är a "))
b=float(input("vad är b "))
c=float(input("vad är c "))
diskr=b**2-4*a*c
if diskr<0:
print("diskr=",diskr)
print("inga reella rötter")
elif diskr==0:
print("diskr=",diskr)
print("en reell rot")
rot1=-b/(2*a)
print(rot1)
else:
print("diskr=",diskr)
print("två reella rötter")
rot1=(-b+sqrt(diskr))/(2*a)
rot2=(-b-sqrt(diskr))/(2*a)
print(rot1,rot2)
- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 3: Starta programmering på riktigt
Övning 1: Funktioner och loopar
LärarkommentarerI den första lektionen i kapitel 3 använder du dina kunskaper om algoritmer och Pythonspråket för att lära dig:
- Intervallhalveringsmetoden i algebra och i sannolikhetslära
- Söka efter lösningar till en tredjegradsekvation
Syfte:
- Implementera en avgränsad while-loop
- Visa på två metoder för att lösa ett problem
Steg 1
Vi skall i denna övning också lösa en ekvation, dvs. finna nollställen till funktionen. Vi ska titta på något som kallas intervallhalve-ringsmetoden. Som exempel har vi valt tredjegradsfunktionen
f(x) = 0,03x3 - 0,3 x2 - 0.6x + 1,45
Denna ekvation kan vi inte lösa exakt med elementära metoder.
Vi börjar med att rita grafen till funktionen för att få en uppfattning om var nollställena är placerade. En tredjegradsfunktion har i allmänhet tre nollställen.
Mellan varje skalstreck är det 5 längdenheter. Vi väljer att titta på det nollställe som ligger längst till höger. Nollstället ligger mellan 10 och 15.
För att förklara den metod vi kommer att använda så visar vi samma metod i ett enklare sammanhang:
Steg 2
Detta resonemang med intervallhalveringar ger att man maximalt behöver 10 gissningar eftersom 210 = 1024. Man kan också skriva att (1/2)10 = 1/1024.
Steg 3
Beskrivning av intervallhalveringsmetoden
Nu ska vi bli lite mer formella och försöka göra en bra algoritm av detta som passar till vårt problem med funktionens nollställe.
Metoden bygger på följande resonemang: Om en funktion växlar tecken i intervallet [a, b] och om funktionen är kontinuerlig så är funktionen noll någonstans i intervallet. Man har då minst ett nollställe i intervallet. Delar man nu intervallet i mitten så att man får två nya intervall. Då kommer vi fortfarande ha teckenväxling i något av de nya intervallen. Detta intervall kommer då att innehålla minst ett nollställe och vi fortsätter med detta intervall och upprepar resonemanget.
Vi förutsätter också att funktionen f(x) är kontinuerlig. Man börjar med ett intervall [a, b] där f(x) växlar tecken, dvs. där f(a)·f(b)< 0.
Steg 4
Eftersom f(x) är kontinuerlig så finns det minst ett nollställe i intervallet [a, b]. Man bildar nu mittpunkten m = (a+b()/2 och delar alltså intervallet i två lika långa delintervall [a, m] och [m, b]. Se figuren. Det delintervall där funktionen växlar tecken är det man är intresserad av. Man behåller alltså [a, m] om f(a)·f(m) < 0, annars behåller vi [m, b]. I detta fall behåller vi alltså [a, m]. Se figur. Sedan går man vidare och delar detta intervall på mitten igen.
Steg 5
Vi gör nu en förstoring och tittar nu på intervallet [10, 12.5] och vi ser att nollstället finns i den högra halvan, dvs i intervallet [11,25, 12,5]. Så här håller man på tills man har ett intervall som är tillräckligt litet och man har uppnått önskad precision i beräkningarna.
Steg 6
Förberedelse för skapandet av ett skript
- Först ser man att nollstället finns mellan 10 och 15.
- Man tar nu medelvärdet av 10 och 15 och ser nästa gång att nollstället ligger mellan 10 och 12,5.
- Nu tar man medelvärdet av 10 och 12,5 och då ser man (nedre figuren) att nollstället ligger mellan 11,25 och 12,5.
- Så här fortsätter man med allt mindre och mindre intervall.
Steg 7
Efter den här ganska långa genomgången kan man börja skriva in sitt skript.
Först definierar man sin funktion och sedan definierar man en funktion med argumenten a, b och prec. a och b är gränserna i intervallen och prec är precisionen, dvs differensen mellan a och b.
Så länge som (while) avståndet b-a är större än den precision man vill ha så utförs beräkningar av medelvärde och sedan kommer if …else-sats med beräkning av vilket tecken (positivt eller negativt värde) som f(a)*f(m) har. Är det negativt så har vi en teckenväxling och nollstället ligger i det vänstra delintervallet. Är det positivt så ligger nollstället i det högra delintervallet.
Steg 8
Tips för inskrivning: Olikhetstecken kommer du åt genom att trycka . while finns i kontrollmenyn. Tryck f1 (Fns..) och sedan Ctl. Där finns också villkorsinstruktionen if .. else.
Tryck nu på f4 (Run) för att köra programmet. Trycka på och välj dela() och tryck sedan på Ok. Fyll nu i argumenten (10,15, 0.001). Tryck sedan på .
Nu får vi beräknade värden på ett smalt intervall. Med två korrekta decimaler blir svaret 11.38.
Steg 9
En variant som gör samma sak
Istället för att ge precision kan vi arbeta med ett antal steg. Istället för en while-sats så har vi nu en for i in range(step)-sats. Vid körning så skriver man t ex dela(10,15,20). Se resultat i skärmbilden till höger.
Steg 10
Med räknarens inbyggda verktyg för bestämning av nollställe får vi detta resultat.
Man plottar då grafen och trycker sedan på [ calc ]. Välj sedan alternativ 2. Vi får resultatet 11,383905
Steg 11
Lärarkommentar: På första sidan i denna övning så visade vi på strategin för att hitta en sida i en bok på 1024 sidor. Här har vi ett skript som fungerar på samma sätt. Användaren får alltså själv göra intervallhalveringar uppåt eller nedåt. Här har vi 100 som övre gräns men användaren kan ju själv bestämma denna gräns.
Vi har fuskat lite och satt ihop två skärmar på räknaren för att kunna visa hela programmet.
Här har vi en körning. Det räckte med 5 gissningar här.
Steg 12
Visa detta skript för eleverna och gör några körningar. För att visa principen kan man börja med ett fåtal tal. Den uppgift eleverna får här är att skriva klart skriptet. Vid körning ska det se ut som det visas på skärmen nedan.
Vi visar här bara den översta delen av skriptet. Eleverna uppgift är alltså att skriva klart! När de är klara och har provkört så ska de göra ett antal körningar och redovisa statistik på antal gissningar.
Övning 2: Funktioner och loopar
LärarkommentarerI den andra övningen i kapitel 3 kommer du att upptäcka hur du upprepar en uppsättning instruktioner genom att använda den avgränsade loopen FOR.
Syfte:
- Använda en funktion
- Upptäcka och implementera den avgränsade loopen For
- Använda for-loopen enkla exempel
Steg 1
Slumpmässigt urval
En ogenomskinlig bag innehåller sex röda och fyra gröna bollar. Vi drar slumpmässigt en boll från påsen, noterar dess färg och lägger sedan tillbaka den i påsen.
Programmera en funktion som simulerar experimentet med bollarna med en slumpmässig variabel.
- Vilka är de möjliga värden variabeln kan ha?
- Vi vill skriva ett skript som kan skilja de röda bollarna från de gröna med hjälp av ett test.
Steg 2
Starta ett nytt skript och döp det till "DRABOLL".
När du arbetar med slumptal krävs inläsning av ett bibliotek för arbete med slumptal. För att göra detta, tryck på f1 (Fns...) och välj i menyn Modul och sedan 2: Random....
Skriv in skriptet här till höger i editorn och se till att ha de indrag som visas. Det är oerhört viktigt i Python.
Steg 3
Skriv in skriptet här till höger i editorn och se till att ha de indrag som visas. Det är oerhört viktigt i Python.
Till höger ser vi konsolen några körningar av det korta skriptet. Om slumpvariabeln X får värdet 1 till och med 6 visas ”grön”. Och om slumpvariabeln X får värdet 7 till och med 10 fås svaret ”röd”.
Lärarkommentar: Detta skript kan modifiera för vilket antal bollar som helst. man kan t.ex. definiera färg(n,r) där n är antalet bollar och r är de röda bollarna.Steg 4
Vi ska nu tillämpa våra kunskaper genom ett exempel på stickprov och beslutsfattande utifrån stickprovet.
En undersökning genomfördes vid lanseringen av en ny show som föreslagits av en fransk konstnär. Denna undersökning som genomförts i en stor stad visade att två tredjedelar av de som såg showen gillade den. Konstnärens agent ansåg att hela den franska befolkningen hade samma uppfattning. Han beställde en undersökning från ett opinionsinstitut för att kontrollera detta.
Steg 5
Befolkningsstudie:
Vid den statistiska undersökningen måste undersökningsinstitutet skapa en funktion som simulerar svaret på situationen.
Vi ska nu skapa denna funktion i enlighet med följande specifikationer:
- Showen uppskattades med en sannolikhet p = 2/3.
- Showen uppskattas inte med sannolikheten p = 1/3
Starta ett nytt skript och namnge det STPROV (förkortning av stickprov)
Skriv den här funktionen i editorn och testa den flera gånger genom att trycka på f4 (Run) och tryck sedan på och väljs sedan fråga() genom att bekräfta med att klicka Ok. Tryck sedan på . Du får svaret 1 eller 0.
Steg 6
Upprepa nu detta ett antal gånger.
Det går fortast om du trycker på och trycker på . Om du gör detta många gånger bör du få ettor ungefär två tredjedelar av gångerna.
Steg 7
Göra en stickprovsundersökning med storleken n
Opininionsinstitutet vill nu göra en simulering där man gör undersökningar med olika värden på storleken n. För att göra detta så måste vi skapa en stickprovsfunktion i skriptet som frågar efter stickprovsstorleken n.
- Vi börjar med att skapa en tom lista L.
- Vi fyller denna lista genom att använda funktionen fråga().
Steg 8
Lärarkommentar: Med Python-språket kan du använda en funktion för att fylla en lista som ökas i steg av en For-loop, som argument i listan. Det här exemplet kan uppnås utan användning av listor. Skriptet måste då ändras något genom att listinstruktionerna ersätts med avgränsade loopar som stegvis ökar en variabel.
Vi ska nu prova stickprovsfunktionen genom att göra ett test med storleken 30.
- Tryck på Run och tryck sedan på tangenten [ vars ] och välj sedan stickprov(). Bekräfta med Ok.
- Fyll i stickprovsstorleken och tryck på [ enter ]. Nu får vi en lista med nollor och ettor på skärmen.
I exemplet på skärmen får vi 17 ettor. Kör nu några gånger och räkna antalet ettor.
Steg 9
Vad händer om vi kör skriptet 1000 gånger?
Vi får hela skärmen full av nollor och ettor. Vi måste hitta ett sätt att titta på andelen ettor. Istället för att returnera listan med satsen return L ska vi nu istället returnera ett värde. Värdet vi ska ha utskrivet vid körning är andelen ettor i listan.
Steg 10
Tryck f1 (Fns…) och sedan List. Där finns nu ett antal funktioner för listor. Det uttryck vi nu ska skriva är
return sum(L)/len(L)
och instruktionen sum ger den aritmetiska summan, dvs vi adderar alla ettor. len ger antalet element i listan.
Steg 11
Körning av programmet
Tryck på Run och sedan på för att välja stickprov(). Titta både på små och stora stickprov och kör programmet ca 10 gånger. Det går snabbt om du efter varje körning trycker på för att göra en ny.
Vad kan du säga om resultaten? Vilka slutsatser kan du dra?
Steg 12
Lärarkommentar: Vi ska nu titta lite närmare på osäkerheten bakom stickprov på andelar. Man stöter ofta på detta i samband med undersökningar om partisympatier.
Vi antar att stickprovsstorleken är 1000 personer, ungefär vad man brukar ha i opinionsundersökningar. Frågan är vad man kan förvänta sig om hur nära andelen i stickprovet kommer andelen i hela befolkningen.Vi kallar den för p.
Vi börjar här med teorin och genomför sedan några undersökningar med slumpen. Man kan visa att i 19 fall av 20 (95 % konfidensintervall) så hamnar stickprovets andel i intervallet
Steg 13
Vi får alltså då en felmarginal på 3 %. Av uttrycket ser vi att felmarginalen beror både på andelen och stickprovsstorleken.
Vi har gjort en plottning för p = 0,65 i marginalen. Man ser hur osäkerheten ökar kraftigt när stickprovsstorleken minskar.
På https://ti-resurser.com/materialdatabas finns en aktivitet, Opinionsundersökning, för TI-Nspire som ger en ordentlig av teorin bakom stickprovsundersökningar.
Övning 3: Funktioner, villkor och loopar
LärarkommentarerI den tredje övningen i kapitel 3 ska vi göra flera simuleringar som illustrerar Stora talens lag i ett praktiskt sammanhang. Vi behöver då en slumpgenerator, därför måste biblioteket för slumptal importeras.
Syfte:
- Använda en funktion
- Implementera den avgränsade loopen For i flera exempel
- Använda villkorssatser
Steg 1
I statistik och sannolikhetsteori är Stora talens lag en sats som beskriver resultatet av att upprepa samma experiment ett stort antal gånger. Denna lag anger att om samma experiment, som ska vara oberoende av varandra, upprepas ett stort antal gånger måste genomsnittet av resultaten av försöken ligga nära det förväntade värdet. Resultatet kommer också närmare det förväntade värdet i takt med att antalet försök ökar.
Steg 2
Exempel: Ett enkelt exempel på lagen är att kasta tärningar. Ett kast innebär sex olika händelser med lika stora sannolikheter. Det förväntade värdet (förkortas ofta EV för Exepected value) av tärningshändelsen är:
(1 + 2 + 3 + 4 + 5 + 6) / 6 = 3,5
Om vi bara kastar en tärning några få gånger kan genomsnittet av de erhållna resultaten vara långt ifrån det förväntade värdet. Låt oss säga att du kastade en tärning tre gånger och resultatet blev 3, 6, 6. Genomsnittet av resultaten blir då 5. Enligt lagen om stora tal, så blir det genomsnittliga värdet om vi kastar tärningarna ett stort antal gånger att vara närmare det förväntade värdet på 3,5.
I denna övning ska vi göra en del experiment med fyra tärningar och titta närmare på sannolikheten experimentellt att få en viss totalsumma.
Steg 3
Kastar du en tärning så är ju sannolikheten 1/6 för varje utfall 1 till och med 6. Kastar du två tärningar så ser utfallen för summan ut som i diagrammet till höger. Man ser direkt att summan 7 kan man få på 6 sätt: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1. Sannolikheten blir alltså 6/36. Man kan också räkna ut maxsumman som 2 gånger 3,5.
Steg 4
För summan 6 och 8 blir sannolikheten 5/36, för summan 5 och 9 blir den 4/36 osv. Se diagrammet i marginalen som visar de olika sannolikheterna.
Steg 5
Nog med grundläggande teori om sannolikheter. Nu ska vi se hur vi kan skriva skript som simulera kast med 4 tärningar.
Simulering
Vi ska nu skriva ett program som utför ett antal simuleringar av kast med fyra tärningar. Vi ska sedan beräkna summan av prickarna vid varje kast och titta på när summan är mindre eller lika med 16. Om summan är <=16 så ökar värdet på ett räkneverk med 1. Satsen räkneverk=räkneverk+1 ökar värdet.
Steg 6
- Då vi ska arbeta med slumptal importerar vi först biblioteksmodulen random import. Tryck f1 (Fns…) och välj sedan i menyn Modul och sedan 2:random.
- Vi definierar sedan funktionen sim1(n) där n är antalet upprepningar av försöket. Tryck f1 (Fns…) och välj func och sedan 1 def function().
- Sedan skriver vi in startvärdet 0 för vårt räkneverk.
- Sedan kommer for-satsen som vi använder för att (upprepa en del av programmet n antal gånger. Vi skriver alltså här sim1(100) om vi vill köra 100 gånger.
- Nu kommer if-satsen där vi undersöker om totala antalet prickar är ≤ 16. Om det är sant så räknas räkneverket upp.
- Till sist beräknas kvoten räkneverk/n som är andelen kast där totalsumman blir ≤ 16.
Steg 7
För att köra programmet så trycker du Run och på tangenten och väljer sedan sim1() och skriver in värdet på n, t.ex. 200. Sedan trycker du på . Kör några gånger med samma värde och se hur det beräknade värdet varierar. Tryck på för att snabbt göra många körningar.
Steg 8
Du kan göra körningen ett stort antal gånger, t. ex. 2000. Kör några gånger. Diagrammet visar de värden vi fick när vi gjorde detta 10 gånger. Vi får värden mellan 0,751 och 0,775 ca.
Lärarkommentar: Diskutera med eleverna skillnaden mellan att skriva
randint(1,6)+randint(1,6)+randint(1,6)+randint(1,6)<=16
som vi gjorde i skriptet och
randint(1,6)*4<=16 eller randint(4,24)
Be dem att skriva in enligt ovan och sedan tolka resultatet.
Steg 9
Exakt beräkning
När vi gjorde ett antal simuleringar fick vi ett medelvärde på ca 0,76. Nu ska vi skriva ett ganska tufft program som gör exakta beräkningar. Det åstadkommer vi genom fyra for-satser (en för varje tärningskast). Det som händer är att programmet går igenom alla kombinationer och tittar vilka som ger 16 prickar eller mindre. Om man skulle göra detta utan någon hjälp av räknare eller dator skulle det ta väldigt lång tid.
Steg 10
Vi kör nu programmet en gång och ser vilket resultat vi får. Sammanlagt finns det 64=1296 kombinationer som ger en totalsumma som är 16 eller mindre. Totalt finns det kombinationer. Detta ger att sannolikheten att få 16 eller mindre är
986/1296 ≈ 0,7608
Cirka tre av fyra gånger så får du alltså i genomsnitt en poängsumma som är 16 eller mindre.
Steg 11
Tabellen nedan visar sannolikheterna för att få totalsumman 4-24. Lägg märke till symmetrin för antalet kombinationer omkring 14 i tabellen. Pröva nu också andra totalsummor och se att det stämmer med tabellen.
Steg 12
Fördjupning:
Om vi plottar totalsumma mot sannolikheten för 4 respektive 6 kast så ser det ut så här. Vi ser tydligt att fördelningen alltmer närmar sig en normalfördelning när antalet tärningar ökar.
Tillämpning: Tester och loopar
LärarkommentarerI denna övning ska vi undersöka s.k. primtal men innan dess så gör vi först en liten genomgång av faktorisering. När man förenklar ett bråk så förkortar man bort gemensamma faktorer i täljaren och nämnaren:
Men hur kommer man på att 65 = 5 · 13 och hur vet man att 13 och 5 inte har någon gemensam faktor?
Att skriva 65 som 5 · 13 kallas att faktorisera 65. Vissa tal kan faktoriseras på flera sätt, till exempel
24 = 6 · 4 = 2 · 3 · 2 · 2
De minsta tänkbara faktorerna (större än ett) kallas primtal. Talen 2 och 3 är alltså primtal.
Steg 1
Definition: Ett primtal är ett heltal större än ett som inte kan faktoriseras i mindre positiva heltal. Om man kan bryta ner ett tal i mindre faktorer är det alltså inte ett primtal. De första primtalen är 2, 3, 5 och 7. Jämna tal (utom 2) är inte primtal eftersom de kan divideras med 2. I marginalen visar vi alla primtal mindre än 100.
Steg 2
Vi ska nu titta på två program som gör faktoruppdelning. Det ena lite mer omfattande programmet arbetar med listor. Vi behöver här förklara betydelsen av symbolen %. Du hittar den genom att trycka f2 (a A #)
I konsolen (Shell) pröva nu att skriva 24%2 resp. 25%2. I det första fallet får du resultatet 0 och i det andra fallet 1. Det som beräknas är resten vid division av två heltal. 24 dividerat med 2 ger ju svaret 12 medan 25 dividerat med 2 ger 12 och resten 1.
Steg 3
En annan viktig sak när man ska kontrollera om ett tal n är ett primtal är att man bara behöver dividera med tal som är mindre än √ n Varför då?
En viktig sats om primtal:
Kortsidan på en rektangel med n rutor måste ha längd som är högst √ n Med andra ord, om ett tal n inte är ett primtal så måste någon faktor vara högst √ n. Vi prövar nu denna sats med talen 83 och 133.
Steg 4
Vi prövar nu denna sats på några tal. Roten ur 83 är ungefär 9 och roten ur 133 är ungefär 11. Vi gör nu beräkningarna utanför Python-appen och vi har lagt in talen i nämnaren som listor. Observera att vi bara behöver kontrollera med primtal i nämnaren. För att omvandla decimaltalen i svaret till bråk så lägger vi till kommandot Bråk som du når om du trycker på tangenten .
Vi ser att 83 är ett primtal men att 133 inte är det. Vi kan dela upp 133 i faktorerna 7 och 19: 7 · 19 = 133
Någon enkel metod för att faktorisera tal finns inte utan man måste dividera med alla mindre faktorer och kontrollera om divisionen går jämnt upp. Jobbigt att göra för hand men nu kan vi skriva ett program som fixar detta.
Steg 5
Här är nu ett enkelt program som löser uppgiften med faktoruppdelning av 133. Pröva gärna med några större men inte alltför stora tal. 133 går bra men när vi försöker faktoruppdela 9737 får vi svaret nedan till höger efter väldigt lång tid (flera minuter!). Hur ska vi tolka det? Efter en del funderande kommer du säkert på att den korrekta primtalsppdelningen 7·13·107 är Se bilderna nedan.
Steg 6
Vi prövar nu ett annat program som är lite mer sofistikerat och där man använder listor och operatorn %. Vi har fuskat lite här och satt ihop två skärmar till en.
Steg 7
Om vi nu kör programmet får vi resultatet nedan. Vi får samma resultat som förut men nu kommer faktorerna i stigande ordning och så får vi förtydligande text också. Dessutom är det betydligt snabbare.
Lärarkommentar: Ta upp de nya instruktioner som inte förekommit i tidigare övningar. Det gäller t.ex append och reverse för listor.
Append lägger till en post i en lista. Exempel:
listaX=[3,5,7]
listaX.append(11)
print(listaX)
[3,5,7,11]
Reverse bytter ordning på posterna i en sekvens. Exempel:
listaX=[3,5,7]
listaX.reverse()
print(listaX)
[7,5,3]
Steg 8
Hitta primtal
Vi övergår nu till att koncentrera oss på tal som är primtal och inte faktoruppdelning. Det första programmet testar bara om det inmatade talet är ett primtal. Enklare än så här kan det knappast bli.Pröva tal av olika storleksordning. Vi har importerat matematikmodulen from math import. Den behövs för att vi vill använda kvadratsrotsfunktionen sqrt().
Steg 9
Tänk också på att operatorn % beräknar resten vid division av två tal.
Tryck på tangenten och välj sedan ärprim() när du vill göra en körning. Skriv sedan i det tal du vill kontrollera inom parenteserna och tryck på .
Steg 10
Det andra programmet har en inputsats och användaren uppmanas alltså att mata in ett tal. Vi måste då lägga in int() i satsen för att det ska fungera. Om man inte definierar att det är tal kommer den inte att kunna utföra beräkningar med värdena. Alltså: För att definiera det som ett heltal skrivs det in enligt denna mall:
heltal = int(input(”Skriv nu in heltalet”)).
Dessa två program kan bara kontrollera ett tal i taget. Det naturliga när man håller på med primtal är att få en lista med ett antal primtal inom ett intervall t.ex.
Steg 11
Här är ett sådant kort program som printar ut primtal inom ett intervall. Printsatsen har med instruktionen end=” ” för att primtalen ska fyllas på vågrätt istället för radbrytning mellan varje tal. Vi har här
Steg 12
Lärarkommentar: På denna sista sida så visar vi hur man kan arbeta med primtal och faktoruppdelning med TI-Nspire®. Om du har möjlighet så visa gärna detta för eleverna. Aktiviteten finns i TI:s materialdatabas och heter Undersöka primtal.
- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 4: Använda biblioteksmodulen ti-plotlib
Övning 1: Komma igång med grafik
LärarkommentarerI den här första övningen i kapitel 4 får du lära dig att skriva och använda en instruktion för att göra grafiska representationer i Python. Du kommer också att lära dig att rita ett diagram och konfigurera skärmen på räknaren.
Syfte:
- Upptäcka ti-plotlib-modulen
- Representation av punkt och linje
- Göra en grafisk presentation
Steg 1
1: Biblioteket eller modulen ti-plotlib
Om du vill utföra en grafisk representation när du kör ett skript måste skriptet kunna förstå de grafiska instruktionerna. Det är därför nöd-
vändigt att "lägga på" de grafiska funktionerna inom ett bibliotek ti-plotlib.
Steg 2
Starta ett nytt skript genom att namnge det K4OVN1 och inkludera ti-plotlib modulen. Du hittar den under f1 (Fns...) sedan Modul och alternativ 5. Välj sedan 1: import ti_plotlib as plt.
För den här första delen ska du skriva ett skript som visar en punkt vars koordinater är kända. Sedan ska du ändra skriptet så att det hittar din punkt i en markör och dessutom ändrar dess färg.
För att slutföra den här första övningen, ska du också namnge koordi-natsystemets axlar och ge en titel till ”grafen”.
Steg 3
Definiera nu en funktion med koordinaterna för punkten som argu-ment och lägg sedan till en instruktion så att punkten visas.
- Rensa först din skärm med hjälp av instruktionen plt.cls () som du hittar i modulen ti_plotlib i menyn.
- För att rita punkten, välj instruktion 6: Plot belägen i ritmenyn (Draw) för ti_plotlib-modulen.
- Välj också önskad markering för punkten.
Steg 4
Fortsätt skriptet genom att begära visning av punkten genom att välja plt.show_plot() (instruktion 9 i ti-plotlib-modulen).
- Be nu om körning av skriptet (tryck f4). Tryck sedan på [vars] - för att komma åt punktfunktionen punkt().
- Ge koordinaterna för en punkt och observera sedan skärmen.
Steg 5
Tryck på [clear] " för att komma ur den grafiska skärmen, sedan på [vars] för att hitta listan över variabler i skriptet.
Ändra koordinaterna för din punkt (t.ex.till punkt(10,10) och upptäck att punkten inte längre syns på skärmen.
Steg 6
2: Förfina din representation
Inkludera plt.cls()-satsen under funktionsdefinitionen för att undvika att menyraden längst ner läggs ovanpå din grafiska representation.
Steg 7
Från de olika alternativen i inställningsmenyn för modulen ti_plotlib så ska du lägga till i skriptet de instruktioner som gör det möjligt att:
-
Ställa in grafikfönstret så här:
Xmin -10; Xmax - 10; Ymin - -10 och Ymax - 10
Du väljer då alternativ 4:Window)
- Visa ett rutnät. Välj alternativ 3: grid. Typ av rutnät väljer du själv.
- Visa axlar (alternativ 6:axlar)
- Ställa in färgen på punkten. Välj Draw i menyn längst upp och sedan väljer du 1: color (r,g,b).
Steg 8
Kör skriptet och observera ändringarna. Du bör få en skärm identisk med den till höger.
Ändra skriptet igen för att ge axlarna ett namn. Till exempel ("x-axel" och "y-axel").
Det gör du genom att inkludera en rad, plt.labels, i skriptet (valfri plats). Den finns som alternativ 7: Labels() på menyn Setup i tiplot-
modulen.
Steg 9
Man kan också lägga till en titel med instruktionen plt.title.
Ska man ha med tecken å, ä eller ö får man gå till teckenpaletten genom att trycka på f2 (a A #).
Övning 2: Grafiskt representera en funktion
LärarkommentarerI denna andra övning i kapitel 4 ska du lära dig att grafiskt representera en funktion med hjälp av biblioteksmodulen ti_plotlib.
Syfte:
- grafiskt representera en funktion
- repetera notationen för en av- gränsad loop
- Göra inställningar för att visa grafik
Steg 1
Vi ska här skapa ett skript med hjälp av biblioteket ti_plotlib, som gör det möjligt att spåra i den grafiska representationen av en funktion g av x med värden i intervallet [a, b] och med N del-segment.
Skriptet du kommer att skapa är generellt så att du lätt kan skapa nya för andra exempel.
Steg 2
Starta ett nytt skript och döp det till KAP4OVN2
- Importera modulen ti_plotlib. Tryck på f1 (Fns...) och välj Modul och sedan 5: ti_plotlib.
- Definiera sedan funktionen g(x) = 0,2x2 - 0,72x - 1.
Steg 3
Om du plottar denna funktion på räknaren utanför Python ser det ut som på skärmen här till höger. Vi ska se hur bilden blir efter Python-
programmeringen. Vid denna plottning har vi valt att plotta kurvan lite tjockare. Man kan välja mellan tunna eller feta linjer och linjerna kan antingen vara hela eller prickade. Grafen här på bilden är plottad med tjocka heldragna linjer.
Man kan även ställa in färgerna på rutnätet, det finns fyra olika gråa nyanser.
Steg 4
Nu tillbaka till programmeringen!
Vi definierar först funktionen graf med argumenten f, a, b, och N.
x-listan lx konstrueras med hjälp av en avgränsad loop (slinga), vars instruktion du når genom att trycka på f1 (Fns…) och sedan välja 4: for i in range (size) bland kontrollinstruktionerna. Listan ly beräknas från listan lx. Vi använder då instruktionen 7: for i in list.
Steg 5
Nu är du redo att utföra den grafiska representationen av funktionen.
Du kan nu infoga instruktioner för att:
- Rensa skärmen: plt.cls().
- Göra inställningar för grafikfönstret:
plt.window (xmin, xmax, ymin,ymax)
- Visa axlar med axelmarkeringar: plt.axes ("on").
- Namnge axlarna: plt.labels ("x", "y")..
- Utföra beräkningar för den grafiska representationen: plt.plot (lx,ly,"O")..
- Visa plottningen av funktionen: plt.show_plot()..
Steg 6
Alla satser ovan finns i ti_plotlib-modulen och i menyerna Setup och
Draw (alternativ 5). Till höger har vi satt ihop två skärmar till en skärm.Obs: Anvisningarna för att välja färg i RGB (röd, grön, blå) sker genom kodning med värden 0 till 255 för varje färg. Man får tänka på att placera instruktionen för färgerna på ett klokt sätt så att man t.ex. undviker att ha koordinataxlarna i rött.
Gör nu en körning av skriptet genom att trycka på tangenten [vars] och sedan välja graf(). Sedan kan du t.ex. välja att visa grafen för funk-tionen g i intervallet [0; 3] med 30 delsegment.
Steg 7
Tryck nu på [enter]. Nu plottas en massa punkter med linjestycken emellan som bildar grafen för funktionen g mellan x-värdena -5 och 8.
Pröva nu att ändra värdet på N till 10 t.ex. Du får då en mer kantig kurva men du ser linjestyckena mellan punkterna tydligt. Du ser nu att 11 punkter plottas.
Steg 8
Steg 9
Vi ska nu rita funktionen 0,3x2- 2x -2i intervallet [-10; 10].
- Starta ett nytt Pythonprogram och döp det till KP4OV2NL och importera först biblioteksmodulen i ti_plotlib.
- Först definierar vi funktionen f.
- Sedan gör vi en lista över x-koordinater (lx).
- Och sedan en lista över motsvarande y-koordinater (ly).
Se skärmbilden till höger:
Steg 10
Nu kan vi fortsätta med de olika instruktionerna för att plotta funktionen. När du exekverar skriptet plottas funktionen direkt. Du behöver alltså inte mata in några argument till funktionen.
Steg 11
För att göra plottningen ännu snyggare kan man skriva instruk-
tionen för lx så här:
lx=[i/5 for i in range (-50,50)]
Då plottas även punkter som för x inte bara har heltalsvärden.
Pröva detta och ändra även punkterna vid plottningen till ”.” Då kan slutresultatet bli enligt den nedersta bilden i marginalen.
Övning 3: Grafiskt representera en funktion
LärarkommentarerI den tredje övningen i kapitel 4 får du lära dig hur du grafiskt representerar en uppsättning data och analyserar dessa data, och sedan beräknar en matematisk modell som anpassar sig till datamängden.
Syfte:
- grafiskt representera en uppsätt- ning av data
- Undersöka om det finns någon bra regressionsmodell
- Använda listor i Python
Steg 1
Scenario: Under en översvämning registrerade myndigheterna varje timme förändringen av den maximala vattennivån i förhållande till en referenspunkt.
Datan finns i tabellen nedan. Du ska representera data med hjälp av ti_plotlib-biblioteket och sedan leta efter en matematisk modell för att göra en extrapolering. Skälet till detta är att kunna förutsäga när vattennivån blir noll i förhållande till en referenspunkt.
T(h) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
H((cm)) | 130 | 127 | 123 | 118 | 116 | 111 | 105 | 103 | 101 | 95 | 86 | 80 | 71 |
Steg 2
Implementering: Starta ett nytt skript och namnge det KAP4OVN3.
- Importera modulen ti_plotlib.
- Spara data i två listor, "t" och "h".
- Förbered sedan den grafiska representationen med bland
annat följande:
- Rensa skärmen plt.cls(.
- Ställ sedan in det grafiska fönstret: xmin -5, xmax 35, ymin -25, ymax 250 genom att skriva plt.window (-5, 35, -25, 250)
- Visa axlar: plt.axes(”on”)
- Visa rutnät: plt.grid(5,50,”dot”)
- Visa den grafiska representationen av data som ett spridningsdiagram med instruktionen plt.scatter(t,h,”+”).
Instruktionerna för fönsterinställning av grafik finns i modulen ti_plotlib på menyn Setup. Instruktioner för plottning och datavisning finns på menyn Draw.
Steg 3
Observera att värdet noll alltid kommer med.
Kör skriptet och observera den grafiska representationen. Om allt gått bra bör du ha fått skärmen här till höger.
Verkar alla punkter ligga någorlunda i linje?
Steg 4
Du ska nu söka efter den matematiska modellen med en metod man kallar för linjär anpassning eller linjär regression. Vi ska söka en linje som så bra som möjligt ligger nära datapunkterna.
För att göra detta måste du lägga till raden
plt.lin_reg(t, h,"center"11)
i skriptet så att regressionslinjen beräknas från listorna t och h och sedan visas och centreras på linje 11 på skärmen.
Steg 5
Steg 6
Genom att lägga till två instruktioner för färg i skriptet kan vi få det ännu snyggare. Vi vill få datapunkterna inkl. grafens titel i en färg och regressionslinjen inkl. den beräknade ekvationen i en annan färg. Se skriptet här till höger och grafen nedan.
Tillämpning: Successiva positioner hos rörelse
LärarkommentarerVid tillämpningen i kapitel 4 kommer du att undersöka en rörelse hos en golfboll utifrån mätningar med ett stroboskop och därefter ska du bygga en grafisk modell av rörelsen med programmering i Python, och med hjälp av biblioteksmodulen ti_plotlib.
Syfte:
- Grafiskt representera en datamängd
- Beräkna och representera vektorer i ett system som modelleras av en punkt
Steg 1
Problemet: Förflyttningen hos en golfboll studeras från en inspelning av rörelsen där man tog bilder med ett visst tidsintervall. Vi vill nu grafiskt visa hastighetsvektorns förändring över tiden.
Bollens position visas i tabellen med tidsintervallet 0,066 s.
I kapitel 5 får du lära dig hur du importerar data till Python-appen från räknarens listor med hjälp av modulen ti_system.
t(s) | 0 | 0.066 | 0.132 | 0.198 | 0.264 | 0.33 | 0.396 | 0.462 | 0.528 | 0.594 | 0.66 |
x (m) | 0.01 | 0.25 | 0.57 | 0.91 | 1.22 | 1.54 | 1.87 | 2.16 | 2.49 | 2.81 | 3.15 |
y (m) | 0.015 | 0.34 | 0.681 | 1.01 | 1.297 | 1.559 | 1.768 | 1.95 | 2.08 | 2.158 | 2.193 |
Steg 2
Komma igång:
- Starta ett nytt skript och döp det till KAP4APPL
- Importera sedan de grafiska biblioteksmodulen ti_plotlib
- Mata nu in mätresultaten för x och y
Steg 3
Beräkna hastighetsvektorerna
Hastighetsvektorn vid tiden t ges av uttrycket
Du kan inte rita hastighetsvektorn från den sista punkten i listan, det måste du ta hänsyn till i koden.
Tips: För att göra den grafiska representationen läsbar har vi en skalfaktor på 2.
Steg 4
Inställning av parametrar för den grafiska representationen:
- plt.cls() för att rensa skärmen
- plt.title (”titel” lägga till en titel till den grafiska bilden.
- plt.window (xmin,xmax,ymin,ymax)) ställa in fönstermåtten
- plt.grid (xscl, yscl, "type") visa ett rutnät med en viss gradering
- plt.color (255,g,255) ställa in färg för visning av punkterna i banan. Här är inställningen en lika blandning av rött och blått, dvs magenta.
- plt.scatter (xlist, ylist, "type") visning av data som ett spridnings diagram
- plt.color (0.0.0) visning av axlar helt i svart.
- plt.pen ("medium," "solid") axlar som mellantjocka linjer.
- plt.labels ("x(m)," "y(m)) visning av axelbeteckningar.
Visas på rad 2 och 12 som förinställd standard.
Steg 5
Vektorspårningen görs som en avgränsad loop med n-1 värden.
- plt.line (x0,y0,x1,y1) för spårning av hastighetsvektorn
- plt.show() visning av hela den grafiska representationen.
- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 5: Använda biblioteksmodulen ti-plotlib
Övning 1: Arbeta med data
LärarkommentarerI denna första övning i kapitel 5 kommer du att upptäcka hur man använder biblioteket ti_system för att importera och exportera listor i ett Pythonskript.
Syfte:
- Importera/exportera listor
- Repetera viktiga grafiska funktioner från Kapitel 4
Steg 1
Med biblioteksmodulen ti_system kan du, antingen ensam eller ihop med andra, kommunicera i båda riktningarna med grafräknaren. Alternativ 2 och 3 tar vi upp i denna övning:
2: var-recall_list (“name”) och
3: store_list ("name"name",var)
Steg 2
De övriga alternativen I detta bibliotek kommer vi att ta upp i de andra övningarna i detta kapitel.
Steg 3
1. Importera data från grafräknaren
a) Skapa två listor
Först kommer vi helt enkelt att skriva in data i listor (L1 och L2)
- Räknaren ska vara inställd i normalläge (ingen programmering). Ta först bort eventuellt innehåll i listorna genom att trycka på [2nd] [mem] och sedan 4: RensaAllaListor
Steg 4
- Gå till listredigeraren och placera markören i kolumnhuvudet hos L1 som på skärmen här till höger.
Steg 5
Steg 6
Tryck nu [2nd] [list] och välj sedan OPS (står för Options som är alternativ) och sedan 5: sekv(. Tryck på [enter] för att välja.
Skriv sedan i fönstret enligt skärmen till höger. Välj Klistra in. Formeln placeras längst ner på inmatningsraden i listeditorn.
Steg 7
Tryck nu på [enter]. I lista L1 får vi nu värden från 0 till och med 12 med en differens på 0,2. Gå sedan med markören till kolumnhuvudet i lista L2, tryck på [enter] och skriv sedan
L2=-0.5L12+3L1+1
Du skriver in L1 genom att trycka på [2nd]{1] À. Tryck sedan på [enter]. Se skärmen till höger. Nu har vi två färdiga listor L1 och L2. Vi ska nu plotta ett spridningsdiagram utifrån data i listorna.Steg 8
Vi ska nu göra inställningar för att plotta data i listorna som ett sprid-
ningsdiagram. Se till att det inte finns några inmatade funktioner i räknaren. Tryck på tangenten [y=] för att kontrollera. Man kan ha funktioner inmatade men då får man istället avmarkera funktionen genom att trycka på likhetstecknet.
Ställ in fönstervisningen så här:
Xmin = -1.5, Xmax = 8,5, Ymin= - 0.5, Ymax = 6.5
Steg 9
b) Importera data till ett Python-skript
- Starta ett nytt script och döp det till KAP5OVN1
- Skapa två variabellistor (tomma) xaxel och yaxel.
- Importera modulerna ti_system och ti_plotlib (det finns ingen viss ordning här)
- Skapa en variabel xaxel och sedan från ti_system-biblioteket väljer du alternativ 2: var-recall_list ("namn"). eftersom x-axelns data finns i L1 ska fältet "namn" betecknat med talet 1.
- På liknande sätt en variabel för y-axelns data och den skriver vi som yaxel= recall_list(”2”).
Steg 10
- Kör skriptet och kontrollera sedan innehållet i dina xaxel- och yaxel-variabler genom att trycka på tangenten [vars].
- Återkalla sedan namnet på xaxel- "listan" och validera detta.
- Gör samma sak med listan för y-värden
Steg 11
c) Grafisk representation
Gör nu inställningar för grafen enligt skärmen här till höger.
Exekvera nu skriptet (Run).
Steg 12
2. Exportera data
Skapa ett nytt skript och döp det till KAP5OV2B
Skapa först en funktion data (a,b,n).
Du skapar sedan två listor med data som grafiskt ska representeras i form av ett spridningsdiagram med värden inom ett intervall [a; b], beräknade med steglängden n.
I listan y beräknar vi kvadratroten för x-listans värden.
För att skapa dessa datalistor bygger vi en avgränsad loop efter att naturligtvis ha skapat två tomma listor.
Steg 13
För att exportera listorna till räknaren så är syntaxen
store_list("list number,"name).
listnumret hos räknaren motsvarar listorna L1 to L6. Om vi kör skriptet och sedan trycker på tangenten [vars] och sedan skriver
data(0,20,1)
så får vi i editorn i listhanteraren (när vi lämnat Python-appen) i statistik-editorn data enligt skärmen till höger.Övning 2: Modellering
LärarkommentarerI denna andra övning i kapitel 5 kommer du att upptäcka hur man använder biblioteket ti_system för att importera och exportera listor i ett Pythonskript.
Syfte:
- Utforska en linjär modell
- Importera resultaten av en linjär modellering till ett Pythonskript.
Steg 1
Steg 2
Scenariot: Vanligtvis är effektuttaget som störst omkring kl. 19. Det är alltså den tidpunkt när ett samhälle konsumerar mest energi. Effektuttaget mäts i watt. Du vill förutsäga konsumtions-topparna nästa helg inom ett område som ligger nära en kontrollcentral. För att åstadkomma denna prognos har du tio värden uppmätta på effektuttaget i MW klockan 19.00 vid olika utetemperaturer.
T (°C) | 11 | -5 | -8 | -6 | 9 | 14 | 4 | -1 | -12 | 3 |
MW | 3 | 5.7 | 6.6 | 6.3 | 3.4 | 2.7 | 4 | 5.1 | 7.1 | 4.6 |
Data är inmatade i räknarens statistikeditor. Temperaturen i L1 och effektuttaget i MW i L2.
Steg 3
Steg 4
Steg 5
Markera därefter på Beräkna och tryck på [enter]. Nu får du ett resultatfönster på skärmen.
Den linjära funktion som beskriver hur effektuttaget K i MW beror av temperaturen t kan skrivas som
K = -0,18⋅t + 5,01
r är korrelationskoefficienten och beskriver hur väl datapunkterna är anpassade till den beräknade regressionsekvationen.
Steg 6
Steg 7
Använda resultaten i ett Python-skript
- Starta ett nytt skript och döp det till KAP5OVN2.
- Lägg till ti_system och ti_plotlib
- Skapa två listor, temp[ ] och kons[ ]
Steg 8
Återkalla innehållet i L1- och L2-listorna i sina respektive namn.
Satsen var-recall_list("name") finns i menyn för ti_system-modulen (se kapitel 5 Övning 1).
Kom också ihåg ekvations-variabeln som är uttrycket för den beräknade linjära modellen.
Steg 9
Steg 10
Steg 11
För att slutföra den här övningen och repetera de kunskaper som för värvats i kapitel 4 kan du nu göra en grafisk representation av dina mätningar och den beräknade regressionsmodellen.
Instruktionen plt.lin_reg ( ) motsvarar alternativ 8: plt.lin_reg (x-list, y-list,”disp”) på ti_plotlib-bibliotekets meny Draw.
Obs: Instruktionen plt.auto_window (x_list, y_list) justerar automatiskt fönsterinställningarna. Det motsvarar ZoomStat på räknaren.
Övning 3: Visning och timeout
LärarkommentarerI denna tredje övning i kapitel 5 kommer du att lära dig hur man använder alternativen disp och sleep hos ti_system-biblioteket.
Syfte:
- Förstå hur instruktionerna disp och sleep fungerar
- Använda dessa instruktioner tillsamman med innehåll i andra bibliotek
Steg 1
1: Använda disp-instruktionen
I de första övningarna i detta kapitel fick du lära dig att importera datalistor och hur man arbetar med regressionsekvationer.
- Starta ett nytt skript och döp det till KAP5OVN3
- Importera modulen ti_system.
Steg 2
- Lägg till raden disp clr( )
- Om du kör skriptet kommer du alltid att få en rensad skärm och promten placeras högst upp på skärmen.
Steg 3
Steg 4
Steg 5
Steg 6
Steg 7
disp_wait ()-satsen pausar skriptkörningen. Tryck på [enter] för att fortsätta exekveringen.
Steg 8
Ta bort statement disp_wait() och ersätt med viloläge (sekunder).
Detta sista påstående introducerar en tidsfördröjning av den angivna varaktigheten.
Således kommer det föreslagna ordet att visas i dess position som motsvarar värdet på p [i] -listan varannan sekund.
Steg 9
Steg 10
2: escape()-instruktioner
- Skapa ett nytt skript och döp det till KAP5OVN3B
- Infoga instruktionen disp_clr() för att rensa skärmen.
- Definiera en funktion vars argument är ett heltal.
I en avgränsad loop kommer instruktionen if escape (): break att stoppa körningen av skriptet om du trycker på [clear].
-
Annars lagras i-värdet för loopsteget i en variabel x.
- Med en paus på 1 sekund kan du se texten "00" på skärmen.
Steg 11
Steg 12
Driften av satsen while not escape() är identiskt när det gäller den tangent som ska tryckas in men här fortsätter skriptet att köras tills tangenten [clear] trycks in.
Tillämpning: Visning och timeout
LärarkommentarerI denna avslutande övning i kapitel 5 ska du fördjupa begreppen som tagits upp i kapitel 4 och 5 för att skapa en simulator som beskriver fysikalisk rörelse.
Syfte:
- Göra en simulering utifrån stroboskopbilder
- Exportera resultat från simuleringen till listor hos räknaren
Steg 1
Här ska Pythonspråket användas för att skapa en simulator av ett fysiskt fenomen. Det handlar om fritt fall.
- Skriptet bör tillåta beskrivning av en rörelse;
- Den grafiska representationen av data ska i grafik visa själva rörelsen
- Data ska exportera till räknarlistorna.
Scenario: En boll tappas utan begynnelsehastighet från höjden h. Bilderna för rörelsen tas med 60 millisekunders intervall. Figuren visar positionen för en boll som är tagen med ett s.k. stroboskop. Ett stroboskop är ett instrument som sänder ut ljuspulser för att lysa upp ett föremål så man kan studera dess rörelse eller hastighet. Ljuspulserna har sänts ut med frekvensen 20 pulser per sekund. Siffrorna visar hur långt bollen har fallit. (Källa: Wikipedia)
Du ska nu skriva ett skript som beräknar positionen för bollen vid olika tidpunkter och sedan representera detta grafiskt.
Steg 2
Beräkna bollens läge vid olika tidpunkter
Bollens position y m beräknas med hjälp av uttrycket där h0 är ursprunglig höjd i m och t är tiden efter nedsläpp:
y = h0 - 1/2 ⋅ g ⋅ t2
g = 9,81 m/s2.
Skapa ett nytt skript och döp det till KAP5APPL
Steg 3
- Importera ti_system- och ti_plotlib-modulerna.
- Rensa skärmen.
- Skapa en funktion fall där argumentet är den ursprungliga höjden varifrån bollen släpps och som visar positionen för bollen vid olika tider.
- Skapa tre tomma listor, x, y och tid.
- Höjden (y-värden) ska beräknas var 60:e millisekund (0,06 s).
- Värdena sparas i listorna om y>0 (bollen kan ju inte sjunka ner i marken).
Skapa en avgränsad loop för att beräkna höjden hos en boll som funktion av tiden. Resultaten ska uttryckas med en noggrannhet på 1/100 och lagras i sina respektive listor. Listorna tid och y exporteras sedan till räknarlistorna L1 och L2.
Steg 4
b) Visning av grafiken
Inställningar för att plotta diagrammet
- Rensa skärmen med instruktionen plt.cls().
- Visa rutnät plt.grid(xscl, yscl, type,(r,g,b)).
- Gör fönsterinställningar plt.window(xmin, xmax, ymin, ymax).
- Ställ in färg för punkter till magenta plt.color(255,0,255).
- Visa spridningsdiagram (punkterna) plt.plot(x-list, y-list, mark).
- Visa plottningen plt.show_plot().
Steg 5
Kör ditt script och anropa din funktion fall genom att trycka på [vars]. Ange sedan som argument ursprungshöjden, t ex. 8 m.
Tryck nu på [enter].
Steg 7
b) Visualisering av de exporterade listorna.
Avsluta nu Pythonappen och visa listorna i statistikeditorn hos räknaren. Plotta sedan ett diagram som visar hur höjden beror av tiden. Med [trace] kan man spåra i diagrammet.
Steg 8
Steg 9
Steg 10
Steg 11
Sedan ställer man in ett bra fönster för att visa rörelsen.
Vi har på bilden här fryst rörelsen genom att trycka på . Om man trycker på igen fortsätter linjen med den lilla bollen sin framfart nedåt. Du märker kanske att det går fortare och fortare. Det är ju en accelererad rörelse vi visar.
Ändra nu visningen av rörelsen så man har en fet prickad linje istället för nyckeln. Ändra också Tsteg till 0.06 som vi hade i Pythonappen.
Tryck nu på och bläddrar dig framåt 0,06 sekunder i taget. Se bilden.
- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 6: Använda TI-Innovator Hub och TI-Innovator Rover
Övning 1: Integrerade sensorer hos hubben
LärarkommentarerI denna första övning i kapitel 6 kommer du att upptäcka hur man använder biblioteket ti_hub för att styra integrerade komponenter hos hubben.
Syfte:
- Upptäcka hubb-modulen
- Skriva ett skript där man integrerar TI-Hub-biblioteket för de integrerade komponenterna
Steg 1
I den här övningen kommer du att använda ti_Innovator biblioteket för att visuellt uppmärksamma en förändring i ljusintensiteten för att senare simulera en skymningsbrytare eller spela in en serie mätningar vid soluppgång eller skymning.
Skymning inträder när dag går mot natt då solen passerar horisonten och solskivan endast delvis är synlig. Längden på skymningen beror på hur lång tid det tar för solen att komma 6° under horisonten. Detta i sin tur beror på hur flack solens skenbara bana är relativt horisonten.
Steg 2
Du kommer också att börja fundera på hur du kombinerar det här biblioteket med de du redan känner till (ti_plotlib och ti_system) för att skapa ett mer komplett naturvetenskapligt projekt.
Skriptet du ska skriva motsvarar följande enkla algoritm:
Mäta omgivande ljusintensitet:
Lum0 ← mätning ± (tolerance?)
Ändra ljusintensitet (lampa; täckning framför ljussensorn)
Lum1 ← mätning
If Lum1 > Lum 0:
Tänd RGB LED i rött (2s)
Annars If Lum0 < Lum1:
Tänd RGB LED i grönt (2s)
Annars: Gör ingenting
Steg 3
Starta ett nytt skript och döp det KAP6OVN1
Det här skriptet måste integrera ti_hub-biblioteket. För detta har du flera möjligheter:
a) Tryck på f3 [Types] och välj alternativ 6 i menyn: 6:Hub Project. Bekräfta genom att trycka på [enter] två eller en gång och sedan OK.
b) Du kan också börja från ett tomt skript och sedan manuellt införliva de bibliotek du behöver.
c) Slutligen kan du också använda de bibliotek och variabler som har skrivits under TI STEM-projekten. Dessa kommer omedelbart att kopieras som "Projektobjekt". Det sista alternativet är bara intressant när du vill skapa ett skript som liknar dem som definierats under STEM-projektet (engelska) Se även den svenska sidan för STEM-projekt
Steg 4
Steg 5
Vi kommer att använda TI-Innovators inbyggda ljusstyrkesensor och RGB-diod. För att skriptet ska kunna hantera dem, låt oss integrera motsvarande bibliotek. För att göra det, välj i Modul-menyn alternativ 6: ti_hub och slutligen i undermenyn 1: Hub-Built-in devices.
Steg 7
- För att programmet ska kunna visa information på en "ren" skärm rensar du skärmen med hjälp av instruktionen disp_clr() i ti_system-biblioteket.
- Skapa en lum0-variabel till vilket ett ljusstyrt mått tilldelas. Satsen brightns.measurement() finns i modul 9: Brightness, som läses in så snart motsvarande modul importerats.
- Visa ett meddelande där användaren uppmanas att ändra ljusintensiteten i närheten av den inbyggda sensorn disp_at().
Steg 8
- Sätt programmet i vänteläge disp_wait(), den tid som ska ändras.
- Skapa en lum1-variabel som den nya mätningen är tilldelad.
- Mätningarna jämförs sedan. Beroende på resultatet av villkorsinstruktionen tänds RGB-lampan i grönt eller rött under 2 sekunder.
Steg 9
Utvidgning av övningen
Ändra föregående skript eller skapa ett nytt med namnet KAP6OV1B. Det nya skriptet bör registrera mätningarna av ljusstyrkan i 40 minuter.
Måtten sparas i en lista [ ].
De som motsvarar tidsvärdet i en t[]-lista.
Skriptet som föreslås nedan ger också en grafisk representation av mätningarna. Du kan jämföra den med diagrammet på nästa sida.
Export till räknarens listeditor föreslås också.
Steg 10
Avtagande av naturligt ljus under den borgerliga skymningen
Ordförklaringar: Temps clair= klart väder
Temps couvert=molnigt väder
Temps couvert +pluie= Molnigt väder + regn
Hauteurs du soleil = solhöjd
Coucher de soleil =Solnedgång
Steg 11
a) Datainsamling
b) Grafisk representation
Bri(n)-funktionen utför datainsamling varje minut i n minuter och returnerar t- och r-listorna.
Funktionen graf(t,r) ritar data t[ ] och r[ ] och exporterar dem sedan till räknarens listor L1 och L2.
Steg 12
- Sätt programmet i vänteläge disp_wait(), den tid som ska ändras.
- Skapa en lum1-variabel som den nya mätningen är tilldelad.
- Mätningarna jämförs sedan. Beroende på resultatet av villkors instruktionen tänds RGB-lampan i grönt eller rött under 2 sekunder.
Övning 2: Indata/Utdata enheter
LärarkommentarerI denna andra övning i kapitel 6 kommer du att lära dig hur man ansluter och använder en indata/utdata-enhet hos TI Innovator med hjälp av ti_hub biblioteket.
Syfte:
- Upptäcka TI_Hub-modulen
- Skriva och använda ett skript för att använda en ”grove” indata/utdata-komponent.
Steg 1
I den här övningen kommer du att använda en potentiometer som är en viktig komponent i alla mätkedjor med sensorer.
En potentiometer är en typ av reglerbart motstånd med tre anslutningar, varav den ena är ansluten till en vridbar glidkontakt som rör sig på ett motståndsspår som avslutas av de andra två som motståndet utsätts för.
Potentiometrar används ofta i elektroniska kretsar. De används till exempel för att styra volymen på en radio. Potentiometrar kan också användas som givare eftersom de omvandlar en position till en spänning. Denna typ av enhet finns i joysticks.
Steg 2
Du kommer att skriva ett skript för att mäta den elektriska spänningen mellan två anslutningar hos potentiometern och sedan visa spänningen på skärmen.
Obs: Tanken med denna övning är inte att studera själva komponenten, utan att integrera den i ett Pythonskript för att få den information som den måste tillhandahålla. Således kommer skriptet som du kommer att skriva att vara lätt att överföra till någon annan typ av givare.
Steg 3
Implementering:
Starta ett nytt skript och döp det KAP6ÖVN2. Du trycker på f3 (New) när du ska namnge ett skript.
ti_system och time-biblioteket importeras och du ska sedan importera Hub-biblioteket som motsvarar potentiometern och möjligtvis ti_plot-biblioteket.
Steg 4
Steg 5
Steg 6
- Skapa en pot( )-funktion tillfälligt utan argument.
- Börja med att rensa skärmen för att få en konsol utan information. För att göra detta infogar du instruktionen dispclr() som finns i ti_system- modulen.
- Skapa en mät-variabel och låt markören blinka bakom namnet på denna variabel. Sök sedan i modulmenyn och välj sedan 8: Potentiometer och sedan den första instruktionen var=potentiometer("port")
Steg 7
Bekräfta genom att trycka på [enter]. Tilldelningen av kommandot för att ansluta potentiometern till port IN 1 är klar.
Steg 8
- Skapa en variabel v för att samla in mätningen hos den anslutna sensorn (variabel mät).
Steg 9
- Kontrollera sensorns funktion efter att tidigare ha placerat potentiometern i ett centralt läge.
- Anslut TI-innovator till räknaren och anslut sedan potentiometern till IN1-porten.
- Anropa pot()-funktion.
- Du bör få information av samma storleksordning som den på skärmen mittemot, men observera att detta inte är en spänning eftersom din potentiometer drivs av en 3,3 V spänning. Värdet som ska hittas finns i intervallet [0; 3,3].
Övning 3: Styra en robot
LärarkommentarerI denna tredje övning i kapitel 6 kommer du att lära dig hur man ansluter robotbilen TI-Innovator Rover med hjälp av biblioteket ti_rover.
Syfte:
- Upptäcka TI_rover-modulen
- Skriva och använda ett skript för att använda TI-Innovator Rover och dess styrdon.
- Använda en öppen loop och en villkorsinstruktion
Steg 1
I den här övningen kommer du att skapa ett skript som ger ROVER möjlighet att köra en bana som markeras av belysning av RGB- dioden, så länge avståndet (mätt med RANGER-sensorn) respekterar en gräns skriven i en villkorsinstruktion.
Steg 2
Steg 3
- Starta ett nytt skript och namnge det KAP6OVN3
- Importera ti-rover-biblioteket från modul-menyn
- Bekräfta genom att trycka på [enter].
Steg 4
- Rensa skärmen med hjälp av instruktionen disp_clr() som finns i ti_system-menyn.
- Fortfarande i ti_system ti_system-menyn väljer du disp_cursor( )-instruktionen med värdet 0 för att inte visa markören.
Steg 5
- Be ROVER att gå vidare. Måttenheten på avståndet lämnas åt ditt val. Standardavståndet är 0,1 m. rv.forward(20) gör att robotfordonet går framåt 2 m. Instruktionen rv.forward( ) finns
i modulmenyn. Välj sedan 7: ti_rover och slutligen
2: forward(distance) i i Drive-menyn.
- Ange sedan början av en öppen loop som finns i modul-menyn och sedan i ti_system-biblioteket.
Steg 6
- Skapa en variabel a till vilken avståndet uppmätt med RANGER tilldelas. För att göra detta så skriv bokstaven a och lämna sedan markören i slutet av den här bokstaven. Skriv sedan instruktionen rv.ranger_measurement( ) som finns imodulmenynsedan 7: ti_roversedan I/O(input-output); 1: Inputs och slutligen1: rv.ranger_measurement( ). Måttenheten är meter.
Steg 7
- Skapa nu villkorssatsen. Om det uppmätta avståndet är mindre än 20 cm stannar roboten och RGB-lysdioden lyser rött. Instruktionen rv.color( ) finns i ti_rover-biblioteket i I/O-menyn alternativ 2: Outputs. rv.stop( ) är en körinstruktion och är därför placerad under motsvarande meny (Drive) . Annars lyser RGB-dioden grönt och roboten fortsätter sin väg tills den inställda sträckan nås. Instruktionen rv.resume() avslutar bearbetningen av åtgärderna i kön.
Steg 8
- I slutet av slingan:
- Roboten stannar. rv.stop().
- Skärmen raderas.
- Lysdioden visar en blå färg.
- Det är 1 s fördröjning innan lysdioden slocknar.
Tillämpning: Representera en tur med Rover
LärarkommentarerI kapitel 6 ska du ansluta TI-Innovator™ Rover med Ti_hub-biblioteket och skapa ett skript som samlar in punkt-koordinaterna under en färd och sedan också visa dessa koordinater grafiskt.
Syfte:
- Undersöka ti_rover-modulen.
- Skriva och använda ett skript för att köra TI-Innovator Rover och dess tillhörande ställdon.
- Använda en sluten slinga.
- Representera data grafiskt
Steg 1
I den här lektionen kommer du att skapa ett skript som ger ti-rover möjlighet att göra en väg som motsvarar ritningen av en polygon.
Hörnens koordinater sparas i listor och representeras sedan grafiskt med hjälp av instruktionerna i ti_plot-biblioteket.Steg 2
Genomförande:
- Starta ett nytt skript och döp det till KAP6APP
- Importera TI-Rover-biblioteket från modulmenyn
- Bekräfta genom att trycka på [enter].
- Importera även ti_plotlib-biblioteket
Steg 3
- Även om det inte är nödvändigt så gör instruktionerna för att rensa skärmen och inte visa markören att skärmen ser trevligare ut. Infoga alltså disp_clr() och disp_cursor(0) från modulmenyn och ti_system sedan.
- Skapa en funktion poly() med antalet sidor n i polygonen som argument och l som standardenheten längd för TI-Rover, dvs dm.
- Vinkeln vid hörnen för varje polygon kommer således att vara lika med a = 360/n.
- Skapa två tomma listor xaxel och yaxel, som är avsedda att ta emot koordinaterna för var och en av dessa hörn.
Steg 4
Skapa en stor öppen loop n.
Följande instruktioner finns i ti_rover-biblioteket:
- Flytta fram Rover l decimeter n gånger
- Sväng vänster med vinkeln a.
- Lägg in en fördröjning på 1 s mellan varje steg.
- Lagra koordinaterna för punkterna i x- och y-listorna.
- Koppla bort Rover i slutet av banan.
- Exportera xaxel- och yaxel-koordinaterna till listorna L1 respektive L2 hos räknaren.
Byt sedan till den grafiska representationen, som ingår i funktionen här men det är fortfarande möjligt att skapa en graffunktion separat som vi gjorde i andra övningar (kapitel 5).
Steg 5
Hur skriptet fungerar:
Kör ditt skript och anropa poly()-funktionen. Skriv (4, 1) för att rita en kvadrat med sidan1 dm.
Steg 7
Om du exporterar listorna till räknarens statistikeditor kan du plotta den grafiska representation som visas här. Om du använder - tangenten så kan du visa koordinaterna för varje punkt.
Faktum är att när du ritar ett segment registrerar räknaren koordinaterna för punkterna i ett segment i polygonen och lagrar sedan koordinaterna för den sista punkten som den första punkten i nästa segment. Speciellt eftersom vi har placerat en fördröjning på 1s mellan varje plottning.
Så rv.path instruktionerna är i vårt fall inte lämpliga.
Med satserna rv.pathlist_x() och rv.pathlist_y(), får vi koordinaterna för ändpunkten två gånger.
Obs: Justera inställningarna på ditt rutnät, beroende på vilka polygoner du vill rita. Detta har avsiktligt ställts in till standardinställningarna här för att observera noggrannheten i ROVER-spåret.
Var också uppmärksam vilken typ av yta som roboten rör sig på. Den får inte erbjuda för mycket motstånd mot rörelse eller tvärtom upp-muntra till glidning.
- Övning 1
- Övning 2
- Övning 3
- Tillämpning
Kapitel 7: Micro:bit
Övning 1: LED-displayen
Download Teacher/Student DocsII den här lektionen kommer du att skriva dina första Python-program för att styra micro:bit- enhetens display på olika sätt. Den här lektionen har två delar:
- Del 1: Möte med utomjordingar
- Del 2: Visa bilder
Mål:
- Att styra displayen micro:bit- enheten med kommandona .show( ), .scroll( ) och .show(image)
- Att styra visningshastigheten med sleep(ms) och delay=
- Att använda en loop.
Steg 1
Innan du börjar, se till att:
- Du använder en TI-84 Plus CE-T Python Edition med OS 5.7 eller högre
- Du är bekväm med att programmera i Python och/eller har redan slutfört kapitlen 1 till 5.
- Din micro:bit är ansluten till din grafräknare och att den är igång
- Du har följt installationsanvisningarna Getting Started Guide:
https://education.ti.com/en/teachers/microbit
och därmed ha TI-runtime-filen på micro:bit- enheten och de senaste micro:bit-modulerna i din grafräknare.
Denna installationsprocess ska bara behöva göras en gång men håll dig informerad regelbundet om uppdateringar/uppgraderingar.
Steg 2
Från startskärmen (avsluta Python-appen) kan du kontrollera att din räknare har lämpliga filer är installerad. Tryck på
[2nd] [+] för [mem], välj Mem Management > AppVars och bläddra till 'M ' för att hitta MICROBIT och se att du har, bland annat, de MB_*- filer som visas här bredvid.
Obs: det finns fler än de som visas i den här bilden: totalt 11 (version 1) eller 13 (version 2) micro:bit AppVars.
Steg 3
Om allt är bra och inställningen har gjorts korrekt, bör din micro:bit se ut så här när den har ström från räknaren:
Displayen på micro:bit- enheten visar TI-logotypen, en ikon för delstaten Texas med en skarpare ljuspunkt nära Dallas, där Texas Instruments huvudkontor ligger.
Steg 4
Del 1: Möte med utomjordingar
<Fns…> Modul screen
Naturligtvis, som med alla andra första program i ett nytt språk eller med en ny programmeringsmiljö, så börjar vi med att visa ett meddelande. Vi ska skriva en text med hjälp av micro:bit- skärmen.
Gå in i Python-appen och skapa ett nytt program.
I OS version 5.7, när du väljer <Fns…> Modul, så ska visas en funktionstangent som heter <Add-On> som ger tillgång till ytterligare moduler. Om du inte ser detta måste du uppdatera till OS 5.7 eller högre.
Tips: Om meddelandet " micro:bit card is not connected" någonsin visas, koppla bara ur kabeln ur micro:bit-enheten eller ur räknaren och anslut den igen. Detta nollställer micro:bit-enheten
Steg 5
Välj <Add-On> och se några ytterligare moduler som är tillgängliga, några av dem visas här. Din lista kan skilja sig men bör innehålla micro:bit-modulen. Välj from microbit import * för att klistra in koden i ditt program.
Steg 6
I editorn så lägger detta till alternativet micro:bit…i både
<Fns…> Modul menyn och i [math] menynu: Micro:bit…
När du lägger till funktioner från Micro:bit kommer denna meny att växa.
Obs: [math] är ett kortkommando för <Fns…> Modul men visar inte funktionstangenten <Add-On>.
Steg 7
Undermenyn micro:bit… innehåller alla verktyg som behövs för att programmera micro:bit -enheten.
Var och en av dessa menyalternativ kommer att klistra in sin egen importsats eftersom verktygen alla finns i separata Python-moduler (AppVars). Om du använder en micro:bit version 1 finns det färre objekt på den här skärmen.
Välj alternativet Display.
Steg 8
Efter att ha valt Display-alternativet så kan du se ett till import-kommando i ditt program:
from mb_disp import *
Steg 9
Titta på [math]-menyn igen: Det har nu lagts till ett menyalternativ för display... längst ner i listan. Välj display...
Steg 10
Menyalternativet display...innehåller funktioner som styr displayen på micro:bit,-rutnätet med 5×5 röda lysdioder i mitten av kortet.
Välj .show(val)
Steg 11
Den blinkande markören är nu placerad på höger parentes i funktionens argumentlista. Det du skriver här blir funktionens argument (indata). Skriv “greetings, earthlings” inom parentes, inklusive citattecken:
display.show(“greetings earthlings”)Tryck [2nd ] [alpha] för att slå på alfa-lock, så att du kan skriva många bokstäver och tryck [+] för att få fram citattecknet. Alla bokstäver som skrivs kommer att vara gemener. För versaler, tryck på [alpha] igen.
Obs: Det finns två extra argument du kan lägga till vid behov:
display.show( ___, delay = 400, wait = True)
delay= (tid i millisekunder) styr hur lång tid varje bokstav visas på displayen.
wait= (True or False)styr om micro:bit -enheten och räknaren ska slutföra visningen innan den går vidare för att göra något annat.
Steg 11b
Testa gärna vad dessa parametrar gör. De kan specificeras, som i raden som visas, med respektive nyckelord.
Detta behövs inte göras, men det rekommenderas för läsbarhetens skull.
Tryck sedan på <Run> för att köra programmet. Titta på displayen på micro:bit -enhetenDu kommer att se bokstäverna i ditt meddelande visas, en bokstav i taget, på displayen. De små bokstäverna "e" visas två gånger men du kan inte skilja dem åt.
Steg 12
Ett bättre sätt att visa låna meddelanden är:
display.show(“greetings earthlings”)
som du kan funna I [math] display… menyn..
Gör föregående ..show()-sats till en kommentar. Placera markören i början av den raden och tryck på [2nd] [3] för att infoga ett '#' och kör sedan programmet igen.
Du kan också helt enkelt ändra .show till..scroll genom att skriva över texten.
Obs: Du kan använda delay= och wait= med .scroll med.
Steg 13
Metoden .scroll() får meddelandet att rulla (flytta) från höger till vänster som en banner över displayen vilket gör det lättare att läsa.
Du kan styra rullningens hastighet med delay =-parametern, där värdet är tiden i millisekunder. Exempelvis:
display.scroll( ___ , delay = 100, wait = True)
Detta ger en fördröjning på 100 millisekunder (0,1 sekunder) mellan varje steg i rullningen. Prova gärna med andra fördröjningsvärden.
Steg 14
Del 2: Visa bilder- Be.Still.My.Beating.Heart
Det här avsnittet visar hur du visar bilder på micro:bit -enheten.
Välj <Files> and make a new program called HEART.
In the Editor, add the two import statements as before:
from microbit import *
from mb_disp import *
Skaffa först mikrobitmodulen från <Fns...> modul <Add-On>
Tryck sedan på [math] Micro:bit... sedan display...
Steg 15
För att visa HEART-bilden på micro:bit-skärmen, använd satsen:
display.show( … )
Detta kommando finns under [math] display…
Med markören fortfarande i slutet på parentesen, välj:
HEART
Under menyn [math] display… och sedan i undermenyn Images.
Obs: Det finns 36 bilder att välja mellan och du kan designa dina egna med var=Image( … ) som finns på undermenyn Display. Se micro:bit- dokumentationen online för information om den här funktionen.
Om du inte har märkt det, för att minska antalet knapptryckningar tillåter menysystemet användandet av uppåt-pil och vänsterpil för att gå så att säga runt bland alternativen, som till exempel:
Välj [math] och sedan uppåt-pil för att komma till display…
Steg 16
Strängen “Image.Heart” ska nu synas i koden som i bilden här bredvid.
Steg 17
Kör programmet med <Run>. Ser du hjärtat, ❤?
Detta program är kvar i micro:bit-enheten tills något annat laddas upp, även efter att programmet är klart. För att återställa den ursprungliga TI-ikonen, så finns en "återställ"-knapp på baksidan av micro:bit- enheten, eller så kan du koppla ur och koppla tillbaka den från räknaren. Eller lämna den kvar inkopplad tills du laddar upp ett annat program.
Steg 18
Gå tillbaks till editor och lägg till ännu ett display.show( )-kommando för att visa ett litet hjärta:
display.show(“Image.HEART_SMALL”, …)
Se till att först hämta display.show( )-kommandot och klistra sedan in strängen “Image.HEART_SMALL”. Du kan hitta detta under samma undermeny för bilder (Image) precis under HEART.
Steg 19
Kör programmet igen. Du kommer se det stora hjärtat en mycket kort stund, följt av det lilla, som ser ut som i bilden.
Steg 20
Göra en loop: För att få de två hjärtan att blinka upprepade gånger, (få hjärtat att slå), så ska vi lägga in de två visningssatserna i en loop. Innan de två displaysatserna så ska vi infoga infogar:
while not escape( ):
♦ ♦
som du hittar under [math] ti_system…
Se till att indentera (göra indrag på) de två displaysatserna så att de ingår i loopen.
Du måste också importera modulen ti_system för att kunna använda denna speciella while-loop. Placera importkommandot överst i koden.
Obs: Indrag är avgörande i Python-program. Python tolkar det så att text med samma indrag hör ihop. Så för att vara en del av loopen så måste de rader som ingår i loopen vara indragen en bit. Om de två visningssatserna inte är indragna lika många mellanslag kommer du att se ett syntaxfel. Använd [mellanslag]-tangenten ([alfa] [0]) eller välj <Tools> Indent► för att dra in båda raderna lika mycket.
Indragsmellanrum indikeras i denna editor som ljusgrå diamantsymboler (♦ ♦) för att hjälpa till med korrekt indrag.
Steg 21
Kör ditt program igen och titta på hur hjärtat slår. Tryck på [clear] -tangenten för att avsluta programmet.
Tips: om du någonsin tror att ditt program har fastnat i en oändlig slinga, tryck och håll ned [on] -knappen på din räknare så tvingas programmet till att avslutas. Detta kan hända om du använder while True:. I dessa lektioner undviker det problemet genom att använda enwhile not escape(): loop istället.
Steg 22
För att kontrollera den hjärtfrekvensen, lägg till argumentet delay= och wait=, och justera värdena i dessa två displaykommandon till det som visas här. Kom ihåg att fördröjningsvärdet är i millisekunder.
Obs: några tomma rader har tagits bort från programmet för att hela programmet ska synas.
Ändra båda wait= parametrarna till False för att se hur snabbt hjärtat blinkar. False finns under <a A #>. . Om du sätter wait = True säger åt micro:bit -enheten att slutföra uppgiften innan den går till nästa uppgift (som 'paus' eller 'sleep'). Om du sätter wait = False går den omedelbart till nästa uppgift och ignorerar delay=-värdetÖvning 2: Knappar
Download Teacher/Student DocsDet finns tre delar i den här lektionen:
- Del 1: Undersök knappfunktionerna
- Del 2: Använd en knapp för att generera data
- Del 3: lagra data i en lista med knappar och överför listan till TI-84 Plus CE-T Python Edition:s vanliga räknarläge.
Mål:
- Att läsa av och bearbeta A- och B-knapparna på micro:bit- enheten.
- Att lära sig skillnaden mellan .was och .is
- Att undersöka insamlad data från micro:bit -enheten.
- Att överföra data från Python till TI-84 Plus CE-T Python Edition:s vanliga räknarläge.
Första 2
Först ska vi testa dessa metoder och sedan så ska vi skriva ett Python-program som samlar in data för att sedan analysera det i TI-84 Plus CE-T Python Edion:s vanliga räknarläge.
Steg 1
Del 1: Använda knappar
Starta ett nytt Pythonprogram med namnet KNAPPAR.
Lägg till ti_system-modulen till din kod med hjälp av [math] ti_system…:
from ti_system import *
Från <fns…> Modul välj <add-on> microbit för att lägga till:
from microbit import *
</Add-on></fns…>
Lägg sedan till loopen:
while not escape():
♦ ♦
Denna speciella while-loop finns under [math] ti_system… eller <Fns…> Modul ti_system…
Viktigt: Importen av micro:bit – modulen måste komma efter importen av ti_system-modulen.
Praktiskt tips: Spara den här filen som MBSTART och använd den som en mall för alla andra micro:bit- program. Öppna och spara filen med namnet på ett nytt program!
Steg 2
För att kunna använda micro:bit- knapparna A och B måste du först importera knappmodulen. Placera markören under alla befintliga importsatser överst i koden (på en tom rad).
Tryck på [math] och välj micro:bit…. Välj buttons and touch… Detta infogar importsatsen from mb_butns import *
Den lägger också nya val i menyn <Fns…> Modul (eller [math]) under micro:bit….
Steg 3
För att testa knapp A, lägg till följande if-sats i while-loopen:
♦ ♦if button_a.was_pressed():
♦ ♦ ♦ ♦print("button A")
Obs: if-satsen är indragen för att vara en del av while-loopen och print() -satsen är indraget ännu mer för att vara en del av if-blocket. Kom ihåg att korrekt indrag är mycket viktigt i Python. Fel indrag kan orsaka syntaxfel eller felaktig exekvering av din kod. Notera de ljusgrå romberna (¨¨) som indikerar mellanslag.
Du hittar if under <Fns…> Ctl. Det läggs automatiskt till inledande mellanslag och under det ytterligare indrag för det som ska vara inne i if-satsen
Steg 3b
Villkoret button_a.was_pressed() finns på menyalternativet:
[math] buttons and touch…...
Lägg märke till att det finns undermenyer för knapp A och knapp B överst på skärmen då du öppnat buttons and touch…, om du använder version 2-moduler finns det också en pin_logo -undermeny.
Välj .was_pressed() under knapp-A-menyn.
Kom ihåg att inte ta bort kolon-tecknet i slutet av if-satsen. Du hittar print( ) under <Fns…> I/O
Skriv texten "Knapp A" i print( )-funktionen.
Obs: .is_pressed() kommer också att diskuteras senare.
Steg 4
Kör programmet, <Run>. Det ser ut som att ingenting händer. Tryck och släpp knappen A på micro:bit -enheten. Du kommer att se "Knapp A" visas på räknarens skärm. Varje gång du trycker och släpper knappen visas texten som i denna bild.
Påminnelse: om du tror att ditt program har fastnat i en oändlig slinga, tryck och håll ned [på]-knappen på din räknare för att stoppa programmet.
Tryck på [clear] för att avsluta while-loopen (och programmet) och återgå sedan till Python editorn <Editor>.
Steg 5
Lägg till en annan if-sats, för att testa knapp B, med villkoret button_b.is_pressed(). Du kommer snart att se hur .is_ och .was_ skiljer sig åt.
♦ ♦if button_b.is_pressed():
♦ ♦ ♦ ♦print("Button B")
Tips: återigen, var uppmärksam på indragen.
Steg 6
Kör programmet igen med <Run>. Prova båda knapparna A och B. Prova med att bara klicka på varje knapp respektive trycka och håll ner varje knapp.
Du kommer att se "Knapp B" upprepade gånger så länge knapp B hålls nedtryckt, men inte "Knapp A". Det är skillnad mellan .was_pressed() , där du behöver släppa upp knappen för att programmet ska kunna reagera igen, och .is_pressed() som bara kontrollerar om knappen är nere i samma ögonblick som kommandot utförs.
Obs: om du trycker på knapp B snabbt kan det hända att programmet inte visar knapp B eftersom knappen inte är nere i samma ögonblick som if-satsen bearbetas.
Steg 7
Del 2: Låt oss använda en av knapparna för att simulera ett kast med en sexsidig tärning. När man trycker på knappen A, så ska en variabel tilldelas ett slumpmässigt heltal från 1 till 6. Du kan använda ‘button A was pressed’ eller " button A is pressed’". (Prova båda för att se skillnaden.)
Vi ska visa värdet på tärningen med hjälp av micro:bit- displayen. Prova gärna själv att lösa problemet innan du tittar på vår lösning. Vi kommer att använda det tidigare skrivna programmet och lägga till kod för att simulera tärningskastningen.
Förresten: Kan du avgöra vilket nummer som finns på undersidan av den avbildade tärningen?Steg 8
Lägg till de två raderna som är markerade enligt bilden. Kommandona
From random import * och randint( , )
finns båda under [math] random…
Variabeln kast och argumenten i ♦ ♦ ♦ ♦die = randint(1, 6) skrivs in manuellt. Lägg märke till att satsen är indragen för att vara en del av if-satsen.
Återigen, var försiktig med indragen
Steg 9
Vi har nu lagt till två nya rader enligt markeringarna. Efter att ”tärningskastet” har gett oss ett utfall så ska vi visa det med micro:bit- enhetens display.
För att kunna använda micro:bit -displayfunktionerna, måste du importera displaymodulen (den översta av de markerade raderna ). Du hittar det under [math] micro:bit….
Lägg sedan till raden
♦ ♦ ♦ ♦display.show(die)
nedanför kast=- satsen för att visa tärningens värde på micro:bit -enheten.
Displayfunktionerna för micro:bit- enheten finns under [math] display...
Kör programmet igen. När du trycker på knapp A ser du "Knapp A" på den räknarens skärm och tärningsvärdet på micro:bit- displayen. Oftast ändras värdet, men inte varje gång. Ibland är det nya slumpvärdet detsamma som det förra, precis som att en tärning kan få samma utfall flera gånger i rad. Detta eftersom kasten är oberoende händelser.
Steg 10
Del 3: Att samla in data: Att kasta en tärningarna med en knapptryckning kan vara nog så nyttig, men för vidare undersökningar så skulle det vara bra att lagra alla dessa värden så att du kan tolka data: vilket nummer förekommer oftast? Vad är medeltalet? och så vidare.
I nästa steg kommer du att lägga till rader till programmet för att:
- Skapa en tom lista
- Lägg till (.append) tärningsvärdet till listan
- Föra över listan från Python till TI-84 Plus CE-systemet för analys
Steg 11
Börja med att lägga till en tom lista. Raden för detta ska läggas till i början av programmet, just före while-loopen:
kasten = [ ]
Variabelnamnet, kasten, skrivs först. Hakparenteserna finns på knappsatsen, och under <a A #>, under [list] ([2nd] [stat] samt under <Fns…> List.
Efter att tärningsvärdet har bestämts läggs det till i listan med satsen
kasten.append(kast)
Du hittar .append() under <Fns…> List. Append betyder lägg till, och kommandot lägger till ett värde i slutet av en lista.
Steg 11b
I slutet av programmet, efter while-loopen är slut, så ska vi överföra listan till en TI-84-lista:
store_list(”KST”, kasten)
Du hitt store_list-funktionen under [math] ti_system...
Observera att denna sats inte ska vara indragen eftersom den inte ska vara inne i while-loopen, utan den ska bara exekveras (köras) en gång i slutet av programmet efter det att [clear] trycks in. Denna funktion lagrar Python-listan som i CE-listan KST. CE-listans namn måste vara i stora bokstäver och bestå av färre än 6 tecken.
**Återigen, var uppmärksam på indragen, speciellt store_list() som inte ska vara indragen alls så att den inte är en del av while-loopen.
Notera: Vi har lagt till delay= och wait= i display.show( )-kommandot såsom förklarades i föregående avsitt.
Obs: Du kan behöva lägga till ett sleep(100)-kommando i while-loopen (precis före if-satsen) om programmet inte reagerar på knapptryckningar på knapp A.Steg 12
Knapp B används inte (ännu). Kan du använda knapp B för något speciellt här?
I det program du har nu så
- om du använder .was_pressed och trycker ner och släpper upp knappen A så får du ett kast per tryckning (Du bör se 'knapp A' på räknarens skärm och siffror på micro:bit-displayen).
- om du i stället använder .is_pressed och håller ner knappen A så sker automatiskt många kast så länge knappen är nedtryckt.
Tryck på [clear] för att avsluta while-slingan. Ditt Pythonprogram har NU en lista som heter kasten och nu har din TI-84 CE också en lista som heter KST. Detta är två separata listor i två separata miljöer, men med samma innehåll.
Avsluta Python och ställ in ett [stat plot]-histogram för KST. Du kan också utföra en 1-var Stats-analys. Ser du ett mönster? Prova fler kast*.
*Obs: på grund av minnesbegränsningar är funktionen store_list( ) begränsad till listor med max 100 element.
Övning 3: Mäta ljusstyrka
Download Teacher/Student DocsI den här lektionen kommer du att använda micro:bit -enheten som en ljussensor och lagra inhämtad data i grafräknarens lista för vidare analys.
Mål:
- Att använda micro:bit -enheten som en ljussensor
- Att överföra data från Python till TI-84 Plus CE-T
- Att analysera data insamlad från micro:bit -enheten
Steg 1
Micro:bit -enheten kan läsa av ljusstyrka med hjälp av displayens lysdioder. Ja, displayens lysdioder kan inte bara generera ljus utan också användas som ljussensorer.
Steg 2
Skapa ett nytt program med namnet LJUS, och lägg till de importer som du ser i figuren, samt den slags while-loop som vi använt förut.
Steg 3
3. Lägg till en importsats högst upp för att komma åt micro:bit- enhetens display-meny :
from mb_disp import *
Lägg till följande tilldelning i while-loopen:
♦ ♦b = display.read_light_level()
Variabelnamnet i står här för intensitet. Skriv i och hämta
=.read_light_level() from [math] Display…
Lägg till en print-sats för att se vad för värde vi har mätt:
♦ ♦print(“b = “, b)
Steg 4
Kör programmet och rikta micro:bit-enhetens LED-sida mot en ljuskälla. Det spelar ingen roll om något visas på displayen. Flytta micro:bit- enheten mot och bort från ljuskällan och observera de ändrade värdena på TI-84-skärmen. Du bör se värden som varierar mellan 0 och 255.
OBS: om du inte ser ändrade värden som i den här bilden, lägg till en sleep(100)-sats i loopen för att sakta ner loopen.
Som du förmodligen förväntar dig, så ju längre bort från ljuskällan, desto lägre ljusnivåvärde.
Nu kommer vi att lägga till kod till programmet för att samla in ljusnivådata. Sedan ska vi skapa ett spridningsdiagram av ljusstyrka kontra tid.
Tryck på [clear] för att avsluta programmet och gå tillbaka till editorn, <Editor>.
Steg 5
Skapa två tomma listor på raderna innan din while loop:
tider = [ ]
ljusi = [ ]
Hakparenteserna finns på knappsatsen, och under <a A #>, under [list] ([2nd] [stat] samt under <Fns…> List.
Du kan använda kortare variabelnamn för att spara in på skrivandet (som td och li).
Lägg också till en variabel för att räkna tid precis innan while-loopen, och sätt dess värde till 0.
t = 0
Undvik att använda ordet "tid" som en variabel eftersom det finns en tidsmodul. Det är en god praxis att använda listnamn i plural, såsom tider, eftersom de innehåller många värden.
Steg 6
I loop-satsen, efter print-satsen, lägg till en sats för att öka tidsvariabeln, t. Vi kommer att använda ett tidsintervall på en sekund mellan ljusavläsningarna, så använd:
♦ ♦t = t + 1
Notera: i Python kan du också skriva detta som: t+=1
Steg 7
Lägg till värdena för t och i till deras respektive listor med hjälp av raderna
♦ ♦tider.append(t)
♦ ♦ljusi.append(i)
Du hittar .append( ) under <Fns…> List. Du kan sedan skriva in variabelnamnen.
Dessa rader lägger till det aktuella i-värdet (ljusintensiteten, ljusstyrkan) och tiden, t, i slutet av respektive lista.
Steg 8
För att reglera tiden mellan mätningarna ska vi lägga till en 1 s lång paus. Tekniskt sett blir det lite längre än en sekund, eftersom raderna innan tar lite tid, men skillnaden blir här försumbar. Lägg till
♦ ♦sleep(1000)
efter de två .append-raderna. Detta pausar datainsamlingen i en sekund mellan varje mätning.
Kommandot sleep( ) ingår i mikrobitmodulen och den är modifierad för att använda millisekunder istället för i sekunder.
Steg 9
Efter while-loopen ska vi lägga till två rader där vi lagrar de två Python-listorna i grafräknarens listor med hjälp av store_list( ) som finns under [math] ti_system…
TI-84-listnamnen (argumenten inom citattecken, " ") måste bestå av stora bokstäver och som mest fem tecken. Vi använder namnen TIDER och LJUSI för dessa listor. Det andra argumentet i store_list( , ) är namnet på den Python-listan som ska lagras.
Steg 10
Kör programmet. Börja med micro:bit-enheten nära din ljuskälla. En exponerad glödlampa eller en smartphone-lampa kan funger bra. Flytta långsamt men stadigt micro:bit- enheten bort från ljuskällan med konstant hastighet tills ljusstyrkan är mindre än 10.
Tryck på [clear] för att avsluta programmet.
Upprepa processen tills du känner att du kan har "bra" data. I figuren visas exempel på insamlat data med hjälp av TI-84 Plus CE-T Stat Editor.
Obs: Det kan vara svårt att få bra data. Det är svårt att hålla en konstant hastighet, dessutom är det svårt att få en rent punktformig ljuskälla. En hel del ljus reflekteras från omgivningen och det har en tendens att ge mer linjärt data en det teoretiskt omvänt kvadratiska.
Steg 11
Du kan nu gå over till räknardelen och ställa in och visa ett spridningsdiagram over insamlat data (TIDER kontra LJUSI).
Använd sedan din grafräknare för att hitta en funktion som passar dina data bäst. Vilken princip från fysiken ska i princip ge grafens form?
En applikation: Att kasta tärningar
Download Teacher/Student DocsI den här applikationen kommer du att skriva ett program för att samla in data med hjälp av micro:bit- enheten och köra programmet samtidigt som du observerar ett punktdiagram växa i ett graffönster med hjälp av ti_plotlib.
Mål:
- Att skriva ett datainsamlingsprogram.
- Att skapa en dynamisk graf som ändrar sig allteftersom programmet körs.
Steg 1
I denna applikation ska du använda i stort sett alla de mikro:bit- färdigheterna du lärt dig i de tidigare övningarna. Vi ska skriva ett program som använder en knapp för att samla in lite data, sedan visa dessa data på micro:bit-kortet samt visa ett växande diagram över distributionen av insamlad data och slutligen ska vi lagra listorna som grafräknar -listor för vidare analys.
Steg 2
Vi ska få micro:bit -kortet att fungera som att kasta två tärningar och visa de två utfallen, ett efter ett. Grafräknaren ska sedan visa ett växande punktdiagram av summorna som beräknats. Vi ska skriva ett program som simulera tärningskasten och samlar in data. I slutet av programmet ska vi lagra data i CE-listor för vidare studier och analys på räknaren.
Så låt oss börja…
Steg 3
Starta ett nytt program och namnge det TARNINGAR.
Du kommer att behöva ett antal Python-verktyg för detta program så det finns en hel del importer som behöver göras:
- ti_system för loopen while not escape( )
- random för slumptalsgenerering, randint( , )
- ti_plotlib för the Pythongrafik
- microbit för micro:bit- enheten i sig själv (under <Fns..> Modules <Add-On>)
- mb_disp för micro:bit displayen (under [math] micro:bit.. …)
- mb_butns för micro:bit -knappar (under
- [math] micro:bit.. …)
Tips: när du utvecklar ett program från kommer du att upptäcka att du behöver fler importsatser än du först trodde. Det går bra att gå tillbaka och lägga till dem efter behov.
Steg 4
Vi ska använd knapp A för att ”kasta” tärningarna och knapp B för att återställa datainsamlingen för att börja om från början. Det kommer då att vara bekvämt att ha en "setup"-funktion som kan användas i olika delar av programmet för att ställa in räknarens grafikfönster.
Starta din kod med en def setup( ): funktion.
Steg 5
Den här funktionen utför inställningskommandona för plottning som indikeras av.plt-prefixet. Du hittar dessa kommandon under [math] ti_plotlib.
Alla dessa satser är indragna för att vara en del av funktionen.
Kom ihåg att ordningen på dessa inställningskommandon är viktig och att de ska användas i den ordning som de visas på menyn.
Färgsatsen finns under Draw-menyn. Vi valde svarta axlar och lila prickar.
Färgvärden är mellan 0 (ingen färg) och 255 (maximal färgintensitet). I den sista raden anger vi hur mycket rött vi ska ha, =255, hur mycket grönt, =0, och hur mycket blått vi ska ha =155. Det ger en ljuslila färg, medans 0,0,0 ger en svart färg.
Steg 6
Skapa två listor:
summor=[0]*13
Listan utfall innehåller alla möjliga utfall. Däremot är utfall[0] och utfall[1] inte möjliga summor utan fungerar som "platshållare" så att indexen matchar elementinnehållet. När summan av tärningarna är 2 kommer vi att öka summor[2]. (Vi skulle också ha kunnat subtrahera två från resultaten och börja utfall med 2.)
Obs: För att skapa ett spridningsdiagram behöver vi två listor där utfall är den första listan och summor är den andra listan.Sedan anropar vi funktionen setup( ) som vi definierade tidigare för att ställa in grafräknarens skärm för plottning.
Steg 7
Börja med det vanliga
while not escape():
♦ ♦ if button_a.is_pressed():
Varför valde vi .is_ istället för .was_? Tänk på skillnaden, eller bara vänta och se…
Ett trycka på knappen A ska:
- kasta” de två ”tärningarna”
- visar utfallen på micro:bit – displayen
- beräkna summan av utfallen
- öka den motsvarande räknaren med ett
- producera ett spridningsdiagram som i sin tur skapar ett stapeldiagram
Försök gärna att skriva koden för knapp A innan du går vidare.
Steg 8
I figuren visas det mesta av koden för knapp A. En sak som saknas är att visa de två tärningarnas resultat på micro:bit- displayen. Det lämnar vi som ett projekt för dig.
Tips: Kommandot
display.show(<variable>, delay=400, wait=True)
visar värdet förSteg 9
Du kan testa ditt program som det är skrivet hittills - även utan visa resultaten på display. Det ska visa ett spridningsdiagram på räknarens skärm när håller ner knappen A . Det är därför vi valde .is_.
Om vi använt .was_ skulle vi behöva klicka och släppa knappen A för att göra ett kast.
Stapeldiagrammet skapas genom att rita ut successiva spridningsdiagram över utfall, summa – par. De gamla punkterna finns kvar, och detta skapar då ett stapeldiagram.
Tryck på [clear] för att avsluta programmet.
Steg 10
Det finns ytterligare ett par saker vi ska lägga till (utöver att få micro:bit- kortet att visa tärningarnas värden under knapp A):
- Knapp B ska fungera som en "återställningsknapp" som rensar skärmen genom att anropa setup( ) och sätta summalistans alla värden till noll igen. Vi lägger till en if-sats med två rader kod som utför detta. Lägg märke till användningen av setup()-funktionen igen.
- De två listorna ska exporteras till CE för vidare undersökning. Du behöver två store_list( , )-satser (som inte är klara i koden som visas), en för varje lista i programmet. Lägg till de som behövs. Tänk på CE-namnens längd, och att de måste skrivas med stora bokstäver.
Var uppmärksam på indragen.
Obs: vi använde .was_ istället för .is_ för knapp B. Varför?
Dessutom, det finns ett par irriterande buggar i programmet. Om man tittar noggrant på den graf du får, i kolumnen motsvarande första summan som blev, så saknas första pricken. Varför? Hur kan man lösa det? För det andra ser man två punkter motsvarande de icke existerande utfallen 0 och 1, och det vore bra om de inte var där. Hur löser vi det?
I grafen som visas så är detta fixat
Steg 11
Efter att du har lagrat de två listorna genom att trycka på [clear] för att avsluta loopen och programmet, avsluta Python-appen ([2nd ] [quit]) och skapa ett spridningsdiagram av UTF (utfall) och SUM (summor).
- Övning 1
- Övning 2
- Övning 3
- En applikation