Thread by @mathsppblog

Are you as curious (and nerdy 🤓) as I am? 🤔

If you are, you are going to love what I'm about to show you 🤯

Let's build a Python 🐍 quine: a program that prints itself!

This thread walks you through the process of building the quine you can see here.

👇🧵

If we want a program that _prints_ itself, we need to start with a print statement:

```
print()
```

When we run this program, a single newline gets printed as output.

But we want a program that prints itself, right?

So let's try putting the program in the `print`.

For that, we try opening " inside the `print` and we start typing the program, itself, inside the string:

```
print("print()")
```

This outputs

```
print()
```

But now our program grew, so we need to keep up with it inside the string.

The code

```
print("print(\"print()\")")
```

produces

```
print("print()")
```

But this is starting to look like a wild goose chase.

The number of prints in the input is always larger than the number of prints on the output.

We need another way of making the output larger.

We need to be able to _reuse_ what we type, otherwise we will always print less than what we typed in the program.

Ok, so let's initialise a string variable and try printing it:

```
s = "print(s)"
print(s)
```

outputs

```
print(s)
```

Doesn't look like we made any progress!

Except, now we can use string formatting to use the string `s` twice, but we only type it once in our source code!

We can try printing `s` twice, with a newline in the middle, because our source code also spans over two lines:

```
s = "print(s)"
print(f"{s}\n{s}")
```

Prints:

```
print(s)
print(s)
```

We need to update `s` to reflect the print statement we have.

Because of nested ", let's intercalate single and double quotes:

```
s = 'print(f"{s}\\n{s}")'
print(f"{s}\n{s}")
```

This produces:

```
print(f"{s}\n{s}")
print(f"{s}\n{s}")
```

This is looking promising!

Now we need the first line of output to look like the assignment statement to `s`.

Let's sprinkle some 's = ':

```
s = 'print(f"s = {s}\\n{s}")'
print(f"s = {s}\n{s}")
```

Prints:

```
s = print(f"s = {s}\n{s}")
print(f"s = {s}\n{s}")
```

We are SO CLOSE!

The issue now is that the first line of output is missing the quotes around the assignment and the \\ because of the escaped newline character...

This is actually easier to solve than it might sound if you know how to use `repr`:

mathspp.com/blog/pydonts/s…

When doing string formatting, using '!r' outputs the `repr` of an object instead of its `str`:

```
s = 'print(f"s = {s!r}\\n{s}")'
print(f"s = {s!r}\n{s}")
```

This prints..:

```
s = 'print(f"s = {s!r}\\n{s}")'
print(f"s = {s!r}\n{s}")
```

The output matches source 100%!!!

I hope you enjoyed this thread!

If you did, follow me (@mathsppblog) for more content like this ;)

Also, retweet the beginning of the thread so more people can build their first quine!!

See you next time 👋

https://twitter.com/mathsppblog/status/1439236568712159237?s=19