def my_tests():
    MyClass(0, 0)
    MyClass(-1, 1)
    MyClass(0.999, 42)
    example1 = MyClass(0, 100)
    print(f"{example1=}")
    example1.method1()
    print(f"{example1=}")
    print(f"{example1.method2()=}")

if __name__ == "__main__":
    my_tests()

from labb6_del2_uppg1 import TodoApp

def test_cli():
    print("\n========== Running test_cli ==========")
    app = TodoApp()
    app.show_commands()

def test_tasks():
    print("\n========== Running test_tasks ==========")
    app = TodoApp()
    app._tasklist.create_task('labb5')
    app._tasklist.create_task('labb6')
    app._tasklist.create_task('labb7')
    app._tasklist.mark_done(1)
    app.show_tasks()

def run_tests():
    test_cli()
    test_tasks()

run_tests()

========== Running test_cli ==========
Kommandon: ny, visa, klar, ?

========== Running test_tasks ==========
0. [ ] labb5
1. [X] labb6
2. [ ] labb7

def check_consecutive(lst, pred):
    for i in range(1, len(lst)):
        if pred(lst[i-1], lst[i]):
            return False
    return True

def has_pairs(lst):
    for i in range(1, len(lst)):
        if lst[i-1] == lst[i]:
            return True
    return False

def is_increasing(lst):
    for i in range(1, len(lst)):
        if lst[i-1] > lst[i]:
            return False
    return True

def has_pairs2(lst):
    return not check_consecutive(lst, lambda x, y: x == y)

def is_increasing2(lst):
    return check_consecutive(lst, lambda x, y: x > y)

print(f'{has_pairs2([1, 2, 3, 4])=}')
print(f'{has_pairs2([1, 2, 3, 4, 3])=}')
print(f'{has_pairs2([1, 2, 3, 3])=}')


print(f'{is_increasing2([1, 2, 3, 4])=}')
print(f'{is_increasing2([1, 2, 3, 3])=}')
print(f'{is_increasing2([1, 2, 3, 5])=}')
print(f'{is_increasing2([1, 2, 3, 2])=}')

has_pairs2([1, 2, 3, 4])=False
has_pairs2([1, 2, 3, 4, 3])=False
has_pairs2([1, 2, 3, 3])=True
is_increasing2([1, 2, 3, 4])=True
is_increasing2([1, 2, 3, 3])=True
is_increasing2([1, 2, 3, 5])=True
is_increasing2([1, 2, 3, 2])=False

def check_consecutive(lst, predicate):
    for i in range(1, len(lst)):
        if predicate(lst[i-1], lst[i]):
            return True
    return False

def has_pairs(lst):
    return check_consecutive(lst, lambda x, y: x == y)

def is_increasing(lst):
    return not(check_consecutive(lst, lambda x, y: x > y))

print(f'{has_pairs([1, 2, 3, 4])=}')
print(f'{has_pairs([1, 2, 3, 4, 3])=}')
print(f'{has_pairs([1, 2, 3, 3])=}')


print(f'{is_increasing([1, 2, 3, 4])=}')
print(f'{is_increasing([1, 2, 3, 3])=}')
print(f'{is_increasing([1, 2, 3, 5])=}')
print(f'{is_increasing([1, 2, 3, 2])=}')

from itertools import pairwise

def check_consecutive(lst, predicate):
    for x, y in pairwise(lst):
        if predicate(x, y):
            return True
    return False

def has_pairs(lst):
    return check_consecutive(lst, lambda x, y: x == y)

def is_increasing(lst):
    return not(check_consecutive(lst, lambda x, y: x > y))

print(f'{has_pairs([1, 2, 3, 4])=}')
print(f'{has_pairs([1, 2, 3, 4, 3])=}')
print(f'{has_pairs([1, 2, 3, 3])=}')


print(f'{is_increasing([1, 2, 3, 4])=}')
print(f'{is_increasing([1, 2, 3, 3])=}')
print(f'{is_increasing([1, 2, 3, 5])=}')
print(f'{is_increasing([1, 2, 3, 2])=}')

has_pairs([1, 2, 3, 4])=False
has_pairs([1, 2, 3, 4, 3])=False
has_pairs([1, 2, 3, 3])=True
is_increasing([1, 2, 3, 4])=True
is_increasing([1, 2, 3, 3])=True
is_increasing([1, 2, 3, 5])=True
is_increasing([1, 2, 3, 2])=False

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 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)

