Изучаем Python по книге Лутца

s = 'spam'
for i in s:
    v = ord(i)
    print(v, end=' ')

s = 'spam'
for i in s:
    v = ord(i)
    print(v, end=' ')
print(sum(v))

>>> X = 'Spam'
>>> def func():
         X = 'NI'
         def nested():
                 print(X)
         nested()
 
    
>>> func()
NI
>>> X
'Spam'

1.    X = 'Spam'                          # глобальной переменной X присваивается значение 'Spam'.
2.    def func():                           # определяется функция с именем func
 
3.        X = 'NI'    # внутри функции func локальной переменной X присваивается значение 'NI' , так как глобальная   
                             переменная X внутри функции не доступна для записи, и поэтому создается локальная переменная X.
4.        def nested():      # внутри функции func определяется вложенная функция nested, для которой функция func 
                                       является объемлющей.
5.                   print(X)    # все что делает функция nested, это печатает значение переменной X из ближайшей области 
                                        видимости, где есть переменная с именем X.
                                     #  рассмотрим области видимости в соответствии с правилом LEGB: ближайшая область видимости,
                                         где есть X, это область объемлющей функции func, где X присвоено значение 'NI'. Поэтому, 
                                         когда бы мы не вызывали функцию nested, она будет выводить на экран значение X 
                                         из объемлющей области, в данном случае 'NI'.
6.        nested()             # находясь внутри функции func, но снаружи функции nested, при работе функции func, 
                                         эта инструкция вызовет функцию функцию nested, которая,  как мы выяснили выше, 
                                         выведет на экран 'NI'.
Так как мы работаем в интерактивном режиме, то все что возвращают выражения и функции сразу выводится на экран
без использования инструкции print.
 
9. func()                           # вызывается функция func . Так как у функции func() нет внутри инструкции return. то она
                                           ничего не возвращает и потому она сама ничего не выводит на экран, но она вызывает
                                           вложенную функцию nested,  которая используя print(X) выводит на экран значение 'NI'.
11. X                               # интерпритатор в интерактивном режиме выводит значение переменной X из глобальной области.               
                                           (так как мы на данны момент уже вышли из функций и находимся в глобальной области. 
                                          Поэтому выводится значение 'Spam'

def func():
    n = int(input())
    i = 0
    for i in range(n):
        print('+___', sep='', end=' ')
    print()
 
    for i in range(n):
        print('|', i + 1, ' /', sep='', end=' ')
    print()
 
    for i in range(n):
        print('|', "__", '\\', sep='', end=' ')
    print()
 
    for i in range(n):
        print('|   ', sep='', end=' ')
    print()
 
func()

5
+___ +___ +___ +___ +___
|1 / |2 / |3 / |4 / |5 /
|__\ |__\ |__\ |__\ |__\
|    |    |    |    |

for i in range(1, 11):
    for j in range(1, 11):
        print(i * j, end=' ')
    print()

1 2 3 4 5 6 7 8 9 10 
2 4 6 8 10 12 14 16 18 20 
3 6 9 12 15 18 21 24 27 30 
4 8 12 16 20 24 28 32 36 40 
5 10 15 20 25 30 35 40 45 50 
6 12 18 24 30 36 42 48 54 60 
7 14 21 28 35 42 49 56 63 70 
8 16 24 32 40 48 56 64 72 80 
9 18 27 36 45 54 63 72 81 90 
10 20 30 40 50 60 70 80 90 100

print(end='\n')

# По данному натуральному n≤9 выведите лесенку из n ступенек, i-я ступенька состоит из чисел от 1 до i без пробелов.
N = int(input())
for x in range(1, N+1):
    print(*range(1, x+1), sep='')

print(1, 2, 3, sep='')

5
1
12
123
1234
12345

def mysum (L) :
    print(L)
    if not L:
        return 0
    else:
        return L[0] + mysum(L[l:]) # Рекурсивный вызов самой себя
#»> mysum([1, 2, 3, 4, 5])

L = [1, 2, 3, 4, 5]
sum = О
while L:
    sum += L[0]
    L = L[l:]

L = [1, 2, 3, 4, 5]
sum = О
for х in L: sum += x

>>> def mysum (L) :
    if not L:
        return 0
    else:
         return L[0] + mysum(L[1:]) # Рекурсивный вызов самой себя
 
        
>>> mysum([1, 2, 3, 4, 5])
15

>>> def mysum (L) :
    print(L)
    if not L:
        return 0
    else:
         return L[0] + mysum(L[1:]) # Рекурсивный вызов самой себя
 
        
>>> mysum([1, 2, 3, 4, 5])
[1, 2, 3, 4, 5]
[2, 3, 4, 5]
[3, 4, 5]
[4, 5]
[5]
[]
15
>>>

>>> L = [1, 2, 3, 4, 5]
>>> sum = 0
>>> while L:
    sum += L[0]
    L = L[1:]
    
>>> sum
15

depth = 0
def mysum (L) :
    global depth
    res = 0
    depth +=1
    if not L:
        res = 0
    else:
        
        # здесь мы только предвычисляем, готовим базу для вычислений
        print("прямой ход рекурсии:  D:[%02d] Res=>[%-2d]:" % (depth,res), L)
        res = L[0] + mysum(L[1:]) # рекурсивный вызов - водораздел двух этапов вычислений
        depth -=1
        #  а вот на этой стадии происходит непосредственый возврат значений всех помещенных в стек вызовов функций
        print("обратный ход рекурсии D:[%02d] Res=>[%-2d]:" % (depth,res), L)
    
    return res
        
mysum([1, 2, 3, 4, 5])