Python and DSA for international students in Germany

Sources: Wissenschaft weltoffen, Im Fokus, Internationale Studierende nach Herkunftsländern; Wissenschaft weltoffen kompakt 2026, English edition (June 2026 version, figures 6, 10, 12 and 37), read 2 and 3 November 2026. Shares appear exactly as published. Modern Age Coders has no link to the DAAD, the DZHW or any university.

The gap we see most often is not syntax. Students can write a loop, read a CSV file and plot a chart. What they have rarely been taught is that x in some_list and x in some_set look identical on the screen and behave completely differently once the data grows. That is a data-structures question, and it is where this course starts.

Our task. A course register holds 50,000 eight-digit student IDs. Today's attendance list has 2,000 IDs: half are taken from the register, half are random. How many attendance IDs are on the register? We answer three ways: search the plain list, search a sorted copy with bisect, and search a set. All IDs are invented.

import bisect
import random
import time

random.seed(44)
register = random.sample(range(10_000_000, 99_999_999), 50_000)
checks = random.sample(register, 1_000) + [random.randrange(10_000_000, 99_999_999) for _ in range(1_000)]

def in_list(ids, queries):
    return sum(1 for q in queries if q in ids)

def in_sorted(ids, queries):
    found = 0
    for q in queries:
        i = bisect.bisect_left(ids, q)
        if i < len(ids) and ids[i] == q:
            found += 1
    return found

def in_set(ids, queries):
    return sum(1 for q in queries if q in ids)

start = time.perf_counter()
as_sorted = sorted(register)
print(f"building the sorted list {(time.perf_counter() - start) * 1000:.2f} ms")
start = time.perf_counter()
as_set = set(register)
print(f"building the set         {(time.perf_counter() - start) * 1000:.2f} ms")
for label, func, data in [("list, x in l", in_list, register),
                          ("sorted list + bisect", in_sorted, as_sorted),
                          ("set, x in s", in_set, as_set)]:
    start = time.perf_counter()
    found = func(data, checks)
    took = time.perf_counter() - start
    print(f"{label:22} found {found:3}  {took * 1000:8.2f} ms")

Our own code, seed 44. The timer is time.perf_counter, documented by Python as its highest-resolution clock for measuring short spans. 1,001 rather than 1,000 are found because one of the random IDs happens to be on the register.

All three agree on the answer, which is the first thing to check. Then read the times against the cost table. The list checks IDs one by one, O(n) per lookup, and it shows: about a third of a second. The sorted list halves its search range each step, O(log n), so about sixteen comparisons per lookup among 50,000 IDs. The set goes, on average, straight to the right place. The build lines matter too: sorting cost 4.04 ms and building the set 0.74 ms, so even for a single batch of 2,000 lookups both pay for themselves many times over. For one single lookup, they would not, and the plain list would be the sensible choice.

1. Run it. Note your own five times. Is the ratio between list and set similar to ours?
2. Double the register. Make it 100,000 IDs and predict, before running, which line roughly doubles and which barely moves.
3. Find the break-even. Reduce the attendance list until building the set costs more than it saves. How many lookups is that?
4. Explain it in two sentences, in English, as if to a lab partner who wrote the list version.

Students from engineering and science often bring their own data: sensor logs, measurement series, simulation output. Where they can share it, we use it in block 2 and block 5, because a structure chosen for your own thesis data is remembered far longer than one chosen for an exercise. Students who also want technical interview practice can continue into our data structures and algorithms course with timed mock problems.

We do not do coursework, theses or graded assignments for anyone; university rules on own work apply, and the point is that you can do it. Questions about visas, residence or student jobs go to the university's international office; we do not advise on them.

Germany runs on MEZ (UTC+1) in winter and MESZ (UTC+2) in summer, as set by the Einheitenzeitgesetz; the winter switch was on 25 October 2026 and the summer switch is on 28 March 2027. India is UTC+5:30 the whole year. Sample slots, not fixed groups.

During exam periods many students pause group classes or move to fewer one-to-one sessions. Tell the mentor your semester dates and the plan follows them.