class City:

    def get_population(self):
        total_population = 0
        for household in self.households:
            total_population += household.get_num_members()
        return total_population

nested_list = [4, [8, [3], [1, [7], [4]]]]

def tree_sum(tree):
    if not tree:
        return 0
    if type(tree[0]) == list:
        return tree_sum(tree[0]) + tree_sum(tree[1:])
    return tree[0] + tree_sum(tree[1:])

print(tree_sum(nested_list))

27

nested_list = [4, [8, [3], [1, [7], [4]]]]

def tree_sum(tree):
    if not tree:
        return 0
    if type(tree[0]) == list:
        return tree_sum(tree[0]) + tree_sum(tree[1:])
    else:
        return tree[0] + tree_sum(tree[1:])

print(tree_sum(nested_list))

class Node:
    
    def __init__(self, value):
        self.value = value
        self._children = []
        
n1 = Node(4)
n2 = Node(8)
n1._children.append(n2)

# - Ofta vill vi representera liknande hierarkiska strukturer av objekt.
#- Vi börjar väldigt explicit genom att definiera klassen `Node` enligt UML-diagrammet till höger.
#- UML-diagrammet visar att `Node` aggregerar sig själv, dvs. varje `Node`-objekt kommer ha en samling "barn-noder".
class Node:

    def  __init__(self, value):
        self.value = value
        self._children = []

n1 = Node(4)
n2 = Node(8)
n1._children.append(n2)

class Node:
    
    def __init__(self, value):
        self.value = value
        self._children = []
    
    def add_child(self, value):
        child = Node(value)
        self._children.append(child)
        return child
        
n1 = Node(4)
n2 = n1.add_child(8)

# Notera att vi inte skapar en ny `Node`-instans först och lägger till den med `add_child`.
#    - Istället låter vi `add_child` ta ett godtyckligt värde och skapa en ny nod med det värdet.
#- Vi låter också `add_child` returnera den nya `Node`-instansen så att vi enkelt kan fortsätta arbeta med den.
class Node:

    def __init__(self, value):
        self.value = value
        self._children = []

    def add_child(self, value):
        child = Node(value)
        self._children.append(child)
        return child

n1 = Node(4)
n2 = n1.add_child(8)

class Node:
    
    def __init__(self, value, parent):
        self.value = value
        self._parent = parent
        self._children = []
    
    def add_child(self, value):
        child = Node(value, self)
        self._children.append(child)
        return child
    
n1 = Node(4, None)
n2 = n1.add_child(8)

# - Ofta vill vi lagra information både om en nods "förälder" och om dess "barn" så att vi enkelt kan navigera både uppåt och nedåt i trädet?
#- Ett vanligt mönster om man vill att barnet ska känna till föräldern är att skicka med föräldern när man skapar barnet.
#    - Vi låter rot-noden ha föräldern `None`.
class Node:

    def __init__(self, value, parent):
        self.value = value
        self._parent = parent
        self._children = []

    def add_child(self, value):
        child = Node(value, self)
        self._children.append(child)
        return child

n1 = Node(4, None)
n2 = n1.add_child(8)

nested_list = [4, [8, [3], [1, [7], [4]]]]

tree_root = Node(4, None)
node_8 = tree_root.add_child(8)
node_3 = node_8.add_child(3)
node_1 = node_8.add_child(1)
node_7 = node_1.add_child(7)
node_4 = node_1.add_child(4)

root = Node(4, None)
node_8 = root.add_child(8)
node_8.add_child(3)
node_1 = node_8.add_child(1)
node_1.add_child(7)
node_1.add_child(4)

def tree_sum(root):
    result = root.value
    for child in root._children:
        result += tree_sum(child)
    return result

tree_sum(tree_root)

27

def tree_sum(root):
    result = root.value
    for child in root._children:
        result += tree_sum(child)
    return result

def tree_sum_rec(root):
    def recurse(children):
        if not children:
            return 0
        else:
            return tree_sum_rec(children[0]) + recurse(children[1:])
    return root.value + recurse(root._children)

print(tree_sum(root))
print(tree_sum_rec(root))

