for i in iterator:
    # do something
else:
    # do something else

This may look quite counterintuitive for the first time, but we will unwrap it in a moment! ✨

First, let's review the basic syntax of a for loop in Python. A for loop allows you to iterate over an iterator (such as a list, tuple, or string) and execute a block of code for each value. Here's an example:

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

This code would output:

apple
banana
cherry

Simple example

Now, let's add an else clause to this loop:

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)
else:
    print("No more fruits")

This code would output:

apple
banana
cherry
No more fruits

In this case, the else block is executed after the for loop has finished normally. If the loop is exited early (for example, by a break statement), the else block will not be executed.

Linear search example

This for..else can be quite helpful in some scenarios. For example, you can use it to check if a value exists in a list:

values = [1, 2, 3, 4, 5]
for value in values:
    if value == 6:
        print("Value found!")
        break
else:
    print("Value not found.")

Let's take a look at another version without using for...else:

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

found = False
for value in values:
    if value == 6:
        found = True
        break

if found:
    print("Value found!")
else:
    print("Value not found.")

You can see, we have to introduce a boolean flag if we do not use the else clause. This makes the control flow more complex.

Breaking out of nested loops

In Python, the break statement only terminates the nearest enclosing loop. In some cases, you may want to break out of a parent loop.

Consider this code that determines if n is a prime number:

n = 11

if n <= 1:
    print(f"{n} is not a prime number!")
    exit()

for i in range(2, n):
    for j in range(2, n):
        if i * j == n:
            print(f"{n} is not a prime number!")
            break
    else:
        continue # only executed if the inner loop did NOT break
    break # only executed if the inner loop DID break
else:
    print(f"{n} is a prime number!")

It works by iterating over all pairs of numbers (i, j) less than n and checking if the product of any of them is equal to n. In the case where we find i * j is equal to n, we can say that n is not a prime number and we would want to exit the outer for loop early.

If the inner loop completes successfully (i.e., without breaking), it means that no pairs of numbers were found whose product equals n. In this case, the else clause of the inner loop is executed. This else clause triggers the continue statement, which causes the outer loop to immediately proceed to the next value of i without executing the remaining code in the outer loop.

If the inner loop breaks at any point, the else clause of the inner loop is skipped and the outer loop would reach the break statement, which breaks the outer loop as well.

PEP 3136 is a Python Enhancement Proposal that proposes support for labels in break and continue statements. However, it was rejected due to the complexity it would add to Python.

The example I have shown above is one of the workarounds that produce clean code. Another solution is to put the code in a function and use return instead. Using a function is usually preferred because code with low cyclomatic complexity is usually more maintainable.

Problem

The code snippet below is an example of a Rust program that can potentially block. It uses the Command struct from the std::process module to spawn a new process that runs the ffmpeg command. It reads an audio file in mp3 format from standard input (stdin), passes it to ffmpeg as input, convert the audio file to ogg format, and then reads the output from ffmpeg and writes it to standard output (stdout).

fn main() {
    let mut cmd = Command::new("ffmpeg")
        .arg("-i")
        .arg("-")
        .arg("-c:a")
        .arg("libopus")
        .arg("-f")
        .arg("ogg")
        .arg("-")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .unwrap();

    let mut input_data = Vec::new();
    stdin().read_to_end(&mut input_data).unwrap();
    let mut output_data = Vec::new();

    let mut stdin = cmd.stdin.take().unwrap();
    let mut stdout = cmd.stdout.take().unwrap();

    stdin.write_all(&input_data).unwrap();
    stdout.read_to_end(&mut output_data).unwrap();

    let exit_status = cmd.wait().unwrap();

    if !exit_status.success() {
        panic!("ffmpeg failed");
    }
}

In this scenario, the Rust program is using the write_all method to write data to the stdin pipe, which is connected to the ffmpeg child process. The ffmpeg process is writing data to its stdout pipe, but nobody is consuming that data.

