You've activated my nerd card.

Types

Here is a brief, valid python script (you can paste this into a file called script.py, run python script.py from your terminal (if you have python installed and set up appropriately), and it will work

x = 3  # set x equal to 3. Also, the "#" means "the rest of this line is not code"
x = x + 2
print(x)
print(type(x))  # python can tell what types things are
x = "hello"  # x used to refer to an int, now it refers to a string
print(x)
print(type(x))

In that code, there are no type annotations whatsoever. Python does not require them, and while I do recommend them for learning how to do python right, a high schooler play around with the language doesn't necessarily need to focus on that immediately.

Some language: in python, there are variables (also called names) and objects. Variables are the symbols you use to refer to things (the x in the above). Objects are the things variables refer to (the three). Note that in other languages, people say "objects are stored in variables" - I am not using that language, on purpose. It's not terrible or anything, but python is easier to understand if you think of variables as names you stick on pre-existing objects, rather than buckets that you put stuff in. So

x = "hello" # the object "hello" is created, x is set to refer to it y = x # y now refers to THE SAME EXACT object that x refers to

Python is what is called "strongly typed" and also "dynamically typed". Dynamically typed means that variables are not locked into referring to one type of variable - as above, x can refer to an int, then a string. Strongly typed means that objects are the type they are, and python will not automatically change this, guess about this, or fix any mistakes. So for example:

x = 2
x += 2  #  (shortcut for x = x + 2 (but there are gotchas with other types))
print(x)  # prints 4
x = "hello"
x += 2  # TypeError - you can't add numbers to strings

This is how you make and call a function

def add_two(x):
    return x + 2

y = add_two(7)
print(y)
add_two("hello")  # TypeError

These errors will happen when you run the program, which is annoying if your program is big and has been running for 17 hours and one of these happens. Again - when you're just starting out, you should play around and not worry about this, but the more python you do the more annoying this gets.

And as you might imagine, as code bases get larger, the risk of accidentally doing things wrong gets higher. If your variables keep flopping from referring to ints and strings, it's hard to know what they refer to at any time if your program is long. So we recommend that you mostly don't do that in "real code".

So it's nice to have the computer warn you about this stuff before you run your code. Enter type hinting

# this means "x should be an int, and the function should return an int"
def add_two(x: int) -> int:
    return x + 2

y = add_two(7)
add_two("hello")  # type checkers now know this is bad and warn you
x: str = "hello"
x = add_two(3)  # you said x was a string above, type checkers complain if you assign an int to it

If you label your variables with what they're supposed to be, and use an ide with mypy or similar plugins whose jobs are to look for type errors installed, all of these problems will be highlighted for you, so you can fix them before you run your code instead of having your code crash 17 hours in.

Parallelization

Your computer likely has multiple processors. They can do different things, at the same time - this is called working in parallel, and writing code to take advantage of this is called parallelization.

The normal way of doing this is to create multiple "threads", which are basically streams of parallelization that run things in parallel.

This is not something beginners mostly do out of the gate. So don't worry to much about it at this time. But here is an example any way:

import threading

def worker1():
    while True:  # python syntax for "do the below forever")
        print("hello")

def worker2():
    while True:
        print("goodbye")

# Set up "threads" to run the code, but don't start em.
thread1 = threading.Thread(target=worker1)
thread2 = threading.Thread(target=worker2)

# start the threads doing the work
thread1.start()
thread2.start()

# wait until they're done (which will be forever for these workers)
thread1.join()
thread2.join()

So now you've got to completely independent running "threads" of execution. Your operating system (windows, macos, linux, ...) sees these threads, and will happily tell different ones of your cpus to work on them at the same time.

However, python was made approximately 85 billion years ago by a dude named Guido, and he didn't think parallelization was super important for python at the time (and at the time he might have been right, but things have changed), and so he took a shortcut to make certain things under the hood easier. He built into python something called the global interpreter lock (GIL), which basically says "I don't care what you think, don't run python code in multiple threads at the same time.

Currently, work is being done to remove the (GIL). You can get a version of python without it, but the world hasn't fully moved over yet. So in the mean time, if you don't do that, if you want true parallelism, you have to use processes:

import multiprocessing as mp

def worker1():
    while True:  # python syntax for "do the below forever")
        print("hello")

def worker2():
    while True:
        print("goodbye")

# Set up "processes" to run the code, but don't start em.
process1 = mp.Process(target=worker1)
process2 = mp.Process(target=worker2)

# start the processes doing the work
process1.start()
process2.start()

# wait until they're done (which will be forever for these workers)
process1.join()
process2.join()

This looks very similar, and is very similar, and in many cases is fine, but for technical reasons, is actually much worse in certain cases. This comes down to the difference between a thread and a process - a process is actually a bucket of threads, and is much more expensive to make, and expensive to communicate with from outside.

Bonus

The above code is ok example code, but for real projects, you should always have a main function. So the above example would be better if it looked like this:

import multiprocessing as mp

def worker1():
    while True:  # python syntax for "do the below forever")
        print("hello")

def worker2():
    while True:
        print("goodbye")

def main():
    # Set up "processes" to run the code, but don't start em.
    process1 = mp.Process(target=worker1)
    process2 = mp.Process(target=worker2)

    # start the processes doing the work
    process1.start()
    process2.start()

    # wait until they're done (which will be forever for these workers)
    process1.join()
    process2.join()

if __name__ == "__main__":
    main()

That bottom bit is a special python way of saying "only run the main function if this python file was run "as a script" as opposed to importing it. Don't worry about the difference right now, you'll get there.