Föreläsningsöversikt¶
- Kort om laboration 4
- Kort om terminologilektionen 6 mars
- Parprogrammering
- Skript i verkligheten
- paket
- virtuella miljöer
- moduler, namespaces
- disposition
- defaultvärden för funktionsargument
- Bryta ut funktioner
- Mer om stränghantering och filläsning
Laboration 4¶
- Tillämpning av det mesta ni lärt er hittills
- skriva funktioner
- bearbeta listor/dictionaries
- läsa data från fil
- strukturera kod
- Rita diagram med
matplotlib
- Övning i att bryta ut funktioner och strukturera kod (Del 2)
Terminologilektion 6e mars¶
- Uppdelat i 3 pass
- 13.15 - 14.30 Y1.a och Y1.b
- 14.30 - 15.45 Y1.c och TMA
- 15.45 - 17.00 MED, MAT, Yi1
- Samling i P42 på utsatt tid
- Kort genomgång av mig
- Sedan följer ni en av assistenterna till anvisad sal (P18, P22, P30, P36 eller stanna i P42)
Parprogrammering¶
- Programmeringsmetod där två programmerare programmerar tillsammans i samma stycke kod samtidigt.
- Populariserades genom utvecklingsmetodiken Extreme Programming (XP).
- Vanligt speciellt inom organisationer som jobbar med sk. agila utvecklingsmetodiker.
- XP, Scrum, Kanban, etc.
- TDDC88 - Programutvecklingsmetodik
Varför parprogrammering?¶
- Fördelar:
- Enskilda uppgifter slutförs snabbare än av en enskild programmerare
- Mindre komplex kod som är enklare att underhålla
- Speciellt komplexa problem där lösningen inte är given från start löses bättre av par
- Lagom jämna par lär sig av varandra och utvecklas snabbare
- Nackdelar:
- Fler programmerartimmar för att slutföra projekt
- $\;\;\;\;\rightarrow$ Mindre tid till testning och debuggning
- Par av noviser skriver sällan produktionsvärdig kod
Parprogrammering i undervisning¶
- Diskutera och bestäm er för vilket litet delproblem som ska göras
- Föraren jobbar på det lilla delproblemet och skriver koden
- Navigatörens jobb är att aktivt granska koden som skrivs
- Navigatörens jobb är inte att berätta för föraren exakt vad hen ska skriva, men kan komma med förslag
- Byt roller ofta! Minst en gång varje halvtimme men helst oftare, använd timer om ni tenderar att glömma.
- Ni behöver inte lösa delproblemet innan ni byter roller.
- Fira när ni löst delproblem.
Tre faser och mönster¶
- Planering: innan ni kör iväg
- Kodproduktion: när koden skrivs
- Omstart: när ni har kört fast
Planering¶
- Både förslag och genomgång av existerande kod / instruktioner
- Det är bra att säga "Jag förstår inte" eller "Jag vet inte"
- Tveka inte om att be varandra förtydliga (om ni är oeniga, fråga assistent)
- Uttryck med egna ord hur du uppfattar situationen
- Undvik fraser som "du får se om en stund", försök att förklara för din partner på en gång
- Anteckna så att ni kommer ihåg det ni kommer fram till
Kodproduktion¶
- Föraren
- berätta hur och vad du tänker
- du kan stanna upp och prata med/fråga navigatören
- undvik att bara sitta tyst och vara i din egna värld (soloprogrammering med åskådare)
- Navigatören läser koden som skrivs och säger till direkt när hen
- upptäcker enklare fel
- inte förstår vad föraren gör, namngivning, etc
Kodproduktion¶
- Navigatören antecknar och sparar större funderingar till senare, t.ex.
- potentiella buggar (t.ex. värden som kan resultera i en krasch)
- funderingar idéer på övergripande design
- saker som ni missat vid planeringen
- Det är OK att skicka tangentbordet mellan er
- vissa saker kan vara lättare för navigatören att uttrycka i kod
- byt roller om det känns bra att göra det men kom ihåg att balansera
Omstart¶
- Ni kan byta fokus och prata om annat en kort stund för att kunna tackla problemet med öppen inställning
- Gå igenom er kod se över det ni gjort
- Försök ha målet i sikte medan ni identifierar hur ni ska göra för att komma vidare
- Hitta lämpligt ställe att börja om på
- Om ni inte kommer överrens, kan det vara lämpligt att ta en kort paus, gå på toa/fika etc, lämna arbetsplatsen
- Ge varandra tid att tänka/gå igenom koden
Varning¶
- Få par är perfekt matchade.
- Om du är den, åtminstone just nu, svagare programmeraren, lämna inte över ansvaret på din partner
- Om du är den, åtminstone just nu, starkare programmeraren, kör inte över din partner
- Glöm inte att byta roller!
Vad gör vi om det inte fungerar att parprogrammera?¶
- Gör uppgifterna enskilt.
- När båda är klara: Byt kod med varandra och granska.
- Diskutera eventuella skillnader.
- Sätt ihop en gemensam slutgiltig version som båda förstår.
- Redovisa gemensam version.
- Skicka in gemensam version i Sendlab.
Skript i verkligheten¶
Skript i verkligheten¶
- paket
- virtuella miljöer
- moduler, namespaces
- disposition: struktur på kod, returnera och använd. mönster för skript
- defaultvärden för argument
Paket¶
Paket för Python¶
- Det finns många fritt tillgängliga paket att använda med Python
- Ingen anledning att återuppfinna hjulet
- Skiljer sig från inbyggda moduler som
math
,random
,os
, etc. genom att de måste installeras separat - Exempel
- Requests (hämta data från webben). https://requests.readthedocs.io/en/master/
- NumPy (matrisberäkningar m.m.). https://numpy.org/
- TensorFlow (maskininlärning). https://www.tensorflow.org/
- Pandas (databearbetning). https://pandas.pydata.org/
- Pillow (bildbehandling). https://python-pillow.org/
- Flask (webbserver). https://palletsprojects.com/p/flask/
- Beautiful Soup (extrahera data från webbsidor). https://www.crummy.com/software/BeautifulSoup/
- OpenCV (bildbehandling). https://docs.opencv.org/master/index.html
Installera paket¶
- Enkelt att installera paket:
$ python3 -m pip install <namn på paket>
Moduler och namespaces¶
Import av moduler¶
- Vi kan importera t.ex. funktioner från moduler.
- T.ex. finns funktionen
randint(a, b)
i modulen random som slumpar fram ett heltal mellan heltalena
ochb
. import random
binder modulenrandom
till prefixetrandom
.
In [ ]:
import random
print(random.randint(1, 10))
- Vi säger att funktionen
random.randint()
ligger i namnrymden (sveng. name spacet)random
.- Vi kan ha flera olika funktioner med samma namn, så länge som de ligger i olika namnrymder.
Moduler och namespaces¶
- namnrymd (eng. namespace): används för att kunna ha olika variabler/funktioner, etc. med samma namn
- Exempel:
In [ ]:
import random
# definition av egen funktion vid namn randint()
def randint():
# anrop till funktion i modulen random
return random.randint(0, 100)
# anrop till egen funktion
randint()
Importera modul¶
- Exempel på import av modul och körning av funktion från modul
In [ ]:
# importera modulen random
import random
# importera modulen matplotlib.pyplot
import matplotlib.pyplot
# anrop till funktionen randint() i modulen random
random.randint(0, 100)
# anrop till funktionen plot() i modulen matplotlib.pyplot
matplotlib.pyplot.plot([0, 1, 2, 3])
Importera modul och bind till annat namn¶
- Om en modul har ett långt namn kan man binda den importerade modulen till ett annat namn
In [ ]:
# importera modulen random till namnrymnden rnd
import random as rnd
# importera modulen matplotlib.pyplot till namnrymden plt
import matplotlib.pyplot as plt
# anrop till funktionen randint() i modulen random
rnd.randint(0, 100)
# anrop till funktionen plot() i modulen matplotlib.pyplot
plt.plot([0, 1, 2, 3])
Importera modul till lokal namnrymd¶
- Man kan importera till den lokala namnrymden för att slippa skriva prefix, men se upp för namnkonflikter!
In [ ]:
# importera modulen random till lokal namnrymd
from random import *
# importera modulen matplotlib.pyplot till lokal namnrymd
from matplotlib.pyplot import *
# anrop till funktionen randint() i modulen random
randint(0, 100)
# anrop till funktionen plot() i modulen matplotlib.pyplot
plot([0, 1, 2, 3])
Importera funktion från modul till aktuell namnrymd¶
- Om man importerar till lokal namnrymd är det bättre att explicit importera specifika delar
In [ ]:
# importera funktionen randint() från modulen random till
# aktuell namnrymd
from random import randint, choice
# importera funktionen plot() från modulen matplotlib.pyplot
# till aktuell namnrymd
from matplotlib.pyplot import plot
# anrop till funktionen randint() från modulen random
randint(0, 100)
choice(["a", "b", "c"])
# anrop till funktionen plot() från modulen matplotlib.pyplot
plot([0, 1, 2, 3])
Använda pythonfil som modul¶
- Filer med pythonkod är moduler
- I filen
uppg1.py
:
def load_csv(filename):
# satser i funktionen
- Import och användning av
uppg1.py
som modul från annan pythonfil i samma katalog
import uppg1
uppg1.load_csv("data.csv")
Vad händer när man importerar en modul?¶
- Vid import körs alla rader från filen som importeras.
- Eventuella problem
- vi vill att viss kod körs när vi använder filen som ett skript
- vi vill inte att skript-koden körs när vi importerar filen som en modul
- Exempel
- Filen
pokedex.py
innehåller kod som kan användas för ta fram information om en Pokémon via PokeAPI - När
pokedex.py
körs kommer den att titta på argumenten som skriptet fått - Vi skriver ett annat program som ska använda sig av Pokémon-data, vi vill därför använda funktionerna i
pokedex.py
, men vill inte att pokedex-skriptet körs.
- Filen
Den nuvarande namnrymnden¶
- Speciella variabeln
__name__
innehåller namnet på namnrymden för koden som körs - Namnrymden för ett skript (huvudprogram) som körs är
"__main__"
- Namnrymden för en kod i en modul är namnet på modulen
- Exempelanvändning: kör inte viss kod när en fil importeras:
# om vi kör filen som ett skript, kör programmet
# annars utvärderas endast funktionerna m.m. i filen
if __name__ == "__main__":
main()
utskrifter.py
¶
In [46]:
print(f"\n{'#'*10} utskrifter.py körs {'#'*10}")
print(f"* __name__ i början av utskrifter.py: {__name__}")
def skriv_ut_namnrymd():
print(f"* __name__ i funktionen skriv_ut_namnrymd(): {__name__}")
print("\nAnropar skriv_ut_namnrymd() från utskrifter.py")
skriv_ut_namnrymd()
if __name__ == "__main__":
print("\n__name__ har värdet '__main__' i utskrifter.py, kör skriv_ut_namnrymd()!")
skriv_ut_namnrymd()
print(f"{'#'*10} utskrifter.py klar {'#'*10}\n")
########## utskrifter.py körs ########## * __name__ i början av utskrifter.py: __main__ Anropar skriv_ut_namnrymd() från utskrifter.py * __name__ i funktionen skriv_ut_namnrymd(): __main__ __name__ har värdet '__main__' i utskrifter.py, kör skriv_ut_namnrymd()! * __name__ i funktionen skriv_ut_namnrymd(): __main__ ########## utskrifter.py klar ##########
skript.py
¶
In [48]:
#!/usr/bin/env python3
print(f"\n{'#'*10} skript.py körs {'#'*10}")
import utskrifter
print("__name__ i skript.py: {}".format(__name__))
print("Anropar utskrifter.skriv_ut_namnrymd() från skript.py")
utskrifter.skriv_ut_namnrymd()
if __name__ == "__main__":
print("Anropar utskrifter.skriv_ut_namnrymd() IGEN från skript.py")
utskrifter.skriv_ut_namnrymd()
print(f"\n{'#'*10} skript.py klar {'#'*10}\n")
########## skript.py körs ########## -------------------------------------------------- __name__ i utskrifter.py: utskrifter Anropar skriv_ut_namnrymd() från utskrifter.py __name__ i skriv_ut_namnrymd(): utskrifter __name__ i skript.py: __main__ Anropar utskrifter.skriv_ut_namnrymd() från skript.py __name__ i skriv_ut_namnrymd(): utskrifter Anropar utskrifter.skriv_ut_namnrymd() IGEN från skript.py __name__ i skriv_ut_namnrymd(): utskrifter ########## skript.py klar ##########
Virtuella miljöer¶
Problem vid installation av paket¶
- Vissa projekt ska köras i miljöer med begränsade resurser
- Dvs vi kan inte installera hur många onödiga paket som helst
- Olika projekt kan behöva olika versioner av samma paket
- Rättigheter kan saknas för att installera paket på systemnivå
- Lösning
- Användar- och/eller projektspecifika virtuella miljöer med t.ex. modulen
venv
- Användar- och/eller projektspecifika virtuella miljöer med t.ex. modulen
- Överkurs: Den som vill ha mer att bita i kan kolla upp
conda
för pakethantering och virtuella miljöer. Mer kraftfullt, men också mer komplext.- Inte tillgängligt i LiUs Linux-miljö.
venv
- inbyggd modul¶
- Skapar virtuell Python-miljö som kan aktiveras/avaktiveras.
- Olika virtuella miljöer kan skapas för olika uppsättningar av Python-paket.
- Endast virtuella miljöer för aktuell version av Python 3 kan skapas, t.ex. 3.11.4 i vårt fall.
- (Med
conda
kan även flera olika Python-versioner existera parallellt.)
- (Med
venv
¶
- Skapa virtuell miljö:
$ python3 -m venv <katalog>
- Aktivera virtuell miljö
$ source venv_mittprojekt/bin/activate
- Av-aktivera virtuell miljö
$ deactivate
- Installera paket i aktiv miljö
$ python3 -m pip install <paket>
Är det inte bättre att installera allt man behöver i en och samma miljö?¶
- I verkligheten jobbar man ofta parallellt i flera olika projekt.
- Alla projekt kan inte ha en produktionsmiljö där där massor onödiga saker finns.
- Utvecklingsmiljön bör spegla produktionsmiljön i möjligaste mån.
Vanlig disposition för skript¶
- importer
- globala variabler
- funktioner
- kod utanför funktioner
Default-värden för parametrar¶
Default-värden¶
- Funktioner med valfria argument; parametrar med defaultvärden
- Används när man vill ha möjligheten att ange fler argument för att ändra en funktions beteende, men vill göra det möjligt att använda funktionen utan att ange alla argument
- Kommer att användas av många av funktionerna i matplotlib (Laboration 4, Del 1)
- Exempel
open(filnamn) # är samma sak som
open(filnamn, 'r', -1, None, None, None, True, None)
Default-värden¶
- Syntax
In [3]:
def funktionsnamn(param1, param2=10, param3=20):
print(f"param1: {param1}, param2: {param2}, param3: {param3}")
- Argument utan default-värde måste alltid anges
- Argument med default-värde kan hoppas över eller anges explicit (nyckelordsargument)
- Positionella argument måste användas före nyckelordsargument.
In [4]:
funktionsnamn(1)
param1: 1, param2: 10, param3: 20
Funktionsdefinitioner, defaultvärden¶
In [ ]:
def print_greeting1(name):
print(f"Hej {name}!")
def print_greeting2(name="Guido"):
print(f"Hej {name}!")
def print_greeting3(name="Eggbert", greeting="Hej"):
print(f"{greeting} {name}!")
print_greeting1("Yoda")
print_greeting2()
print_greeting3(greeting="Tjena")
print_greeting3("Tjena")
print_greeting3(greeting="Tjena", "Eggbert")
Använd inte föränderliga värden som defaultvärden¶
In [5]:
def get_short_names(name_candidates, short_names=[]):
for name in name_candidates:
if len(name) < 4:
short_names.append(name)
return short_names
In [6]:
print(get_short_names(["1234", "12345", "12"]))
['12']
In [7]:
print(get_short_names(["abcd", "abcde", "ab"]))
['12', 'ab']
Lösning: använd istället None
som defaultvärde, hantera i funktionen¶
In [8]:
def get_short_names(name_candidates, short_names=None):
if short_names is None:
short_names = []
for name in name_candidates:
if len(name) < 4:
short_names.append(name)
return short_names
In [9]:
print(get_short_names(["1234", "12345", "12"]))
['12']
In [10]:
print(get_short_names(["abcd", "abcde", "ab"]))
['ab']
Bryta ut funktioner¶
Varför bryta ut funktion?¶
- Minska upprepad kod
- lättare att underhålla kod och uppdatera kod
- lättare att läsa kod, inte lika lång
- Minska väldigt snarlik kod
- ersätt snarlika kodavsnitt med funktion som anpassar beteende givet argumenten
- Underlätta läsning av kod – givet att bra funktionsnamn används.
Bryta ut funktioner, saker att tänka på¶
- Scope: globala variabler och lokala variabler
- Lokala variabler
- alla variabler som definieras inne i en funktion (inkl. argumenten) är bara tillgängliga inuti funktionen
- Globala variabler
- variabler som definieras utanför funktioner är globala
- om de ska användas inuti en funktion bör nyckelordet global användas
- Undvik att använda globala variabler. Konstanter är ok, använd i så fall variabelnamn med endast versaler
Scope¶
- Globala variabler
- tillgängliga överallt
- Lokala variabler
- endast tillgängliga i en funktion
- Två olika funktioner kan använda sig av samma variabelnamn
- Vid användning av globala variabler, använd nyckelordet
global
- Rekommendation: använd inte globala variabler om de inte används som konstanter. I de fallen, använd variabelnamn med enbart VERSALER
Namngivning¶
- Bra namn hjälper läsaren och programmeraren förstå vad koden gör.
- Dåliga namn är intetsägande eller, ännu värre, vilseledande.
- Använd verbliknande namn till funktioner
show_commands()
,get_shortest_name()
,load_data()
- Använd substantivliknande namn till variabler; singular om det är ett värde, plural om det handlar flera värden (t.ex. listor och dictionaries)
command
,commands
,name
,names
Exempel, scope¶
- Globala och lokala variabler:
localglobal.py
- Varför blir det fel:
localvars.py
- Varför blir det fel:
globalvars.py
Bryta ut funktioner, exempel på tillvägagångssätt¶
- Ta kod som upprepas och stoppa in den i en funktion
- Lägg till argument till funktionen efter behov.
- Byt ut upprepande kod mot anrop till funktionen du skapat.
- Vid parprogrammering är en typisk uppgift för navigatören att påpeka när kod bör brytas ut till en egen funktion.
treasure_finder.py
¶
In [28]:
def treasure_finder():
map1 = [55, 94, 39, 38, 57, 25, 53, 13, 57, 51]
map2 = [71, 44, 98, 26, 18, 64, 37, 91, 81, 14]
treasure_value = 81
treasure_found = False
pos = 0
while pos < len(map1):
if map1[pos] == treasure_value:
treasure_found = True
break
pos += 1
if treasure_found:
print(f"Yay! Found treasure in map1 at position {pos}!")
else:
print("No treasure found in map1 :(")
treasure_found = False
pos = 0
while pos < len(map2):
if map2[pos] == treasure_value:
treasure_found = True
break
pos += 1
if treasure_found:
print(f"Yay! Found treasure in map2 at position {pos}!")
else:
print("No treasure found in map2 :(")
treasure_finder()
No treasure found in map1 :( Yay! Found treasure in map2 at position 8!
treasure_finder_funcs.py
¶
In [29]:
def get_treasure_position(lst, treasure_value):
pos = 0
while pos < len(lst):
if lst[pos] == treasure_value:
return pos
pos += 1
return -1
def print_result(map_name, pos):
if pos >= 0:
print(f"Yay! Found treasure in {map_name} at position {pos}!")
else:
print(f"No treasure found in {map_name} :(")
def treasure_finder():
map1 = [55, 94, 39, 38, 57, 25, 53, 13, 57, 51]
map2 = [71, 44, 98, 26, 18, 64, 37, 91, 81, 14]
treasure_value = 81
treasure_pos = get_treasure_position(map1, treasure_value)
print_result("map1", treasure_pos)
treasure_pos = get_treasure_position(map2, treasure_value)
print_result("map2", treasure_pos)
treasure_finder()
No treasure found in map1 :( Yay! Found treasure in map2 at position 8!
Riktlinjer för vad och hur man ska bryta ut¶
- Försöka att se till att varje funktion endast gör en sak.
- Försök att hålla funktioner korta (olika beroende på kodstil).
- Ex. ~10 rader.
- Låt funktioner ha verbliknande namn.
- Låt variabler ha substantivliknande namn.
- Använd förklarande namn.
- Använd namn i plural för listor och dictionaries.
Bra heurestiker för att bryta ut funktioner¶
- Försök se till så att en funktion bara gör en sak.
- Är det svårt att skriva en lättförståelig men utförlig dokumentationssträng?
- I så fall bör funktionen brytas upp i mindre delar.
- Sätt en maxlängd på hur många rader en funktion får ha.
- Sätt ett maxdjup på hur många nivåer av indentering en funktion får ha.
Återbesök: filläsning och stränghantering¶
Läsa från textfil¶
- Öppna fil:
file = open(filename)
- Läs rader från öppen fil:
lines = file.readlines()
- Stäng öppen fil:
file.close()
- Bearbeta rader: t.ex.
for line in lines:
- Viktigt: Vad för datastruktur får vi från
file.readlines()
?
with
-satsen - ett bättre sätt att öppna filer¶
with
-satsen används för att förenkla resurs- och felhantering.- De flesta användningsområdena för
with
ligger utanför den här kursens omfattning, men:
with open('file_path') as file:
lines = file.readlines()
with
-satsen hanterar automatiskt stängning av öppnade filer när blocket avslutas, även om programmet skulle råka krascha.
Praktiska strängmetoder¶
str.split()
¶
- Skapar en lista av delsträngar, skapade genom att dela strängen vid en viss sekvens (blanktecken som default)
- Blanktecken (eng. whitespace) representerar något av de olika blanka tecken som förekommer i text, t.ex. mellanslag, radbrytning och tab.
str.split()
In [5]:
"""hej, hopp, nepp""".split()
Out[5]:
['hej,', 'hopp,', 'nepp']
- För att ange en specifik sekvens som ska dela strängen skickar man med ett argument till den första parametern,
sep
.- Dvs.
str.split(separator)
ellerstr.split(sep=separator)
- Dvs.
In [ ]:
"hej, hopp, nepp".split(", ")
str.join(lista)
¶
- Eftersom strängar är immutable så är det ineffektivt att genomföra många konkateneringar på raken.
- Istället kan vi använda
str.join(lista)
som tar en lista av delsträngar och slår ihop dem till en sträng med strängen som metoden anropas på mellan varje delsträng.
In [8]:
"".join(["hej", "hopp", "nepp"])
Out[8]:
'hejhoppnepp'
In [9]:
" - ".join(["hej", "hopp", "nepp"])
Out[9]:
'hej - hopp - nepp'
str.join(lista)
, forts.¶
- För att stegvis bygga upp en sträng i en loop kan vi alltså ersätta:
result = ""
for string in iterable:
result += string
- med:
partials = []
for string in iterable:
partials.append(string)
result = "".join([partials])
- Vilket, om vi ska göra många konkateneringar, kan ha mycket stor betydelse för hur snabbt programmet kör.
str.join(lista)
, exempel¶
- En funktion som givet en sträng och en dictionary med ersättningsregler returnerar en ny sträng med tecken utbytta enligt reglerna.
- Reglerna anges som t.ex.
{'a': 'ä', 'o': 'ö'}
för att byta ut alla 'a' mot 'ä' och alla 'o' mot 'ö'
- Reglerna anges som t.ex.
In [2]:
def replacer(original, rules):
partials = []
for char in original:
if char in rules.keys():
partials.append(rules[char])
else:
partials.append(char)
return "".join(partials)
Jämförelse mellan direkt konkatenering och str.join()
¶
In [39]:
def replacer_concat(original, rules):
result = ""
for char in original:
if char in rules.keys():
result += rules[char]
else:
result += char
return result
In [34]:
import timeit
test_var = 'nästäppa'*10000
In [45]:
print("concat: ", timeit.timeit("replacer_concat(test_var, {'t': 'd', 'p': 'b'})", number=100, globals=globals()))
print("join: ", timeit.timeit("replacer(test_var, {'t': 'd', 'p': 'b'})", number=100, globals=globals()))
concat: 1.4143314000684768 join: 0.741510899970308
Ännu snabbare lösning med split
och join
¶
In [ ]:
def replacer_split_inplace(original, rules):
result = original.split()
for i, char in enumerate(result):
if char in rules.keys():
result[i] = rules[char]
return ''.join(result)
In [41]:
print("concat: ", timeit.timeit("replacer_concat(test_var, {'t': 'd', 'p': 'b'})", number=100, globals=globals()))
print("join: ", timeit.timeit("replacer(test_var, {'t': 'd', 'p': 'b'})", number=100, globals=globals()))
print("inplace: ", timeit.timeit("replacer_split_inplace(test_var, {'t': 'd', 'p': 'b'})", number=100, globals=globals()))
concat: 1.3902235999703407 join: 0.732720100088045 inplace: 0.006920000072568655
str.strip()
, str.lstrip()
, str.rstrip()
¶
- Ta bort alla blanktecken i början och/eller slutet av strängar.
- str.rstrip()
- r för right, dvs tar bort blanktecken till höger, dvs i slutet av strängen
- str.lstrip()
- l för left, dvs tar bort blanktecken till vänster, dvs i början av strängen
- str.strip()
- Tar bort blanktecken i både början och slutet.
str.strip()
, str.lstrip()
, str.rstrip()
exempel¶
In [42]:
" hej vad heter du? \n".rstrip()
Out[42]:
' hej vad heter du?'
In [43]:
" hej vad heter du? \n".lstrip()
Out[43]:
'hej vad heter du? \n'
In [44]:
" hej vad heter du? \n".strip()
Out[44]:
'hej vad heter du?'
Läsa från textfil¶
- Öppna fil
with open('file_path') as datafile:
- Läs rader från öppen fil, t.ex.
for row in datafile:
- eller
datarows = datafile.readlines()
for row in datarows:
- För varje rad, bearbeta raden, t.ex.
- hoppa över rad (använd
continue
) - ta bort radbryt från slutet av raden med
str.rstrip()
- konvertera från sträng till annan datatyp
- dela upp raden med
str.split()
- stoppa in värden i lista
- hoppa över rad (använd