Data Structures and Functions on kodkod | Intro Course

list: Creating, Accessing, Adding, Removing, Searching and Looping

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

list is the most common data structure in Python. We already used it briefly. Today we will learn it properly:

tuple and set: a Fixed Record and a Collection Without Duplicates

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

Two more data structures, each with a “superpower” of its own:

tuple — like a list, but fixed: it cannot be changed after it is created.
set — a collection without duplicates and without order, which lets you check very quickly whether a value is in it.

Why do we need this?

A tuple suits data that represents one record with a fixed structure: a point (x, y), a date (2026, 10, 6), a row from a Database (7, "Dana", 24). In the backend and databases topics, every row that comes back from the Database will arrive as a tuple! Being fixed guarantees that no code changes a record “by mistake”.
A set suits cases where you want uniqueness: how many different users visited the site today? Which tags does a post have? Who is registered for two courses at once?

Explanation from the basics

tuple

A tuple is an ordered sequence of values, that cannot be changed (Immutable). Once it is created, you cannot add, remove or replace items.

dict: Key and Value

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

A dict (Dictionary) is a structure that holds pairs of a key and a value. Instead of accessing by position ([0]), you access by name (["name"]).

Slicing, Mutable versus Immutable, and is versus ==

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

Slicing — how to cut out part of a list, a tuple or a string.
Mutable versus Immutable — what can be changed and what cannot, and why it matters.
References — what happens when you write b = a.
is versus == — “the same value” versus “exactly the same object”.

Why do we need this?

Slicing is everywhere: the first 10 results, the last 3 characters of a card number (****1234), “page 2” of a list.
Mutable is the source of one of the most confusing bugs in Python: “I changed one list, and suddenly the second one changed too!”. Understanding this topic prevents hours of debugging. And in the OOP topic, objects of classes behave exactly like this.

Explanation from the basics

Slicing

Slicing creates a new sequence from part of an existing sequence:

Functions in Depth: Default Values, Functions as Objects, *args, **kwargs and Lambda

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

In the clean code and debugging topic we learned the basics: def, parameters, return. Today we will learn a few abilities that make functions much more flexible:

Scope: Local, Enclosing, Global and Built-in (LEGB)

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

Scope = the area of the code where a name (a variable or a function) is known. We will learn:

Pure Functions and Side Effects

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

What a Pure Function is.
What a Side Effect is — and which kinds exist.
The trap of changing a list that was received as a parameter.
How to write a pure version of a function.

Why do we need this?

Here is a function that looks innocent:

Higher-Order Functions: Functions That Receive and Return Functions

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

What a Higher-Order Function is.
How to pass a function as a parameter — and why without brackets.
The built-in functions map and filter.
The key parameter of sorted, max and min.
A function that returns a function.

Why do we need this?

Two almost identical functions:

Nested Functions, Closures and nonlocal

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

Nested Function — a function defined inside a function.
Enclosing — the E of LEGB, up close.
Closure — a function that “remembers” variables.
nonlocal — how to change a variable of the enclosing function.

Why do we need this?

A private helper function: sometimes a function needs a small helper function that belongs only to it. There is no reason for it to be global and get mixed up with the rest of the code.
Functions that remember state: in the previous lesson we saw that make_multiplier(2) returns a function that “remembers” the number 2. Today we will understand how it works — and how to build a counter, an accumulator or a cache without global.

Explanation from the basics

A function inside a function

You can define a def inside a def. The inner function:

Decorators: Adding Behavior to a Function Without Touching It

Mon, 01 Jan 0001 00:00:00 +0000

What will we learn?

What a Decorator is and why it is useful.
How to build a Decorator: a function that receives a function and returns a wrapper.
The @ syntax.
A wrapper that fits any function, with *args and **kwargs.

Why do we need this?

We want to print a message every time a function is called — for debugging: