Lists

A list is a countable sequence of ordered and repeatable elements. It is countable because there is a proper way of knowing the length of the list (i.e. how many elements it contains). In particular, ThyMopani makes available a particular support algorithm, i.e. def len(countable_object), that takes a countable element as input (like a list), and returns the number of elements that it contains. Its elements are ordered because they are placed in the list in a specific order, which is preserved even if we add or remove particular elements. Its elements are also repeatable since they may appear more than one time in the list.

Of course, there exist several real examples of such abstract lists in real-life objects. For instance, in Figure 2, we show a table of content of a book and a bibliographic reference list of an article. Both of them are concrete objects that are built starting from the abstract notion of a list. 

In ThyMopani, a new list can be instantiated by means of the constructor list(). For instance, my_first_list = list() will create an empty list and associates it to the variable my_first_list. A list can be seen as a left-to-right sequence of elements, where the left-most identifies the head of the list, while the last one represents the tail of the list. Several operations can be done on lists, in particular:

• the method <list>.append(<element>) is used for adding a new element to the list – for instance, my_first_list.append(34) and ​my_first_list.append(15) will add the number 34 to the list, and the number 15 as follower of the previous one;

• the method <list>.remove(<element>) is used for removing the first instance of an element in the list – for instance, my_first_list.remove(34) will remove the first number 34 which is encountered by scanning the list from its begin (i.e. from the first-added elements to the last-added ones), obtaining, thus, a list with just the element 15 included in it;
• the method <list>.extend(<another_list>) is used for adding all the elements included in <another_list> to the current list – for instance, if we have the list my_second_list​ containing the numbers 1 and 83, my_first_list.extend(my_second_list) will add 1 and 83 as followers of 15.