class Node:
    
    def __init__(self, value, parent):
        self.value = value
        self._parent = parent
        self._children = []
        
    def add_child(self, value):
        child = Node(value, self)
        self._children.append(child)
        return child
    
    def tree_sum(self):
        child_sums = []
        for child in self._children:
            child_sums.append(child.tree_sum())
        return self.value + sum(child_sums)
    
tree_root.tree_sum()

27

class Node:

    def tree_sum(self):
        child_sums = []
        for child in self._children:
            child_sums.append(child.tree_sum())
        return self.value + sum(child_sums)

    def __init__(self, value, parent):
        self.value = value
        self._parent = parent
        self._children = []

    def add_child(self, value):
        child = Node(value, self)
        self._children.append(child)
        return child

root = Node(4, None)
node_8 = root.add_child(8)
node_3 = node_8.add_child(3)
node_1 = node_8.add_child(1)
node_7 = node_1.add_child(7)
node_4 = node_1.add_child(4)

print(root.tree_sum())

nums = [1, 2, 3, 4, 5]

list(map(lambda x: x**3, nums))

[1, 8, 27, 64, 125]

print(list(map(lambda x: x**3, nums)))

nums = [1, 2, 3, 4, 5]

list(filter(lambda x: x%2==0, nums))

[2, 4]

print(list(filter(lambda x: x%2==0, nums)))

from functools import reduce

nums = [1, 2, 3, 4, 5]

reduce(lambda x, y: x*y, nums)

120

print(reduce(lambda x, y: x*y, nums))

class Node:
    
    def reduce(self, fn):
        reduced_children = []
        for child in self._children:
            reduced_children.append(child.reduce(fn))
        return fn(self.value, reduced_children)
    
    def apply(self, fn, depth=0):
        self.value = fn(self.value, depth)
        for child in self._children:
            child.apply(fn, depth+1)
        return self
    
    def __init__(self, value, parent):
        self.value = value
        self._parent = parent
        self._children = []
        
    def add_child(self, value):
        child = Node(value, self)
        self._children.append(child)
        return child

tree_root = Node(4, None)
node_8 = tree_root.add_child(8)
node_3 = node_8.add_child(3)
node_1 = node_8.add_child(1)
node_7 = node_1.add_child(7)
node_4 = node_1.add_child(4)

def depth_gauge(x, y):
    if not y:
        return 0
    else:
        return max(y)+1

print('tree_sum:', tree_root.reduce(lambda x, y: x + sum(y)))
print('list_representation:', tree_root.reduce(lambda x, y: [x] + y))
print('tree_depth:', tree_root.reduce(lambda x, y: depth_gauge(x, y)))

def printer(x, depth):
    print(x, end=', ')
    return x

def depth_printer(x, depth):
    print('  '*depth + str(x))

print('Adding 1 to every node.')
tree_root.apply(lambda x, y: x+1)
print('Printing node values comma-separated:')
tree_root.apply(printer)
print('\nPrinting node values with depth to indicate nesting:')
tree_root.apply(depth_printer)

tree_sum: 27
list_representation: [4, [8, [3], [1, [7], [4]]]]
tree_depth: 3
Adding 1 to every node.
Printing node values comma-separated:
5, 9, 4, 2, 8, 5, 
Printing node values with depth to indicate nesting:
5
  9
    4
    2
      8
      5

<__main__.Node at 0x7fc3b0540c70>

def reduce(self, fn):
        reduced_children = []
        for child in self._children:
            reduced_children.append(child.reduce(fn))
        return fn(self.value, reduced_children)

    def tree_apply(self, fn, depth=0):
        self.value = fn(self.value, depth)
        for child in self._children:
            child.tree_apply(fn, depth+1)

def depth_gauge(x, y):
    if not y:
        return 0
    else:
        return max(y)+1

print(root.tree_reduce(lambda x, y: x + sum(y)))
print(root.tree_reduce(lambda x, y: [x] + y))
print(root.tree_reduce(lambda x, y: depth_gauge(x, y)))

def printer(x, depth):
    print(x)
    return x

def depth_printer(x, depth):
    print('  '*depth + str(x))

#root.tree_apply(lambda x, y: x+1)
#root.tree_apply(printer)
root.tree_apply(depth_printer)

from zcb import *

