9021_TUT_1

Slide 1: Introduction

Today, we are going to walk through six Python functions that perform various tasks involving integers, lists, and text files. Each function demonstrates different ways to manipulate data, including string formatting, list processing, and reading from files.

Slide 2: Function 1 - f1(m, n)

The first function, f1, generates a simple string pattern. Here’s how it works:

def f1(m, n):
    return ('|' + '_' * n + '|') * m

1. The function takes two integer arguments, m and n. Both are assumed to be at least 0.
2. It constructs a pattern consisting of vertical bars (|) enclosing underscores (_), repeated m times. The number of underscores between the bars is determined by n.
3. For example, if m = 3 and n = 4, the output would be:

   |____||____||____|

Slide 3: Function 2 - f2(n)

The second function, f2, creates a square pattern made up of digits. Here’s the function:

def f2(n):
    return (str(n) * n + '\n') * n

1. This function takes an integer n and generates a square of n rows, where each row contains the digit n repeated n times.
2. The pattern ends with a newline after each row.
3. For example, if n = 3, the output will be:

   333
   333
   333

Slide 4: Function 3 - f3(L)

Next, we have f3, which works on a list of integers:

def f3(L):
    while len(L) > 1 and L[0] > L[1]:
        L.remove(L[0])
    print(L)

1. This function removes elements from the start of the list until the first two consecutive elements are in non-decreasing order.
2. The process continues as long as the first element is strictly greater than the second element.
3. Once the list is stable, it prints the modified list.
4. For example, if L = [9, 8, 7, 10], the function will remove 9, 8, and 7, leaving [10].

Slide 5: Function 4 - f4(D, n)

The fourth function, f4, works with dictionaries:

def f4(D, n):
    if n not in D:
        return []
    ans = [n]
    while n in D and D[n] > n:
        ans.append(D[n])
        n = D[n]
    return ans

1. This function takes a dictionary D and an integer n. It generates a strictly increasing sequence of integers based on the relationships defined in the dictionary.
2. Starting from n, it appends D[n], D[D[n]], and so on to the list, as long as each subsequent value is greater than the previous one.
3. For example, if D = {1: 2, 2: 3, 3: 5} and n = 1, the function will return [1, 2, 3, 5].

Slide 6: Function 5 - f5(filename)

The fifth function, f5, reads from a file and processes each line:

def f5(filename):
    with open(filename) as f:
        for i in f:
            name, number = i.split(',')
            number = int(number) * 1000
            print(f"{number} people named {name}")

1. This function reads a text file, where each line consists of a name and a count separated by a comma.
2. The function multiplies the count by 1000 and prints the result in the format: “X people named Y”.
3. For example, if the file contains a line “John,5”, it will print:

   5000 people named John

Slide 7: Function 6 - f6(filename)

The final function, f6, also reads from a text file, but with a different format:

def f6(filename):
    with open(filename) as f:
        for i in f:
            if not i.isspace():
                number, charactor = i.split()
                print(int(number) * charactor)

1. This function reads lines that contain an integer followed by a symbol (e.g., “5 *”).
2. It multiplies the symbol by the integer and prints the result.
3. For example, if the file contains the line “3 # “, the function will print:

   ###