Typisk lista

frukt = ["Banan", "Äpple", "Päron"] print(frukt)

Lägg till

frukt = ["Banan", "Äpple", "Päron"] frukt.append("Apelsin") print(frukt)

Ta bort

frukt = ["Banan", "Äpple", "Päron"] frukt.remove("Banan") print(frukt)

Komma åt ett element

frukt = ["Banan", "Äpple", "Päron"] f = frukt[1] print(f)

Ändra ett element

frukt = ["Banan", "Äpple", "Päron"] frukt[1] = "Gurka" print(frukt)

Loopa över alla element

frukt = ["Banan", "Äpple", "Päron"] for i in range(0,len(frukt)): print(frukt[i])

Eller ...

frukt = ["Banan", "Äpple", "Päron"] for f in frukt: print(f)

Typisk dictionary

medlem = { "namn" : "Ingrid", "sport" : "Dans" } print(medlem)

Nästlad dictionary

medlem = { 1: { "namn" : "Ingrid", "sport" : "Dans" }, 2: { "namn" : "Olle", "sport" : "MMA" } } print(medlem) print(medlem[2]) print(medlem[2]["namn"])

Lista av dictionary

medlem = [ { "namn" : "Ingrid", "sport" : "Dans" }, { "namn" : "Olle", "sport" : "MMA" } ] print(medlem) print(medlem[0]) print(medlem[0]["namn"])

Typisk if -sats

a = 4 if a > 3: print("a är mer än 3")

Typisk if ... else

a = 2 if a > 3: print("a är mer än 3") else: print("3 eller mindre")

Typisk elif

a = 2 if a == 1: print("a är ett") elif a == 2: print("a är två") elif a == 3: print("a är tre")

Typisk loop från 1 till 5

for i in range(1,6): print(i)

Loop över en sträng

namn = "Ingrid" for t in namn: print(t)

Loop över lista

l = [1, 10, 5, 67] for tal in l: print(tal)

En funktion utan parameter

def hej(): print("hej") hej()

En funktion med parameter

def hej(namn): print("hej "+namn) hej("Olle")

Parameter och returvärde

def dubbla(x): return(x*2) print(dubbla(4))

Typisk class

class Elev: fornamn = "Ej imtatat" efternamn = "Ej imtatat" tele = "okänt" klass = "okänt" nyelev = Elev() print(nyelev.fornamn)

class med __init__

class Elev: def __init__(self, f, e, t, k): self.fornamn = f self.efternamn = e self.tele = t self.klass = k nyelev = Elev("Anders","Andersson","070707","TKINT") print(nyelev.fornamn)

class med __str__

class Elev: def __init__(self, f, e, t, k): self.fornamn = f self.efternamn = e self.tele = t self.klass = k def __str__(self): return(f"{self.fornamn} {self.efternamn}\n{self.klass}") elever = [ Elev("Anders","Andersson","070707","TKINT"), Elev("Per","Persson","06060606","TKINT") ] print(elever[0]) print(elever[1])

Arv

class Shape: def __init__(self, x, y): self.xpos = x self.ypos = y def rita(self): print(f"Shape ritar på pos {self.xpos},{self.ypos}") class Cirkel(Shape): def __init__(self, x, y, r): super().__init__(x, y) self.radie = r def rita(self): print(f"Cirkel ritar på pos {self.xpos},{self.ypos}") class Rektangel(Shape): def __init__(self, x, y, h, b): super().__init__(x, y) self.hojd = h self.bredd = b def rita(self): print(f"Rektangel ritar på pos {self.xpos},{self.ypos}") former = [Rektangel(11,11,5,10), Cirkel(12,12,8), Cirkel(14,14,80)] for form in former: form.rita()

Läser en rad i taget ...

f = open('/ex/text.txt') for rad in f: print(rad,end="") f.close()

Läser en rad. Returnerar ’ ’ vid filslut ...

f = open('/ex/text.txt') rad = f.readline() print(rad) f.close()

Läser hela filen och returnerar ...

f = open('/ex/text.txt') text = f.read() print(text) f.close()

Läser 10 tecken och returnerar ’ ’ vid filslut

f = open('/ex/text.txt') text = f.read(10) print(text) f.close()

Läser alla raderna. Ger en lista med rader.

f = open('/ex/text.txt') text = f.readlines() print(text) print() for i in range(0,len(text)): print(text[i]) f.close()

Funktion	Beskrivning
random()	Genererar slumptal mellan 0 och 1

randrange()	Genererar slumptal mellan 2 heltal

Labba med reguljära uttryck

