namn = in("Skriv ditt namn: ")
skriv(namn)

Skriv ditt namn: Edvard
Edvard

skriv("Hej, Världen!")
töm()
skriv("Hej")

Hej

skriv(typ("Hej"))
skriv(typ(1))
skriv(typ([1, 2, 3]))

Sträng
Heltal
Lista

skriv(Sträng(20) + "3")

203

skriv(Heltal("20") + 3)

23

skriv(Bool(0))
skriv(Bool(1))
skriv(Bool("hej"))
skriv(Bool(""))

Falskt
Sant
Sant
Falskt

skriv(Decimal("3.3") + 3)

6.3

skriv(Lista("abc"))

['a', 'b', 'c']

skriv("hej".versal())

HEJ

skriv("Hej".gemen())

hej

skriv("HEJ".ärversal())
skriv("Hej".ärversal())

Sant
Falskt

skriv ("hej".ärgemen())
skriv ("Hej".ärgemen())

Sant
Falskt

skriv(runda(1.2))

1

skriv(runda(8.5673, 3))

8.567

lista = ["a", "b"]
skriv (lista)
lista.till("c")
skriv(lista)

["a", "b"]
["a", "b", "c"]

lista = ["a", "b"]
skriv(lista)
lista.bort(1)
skriv(lista)

["a", "b"]
["a"]

lista = ["a", "b"]
skriv(lista)
lista.infoga(1, "c")
skriv(lista)

["a", "b"]
["a", "c", "b"]

lista = ["a", "b", "c"]
skriv(lista.index("a"))
skriv(lista.index("c"))
skriv(lista.index("b"))

0
2
1

lista = ["a", "c", "b"]
skriv(sortera(lista))

["a", "b", "c"]

lista = [1, 10, 2, 0]
skriv(sortera(lista))

[0, 1, 2, 10]

sträng = "Hej världen"
skriv(sträng.dela())

["Hej", "världen"]

sträng = "1,2,3,4"
skriv(sträng.dela(","))

["1", "2", "3", "4"]

sträng = "1,2,3,4"
skriv(sträng.dela(",", 2))

["1", "2", "3,4"]

lista = ["a", "b", "c"]
skriv("".foga(lista))

abc

lista = ["a", "b", "c"]
skriv(",".foga(lista))

a,b,c

lista = ["a", "b", "c"]
skriv(" hej ".foga(lista))

a hej b hej c

lista = ["a", "c", "b"]
skriv(lista.blanda())
skriv(lista.blanda())

["a", "c", "b"]
["c", "a", "b"]

lexikon = {a: "Ananas", b: "Banan", c: "Citron"}
skriv(lexikon.nycklar())

['a', 'b', 'c']

var = "Haj!"
var = var.ersätt("a", "e")
skriv(var)

Hej!

var = "Hej!"
var = var.ersätt("!", "")
skriv(var)

Hej

skriv(slump(0, 2))
skriv(slump(0, 2))
skriv(slump(0, 2))

2
0
1

val = ["a", "b", "c"]
skriv(slumpval(val))

b

nummer = 2
skriv(nummer.ärnum())

Attributfel (rad 2)

nummer = "2"
skriv(nummer.ärnum())

Sant

nummer = -2
skriv(matte.abs(nummer))

2

skriv(matte.tak(300.72))

3001.0

1 skriv (matte.tak(-23.11))

-23.0

skriv(matte.golv(300.72))

300.0

skriv(matte.golv(-23.11))

-24.0

skriv(matte.fakultet(23))

25852016738884976640000

skriv(matte.sin(3))
skriv(matte.cos(3))
skriv(matte.tan(3))

0.1411200080598672
-0.9899924966004454
-0.1425465430742778

skriv(matte.asin(0.64))
skriv(matte.acos(0.64))
skriv(matte.atan(0.64))

0.694498265626556
0.8762980611683406
0.5693131911006619

skriv(matte.potens(4, 3))

64

skriv(matte.kvadratrot(10))

3.1622776601683795

skriv(matte.log(10))

2.302585092994046

skriv(matte.grader(180))
skriv(matte.radianer(10313.240312354817))

10313.240312354817
180.0

skriv(matte.e())
skriv(matte.pi())

2.718281828459045
3.141592653589793

skriv(tid.epok(x))

1545925769.9618232

skriv(tid.tid())
skriv(tid.tid(1545925769.9618232))

Sat May 9 17:45:59 2020
Thu Dec 27 15:49:29 2018

skriv(tid.datum(2020, 21, 5))
skriv(typ(tid.datum(2020, 21, 5)))

2020-05-09
datum

skriv(tid.nu())
skriv(typ(tid.nu()))

2020-05-09 21:06:31.142564
datum & tid