# Bag är en klass definierad i filen zcb.py
# Vad ser koden ut att göra?

bag = Bag()
bag.open()
bag.add("candy")
bag.close()

bag.open()
bag.add("egg")
bag.close()

bag.add("flower")
print(bag)

from zcb import *
    
# Bag är en klass definierad i filen zcb.py
# Vad ser koden ut att göra?
    
bag = Bag()
bag.open()
bag.add("candy")
bag.close()
    
bag.open()
bag.add("egg")
bag.close()
    
bag.add("flower")
print(bag)

Trying to open zipper...
The zipper is open.
Trying to add 'CANDY' to bag..
CANDY added.
Trying to close zipper...
The zipper is closed.
Trying to open zipper...
The zipper broke!
Cannot open zipper. The zipper is broken.
Trying to add 'EGG' to bag..
Open zipper first.
Trying to close zipper...
Cannot close zipper. The zipper is broken.
Trying to add 'FLOWER' to bag..
Open zipper first.
A green bag. The zipper is broken. The container is 20.0 percent full. Items: CANDY.

#from zcb import *
    
# Bag är en klass definierad i filen zcb.py
# Vad ser koden ut att göra?
    
bag = Bag()
bag.open()
bag.add("candy")
bag.close()
    
bag.open()
bag.add("egg")
bag.close()
    
bag.add("flower")
print(bag)

Trying to open zipper...
The zipper broke!
Cannot open zipper. The zipper is broken.
Trying to add 'CANDY' to bag..
Open zipper first.
Trying to close zipper...
Cannot close zipper. The zipper is broken.
Trying to open zipper...
Cannot open zipper. The zipper is broken.
Trying to add 'EGG' to bag..
Open zipper first.
Trying to close zipper...
Cannot close zipper. The zipper is broken.
Trying to add 'FLOWER' to bag..
Open zipper first.
A green bag. The zipper is broken. The container is 0.0 percent full. Items: None.

class Bag(object):

    def open(self):
        self._zipper.open()

class Zipper(object):

    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}")

class Bank(object):

    def __init__(self):
        self.clients = []

    def __str__(self):
        output = "THE BANK\n"
        for client in self.clients:
            output += f"{client}\n"
        return output


class Client(object):

    def __init__(self, name):
        self.name = name
        self.accounts = []

    def __str__(self):
        output = f"Client name: {self.name}\n  Accounts:\n"
        if len(self.accounts) > 0:
            for account in self.accounts:
                output += f"    {account}"
        else:
            output += "    No accounts."
        return output

class Bank(object):

    def __init__(self):
        self.clients = []

    def __str__(self):
        output = "THE BANK\n"
        for client in self.clients:
            output += f"{client}\n"
        return output

    
class Client(object):

    def __init__(self, name):
        self.name = name
        self.accounts = []

    def __str__(self):
        output = f"Client name: {self.name}\n  Accounts:\n"
        if len(self.accounts) > 0:
            for account in self.accounts:
                output += f"    {account}"
        else:
            output += "    No accounts."
        return output
class Account(object):

    def __init__(self, account_id):
        self.account_id = account_id
        self.transactions = []
        self.balance = 0.0

    def __str__(self):
        return f"#{self.account_id}: {self.balance}"

if __name__ == "__main__":
    bank = Bank()
    c1 = Client("Nario")
    bank.clients.append(c1)

    bank.clients.append(Client("Duigi"))
    a1 = Account(1)
    bank.clients[0].accounts.append(a1)

    print(bank)

if __name__ == "__main__":
    bank = Bank()
    c1 = Client("Nario")
    bank.clients.append(c1)

    bank.clients.append(Client("Duigi"))
    a1 = Account(1)
    bank.clients[0].accounts.append(a1)

    print(bank)

class Bank(object):

    def __init__(self):
        self._num_accounts = 0
        self._clients = []
        self._accounts = []

    def new_client(self, client_name):
        self._clients.append(Client(client_name))
        self.new_account(client_name)

    def new_account(self, client_name):
        client_found = False
        # leta efter kund
        for client in self._clients:
            if client.name == client_name:
                client_found = True
                break
        # avbryt om inte kunden hittas
        if not client_found:
            print(f"ERROR: No such client, '{client_name}'")
            return
        # skapa konto, lägg till banken och kunden
        else:
            self._num_accounts += 1
            new_account = Account(self._num_accounts)
            client.add_account(new_account)
            self._accounts.append(new_account)

    def __str__(self):
        output = "THE BANK\n"
        for client in self._clients:
            output += f"{client}\n"
        return output