Tecken	Beskrivning
.	Alla tecken utom nyrad.
\.	En punkt (osv för \*, \(, \\, m.fl.)
^	Start av sträng.
$	Slut av sträng.
\d,\w,\s	Siffra, legal variabel [A-Za-z0-9_], mellanslag.
\D,\W,\S	Allt utom dito.
[abc]	Tecken a, b, or c.
[a-z]	a till z.
[^abc]	Alla tecken utom a, b, or c.
aa\|bb	Antingen aa or bb.
?	Inget eller 1 av föregående element.
*	Inget eller många av föregående element.
+	Ett eller fler av föregående element.
{n}	Exakt n av föregående element.
{n,}	n eller fler av föregående element.
{m,n}	Mellan m och n av föregående element.
??,*?,+?,
{n}?, etc.	Samma som ovan men så få ggr som möjligt.
(expr)	Fångar det som matchas för att använda med \1, etc.
(?:expr)	Ej-matchande grupp.
(?=expr)	Följt av by expr.
(?!expr)	Ej följt av expr.

Funktion	Beskrivning
datetime.now()	Tid just nu

strftime()	Formaterar tid/datum

Funktion	Beskrivning
load()	Läser in fil och omvandlar till dictionary

loads()	Läser in json -formaterad sträng ochomvandlar till dictionary

dumps()	Tar ett objekt och omvandlar till json -formaterad sträng

Funktion	Beskrivning
abs()	Absolutbelopp

aiter()	?
all()	True, om alla är True

anext()	?
any()	True, om någon är True

ascii()	Ger utskrivbar version

bin()	Ger binärkoden för tal

bool()	Typkonverterar till bool

breakpoint()	?
bytearray()	Returnerar objektets byte -array från minnet

bytes()	Returnerar objektets byte -array från minnet

callable()	True eller false beroende på om objektet är anropbart.

chr()	Ascii-kod till bokstav

classmethod()	?
compile()	Kompilerar kod och returnerar objektkod

complex()	Skapar ett komplext tal

delattr()	Tar bort attribut på klass

dict()	Skapar en dictionary

dir()	?
divmod()	Hela & delar efter div

enumerate()	Skapar en itererbar lista och lägger till ett index

eval()	Evaluerar uttrycket i argumentet

exec()	Exekverar koden i argumentet

filter()	Applicerar funktion på listas alla element

float()	Typkonverterar till float

format()	Formatera textsträng

frozenset()	?
getattr()	Ger attribut på klass

globals()	Returnerar globala variabler i kontexten

hasattr()	Kollor om klass har attribut

hash()	Skapar hashvärde

help()	Fungerar i python shell som hjälpsystem

hex()	Typkonverterar till hex

id()	Id (minnesadsress) för objekt

input()	Input från användaren

int()	Typkonverterar till int

isinstance()	?
issubclass()	True om subklass till annan

iter()	?
len()	Antalet element i lista

list()	Typkonverterar till lista

locals()	Lokala variabler i kontexten

map()	Applicerar funktion på alla element i lista

max()	Returnerar max i lista

memoryview()	?
min()	Returnerar min i lista

next()	?
object()	?
oct()	Konv till oktadecimalt

open()	?
ord()	Bokstav till ascii-kod

pow()	Räknar ut X^Y

print()	Utskrifter i konsolen

property()	?
range()	Skapar lista utifrån villkoren

repr()	?
reversed()	Skapar en reverserad iterator

round()	Avrundar ett tal

set()	Skapar set av tex lista

setattr()	Sätter/skapar attribut i klass

slice()	?
sorted()	Sorterar en lista

staticmethod()	?
str()	Typkonverterar till sträng

strip()	Rensar bort önskvärda tecken i slutet/början

sum()	Summan av element

super()	Referens till superklassen

tuple()	konverterar till tuple

type()	Ger typen av objektet

vars()	Dict med variabler och värde för objekt

zip()	Zippar ihop tuppler

Kod	Beskrivning
%d	integer decimal
%i	integer decimal
%o	oktal (bas 8)
%x	hexadecimal (bas 16)
%X	HEXadecimal (bas 16)
%e	floating point exp form
%E	floating point EXP form
%f	floating point decimal form
%F	floating point decimal form
%c	enstaka tecken
%r	Konv. till sträng med repr()
%s	Konv. till sträng med str()
%a	Konv. till sträng med ascii()

Dec	Kod	Beskrivning
007	\a	Terminal ljud
008	\b	Backspace
009	\t	TAB
010	\n	Nyrad (ner+start)
011	\v	Vertikal TAB
012	\f	Formfeed
013	\r	Return

Dec	Okt	Hex	Binärt	Ascii
000	000	00	0000 0000	NUL
001	001	01	0000 0001	SOH
002	002	02	0000 0010	STX
003	003	03	0000 0011	ETX
004	004	04	0000 0100	EOT
005	005	05	0000 0101	ENQ
006	006	06	0000 0110	ACK
007	007	07	0000 0111	BEL
008	010	08	0000 1000	BS
009	011	09	0000 1001	HT
010	012	0A	0000 1010	LF
011	013	0B	0000 1011	VT
012	014	0C	0000 1100	FF
013	015	0D	0000 1101	CR
014	016	0E	0000 1110	SO
015	017	0F	0000 1111	SI
016	020	10	0001 0000	DLE
017	021	11	0001 0001	DC1
018	022	12	0001 0010	DC2
019	023	13	0001 0011	DC3
020	024	14	0001 0100	DC4
021	025	15	0001 0101	NAK
022	026	16	0001 0110	SYN
023	027	17	0001 0111	ETB
024	030	18	0001 1000	CAN
025	031	19	0001 1001	EM
026	032	1A	0001 1010	SUB
027	033	1B	0001 1011	ESC
028	034	1C	0001 1100	FS
029	035	1D	0001 1101	GS
030	036	1E	0001 1110	RS
031	037	1F	0001 1111	US
032	040	20	0010 0000	SP
033	041	21	0010 0001	!
034	042	22	0010 0010	"
035	043	23	0010 0011	#
036	044	24	0010 0100	$
037	045	25	0010 0101	%
038	046	26	0010 0110	&
039	047	27	0010 0111	'
040	050	28	0010 1000	(
041	051	29	0010 1001	)
042	052	2A	0010 1010	*
043	053	2B	0010 1011	+
044	054	2C	0010 1100	,
045	055	2D	0010 1101	-
046	056	2E	0010 1110	.
047	057	2F	0010 1111	/
048	060	30	0011 0000	0
049	061	31	0011 0001	1
050	062	32	0011 0010	2
051	063	33	0011 0011	3
052	064	34	0011 0100	4
053	065	35	0011 0101	5
054	066	36	0011 0110	6
055	067	37	0011 0111	7
056	070	38	0011 1000	8
057	071	39	0011 1001	9
058	072	3A	0011 1010	:
059	073	3B	0011 1011	;
060	074	3C	0011 1100	<
061	075	3D	0011 1101	=
062	076	3E	0011 1110	>
063	077	3F	0011 1111	?
064	100	40	0100 0000	@
065	101	41	0100 0001	A
066	102	42	0100 0010	B
067	103	43	0100 0011	C
068	104	44	0100 0100	D
069	105	45	0100 0101	E
070	106	46	0100 0110	F
071	107	47	0100 0111	G
072	110	48	0100 1000	H
073	111	49	0100 1001	I
074	112	4A	0100 1010	J
075	113	4B	0100 1011	K
076	114	4C	0100 1100	L
077	115	4D	0100 1101	M
078	116	4E	0100 1110	N
079	117	4F	0100 1111	O
080	120	50	0101 0000	P
081	121	51	0101 0001	Q
082	122	52	0101 0010	R
083	123	53	0101 0011	S
084	124	54	0101 0100	T
085	125	55	0101 0101	U
086	126	56	0101 0110	V
087	127	57	0101 0111	W
088	130	58	0101 1000	X
089	131	59	0101 1001	Y
090	132	5A	0101 1010	Z
091	133	5B	0101 1011	[
092	134	5C	0101 1100	\
093	135	5D	0101 1101	]
094	136	5E	0101 1110	^
095	137	5F	0101 1111	_
096	140	60	0110 0000	`
097	141	61	0110 0001	a
098	142	62	0110 0010	b
099	143	63	0110 0011	c
100	144	64	0110 0100	d
101	145	65	0110 0101	e
102	146	66	0110 0110	f
103	147	67	0110 0111	g
104	150	68	0110 1000	h
105	151	69	0110 1001	i
106	152	6A	0110 1010	j
107	153	6B	0110 1011	k
108	154	6C	0110 1100	l
109	155	6D	0110 1101	m
110	156	6E	0110 1110	n
111	157	6F	0110 1111	o
112	160	70	0111 0000	p
113	161	71	0111 0001	q
114	162	72	0111 0010	r
115	163	73	0111 0011	s
116	164	74	0111 0100	t
117	165	75	0111 0101	u
118	166	76	0111 0110	v
119	167	77	0111 0111	w
120	170	78	0111 1000	x
121	171	79	0111 1001	y
122	172	7A	0111 1010	z
123	173	7B	0111 1011	{
124	174	7C	0111 1100	\|
125	175	7D	0111 1101	}
126	176	7E	0111 1110	~
127	177	7F	0111 1111	DEL

Start | rindex

rindex(sub[, start[, end]])

Returnerar index till den positionen där sökordet sub hittas. Funktionen är speciell på så vis att den söke från höger i strängen.

s = "Kalle köpte en bil i västerås och sedan köpte han godis" print(s.rindex("köpte"))

Skriv ut ...

Tack för ditt bidrag

Spara som ...

Läs in

Skicka in bidrag

Skapa kort länk

rindex(sub[, start[, end]])