In Listing 1, we show some examples of the use of lists in ThyMopani. In these examples, we describe with natural language comments (introduced by a #) the various aspects related to the creation and modification of lists.

​my_first_list = list()  # this creates a new list

my_first_list.append(34)  # these two lines add two numbers
my_first_list.append(15)  # to the list in this precise order
# currently my_first_list contains two elements: 
# list([ 34, 15 ])

my_first_list.append("Silvio")  # a list can contains element of any kind
# now my_first_list contains: 
# list([34, 15, "Silvio"])

my_first_list.remove(34)  # it removes the first intance of the number 34
# my_first_list became: 
# list([15, "Silvio"])

my_first_list.extend(my_first_list)  # it add again all the elements in my_first_list to the list itself
# current status of my_first_list: 
# list([15, "Silvio", 15, "Silvio"])

my_first_list_len = len(my_first_list) # it stores 4 in my_first_list_len

Stacks

A stack is a kind of list seen from a particular perspective, i.e. from bottom to top, and with a specific set of operations. Figure 3 shows two different example of stacks in real-life objects. We have a stack of chairs (left) and a pile of books (right). The main characteristic of the elements of this structure is that they follow a last in first out strategy (LIFO) for addition and removal. Basically, it means that the last element inserted in the structure is placed in the top of the stack and, thus, it is also the first one that will be removed when requested. In addition, to obtain the element placed, for instance, in the middle of the stack, we necessarily need to remove all the elements that have been added after such middle element, from the most recent elements to the eldest ones.

In ThyMopeni, a new stack can be instantiated by means of the constructor deque(). For instance, my_first_stack = deque() will create an empty stack and associates it to the variable my_first_stack. Three main operations can be done on stacks, in particular:

• the method <stack>.append(<element>) is used for adding a new element on the top of the stack – for instance, my_first_stack.append(34) and ​my_first_stack.append(15) will add the number 34 to the stack, and the number 15 upon previous one;

• the method <stack>.pop() is used for removing the element on the top of the stack, that will be returned – for instance, my_first_stack.pop() will remove the number 15 and will be returned as well, obtaining, thus, a stack with just the element 34 included in it;
• the method <stack>.extend(<another_stack>) is used for adding all the elements included in <another_stack> on the top of the current stack – for instance, if we have the list my_second_stack containing the numbers 1 and 83, my_first_stack.extend(my_second_stack) will add 1 and 83 on top of 34.

In Listing 2, we show some examples of the use of stacks in ThyMopani. In particular, we organise in a stack some books (actually, their titles) written by Neil Gaiman.

​my_first_stack = deque()  # this creates a new stack

my_first_stack.append("Good Omens")  # these two lines add two books
my_first_stack.append("Neverwhere")  # to the stack in this precise order (this is on top)
# currently my_first_stack contains two elements: 
#        "Neverwhere"])
# deque(["Good Omens",

my_first_stack.append("The Name of the Rose")  # add a new book
# now my_first_stack contains:
#        "The Name of the Rose")]
#        "Neverwhere",
# deque(["Good Omens",

my_first_stack.pop()  # it removes the element on top of the stack, i.e. "The Name of the Rose"
# my_first_stack became:
#        "Neverwhere"])
# deque(["Good Omens",

​my_second_stack = deque()  # this creates a new stack
my_second_stack.append("American Gods")   # these two lines add two books
my_second_stack.append("Fragile Things")  # to the stack in this precise order (this is on top)
# currently my_second_stack contains two elements: 
#        "Fragile Things"])
# deque(["American Gods",

my_first_stack.extend(my_second_stack)  # it add all the elements in my_second_stack on top of my_first_stack
# current status of my_first_stack:
#        "Fragile Things"])
#        "American Gods",
#        "Neverwhere",
# deque(["Good Omens",

Queue

A queue is a kind of list seen by another perspective, i.e. from left to right, and with a specific set of operations. Figure 4  shows two different example of queues in real-life objects. We have a queue of children (left) and a line of cabs (right). The main characteristic of the elements of this structure is that they follow a first in first out strategy (FIFO) for addition and removal. Basically, it means that the first element inserted in the structure is placed in the left-most part of the queue and, thus, it is also the first one that will be removed when requested. Similar to stacks, even in queues it is necessary to remove all the elements that have been added before a certain target element – i.e. from the eldest elements to the most recent ones – to obtain it.

In ThyMopeni, a new stack can be instantiated by means of the constructor deque(), which is the same used for stasks. Thus, it is the way one uses it that classifies the object instantiated as a stack or a queue. Thus, as before, my_first_queue = deque() will create an empty queue and associates it to the variable my_first_queue. Three main operations can be done on stacks, in particular:

• the method <queue>.append(<element>) is used for adding a new element on at the first available position in the queue, i.e. from the right of the queue – for instance, my_first_queue.append(34) and ​my_first_queue.append(15) will add the number 34 to the queue as the first element, and the number 15 after the previous one;

• the method <queue>.leftpop() is used for removing the first element of the queue, i.e. the first appended, that will be returned – for instance, my_first_queue.leftpop() will remove the number 34 and will be returned as well, obtaining, thus, a queue with just the element 15 included in it;
• the method <queue>.extend(<another_queue>) is used for adding all the elements included in <another_queue> after (i.e. on the right of) those ones already included in the current queue – for instance, if we have the list my_second_queue containing the numbers 1 and 83, my_first_queue.extend(my_second_queue) will add 1 and 83 after 34.

In Listing 3, we show some examples of the use of queues in ThyMopani. In particular, we organise in a queue some (fictional) people that are waiting in the library so as to borrow some books.

​​my_first_queue = deque()  # this creates a new queue

my_first_stack.append("Vanessa Ives")  # these two lines add two people
my_first_stack.append("Mike Wheeler")  # to the stack in this precise order (this is on top)
# currently my_first_queue contains two elements: 
# deque(["Vanessa Ives", "Mike Wheeler")

my_first_queue.append("Eleven")  # add a new person
# now my_first_queue contains:
# deque(["Vanessa Ives", "Mike Wheeler", "Eleven"])

my_first_stack.popleft()  # it removes the first element added in the queue, i.e. "Vanessa Ives"
# my_first_stack became:
# deque(["Mike Wheeler", "Eleven"])

​my_second_queue = deque()  # this creates a new queue
my_second_queue.append("Micheal Walsh")   # these two lines add two people
my_second_queue.append("Lawrence Cohen")  # to the queue in this precise order
# currently my_second_queue contains two elements: 
# deque(["Michael Walsh", "Lawrence Cohen"])

my_first_queue.extend(my_second_queue)  # it add all the elements in my_second_queue on the right of my_first_queue
# current status of my_first_queue:
# deque(["Mike Wheeler", "Eleven", "Michael Walsh", "Lawrence Cohen"])