When the stdout pipe buffer fills up, the ffmpeg process will block while trying to write further data. This means it will also stop reading data from stdin, causing the stdin pipe buffer to fill up. When the stdin pipe buffer is full, the parent Rust process will also block while trying to write further data.

Solution

To avoid this issue, the program can use another thread to write the data to stdin, allowing the ffmpeg process to read from stdin and the parent process to write to it concurrently.

fn main() {
    let mut cmd = Command::new("ffmpeg")
        .arg("-i")
        .arg("-")
        .arg("-c:a")
        .arg("libopus")
        .arg("-f")
        .arg("ogg")
        .arg("-")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .unwrap();

    let mut input_data = Vec::new();
    stdin().read_to_end(&mut input_data).unwrap();
    let mut output_data = Vec::new();

    let mut stdin = cmd.stdin.take().unwrap();
    let mut stdout = cmd.stdout.take().unwrap();

    // Use a thread to write to stdin
    let writer = thread::spawn(move || {
        stdin.write_all(&input_data).unwrap();
    });

    stdout.read_to_end(&mut output_data).unwrap();

    writer.join().unwrap();

    let exit_status = cmd.wait().unwrap();

    if !exit_status.success() {
        panic!("ffmpeg failed");
    }
}

Why am I doing this?

I'm working on a Telegram bot that can send voice messages.

Since the sendVoice API in Telegram only accepts .OGG file encoded with OPUS, I created this simple Rust program wrapped in an Actix Web server.

Source code: https://github.com/lzm0/mpeg2opus

If you want to get the current LocalDateTime in a different time zone, the best approach is to use an Instant and then convert it to a ZonedDateTime. Use ZonedDateTime.toLocalDateTime to extract the LocalDateTime part of this date-time.

The example below shows how clocks were turned forward and backward an hour in java.time during DST changes in 2022.

import java.time.{ZoneId, ZonedDateTime, LocalDateTime, Instant}
import java.time.temporal.ChronoUnit

val halfAnHourBeforeDstStarted = Instant.parse("2022-03-13T07:30:00.00Z")
val halfAnHourBeforeDstEnds = Instant.parse("2022-11-06T06:30:00.00Z")

/*
Mar 13, 2022 - Daylight Saving Time Started
Sunday, March 13, 2022, 2:00:00 am clocks were turned forward 1 hour to
Sunday, March 13, 2022, 3:00:00 am local daylight time instead.
 */
halfAnHourBeforeDstStarted.atZone(ZoneId.of("US/Central")).toLocalDateTime
// = 2022-03-13T01:30
halfAnHourBeforeDstStarted
  .plus(1, ChronoUnit.HOURS)
  .atZone(ZoneId.of("US/Central"))
  .toLocalDateTime
// = 2022-03-13T03:30

/*
Nov 6, 2022 - Daylight Saving Time Ends
Sunday, November 6, 2022, 2:00:00 am clocks are turned backward 1 hour to
Sunday, November 6, 2022, 1:00:00 am local standard time instead.
 */
halfAnHourBeforeDstEnds.atZone(ZoneId.of("US/Central")).toLocalDateTime
// = 2022-11-06T01:30
halfAnHourBeforeDstEnds
  .plus(1, ChronoUnit.HOURS)
  .atZone(ZoneId.of("US/Central"))
  .toLocalDateTime
// = 2022-11-06T01:30

reference: https://www.timeanddate.com/time/change/usa

Reduce example:

scala> (1 to 10).reduce(_ * _)
val res0: Int = 3628800

Fold example:

scala> (1 to 10).fold(0)(_ * _)
val res0: Int = 0

scala> (1 to 10).fold(1)(_ * _)
val res1: Int = 3628800

This is because reduce requires the operator to be both commutative and associative, whereas fold requires the operator to be associative only.

A reminder of some basic arithmetics concepts:

Commutative property: \[ a + b = b + c \]

Associative property: \[ (a + b) + c= a + (b + c) \]