class Bank(object):

    def __init__(self):
        self._num_accounts = 0
        self._clients = []
        self._accounts = []

    def new_client(self, client_name):
        self._clients.append(Client(client_name))
        self.new_account(client_name)

    def new_account(self, client_name):
        client_found = False
        # leta efter kund
        for client in self._clients:
            if client.name == client_name:
                client_found = True
                break
        # avbryt om inte kunden hittas
        if not client_found:
            print(f"ERROR: No such client, '{client_name}'")
            return
        # skapa konto, lägg till banken och kunden
        else:
            self._num_accounts += 1
            new_account = Account(self._num_accounts)
            client.add_account(new_account)
            self._accounts.append(new_account)
    
    def __str__(self):
        output = "THE BANK\n"
        for client in self._clients:
            output += f"{client}\n"
        return output


class Client(object):

    def __init__(self, name):
        self.name = name
        self._accounts = []

    def add_account(self, account):
        self._accounts.append(account)

    def __str__(self):
        output = f"Client name: {self.name}\n  Accounts:\n"
        for account in self._accounts:
            output += f"    {account}"
        return output


class Account(object):

    def __init__(self, account_id):
        self.account_id = account_id
        self._transactions = []
        self._balance = 0.0

    def __str__(self):
        return f"#{self._account_id}: {self._balance}"


if __name__ == "__main__":
    bank = Bank()
    bank.new_client("Nario")
    bank.new_client("Duigi")
    print(bank)

class Bank(object):

    def __init__(self):
        self._num_accounts = 0
        self._num_clients = 0
        self._clients = {}
        self._accounts = {}

    def new_client(self, client_name):
        self._num_clients += 1
        # endast för att göra efterföljande kod lättare att läsa
        client_id = self._num_clients
        self._clients[self._num_clients] = Client(client_name, client_id)
        self.new_account(client_id)

    def new_account(self, client_id):
        # avbryt om inte kunden hittas
        if client_id not in self._clients:
            print(f"ERROR: Client id '{client_id}' not found.")
        else:
            self._num_accounts += 1
            new_account = Account(self._num_accounts)
            # samma Account-instans läggs till både banken och kunden
            self._clients[client_id].add_account(new_account)
            self._accounts[self._num_accounts] = new_account

    def __str__(self):
        output = "THE BANK\n\n"
        for client in self._clients.values():
            output += f"{client}\n"
        return output

class Bank(object):

    def __init__(self):
        self._num_accounts = 0
        self._num_clients = 0
        self._clients = {}
        self._accounts = {}

    def new_client(self, client_name):
        self._num_clients += 1
        # endast för att göra efterföljande kod lättare att läsa
        client_id = self._num_clients
        self._clients[self._num_clients] = Client(client_name, client_id)
        self.new_account(client_id)

    def new_account(self, client_id):
        # avbryt om inte kunden hittas
        if client_id not in self._clients:
            print(f"ERROR: Client id '{client_id}' not found.")
        else:
            self._num_accounts += 1
            new_account = Account(self._num_accounts)
            # samma Account-instans läggs till både banken och kunden
            self._clients[client_id].add_account(new_account)
            self._accounts[self._num_accounts] = new_account

    def __str__(self):
        output = "THE BANK\n\n"
        for client in self._clients.values():
            output += f"{client}\n"
        return output


class Client(object):

    def __init__(self, name, client_id):
        self.name = name
        self.client_id = client_id
        self._accounts = []

    def add_account(self, account):
        self._accounts.append(account)

    def __str__(self):
        output = f"Client name: {self.name} (id: {self.client_id})\nAccounts:\n"
        for account in self._accounts:
            output += f"  {account}"
        return output


class Account(object):

    def __init__(self, account_id):
        self.account_id = account_id
        self._transactions = []
        self._balance = 0.0

    def __str__(self):
        return f"#{self._account_id}: {self._balance}"


if __name__ == "__main__":
    bank = Bank()
    bank.new_client("Nario")
    bank.new_client("Duigi")
    print(bank)

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()

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()

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()

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!")

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()

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)

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()

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)

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

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()

