class ReflexAgentWithState(BaseAgent):
class State:
def __init__(self):
self.bump = False
self.previous_action = ""
self.actions = ["GoRight", "GoLeft", "GoForward", "GoBack"]
def __repr__(self):
if self.bump:
return self.previous_action + " resulted in a bump"
else:
return self.previous_action
def update_state_with_percept(self, percept, state):
if percept[1] == "bump":
state.bump = True
else:
state.bump = False
return state
def choose_action(self, state):
actions = state.actions
if state.bump:
actions.remove(state.previous_action)
return random.choice(actions)
def update_state_with_action(self, action, state):
state.previous_action = action
# Print the representation (i.e. __repr__) of the state
print(state)
return state
"3953 bananer!"
är ett värde av datatypen str
("string"/sträng).["hej", 36, True]
är en instans av klassen list
.self
för att referera till den den egna instansen: self.instansvariabel
get_
: hämta ett värde från ett objekt (antingen beräknat eller direkt från ett attribut)set_
: sätt att värde (bör egentligen undvikas)add_
: lägg till ett värderemove_
: ta bort ett värdeload_
: ladda data från filsave_
: spara data till filis_X
: returnera True
om X stämmer, annars False
has_X
: returnera True
om objektet har X, annars False
<lägst antal>..<högst antal>
, *
betyder godtyckligt många), exempel: 0..1
, 1..1
, 0..*
lästa_böcker
squares
contacts
0..1
: noll eller en0..*
: noll eller flera1..*
: en eller fler3
: exakt tre0..3
: noll till tre5..9
: fem till nioclass DataFile(object):
def __init__(self, filepath=None):
self.filepath = filepath
data = DataFile("data.txt")
print(data)
DataFile
bygger vidare på object
, kallar man object
för basklassen för klassen DataFile
.MyClass
kan i sin tur ha en superklass, och så vidare, hela vägen tills vi når object
. Alla dessa klasser kallar vi för superklasser till MyClass
.object
, är en härledd klass (eng. derived class), dvs. en klass som har en basklass.DataFile
är en klass härledd från klassen object
.MyClass
kan i sin tur ha en subklass, och så vidare. Precis som med superklasser kallar vi alla dessa klasser för subklasser till MyClass
.class Base(object):
pass
class Derived(Base):
pass
class ReflexAgentWithState(BaseAgent):
class State:
def __init__(self):
self.bump = False
self.previous_action = ""
self.actions = ["GoRight", "GoLeft", "GoForward", "GoBack"]
def __repr__(self):
if self.bump:
return self.previous_action + " resulted in a bump"
else:
return self.previous_action
def update_state_with_percept(self, percept, state):
if percept[1] == "bump":
state.bump = True
else:
state.bump = False
return state
def choose_action(self, state):
actions = state.actions
if state.bump:
actions.remove(state.previous_action)
return random.choice(actions)
def update_state_with_action(self, action, state):
state.previous_action = action
# Print the representation (i.e. __repr__) of the state
print(state)
return state
__str__
eftersom den __str__
de ärvt från object
bara skriver ut vilken klass ett objekt tillhör och på vilken minnesadress objektet är lagrat.class Bag(object):
def __init__(self):
self.contents = set()
def put(self, obj):
self.contents.add(obj)
my_bag = Bag()
my_bag.put("phone")
my_bag.put("keys")
my_bag.put("banana")
print(my_bag)
<__main__.Bag object at 0x000002527840F310>
if
/else
:if
/else
- kontrollera först, utför sentry
/except
- utför först, hantera ev. felZeroDivisionError
: inträffar när man försökt dividera ett tal med 0IOError
: inträffar t.ex. om man försöker öppna en fil som inte finnsIndexError
: inträffar när man använder ett ogiltigt index för en specifik listaKeyError
: inträffar när man försöker komma åt värdet för en nyckel som inte finns i ett dictionaryTypeError
: inträffar t.ex. när man försöker använda operatorn +
på en sträng och ett heltalException
som basklass.BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- StopAsyncIteration
+-- ArithmeticError
| +-- FloatingPointError
| +-- OverflowError
| +-- ZeroDivisionError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
| +-- ModuleNotFoundError
+-- LookupError
| +-- IndexError
| +-- KeyError
+-- MemoryError
+-- NameError
| +-- UnboundLocalError
+-- OSError
| +-- BlockingIOError
| +-- ChildProcessError
| +-- ConnectionError
| | +-- BrokenPipeError
| | +-- ConnectionAbortedError
| | +-- ConnectionRefusedError
| | +-- ConnectionResetError
| +-- FileExistsError
| +-- FileNotFoundError
| +-- InterruptedError
| +-- IsADirectoryError
| +-- NotADirectoryError
| +-- PermissionError
| +-- ProcessLookupError
| +-- TimeoutError
+-- ReferenceError
+-- RuntimeError
| +-- NotImplementedError
| +-- RecursionError
+-- SyntaxError
| +-- IndentationError
| +-- TabError
+-- SystemError
+-- TypeError
+-- ValueError
| +-- UnicodeError
| +-- UnicodeDecodeError
| +-- UnicodeEncodeError
| +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning
+-- BytesWarning
+-- ResourceWarning
try
-except
-satser.try
-block.except
-block.try:
# här lägger man koden som kan utlösa ett undantag
except [typ av exception] [as <namn på undantagsinstans>]:
# här lägger man koden för vad som ska hända
as
används. Mindre än/större än-tecknena ska inte heller stå medletters = ["a", "b", "c", "d", "e", "f"]
l_index = 0
while True:
print(letters[l_index])
l_index += 1
a b c d e f
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) Cell In[22], line 4 2 l_index = 0 3 while True: ----> 4 print(letters[l_index]) 5 l_index += 1 IndexError: list index out of range
letters = ["a", "b", "c", "d", "e", "f"]
try:
l_index = 0
while True:
print(letters[l_index])
l_index += 1
except:
print("An exception was raised.")
a b c d e f An exception was raised.
letters = ["a", "b", "c", "d", "e", "f"]
try:
l_index = 0
while True:
print(letters[l_index])
l_index += 1
except Exception as error:
print("An exception was raised.")
print(error)
a b c d e f An exception was raised. list index out of range
letters = ["a", "b", "c", "d", "e", "f"]
try:
l_index = 0
while True:
print(letters[l_index])
l_index += 1
except IndexError:
print(f"Index {str(l_index)} is out of bounds.")
a b c d e f Index 6 is out of bounds.
letters = ["a", "b", "c", "d", "e", "f"]
try:
l_index = 0
while True:
print(letters[l_index])
l_index += 1
except IndexError as index_error:
print("Index " + str(l_index) + " is out of bounds.")
print(index_error)
a b c d e f Index 6 is out of bounds. list index out of range
def get_dog_desc(dog_dict):
try:
output_string = "My name is " + dog_dict['name'] + " "
output_string += "and I am " + str(dog_dict['age']) + " years old."
return output_string
except TypeError as type_error:
print("Argument not a dictionary")
print(type_error)
except KeyError as key_error:
print("Wrong keys in dictionary.")
print(key_error)
print(get_dog_desc(['Pluto', 93]))
Argument not a dictionary list indices must be integers or slices, not str None
print(get_dog_desc({'namn': 'Pluto', 'ålder': 93}))
Wrong keys in dictionary. 'name' None
print(get_dog_desc({'name': 'Pluto', 'age': 93}))
My name is Pluto and I am 93 years old.
def get_dog_desc(dog_dict):
try:
output_string = "My name is " + dog_dict['name'] + " "
output_string += "and I am " + str(dog_dict['age']) + " years old."
return output_string
except (TypeError, KeyError) as error:
print("Not a dictionary or key not present in dictionary.")
print(error)
print(get_dog_desc({'namn': 'Pluto', 'ålder': 93}))
Not a dictionary or key not present in dictionary. 'name' None
__str__
¶__str__
¶__str__
används när en instans av en klass (ett objekt) ska visas som en sträng__str__
tar inte emot några argument förrutom self
__str__
ska returnera en sträng (representationen av instansen)__str__
används avstr
för att konvertera ett objekt till en strängprint
när ett objekt ska skrivas ut__str__
direkt, utan använd funktionen str
om om du vill ha strängen, eller låt den anropas implicit, t.ex. när du vill skriva ut ett objekt med print
class Player(object):
def __init__(self, name):
self.name = name
self.inventory = []
self.hp = 100
def add_item(self, item_name):
self.inventory.append(item_name)
def __str__(self):
return f"Player name: {self.name}. HP: {self.hp}. Items: {','.join(self.inventory)}"
if __name__ == "__main__":
p1 = Player("Nario")
p1.add_item("Mushroom")
p1.add_item("Star")
print(p1)
class Person(object):
def __init__(self, name):
self.name = name
self.accounts = []
def add_account(self, account_id):
self.accounts.append(account_id)
def __str__(self):
return f"Name: {self.name}. Accounts: {', '.join(self.accounts)}"
if __name__ == "__main__":
p1= Person("Nario")
p1.add_account("123456")
p1.add_account("123457")
print(p1)
__str__
¶</div>
class City(object):
def __init__(self, name):
self.households = []
self.name = name
def add_household(self, household):
self.households.append(household)
def get_population(self):
total_population = 0
for household in self.households:
total_population += household.get_num_members()
return total_population
def __str__(self):
output = f"City: {self.name}\nPopulation: {self.get_population()}\n"
for household in self.households:
output += f" * {household}\n"
return output
class Household(object):
def __init__(self, name):
self.name = name
self.members = []
def add_member(self, name):
self.members.append(name)
def get_num_members(self):
return len(self.members)
def __str__(self):
return f"Household '{self.name}', ({self.get_num_members()} ppl)"
flaxtown = City("Linköping")
household1 = Household("Rydsvägen 1")
household1.add_member("A")
household1.add_member("B")
household2 = Household("Rydsvägen 2")
household2.add_member("C")
flaxtown.add_household(household1)
flaxtown.add_household(household2)
print(flaxtown)
City: Linköping Population: 3 * Household 'Rydsvägen 1', (2 ppl) * Household 'Rydsvägen 2', (1 ppl)
</div>
class Bag(object):
def __init__(self, color="green"):
self.color = color
self.zipper = Zipper()
self.container = Container()
def open(self):
self.zipper.open()
def close(self):
self.zipper.close()
def add(self, item):
item = item.upper()
print(f"Trying to add '{item}' to bag..")
if self.zipper.is_open():
self.container.add(item)
else:
print("Open zipper first.")
def __str__(self):
return f"A {self.color} bag. {self.zipper} {self.container}"
class Zipper(object):
def __init__(self):
self.state = "open"
self.chance_to_break = 0.2
def is_open(self):
return self.state == "open"
def is_broken(self):
return self.state == "broken"
def open(self):
print("Trying to open zipper...")
self.try_to_break()
if not self.is_broken():
self.state = "open"
print(self)
else:
print(f"Cannot open zipper. {self}")
def close(self):
print("Trying to close zipper...")
self.try_to_break()
if not self.is_broken():
self.state = "closed"
print(self)
else:
print(f"Cannot close zipper. {self}")
def try_to_break(self):
if random.random() <= self.chance_to_break:
self.state = "broken"
print("The zipper broke!")
def __str__(self):
return f"The zipper is {self.state}."
class Container(object):
def __init__(self, capacity=5):
self.items = []
self.capacity = capacity
def add(self, item):
if len(self.items) < self.capacity:
self.items.append(item)
print(f"{item} added.")
else:
print("f{item} not added. Container full.")
def __str__(self):
if not self.items:
items_str = "None"
else:
items_str = ", ".join(self.items)
fill_level = len(self.items)/self.capacity * 100
return f"The container is {fill_level:.2f}% full. Items: {items_str}."
Bag
känner till en instans av klassen Zipper
. Zipper
har rollen zipper
i Bag
Bag
känner till en instans av klassen Container
. Container
har rollen container
i Bag
Citron
har en metod mumsa
brukar man i text (t.ex. dokumentation) hänvisa till metoden mumsa
som Citron.mumsa
.Book
och Page
är klasser så ska "Book innehåller Page-objekt" tolkas somBook
-objekt innehåller Page
-objekt", dvsBook
innehåller instanser av klassen Page
", dvsBook
har en instansvariabel som refererar till instanser av klassen Page
"</div>
</div>
Bank
-klassennew_client
: skapa kund, se till att varje kund har ett kontonew_account
: skapa nytt konto, måste ha en kund att koppla det till instansvariaben num_accounts
för antal konton som skapatsClient
-klassenadd_account
: lägg till konto till kundClient
-instans) har minst ett konto (en Account
-instans)Bank
-instansen känner till alla Client
-instanser och alla Account
-instanserClient
-instanser har referenser till alla dess Account
-instanser</div>
Bank
-klassennum_clients
(används som nyckel)client_id
som argument till new_account
Client
-klassenclient_id
</div>
from bank3 import *
def new_client(bank):
print("new_client() körs")
def show_clients(bank):
print("show_clients() körs")
def main():
bank = Bank()
while True:
user_input = input("Vad vill du göra? ").lower()
if user_input == 'q':
break
elif user_input == "ny kund":
new_client(bank)
elif user_input == "visa kunder":
show_clients(bank)
else:
print("Okänt kommando.")
if __name__ == '__main__':
main()
Vad vill du göra? q
from bank3 import *
def new_client(bank):
print("new_client() körs")
def show_clients(bank):
print("show_clients() körs")
def main():
commands = {'ny kund': new_client,
'visa kunder': show_clients}
bank = Bank()
while True:
user_input = input("Vad vill du göra? ").lower()
if user_input == 'q':
break
elif user_input in commands:
commands[user_input](bank)
else:
print("Okänt kommando.")
if __name__ == '__main__':
main()
Vad vill du göra? q
from bank3 import *
def new_client(bank):
print("new_client() körs")
def show_clients(bank):
print("show_clients() körs")
def main():
commands = {'ny kund': new_client,
'visa kunder': show_clients}
bank = Bank()
while True:
user_input = input("Vad vill du göra? ").lower()
try:
if user_input == 'q':
break
commands[user_input](bank)
except KeyError:
print("Okänt kommando.")
if __name__ == '__main__':
main()
Vad vill du göra? a Okänt kommando. Vad vill du göra? q
</div>
from bank3 import *
def new_client(bank):
while True:
confirmed = ""
client_name = input("Ange kundens namn: ")
while confirmed not in ["j", "n"]:
confirmed = input(f"Du skrev '{client_name}', är det OK? [j/n]: ")
if confirmed == "j":
bank.new_client(client_name)
break
else:
print("Ok, skriv in igen!")
def show_clients(bank):
print(bank)
def main():
commands = {'ny kund': new_client,
'visa kunder': show_clients}
bank = Bank()
while True:
user_input = input("Vad vill du göra? ").lower()
try:
if user_input == 'q':
break
commands[user_input](bank)
except KeyError:
print("Okänt kommando.")
main()
</div>
from bank3 import *
def get_user_confirmation(message, yes, no):
user_input = ""
while user_input not in [yes, no]:
user_input = input(f"{message} [{yes}/{no}]: ")
return user_input == yes
def new_client(bank):
while True:
client_name = input("Ange kundens namn: ")
message = f"Du skrev '{client_name}', är det OK?"
if get_user_confirmation(message, "j", "n"):
bank.new_client(client_name)
break
else:
print("Ok, skriv in igen!")
def show_clients(bank):
print(bank)
def main():
commands = {'ny kund': new_client,
'visa kunder': show_clients}
bank = Bank()
while True:
user_input = input("Vad vill du göra? ").lower()
try:
if user_input == 'q':
break
commands[user_input](bank)
except KeyError:
print("Okänt kommando.")
if __name__ == '__main__':
main()
Vad vill du göra? ny kund Ange kundens namn: dada Du skrev 'dada', är det OK? [j/n]: f Du skrev 'dada', är det OK? [j/n]: j Vad vill du göra? visa kunder THE BANK Client name: dada (id: 1) Accounts: #1: 0.0 Vad vill du göra? q
</div>
</div>
from bank3 import *
class BankApp(object):
def __init__(self):
self.commands = {'ny kund': self.new_client,
'visa kunder': self.show_clients}
self.bank = Bank()
def run(self):
while True:
user_input = input("Vad vill du göra? ").lower()
try:
if user_input == 'q':
break
self.commands[user_input]()
except KeyError:
print("Okänt kommando.")
def get_user_confirmation(self, message, yes, no):
user_input = ""
while user_input not in [yes, no]:
user_input = input(f"{message} [{yes}/{no}]: ")
return user_input == yes
def new_client(self):
while True:
client_name = input("Ange kundens namn: ")
message = f"Du skrev '{client_name}', är det OK?"
if self.get_user_confirmation(message, "j", "n"):
self.bank.new_client(client_name)
break
else:
print("Ok, skriv in igen!")
def show_clients(self):
print(self.bank)
if __name__ == '__main__':
app = BankApp()
app.run()