skriv(tid.idag())

2020-05-09

öppna('min_fil.txt', 'w+') som minFil:
    ...

öppna('min_fil.txt') som minFil:
    skriv(minFil.läs())

öppna("fil.txt", "w+") som fil:
    fil.överför("ny text")

Hej, Världen!
ny text!

var = {a: "alpha", b: "beta", namn: "Edvard"}
skriv(var["a"])
skriv(var["namn"])

alpha
Edvard

var = Sant
om var == Sant:
    skriv("Sant!")

Sant!

var = Falskt
om var == Sant:
    skriv ("Sant!")

var = Sant
om var == Sant:
    skriv("Sant!")
anom var == Falskt:
    skriv("Falskt!")

Falskt!

var = Sant
om var == Sant och längd(var) == 3:
    skriv("Sant!")
annars:
    skriv("Falskt!")

Falskt!

namn = in("Skriv ditt namn: ")
skriv("Hej" + namn om namn != "" annars "Inget namn givet!")

Skriv ditt namn: Jonas
Hej Jonas
Skriv ditt namn:
Inget namn givet!

för i inom området(0,11):
    skriv(i)

0
1
2
3
4
5
6
7
8
9
10

lista = ["a", "b", "c"]

för(sak inom lista):
    skriv (sak)

a
b
c

lista = ["a", "b", "c"]

för index, sak inom numrera(lista):
    skriv (sak)
    skriv (index)

a
0
b
1
c
2

i = 0

medan i < 10:
    skriv (i)
    i += 1

0
1
2
3
4
5
6
7
8
9
10

def addition(num_a, num_b):
    returnera num_a+num_b

skriv(addition(1, 2))

3

def skrivare(text):
    skriv(text)

skrivare("Hej, Världen!")

Hej, Världen!

klass person:
    def __init__(själv, namn, ålder):
        själv.namn = namn
        själv.ålder = ålder

    def åldra(själv):
        själv.ålder = själv.ålder + 1

# En person 
person1 = person("Karl", 25)
skriv(person1.namn)
skriv(person1.ålder)
person1.åldra()
skriv(person.ålder)

# En annan person.
person2 = person("Jonas", 2)
skriv(person2.namn)
skriv(person2.ålder)

Karl
25
26
Jonas
2

försök:
    # Kod som kan kasta felmeddelanden.

var = in("Skriv ett nummer lägre en 5: ")