TDDE44 Programmering, grundkurs¶

Föreläsning 6.1-6.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt, FÖ 6.1-6.2¶

Slutsatser av halvtidsutvärderingen¶

Att programmera bättre?¶

generella principer

Vad menar vi med "bättre"?¶

Regel 0: Testa ofta¶

Skriv lättläst och lättöverskådlig kod¶

Dela upp ett problem

Delegera / skicka vidare uppgiften¶

Återanvända kod¶

DRY-principen¶

Klassdiagram i UML

repetition innan vi går vidare

Klassdiagram i UML¶

Klassdiagram, Laboration 5, Del 1

Association i klassdiagram¶

Exempel¶

Aggregation¶

Exempel: Städer, hushåll och befolkning

Aggregering av data¶

Aggregation i klassdiagram¶

Aggregering av data¶

Exempel på att delegera vidare uppgift/rollfördelning¶

Laboration 6 - Del 2. Uppgift 1¶

Laboration 6 - Del 2. Uppgift 2¶

Laboration 6 - Del 2. Uppgift 3¶

Nästlade strukturer av objekt¶

Nästlade strukturer, repetition¶

Trädstrukturer av objekt¶

En klass för trädstrukturer¶

En klass för trädstrukturer¶

En klass för trädstrukturer¶

Träd med Node¶

Trädsumma med Node¶

Vad gjorde jag för fel i tree_sum?¶

Jag bröt inkapslingen!¶

(och det var inte i en testfunktion)

Hur kommer vi runt det?¶

Vi gör tree_sum till en metod!¶

Är tree_sum-metoden bra?¶

Mellanspel: Varför reduce?¶

map¶

map, exempel¶

Kärt barn har många namn¶

filter¶

filter, exempel¶

Kärt barn har många namn¶

reduce¶

reduce, exempel¶

Kärt barn har många namn¶

Kan vi generalisera tree_sum-metoden?¶

Komposition¶

Exempel: En väska med dess delar och funktionalitet

Modell av en väska¶

Komposition av objekt¶

Komposition i klassdiagram¶

Klassdiagram i UML med alla klasser¶

bagscript.py¶

bagscript.py¶

zcb.py - klassen Bag¶

zcb.py - klassen Bag¶

zcb.py - Klassen Zipper¶

zcb.py - klassen Container¶

Demo¶

Laboration 6 - Del 1¶

Sammansättning och wrapper-metoder¶

Exempel, flera nivåer (3 klasser)¶

Bank har kunder. Kunder har konton

En första version¶

bank1.py¶

bank1.py¶

Metoder istället för att jobba direkt med instansvariablerna¶

Metoder istället för att jobba direkt med instansvariablerna¶

bank2.py¶

bank2.py¶

Exempel på förändring av implementation av modell/abstaktion: dictionarys istället för listor¶

Exempel på förändring av implementation av modell/abstaktion: dictionarys istället för listor¶

Träd med `Node`¶

Trädsumma med `Node`¶

Vad gjorde jag för fel i `tree_sum`?¶

Vi gör `tree_sum` till en metod!¶

Är `tree_sum`-metoden bra?¶

Mellanspel: Varför `reduce`?¶

`map`¶

`map`, exempel¶

`filter`¶

`filter`, exempel¶

`reduce`¶

`reduce`, exempel¶

Kan vi generalisera `tree_sum`-metoden?¶

`bagscript.py`¶

`bagscript.py`¶

`zcb.py` - klassen `Bag`¶

`zcb.py` - klassen `Bag`¶

`zcb.py` - Klassen `Zipper`¶

`zcb.py` - klassen `Container`¶

`bank1.py`¶

`bank1.py`¶

`bank2.py`¶

`bank2.py`¶

`bank3.py`¶

`bank3.py`¶

`interaktionsloop1.py` med interaktionsloop¶

`interaktionsloop2a.py` med dictionary och funktionsobjekt¶

`interaktionsloop2b.py` med dictionary och funktionsobjekt¶

`interaktionsloop3.py` med interaktiv funktion som skapar ny kund¶

`interaktionsloop4.py` med utbruten bekräftelsefunktion¶

`interaktionsloop4.py`¶

`interaktionsloop5.py` med instans som huvudprogram¶