our_string = "The cake is a lie"
our_list = list(our_string)
print(our_list)

['T', 'h', 'e', ' ', 'c', 'a', 'k', 'e', ' ', 'i', 's', ' ', 'a', ' ', 'l', 'i', 'e']

What this does is essentially looping though the string, one character at a time, and then putting each element in the list. Rarely very useful.

What is useful is splitting the string whenever a certain character appears

our_string = "The cake is a lie"
our_list = our_string.split(" ")
print(our_list)

['The', 'cake', 'is', 'a', 'lie']

our_dictionary = {"some key": "some value"}
print(our_dictionary["some key"])             # You can fetch using the bracket syntax

our_dictionary["some key"] = "another value"  # It's easy to create (in this case write over) an entry
print(our_dictionary.pop("some key"))         # Removes and returns the value with the given key
assert len(our_dictionary) == 0               # Our dictionary is now empty

our_dictionary[1] = "one"                     # We can even have keys of different types in the same dict
our_dictionary["one"] = 1
print(our_dictionary)                         # A dict like this might be useful for... something.

s = 1
for i in range(101):
    s = our_dictionary[s]
print(s)

some value
another value
{1: 'one', 'one': 1}
one

def multiply_by_2(n):
    """This is a so called docstring"""
    return n*2

Running it

our_list = []
for i in range(10):
    our_list.append(multiply_by_2(i))
print(our_list)

A shorter way to write it is:

print([multiply_by_2(i) for i in range(10)])   # This is called a list comprehension

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

def fibonacci(n):
    """Returns the n'th Fibonacci number using iteration"""
    i = 1
    j = 0
    for _ in range(n):
        tmp = i
        i += j
        j = tmp
    return i

def fibonacci(n):
    """Returns the n'th Fibonacci number using recursion"""
    if n < 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

def add_one(i):
    return i+1

def f(g, argument):
    """Runs and returns g(argument)"""
    return g(argument)

i = 0
while i < 10;
  i = f(add_one, 1)
print("Done! Ran " + str(i) + " times!")

def logging_decorator(f):
    def g():
        print("Will now execute function")
        f()
        print("Function executed")
    return g

def f():
    print("Running function")
f = logging_decorator(f)   # Passes a function into another function which
                           # returns a new function which is assigned to f

The last part can be written with the fancy decorator syntax as:

@logging_decorator
def f():
    print("Running function")

They are exactly equivalent

class Animal:
    def __init__(self, name):
        self.name = name

    def walk_to(self, animal):
        print(self.name + " walks to " + animal.name)

class Dog(Animal):
    def __init__(self, name, loud=False):
        Animal.__init__(self, name)   # Run the Animal constructor on self before continuing
        self.loud = loud

    def bark(self):
        if self.loud:
            print("WOOF!")
        else:
            print("woof!")

toto = Dog("Toto")   # Toto is a fictional dog in L. Frank Baum's Oz series of children's books
toto.bark()

fluffy = Dog("Fluffy", loud=True)    # A giant three-headed dog from Harry Potter
fluffy.walk_to(toto)
fluffy.bark()