försök {
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

var = in("Skriv ett nummer lägre en 5: ")

försök:
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

fånga error:
    skriv (error)

Skriv ett nummer lägre en 5: 3
OK!

Skriv ett nummer lägre en 5: 7
För stort!

var = in("Skriv ett nummer lägre en 5: ")

försök:
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

fånga error:
    skriv (error)

slutligen:
    skriv ("Hej då!")

Skriv ett nummer lägre en 5: 3
OK!
Hej då!

Skriv ett nummer lägre en 5: 7
För stort!
Hej då!

def addera(num1, num2):
    returnera num1+num2

def subtrahera(num1, num2):
    returnera num1-num2

importera matematik

skriv(matematik.addera(1, 2))
skriv(matematik.subtrahera(10, 5))

3
5

def bibliotek__enkelt__funktion1(var1):
    return funktion2() + var1

def funktion2():
    return 1+2

utöka bibliotek

skriv(bibliotek.funktion1(3))
skriv (bibliotek.funktion2())

6
Syntaxfel

var => a, b : a + b
skriv(var(1, 2))

3

skriv("Hej "Edvard", hur mår du?")

Hej , hur mår du?

skriv("Hej \"Edvard\", hur mår du?")

Hej "Edvard", hur mår du?

Dokumentation för Enkelt 5.0 Senast uppdaterad 3 Oktober 2020.

---

Funktioner

Skriv()

Skriver data till konsolen.

Hur Skriv() används:

skriv([parametrar])

Längd()

Returnerar längden på data. Längd() kan användas för att få antalet tecken i en sträng, antalet siffror i en variabel eller antalet element i en lista.

Hur Längd() används:

längd([data])

In()

Tar in användarinput från konsolen. In() används för att göra program interaktiva.

Hur In() används:

in([titel])

Exempel

namn = in("Skriv ditt namn: ")
skriv(namn)

Utdata

Skriv ditt namn: Edvard
Edvard

Töm()

Tömmer konsolen. Det kan vara praktiskt om ditt program behöver visa mycket information.

Hur Töm() används:

töm()

Exempel

skriv("Hej, Världen!")
töm()
skriv("Hej")

Utdata

Hej

Typ()

Returnerar vilken datatyp något är.

Hur Typ() används:

typ([data])

Exempel

skriv(typ("Hej"))
skriv(typ(1))
skriv(typ([1, 2, 3]))

Utdata

Sträng
Heltal
Lista

Konvertering av datatyper

Sträng()

Konverterar data till sträng-/textdatatypen.

Hur Sträng() används:

Sträng([data])

Exempel

skriv(Sträng(20) + "3")

Utdata

203

Heltal()

Konverterar data till heltals-/nummerdatatypen.

Hur Heltal() används:

Heltal([data])

Exempel

skriv(Heltal("20") + 3)

Utdata

23

Bool()

Konverterar data till booleskdatatypen

Hur Bool() används:

Bool([data])

Exempel

skriv(Bool(0))
skriv(Bool(1))
skriv(Bool("hej"))
skriv(Bool(""))

Utdata

Falskt
Sant
Sant
Falskt

Decimal()

Konverterar data till decimaldatatypen

Hur Decimal() används:

Decimal([data])

Exempel

skriv(Decimal("3.3") + 3)

Utdata

6.3

Lista()

Konverterar data till listdatatypen, och/eller skapar listor.

Hur Lista() används:

Lista([sekvens])

Exempel

skriv(Lista("abc"))

Utdata

['a', 'b', 'c']

Lexikon()

Konverterar data till lexikondatatypen, och/eller skapar lexikon.

Hur Lexikon() används:

Lexikon([parametrar])

Versaler & Gemener

Versal()

Konverterar text till versaler (stora bokstäver).

Hur Versal() används:

[sträng].versal()

Exempel

skriv("hej".versal())

Utdata

HEJ

Gemen()

Konverterar text till gemener (småbokstäver).

Hur Gemen() används:

[sträng].genen()

Exempel

skriv("Hej".gemen())

Utdata

hej

Ärversal()

Returnerar sant om en sträng är endast versaler.

Hur Ärversal() används:

[sträng].ärversal()

Exempel

skriv("HEJ".ärversal())
skriv("Hej".ärversal())

Utdata

Sant
Falskt

Ärgemen()

Returnerar sant om en sträng är endast gemener.

Hur Ärgemen() används:

[sträng].ärgemen()

Exempel

skriv ("hej".ärgemen())
skriv ("Hej".ärgemen())

Utdata

Sant
Falskt

Runda()

Avrundar decimaltal till närmaste heltal. Du kan också avrunda till ett decimaltal genom att specificera antalet decimaler.

Hur Runda() används:

runda([decimaltal], [antalet decimaler])

Exempel 1

skriv(runda(1.2))

Utdata

1

Exempel 2

skriv(runda(8.5673, 3))

Utdata

8.567

Funktioner för listor

Lista()

/i/ Se Konvertering av datatyper -> Lista().

Till()

Lägger till element i listor.

Hur Till() används:

[lista].till([data])

Exempel

lista = ["a", "b"]
skriv (lista)
lista.till("c")
skriv(lista)

Utdata

["a", "b"]
["a", "b", "c"]

Bort()

Tar bort element från listor.

Hur Bort() används:

[lista].bort([indexnummer])

Exempel

lista = ["a", "b"]
skriv(lista)
lista.bort(1)
skriv(lista)

Utdata

["a", "b"]
["a"]

Infoga()

Infogar element till specifika platser i listor.

Hur Infoga() används:

[lista].infoga([index], [element])

Exempel

lista = ["a", "b"]
skriv(lista)
lista.infoga(1, "c")
skriv(lista)

Utdata

["a", "b"]
["a", "c", "b"]

Index()

Returnerar indexnumret för ett element i en lista.

Hur Index() används:

[lista].index([element])

Exempel

lista = ["a", "b", "c"]
skriv(lista.index("a"))
skriv(lista.index("c"))
skriv(lista.index("b"))

Utdata

0
2
1

Sortera()

Sorterar listor (a-ö/0-9).

Hur Sortera() används:

sortera([lista])

Exempel 1

lista = ["a", "c", "b"]
skriv(sortera(lista))

Utdata

["a", "b", "c"]

Exempel 2

lista = [1, 10, 2, 0]
skriv(sortera(lista))

Utdata

[0, 1, 2, 10]

Dela()

Konvertera strängar till en listor. Du kan specificera separatorn (förvalet är blanksteg), och hur lång du vill att listan ska vara.

Hur Dela() används:

[sträng].dela([separator], [längd])

Exempel 1

sträng = "Hej världen"
skriv(sträng.dela())

Utdata

["Hej", "världen"]

Exempel 2

sträng = "1,2,3,4"
skriv(sträng.dela(","))

Utdata

["1", "2", "3", "4"]

Exempel 3

sträng = "1,2,3,4"
skriv(sträng.dela(",", 2))

Utdata

["1", "2", "3,4"]

Foga()

Motsatsen till Dela(). Fogar ihop listor till strängar.

Hur Foga() används:

[separator].foga([lista])

Exempel 1

lista = ["a", "b", "c"]
skriv("".foga(lista))

Utdata

abc

Exempel 2

lista = ["a", "b", "c"]
skriv(",".foga(lista))

Utdata

a,b,c

Exempel 3

lista = ["a", "b", "c"]
skriv(" hej ".foga(lista))

Utdata

a hej b hej c

Blanda

Blandar en lista slumpmässigt.

Hur Blanda() används:

[lista].blanda()

Exempel

lista = ["a", "c", "b"]
skriv(lista.blanda())
skriv(lista.blanda())

Utdata

["a", "c", "b"]
["c", "a", "b"]

Funktioner för lexikon

Lexikon()

/i/ Se Konvertering av datatyper -> Lexikon().

Nycklar()

Returnera en lista med alla nycklar i ett lexikon.

Hur används Nycklar()

[lexikon].nycklar()

Exempel

lexikon = {a: "Ananas", b: "Banan", c: "Citron"}
skriv(lexikon.nycklar())

Utdata

['a', 'b', 'c']

Ersätt()

Ersätta tecken och/eller strängdelar i strängar.

Hur Ersätt() används:

[sträng].ersätt([tecken], [ersättning])

Exempel 1

var = "Haj!"
var = var.ersätt("a", "e")
skriv(var)

Utdata

Hej!

Exempel 2

var = "Hej!"
var = var.ersätt("!", "")
skriv(var)

Utdata

Hej

Slump

Slump()

Genererar slumpmässiga heltal.

Hur Slump() används:

slump([start], [slut])

Exempel

skriv(slump(0, 2))
skriv(slump(0, 2))
skriv(slump(0, 2))

Utdata

2
0
1

Slumpval()

Genererar ett slumpmässigt val från en lista eller ett lexikon.

Hur Slumpval() används:

slumpval([lista eller lexikon])

Exempel

val = ["a", "b", "c"]
skriv(slumpval(val))

Utdata

b

Blanda()

/i/ Se Funktioner för listor -> Blanda().

Ärnum()

Kollar om en sträng är en siffra.

Hur Ärnum() används:

[data].ärnum()

Exempel 1

nummer = 2
skriv(nummer.ärnum())

Utdata

Attributfel (rad 2)

Exempel 2

nummer = "2"
skriv(nummer.ärnum())

Utdata

Sant

Matte

Matte är en av Enkelts inbyggda utökningsbibliotek. Matte innehåller olika funktioner realterat till matematik och uträkningar.

Eftersom Matte är ett utökningsbibliotek behöver man specifiera .matte före varje funktionsanrop.

Hur Matte används:

matte.[funktion]

Abs()

Returnerar det absoluta värdet av ett tal. Talet kan vara ett heltal eller decimaltal.

Hur Abs() används:

matte.abs([tal])

Exempel 1

nummer = -2
skriv(matte.abs(nummer))

Utdata

2

Tak()

Returnerar det minsta heltalet som inte är mindre än det tal som matats in.

Hur Tak() används:

matte.tak([tal])

Exempel 1

skriv(matte.tak(300.72))

Utdata

3001.0

Exempel 2

1 skriv (matte.tak(-23.11))

Utdata

-23.0

Golv()

Returnerar det största heltalet som inte är större än det tal som matats in.

Hur Golv() används:

matte.golv([tal])

Exempel 1

skriv(matte.golv(300.72))

Utdata

300.0

Exempel 2

skriv(matte.golv(-23.11))

Utdata

-24.0

Fakultet()

Returnerar fakulteten för det tal som matas in. För ett heltal större än noll är fakulteten lika med produkten av alla heltal från 1 upp till och med talet själv.

Hur Fakultet() används:

matte.fakultet([tal])

Exempel 1

skriv(matte.fakultet(23))

Utdata

25852016738884976640000

Sin(), Cos(), & Tan()

Sin()-funktionen returnerar sinus för det tal som matas in. Cos()-funktionen returnerar cosinus för det tal som matas in. Tan()-funktionen returnerar tangens för det tal som matas in.

Hur Sin(), Cos() & Tan() används:

matte.sin([tal])

matte.cos([tal])

matte.tan([tal])

Exempel

skriv(matte.sin(3))
skriv(matte.cos(3))
skriv(matte.tan(3))

Utdata

0.1411200080598672
-0.9899924966004454
-0.1425465430742778

Asin(), Acos(), & Atan()

Asin() returnerar bågsinus för det tal som matas in.

Acos() returnerar bågcosinus för det tal som matas in.

Atan() returnerar bågtangens för det tal som matas in.

Hur Asin(), Acos() & Atan() används:

matte.asin([tal]) matte.acos([tal]) matte.atan([tal])

Exempel

skriv(matte.asin(0.64))
skriv(matte.acos(0.64))
skriv(matte.atan(0.64))

Utdata

0.694498265626556
0.8762980611683406
0.5693131911006619

Potens()

Returnerar det första talet upphöjt till det andra talet.

Hur Potens() används:

matte.potens([tal], [uphöjt till])

Exempel

skriv(matte.potens(4, 3))

Utdata

64

Kvadratrot()

Ger kvadratroten av ett tal.

Hur Kvadratrot() används:

matte.kvadratrot([tal])

Exempel

skriv(matte.kvadratrot(10))

Utdata

3.1622776601683795

Log()

Returnerar logaritmen för ett tal. Logaritmen för ett tal a är den exponent x till vilket ett givet tal, med basen b, måste upphöjas för att anta värdet a.

Hur Log() används:

matte.log([tal])

Exempel

skriv(matte.log(10))

Utdata

2.302585092994046

Grader() & Radianer()

Grader()-funktionen konverterar radianer till grader. Radianer()-funktionen konverterar grader till radianer.

Hur Grader() & Radianer() används:

matte.grader([radianer])

matte.radianer([grader])

Exempel

skriv(matte.grader(180))
skriv(matte.radianer(10313.240312354817))

Utdata

10313.240312354817
180.0

E() & Pi()

E() returnerar det matematiska konstanten e.

Pi() returnerar pi.

Hur E() & Pi() används:

matte.e()

matte.pi()

Exempel

skriv(matte.e())
skriv(matte.pi())

Utdata

2.718281828459045
3.141592653589793

Tid

Tid är en av Enkelts inbyggda utökningsbibliotek. Tid innehåller olika funktioner realterat till datum och tid.

Eftersom Tid är ett utökningsbibliotek behöver man specifiera .tid före varje funktionsanrop.

Hur Tid används:

tid.[funktion]

Epok()

Returnerar antalet sekunder sedan 1:a januari 1970 (Unix-epoken).

Hur Epok() används:

tid.epok()

Exempel

skriv(tid.epok(x))

Utdata

1545925769.9618232

Tid()

Returnerar dagens datum och tid. Kan även konvertera epoksekunder till läsbara datum.

Hur Tid() används:

tid.tid()

tid.tid([epoksekunder])

Exempel

skriv(tid.tid())
skriv(tid.tid(1545925769.9618232))

Utdata

Sat May 9 17:45:59 2020
Thu Dec 27 15:49:29 2018

Datum()

Tar in ett årtal en måndag, och en dag, och returnerar ett datumobjekt.

Hur Datum() används:

tid.datum([år], [månad], [dag])

Exempel

skriv(tid.datum(2020, 21, 5))
skriv(typ(tid.datum(2020, 21, 5)))

Utdata

2020-05-09
datum

Nu()

Returnerar ett datum- & tidsobjekt med dagens datum och tid.

Hur Nu() används:

tid.nu()

Exempel

skriv(tid.nu())
skriv(typ(tid.nu()))

Utdata

2020-05-09 21:06:31.142564
datum & tid

Idag()

Returnerar dagens datum i ett datumobjekt.

Hur Idag() används:

tid.idag()

Exempel

skriv(tid.idag())

Utdata

2020-05-09

Arbete med filer

/i/ Går inte att använda i webbredigeraren

Öppna()

Öppnar textfiler. Funktionen tar in två argument: ett filnamn/sökväg och ett öppningsläge som kan vara 'r' (read) för att läsa, 'w' (write) för överförning av text, eller 'a' (append) för att överföra text utan att skriva över det gamla innehållet. Man kan också lägga till ett '+' för 'w' för att skapa filen om den inte hittas. 'r+' öppnar filen för både läsning och överförning.

Hur Öppna() används:

öppna([fil], [läge]) som [variabel för filen] {}

Exempel

öppna('min_fil.txt', 'w+') som minFil:
    ...

Läs()

Läser innehållet från öppna texfiler.

Hur Läs() används:

[fil].läs()

Exempel

öppna('min_fil.txt') som minFil:
    skriv(minFil.läs())

Överför()

Överför/skriver text till öppna textfiler.

Hur Överför() används:

[fil].överför([data])

Exempel

öppna("fil.txt", "w+") som fil:
    fil.överför("ny text")

Utdata

Hej, Världen!
ny text!

---

Variabler

Sträng

Text-/strängvariabler deklareras med enkla eller dubbla citattecken. En sträng kan innehålla bokstäver, tecken och siffror.

Hur strängvariabler används:

variabel = "text"

Heltal

Heltalsvariabler innehåller heltal.

Hur heltalsvariabler används:

variabel = 2

Lista

Listor är en variabeldatatyp där du kan spara flera värden i samma variabel och under samma variabelnamn. Listor deklareras med fyrkantiga parenteser, alltså [ och ]. Saker i listor kallas för element och de separeras med kommatecken.

Hur listor används:

variabel = ["a", 1]

Lexikon

Lexikon är en variabeldatatyp som fungera lite som listor men med den skillnaden att istället för att ge alla element en indexnummer har de en nyckel. Lexikon deklareras med krulliga parenteser, alltså { och }. Varje element beskrivs först med en nyckel följt av ett kolon och sedan ett värde för elementet. Nycklar kan skrivas med eller utan citationstecken runt sig.

Hur lexikon används:

variabel = {a: "alpha", b: "beta", namn: "Edvard"}

Exempel

var = {a: "alpha", b: "beta", namn: "Edvard"}
skriv(var["a"])
skriv(var["namn"])

Utdata

alpha
Edvard

Boolesk

Boolesk-variabler är antingen sanna eller falska.

Hur booleskvariabler används:

variabel = Sant

variabel = Falskt

---

Kontroll

Villkorssatser

Om()

Kör koden innom satsen om uttrycket stämmer.

Hur Om() används:

om([uttryck])

Exempel 1

var = Sant
om var == Sant:
    skriv("Sant!")

Utdata

Sant!

Exempel 2

var = Falskt
om var == Sant:
    skriv ("Sant!")

Utdata

Anom()

Kör koden inom satsen om uttrycket stämmer och det föregående uttrycket inte stämmer.

Hur Anom() används:

anom([uttryck]):

Exempel

var = Sant
om var == Sant:
    skriv("Sant!")
anom var == Falskt:
    skriv("Falskt!")

Utdata

Falskt!

Annars

Kör koden inom satsen om alla tidigare Om()- & Anom()-uttryck inte stämmer.

Hur annars används:

annars:

Exempel /i/ Du kan använda dig av nyckelorden: och & eller, i om- och anom-uttryck.

var = Sant
om var == Sant och längd(var) == 3:
    skriv("Sant!")
annars:
    skriv("Falskt!")

Utdata

Falskt!

Ternära operatorer

Ett sätt att använda om- och annars-uttryck på en rad.

Hur ternära opertorer används:

[stämmer] om [uttryck] annars [stämmer inte]

Exempel

Skriv en hälsning om ett namn givits.

namn = in("Skriv ditt namn: ")
skriv("Hej" + namn om namn != "" annars "Inget namn givet!")

Utdata

Skriv ditt namn: Jonas
Hej Jonas
Skriv ditt namn:
Inget namn givet!

Loopar

Loopar behövs om man ska göra något flera gånger. Enkelt har två typer av loopar: för-loopar och medan-loopar.

För-loop

En för loop används för att "loopa över" något. Man kan b.la. loopa igenom en lista eller räkna upp (eller) ner till ett tal.

Exempel 1

Här är en för loop som skriver ut siffrorna 0 till 10. I för-loopen har man en variabel som ändras, man brukar ofta kalla den variabeln för i.

för i inom området(0,11):
    skriv(i)

Utdata

0
1
2
3
4
5
6
7
8
9
10

Lägg märke till att om man du vill loopa upp till 10 måste du skriva området(0,11) om man istället skulle skriva området(0,10) skulle loopen bara räkna till 9!

/i/ Märker du att man kan läsa vad loopen gör så här: för i inom området 0 till 11, skriv i.

Exempel 2

Här är en för-loop som loopar genom alla element i en lista.

lista = ["a", "b", "c"]

för(sak inom lista):
    skriv (sak)

Utdata

a
b
c

Exempel 3

Här är en för-loop som loopar genom alla element i en lista samt numrerar elementen.

lista = ["a", "b", "c"]

för index, sak inom numrera(lista):
    skriv (sak)
    skriv (index)

Utdata

a
0
b
1
c
2

Medan-loop

Medan-loopen kör koden inom sig så länge som ett uttryck stämmer.

Exempel 1

Här är en medan-loop som räknar upp siffrorna 0 till 10.

i = 0

medan i < 10:
    skriv (i)
    i += 1

Utdata

0
1
2
3
4
5
6
7
8
9
10

/i/ Lägg märke till att man här också kan läsa loopen rakt: medan i är mindre än 10, skriv i.

Nyckelord

Det finns två nyckelord du kan använda dig av i loopar. Dessa är:

• Bryt
• Fortsätt

Bryt

Används då du vill bryta dig ut från en loop. Då du skriver bryt inuti en loop så avslutas loopen och programmet fortsätter som vanligt utanför/efter loopen.

Fortsätt

Fortsätt är nästan motsatsen till bryt, loopen fortsätter men hoppar över resten av loopen. Fortsätt är något man inte behöver använda väldigt ofta och för det mesta kan man skriva om loopen så att fortsätt inte behövs.

Funktioner

En funktion är som en maskin som tar in argument/parametrar. Argument kan vara vilken datatyp som helst (sträng, heltal, boolesk, osv.). Funktionen använder sedan dessa argument och antingen returnerar funktionen något eller så utför den sin uppgift utan att returnera något.

När man vill returnera något så använder man nyckelordet returnera + det man vill returnera: returnera [något att returnera]

Hur funktioner används:

def funktionsnamn([argument]):

Exempel 1

Här är en funktion som adderar ihop två nummer.

def addition(num_a, num_b):
    returnera num_a+num_b

skriv(addition(1, 2))

Utdata

3

Exempel 2

Här är en funktion som skriver ut text.

def skrivare(text):
    skriv(text)

skrivare("Hej, Världen!")

Utdata

Hej, Världen!

Klasser

Klasser är ett lite mer komplicerat koncept inom programmering men de är väldigt användbara och öppnar upp en helt ny värld av möjlighetet med så kallad Objektorienterad programmering. En klass är egentligen ett block med funktioner som är relaterade. När man talar om klasser talar man ofta om objekt och de är också i den kontexten som den här dokumentationen kommer att följa. Ett objekt är en samling funktioner och värden som kan användas som en sorts ritning (exempel följer:)

Hur Klasser används:

klass [namn]:

Exempel 1

Ett objekt som representerar en person

klass person:
    def __init__(själv, namn, ålder):
        själv.namn = namn
        själv.ålder = ålder

    def åldra(själv):
        själv.ålder = själv.ålder + 1

# En person 
person1 = person("Karl", 25)
skriv(person1.namn)
skriv(person1.ålder)
person1.åldra()
skriv(person.ålder)

# En annan person.
person2 = person("Jonas", 2)
skriv(person2.namn)
skriv(person2.ålder)

Utdata

Karl
25
26
Jonas
2

/i/ OBS! Märkt att funktioner i klasser altid tar själv som första argument!

Felhantering

Felhantering gå ut på att fånga och kasta felmeddelanden i sitt program.

Försök

Används då du inte kan vara säker på att något kommer att fungera, d.v.s. att något inte kommer orsaka ett felmeddelande.

Hur försök används:

försök:

Exempel

försök:
    # Kod som kan kasta felmeddelanden.

Kasta()

Med Kasta()-funktionen kan du skapa ett felmeddelande som kan fångas i fånga.

Hur Kasta() används:

kasta([felmeddelande])

Exempel

var = in("Skriv ett nummer lägre en 5: ")

försök {
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

Fånga

Med Fånga() fångar du felmeddelanden.

Hur Fånga() används:

fånga [variabelnamn för felmeddelander]:

Exempel

var = in("Skriv ett nummer lägre en 5: ")

försök:
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

fånga error:
    skriv (error)

Utdata (variation 1)

Skriv ett nummer lägre en 5: 3
OK!

Utdata (variation 2)

Skriv ett nummer lägre en 5: 7
För stort!

Slutligen

Slutligen används då du avslutningsvis vill göra något (exempel snart). Slutligen används oftast i kontext med felhantering med kan också används med b.la. för-loopar.

Hur slutligen används:

slutligen:

Exempel

var = in("Skriv ett nummer lägre en 5: ")

försök:
    om var < 5:
        skriv ("OK!")
    annars:
        kasta("För stort!")

fånga error:
    skriv (error)

slutligen:
    skriv ("Hej då!")

Utdata (variation 1)

Skriv ett nummer lägre en 5: 3
OK!
Hej då!

Utdata (variation 2)

Skriv ett nummer lägre en 5: 7
För stort!
Hej då!

Som du kan se så körs koden innuti slutligen alltid.

---

Nyckelord

Här är en lista och en kort beskrivining för alla nyckelord i språket.

Hur Nyckelord används:

[nykelord]

Nyckelord | Beskrivning --- | --- Falskt | Boolesk, sant Sant | Boolesk, sant. annars | Används efter Om() och/eller Anom(). Körs bara om Om() -uttrycket och/eller Anom() -uttrycket inte stämmer/är falskt. bryt | Används i loopar. Bryter ut ur loopen och fortsätter programmet som vanligt. Används främst i medan-loopar. def | Kort för: definiera. Används för att definiera/deklarera funktioner. Funktioner deklareras alltid högst upp i koden. fortsätt | Används i loopar. Hoppar över resten av loopen och går vidare till början. inom | Används i för-loopar: för i, inom området(0,11) {}. mattee | Används för att få siffran e. mattepi | Används för att få pi. inte | Används i Om() och Anom() "svänger om" en boolesk. returnera | Används i funktioner när man ska returnera ett värde. och | och kan användas i om/anom uttryck samt i medan-loopar. Och gör att man kan kolla om två uttryck stämmer. eller | eller kan användas i om/anom uttryck samt i medan-loopar. Och gör att man kan kolla om ett eller ett annat uttryck stämmer. global | infoga en global variabel. passera | ignorera resten.

---

Operatorer

Här är en lista och en kort beskrivining för alla operatorer i språket.

Hur Operatorer används:

[operator]

Operator | Beskrivning --- | ---

• | Addition och sammanfogning, plus.
• | Subtraktion, minus.
• | Multiplikation, gånger. / | Division, snedstreck. % | Modulo, procent, procenttecken. < | Mindre än.

| Större än. = | Lika med. == | Lika med i kontrollsyfte. ! | Inte. != | Inte lika med. . | Punkt. : | Separator i b.la. loopar. ; | Slut. , | Separator. ( | Funktionsstart. ) | Funktionsslut.

---

Avancerade funktioner

Importering

Importering går ut på att använda externa bibliotek i sin kod. Vad betyder det? Jo, I Enkelt så finns det en del inbyggda funktioner, men om du har gjort en funktion som du tycker är praktisk så kan du göra den till ett bibliotek. Ett bibliotek är en enkelt-fil som innehåller en eller flera funktioner. Du kan sedan importera filen in i ett annat enkelt-projekt och använda funktionerna från biblioteket där utan att behöva kopiera in dem eller skriva av dem.

Hur Importering används:

importera = [bibliotek]

Exempel Exempel på hur importering kan användas. Vi har två enkelt-filer: matematik.e och kod.e. Matematik.e är ett bibliotek och kod.e är skriptet där vi vill använda biblioteket.

matematik.e

def addera(num1, num2):
    returnera num1+num2

def subtrahera(num1, num2):
    returnera num1-num2

kod.e

importera matematik

skriv(matematik.addera(1, 2))
skriv(matematik.subtrahera(10, 5))

Utdata

3
5

Här så importerade alltså filen kod.e matematik.e och då kunde funktionerna från matetik.e användas i kod.e!

Bibliotek

Bibliotek är skript med samlade funktioner som kan importeras och användas i andra skript.

Hur Bibliotek används:

importera = [bibliotek]

Om du har gjort ett bibliotek och du vill dela det med dig så kan du ladda upp det till bibliotek.enkelt.io så att andra kan använda ditt bibliotek i sina program. Klicka bara på länken för att läsa mer.

Utökningar

Utökningar är liknade till bibliotek men med den skillnaden att de skrivs i Python och inte i Enkelt. Utökningsbibliotek har filtypen .epy.

Hur utökningar används:

importera [utökningsbibliotek]

Hur skriver man ett utökningsbibliotek?

• Skapa en .epy fil.
• Skriv dina funktioner med Python.
• Se till att namnen på de funkioner som kommer kunna användas via Enkelt fäljer det här namnformatet: [namnet på ditt utökningsbibliotek]__enkelt__[namnet på din funktion]

Exempel

Utökningsbibliotek: (bibliotek.epy)

def bibliotek__enkelt__funktion1(var1):
    return funktion2() + var1

def funktion2():
    return 1+2

Enkeltskript: (kod.e)

utöka bibliotek

skriv(bibliotek.funktion1(3))
skriv (bibliotek.funktion2())

Utdata

6
Syntaxfel

Lambda-funktioner

Lambda-funktioner är ett ganska så avancerat koncept, men i sin enklaste form är de enradiga funktioner.

Hur lambda-funktioner används:

Deklarering

[variabel] => [kommaseparerade argument] : [kod...]

Användning

[variabel]([kommaseparerade värden])

Exempel

var => a, b : a + b
skriv(var(1, 2))

Utdata

3

Flykt

Flykt (escaping) behövs då en sträng behöver innehålla vissa specialtecken, b.la. \ och ", samt '.

Hur flykt används:

\[tecken du vill fly]

Exempel 1

Här förväntar vi oss utdatan: Hej "Edvard", hur mår du?

skriv("Hej "Edvard", hur mår du?")

Utdata

Hej , hur mår du?

Det blev fel! Man måste fly citationstecken.

Exempel 2

Här förväntar vi oss samma som i exempel 1.

skriv("Hej \"Edvard\", hur mår du?")

Utdata

Hej "Edvard", hur mår du?

Nu blev det rätt!

---