P1

'''
there cannot be more than one instruction in a line.
'''

'''
print() begins its output from a new line each time it starts its execution; you can change this behavior, but you can also use it to your advantage;
'''

'''
the instructions in the code are executed in the same order in which they have been placed in the source file; no next instruction is executed until the previous one is completed (there are some exceptions to this rule, but you can ignore them for now)
'''

print("The itsy bitsy spider . \
climbed up the waterspout.")
print()
print("Down came the rain\nand washed the spider out.")

'''
The itsy bitsy spider . climbed up the waterspout.

Down came the rain
and washed the spider out.
'''

'''
The backslash (\) has a very special meaning when used inside strings - this is called the escape character.
'''

'''
print("\") SyntaxError: EOL while scanning string literal
'''

print("\\") # \
print("The itsy" , "bitsy" , "spider") # The itsy bitsy spider

'''
a print() function invoked with more than one argument outputs them all on one line;
the print() function puts a space between the outputted arguments on its own initiative.

The print() function - the positional way of passing the arguments

a keyword argument consists of three elements: a keyword identifying the argument (end here); an equal sign (=); and a value assigned to that argument;
any keyword arguments have to be put after the last positional argument (this is very important)
'''

print("My name is", "Python.", end=" ")
print("Monty Python.") # My name is Python. Monty Python.

print("My", "name", "is", "Monty", "Python.", sep="-") # My-name-is-Monty-Python.

print("My", "name", "is", sep="_", end="|||")
print("Monty", "Python.", sep="*", end="*\n") # My_name_is|||Monty*Python.*

'''
A literal is data whose values are determined by the literal itself.

you can write this number either like this: 11111111, or like that: 11_111_111

If an integer number is preceded by an 0O or 0o prefix (zero-o), it will be treated as an octal value. This means that the number must contain digits taken from the [0..7] range only.

0o123 is an octal number with a (decimal) value equal to 83.

The print() function does the conversion automatically.

Hexadecimal numbers should be preceded by the prefix 0x or 0X (zero-x).

0x123 is a hexadecimal number with a (decimal) value equal to 291. The print() function can manage these values too.
'''
print(12_3_47 + 3); # 12350

print(0o123) # 83
print(0x123) #123

print(.4, 4.) # 0.4 4.0
print(3E8) # 300000000.0

print(3.6E-84) # 3.6e-84
print(0.0000000000000000000001) # 1e-22

'''
Python always chooses the more economical form of the number's presentation, and you should take this into consideration when creating literals.
'''

print("I like \"Monty Python\"") # I like "Monty Python"
print('I like "Monty Python"') # I like "Monty Python"

'''
string can be empty - it may contain no characters at all.

''
""
'''

print(True > False) # True
print(True < False) # False
print(True == False) # False
print(not True == False) # True

print('"I\'m"\n""learning""\n"""Python"""') #"I'm"
""learning""
"""Python"""

'''
1011 is 11 because (2**3) + 0 + (2**1) + (2**0) = 11
'''

print(2+2) # 4

'''
Remember: Data and operators when connected together form expressions. The simplest expression is a literal itself.
'''

print(2 ** 3) # 8
print(2 ** 3.) # 8.0
print(2.3 ** 3) # 12.166999999999998
print(2. ** 3.4) # 10.556063286183154

print(2 * 3) # 6
print(2 * 3.) # 6.0
print(2. * 3) # 6.0
print(2. * 3.) # 6.0

print(6 / 3) # 2.0
print(6 / 3.) # 2.0
print(6. / 3) # 2.0
print(6. / 3.) # 2.0

print(6 // 3) # 2
print(6 // 3.) # 2.0
print(6. // 3) # 2.0
print(6. // 3.) # 2.0

print(6 // 4) # 1
print(6. // 4) # 1.0
print(-6 // 4) # -2
print(6. // -4) # -2.0

'''
// (double slash) sign is an integer divisional operator,
 its result lacks the fractional part - it's absent (for integers),
 or is always equal to zero (for floats);
 this means that the results are always rounded to the lesser integer;
'''

print(14 % 4) # 2
print(12 % 4.5) # 3.0
print(0 / 3) # 0.0
print(0.1 / 0) # ZeroDivisionError: float division by zero

print(-4 + 4) # 0
print(-4. + 8) # 4.0

print(-4 - 4) # -8 # used as unary and binary operator
print(4. - 8) # -4.0 # used as binary operator
print(-1.1) # -1.1 # used as unary operator

print(+2) #. 2

print(9 % 6 % 2) # 1 # left side binding
print(2 ** 2 ** 3) # 256 # right side binding

'''
Priority    Operator
1   +, -    unary
2   **
3   *, /, //, %
4   +, -    binary
'''
print(2 * 3 % 5) # 1
print((5 * ((25 % 13) + 100) / (2 * 13)) // 2) # 10.0

'''
1. An expression is a combination of values (or variables, operators, calls to functions - you will learn about them soon) which evaluates to a value, e.g., 1 + 2.

2. Operators are special symbols or keywords which are able to operate on the values and perform (mathematical) operations, e.g., the * operator multiplies two values: x * y.

3. Arithmetic operators in Python: + (addition), - (subtraction), * (multiplication), / (classic division - always returns a float), % (modulus - divides left operand by right operand and returns the remainder of the operation, e.g., 5 % 2 = 1), ** (exponentiation - left operand raised to the power of right operand, e.g., 2 ** 3 = 2 * 2 * 2 = 8), // (floor/integer division - returns a number resulting from division, but rounded down to the nearest whole number, e.g., 3 // 2.0 = 1.0)

4. A unary operator is an operator with only one operand, e.g., -1, or +3.

5. A binary operator is an operator with two operands, e.g., 4 + 5, or 12 % 5.

6. Some operators act before others - the hierarchy of priorities:

unary + and - have the highest priority
then: **, then: *, /, and %, and then the lowest priority: binary + and -.
7. Subexpressions in parentheses are always calculated first, e.g., 15 - 1 * (5 * (1 + 2)) = 0.

8. The exponentiation operator uses right-sided binding, e.g., 2 ** 2 ** 3 = 256.
,,,
print((2 ** 4), (2 * 4.), (2 * 4)) # 16 8.0 8
print((-2 / 4), (2 / 4), (2 // 4), (-2 // 4)) # -0.5 0.5 0 -1
print((2 % -4), (2 % 4), (2 ** 3 ** 2)) # -2 2 512

'''
the name of the variable must be composed of upper-case or lower-case letters, digits, and the character _ (underscore)
the name of the variable must begin with a letter;
the underscore character is a letter;
upper- and lower-case letters are treated as different (a little differently than in the real world - Alice and ALICE are the same first names, but in Python they are two different variable names, and consequently, two different variables);
the name of the variable must not be any of Python's reserved words (the keywords - we'll explain more about this soon).
'''

'''
Keywords
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''
print(AbraCaDabra) # NameError: name 'AbraCaDabra' is not defined

var = 3
print("Python version: " + var) # TypeError: can only concatenate str (not "int") to str

a = 3.0
b = 4.0
c = (a ** 2 + b ** 2) ** 0.5 # √ (x)  = x(½)
print("c =", c) # 5.0

'''
1. A variable is a named location reserved to store values in the memory. A variable is created or initialized automatically when you assign a value to it for the first time. (2.1.4.1)

2. Each variable must have a unique name - an identifier. A legal identifier name must be a non-empty sequence of characters, must begin with the underscore(_), or a letter, and it cannot be a Python keyword. The first character may be followed by underscores, letters, and digits. Identifiers in Python are case-sensitive. (2.1.4.1)

3. Python is a dynamically-typed language, which means you don't need to declare variables in it. (2.1.4.3) To assign values to variables, you can use a simple assignment operator in the form of the equal (=) sign, i.e., var = 1.

4. You can also use compound assignment operators (shortcut operators) to modify values assigned to variables, e.g., var += 1, or var /= 5 * 2. (2.1.4.8)

5. You can assign new values to already existing variables using the assignment operator or one of the compound operators, e.g.: (2.1.4.5)

var = 2
print(var)

var = 3
print(var)

var += 1
print(var)


6. You can combine text and variables using the + operator, and use the print() function to output strings and variables, e.g.: (2.1.4.4)

var = "007"
print("Agent " + var)
'''

a = 6
b = 3
a /= 2 * b
print(a) # 1.0

anything = input("Tell me anything...")
print(anything)

'''
result of the input() function is a string.
'''

anything = float(input("Enter a number: "))
print(anything ** 2.0) # 4 -> 16.0

print("James" * 3) # JamesJamesJames
print(3 * "caT") # caTcaTcaT
print(0 * "caT") #
print(-10 * "caT") #

print("No " + str(4)) # No 4

'''
1. The print() function sends data to the console, while the input() function gets data from the console.

2. The input() function comes with an optional parameter: the prompt string. It allows you to write a message before the user input, e.g.:

name = input("Enter your name: ")
print("Hello, " + name + ". Nice to meet you!")


3. When the input() function is called, the program's flow is stopped, the prompt symbol keeps blinking (it prompts the user to take action when the console is switched to input mode) until the user has entered an input and/or pressed the Enter key.

NOTE

You can test the functionality of the input() function in its full scope locally on your machine. For resource optimization reasons, we have limited the maximum program execution time in Edube to a few seconds. Go to Sandbox, copy-paste the above snippet, run the program, and do nothing - just wait a few seconds to see what happens. Your program should be stopped automatically after a short moment. Now open IDLE, and run the same program there - can you see the difference?

Tip: the above-mentioned feature of the input() function can be used to prompt the user to end a program. Look at the code below:

name = input("Enter your name: ")
print("Hello, " + name + ". Nice to meet you!")

print("\nPress Enter to end the program.")
input()
print("THE END.")


3. The result of the input() function is a string. You can add strings to each other using the concatenation (+) operator. Check out this code:

num_1 = input("Enter the first number: ") # Enter 12
num_2 = input("Enter the second number: ") # Enter 21

print(num_1 + num_2) # the program returns 1221


4. You can also multiply (* - replication) strings, e.g.:

my_input = input("Enter something: ") # Example input: hello
print(my_input * 3) # Expected output: hellohellohello
'''

x = input("Enter a number: ") # The user enters 2
print(type(input("Enter a number: "))) # <class 'str'>

'''
== is a binary operator with left-sided binding. It needs two arguments and checks if they are equal.
'''

The question will be as follows:

black_sheep == 2 * white_sheep


Due to the low priority of the == operator, the question shall be treated as equivalent to this one:

black_sheep == (2 * white_sheep) # True # Due to low priority of == operator, be treated as black_sheep == 2 * white_sheep
print(4 == 2 * 2) # True
print(4 == 2 + 2) # True

'''
Priority    Operator
1   +, -    unary
2   **
3   *, /, //, %
4   +, -    binary
5   <, <=, >, >=
6   ==, !=
'''
print(2 == 2.) # True # Python is able to convert the integer value into its real equivalent

'''
note: if there is more than one instruction in the indented part, the indentation should be the same in all lines; even though it may look the same if you use tabs mixed with spaces, it's important to make all indentations exactly the same - Python 3 does not allow mixing spaces and tabs for indentation.
'''

if sheep_counter >= 120:
    make_a_bed() # executed conditionally
    take_a_shower() # executed conditionally
    sleep_and_dream() # executed conditionally
feed_the_sheepdogs() # executed always

if the_weather_is_good:
    if nice_restaurant_is_found:
        have_lunch()
    else:
        eat_a_sandwich()
else:
    if tickets_are_available:
        go_to_the_theater()
    else:
        go_shopping()

if the_weather_is_good:
    go_for_a_walk()
elif tickets_are_available:
    go_to_the_theater()
elif table_is_available:
    go_for_lunch()
else:
    play_chess_at_home()

'''
you mustn't use else without a preceding if;
else is always the last branch of the cascade, regardless of whether you've used elif or not;
else is an optional part of the cascade, and may be omitted;
if there is an else branch in the cascade, only one of all the branches is executed;
if there is no else branch, it's possible that none of the available branches is executed.
''''

# Read two numbers
number1 = int(input("Enter the first number: "))
number2 = int(input("Enter the second number: "))

# Choose the larger number
if number1 > number2:
    larger_number = number1
else: larger_number = number2

# Print the result
print("The larger number is:", larger_number)

'''
1. The comparison (or the so-called relational) operators are used to compare values. The table below illustrates how the comparison operators work, assuming that x = 0, y = 1, and z = 0:

Operator    Description Example
==  returns if operands' values are equal, and False otherwise
x == y  # False
x == z  # True

!=  returns True if operands' values are not equal, and False otherwise
x != y  # True
x != z  # False

>   True if the left operand's value is greater than the right operand's value, and False otherwise
x > y  # False
y > z  # True

<   True if the left operand's value is less than the right operand's value, and False otherwise
x < y  # True
y < z  # False

≥ True if the left operand's value is greater than or equal to the right operand's value, and False otherwise
x >= y  # False
x >= z  # True
y >= z  # True

≤ True if the left operand's value is less than or equal to the right operand's value, and False otherwise
x <= y  # True
x <= z  # True
y <= z  # False

2. When you want to execute some code only if a certain condition is met, you can use a conditional statement:

a single if statement, e.g.:

x = 10

if x == 10: # condition
    print("x is equal to 10")  # Executed if the condition is True.


a series of if statements, e.g.:

x = 10

if x > 5: # condition one
    print("x is greater than 5")  # Executed if condition one is True.

if x < 10: # condition two
    print("x is less than 10")  # Executed if condition two is True.

if x == 10: # condition three
    print("x is equal to 10")  # Executed if condition three is True.


Each if statement is tested separately.
'''
x, y, z = 5, 10, 8
x, y, z = z, y, x

print(x > z) # True
print((y - 5) == x) # False



x = 10

if x == 10:
    print(x == 10)  # True
if x > 5:
    print(x > 5)  # True
if x < 10:
    print(x < 10)
else:
    print("else")  # else


x = "1"

if x == 1:
    print("one")
elif x == "1":
    if int(x) > 1:
        print("two")
    elif int(x) < 1:
        print("three")
    else:
        print("four") # four
if int(x) == 1:
    print("five") # five
else:
    print("six")


x = 1
y = 1.0
z = "1"

if x == y:
    print("one") # one
if y == int(z):
    print("two") # two
elif x == y:
    print("three")
else:
    print("four")

'''
when the condition is met, if performs its statements only once; while repeats the execution as long as the condition evaluates to True.

Note: all the rules regarding indentation are applicable here, too.

if you want to execute more than one statement inside one while, you must (as with if) indent all the instructions in the same way;
an instruction or set of instructions executed inside the while loop is called the loop's body;
if the condition is False (equal to zero) as early as when it is tested for the first time, the body is not executed even once (note the analogy of not having to do anything if there is nothing to do);
the body should be able to change the condition's value, because if the condition is True at the beginning, the body might run continuously to infinity - notice that doing a thing usually decreases the number of things to do).

'''

while True:
    print("I'm stuck inside a loop.") # infinite loop


---
# Store the current largest number here.
largest_number = -999999999

# Input the first value.
number = int(input("Enter a number or type -1 to stop: "))

# If the number is not equal to -1, continue.
while number != -1:
    # Is number larger than largest_number?
    if number > largest_number:
        # Yes, update largest_number.
        largest_number = number
    # Input the next number.
    number = int(input("Enter a number or type -1 to stop: "))

# Print the largest number.
print("The largest number is:", largest_number)

---
# A program that reads a sequence of numbers
# and counts how many numbers are even and how many are odd.
# The program terminates when zero is entered.

odd_numbers = 0
even_numbers = 0

# Read the first number.
number = int(input("Enter a number or type 0 to stop: "))

# 0 terminates execution.
while number != 0:
    # Check if the number is odd.
    if number % 2 == 1:
        # Increase the odd_numbers counter.
        odd_numbers += 1
    else:
        # Increase the even_numbers counter.
        even_numbers += 1
    # Read the next number.
    number = int(input("Enter a number or type 0 to stop: "))

# Print results.
print("Odd numbers count:", odd_numbers)
print("Even numbers count:", even_numbers)

'''
two forms are equivalent:

while number != 0: and while number:.

if number % 2 == 1: and if number % 2:.
'''

counter = 5 # Using a counter variable to exit a loop
while counter != 0:
    print("Inside the loop.", counter)
    counter -= 1
print("Outside the loop.", counter)

---
i = 0
while i < 10:
    print("Not 10 yet")
    i += 1
---
for i in range(10):
    print("Not 10 yet")
    pass

'''
the for keyword opens the for loop; note - there's no condition after it; you don't have to think about conditions, as they're checked internally, without any intervention;
any variable after the for keyword is the control variable of the loop; it counts the loop's turns, and does it automatically;
the in keyword introduces a syntax element describing the range of possible values being assigned to the control variable;
the range() function (this is a very special function) is responsible for generating all the desired values of the control variable; in our example, the function will create (we can even say that it will feed the loop with) subsequent values from the following set: 0, 1, 2 .. 97, 98, 99; note: in this case, the range() function starts its job from 0 and finishes it one step (one integer number) before the value of its argument;
note the pass keyword inside the loop body - it does nothing at all; it's an empty instruction - we put it here because the for loop's syntax demands at least one instruction inside the body (by the way - if, elif, else and while express the same thing)
'''
for i in range(10):
    print("The value of i is currently", i)

'''
the loop has been executed ten times (it's the range() function's argument)
the last control variable's value is 9 (not 10, as it starts from 0, not from 1)
'''

for i in range(2, 8):
    print("The value of i is currently", i)

'''
range() first argument determines the initial value of the control variable. 2 here.

last argument is first value the control variable will not be assigned ,8 here. It goes only till 7.

Note: the range() function accepts only integers as its arguments, and generates sequences of integers.
'''
for i in range(2, 8, 3):
    print("The value of i is currently", i)

# The value of i is currently 2
# The value of i is currently 5

'''
range() function's third argument is an increment - it's a value added to control the variable at every loop turn (as you may suspect, the default value of the increment is 1).
'''

for i in range(1, 1):
    print("The value of i is currently", i) # No output, set generated by the range() function is empty

for i in range(1, 2, 3):
    print("The value of i is currently", i) # The value of i is currently 1

for i in range(2, 1):
    print("The value of i is currently", i) # No output, set generated by the range() has to be sorted in ascending order.
# second argument must be greater than the first

power = 1
for expo in range(16):
    print("2 to the power of", expo, "is", power)
    power *= 2


import time
for second in range(1, 6):
    print(second, "Mississippi")
    time.sleep(1) # suspend execution for one second

'''
break - exits the loop immediately, and unconditionally ends the loop's operation; the program begins to execute the nearest instruction after the loop's body;
continue - behaves as if the program has suddenly reached the end of the body; the next turn is started and the condition expression is tested immediately.
'''
for i in range(1, 4):
    if i == 2:
        break
    print("Before break.", i) # Before break. 1


for i in range(1, 4):
    if i == 2:
        continue
    print("Not with continue", i)
# Not with continue 1
# Not with continue 3

i = 1
while i < 2:
    print(i)
    i += 1
else:
    print("else:", i)
# 1
# else: 2

'''
loop's else branch is always executed once, regardless of whether the loop has entered its body or not
'''

i = 111
for i in range(2, 1):
    print(i)
else:
    print("else:", i) # else: 111

'''
1. There are two types of loops in Python: while and for:

the while loop executes a statement or a set of statements as long as a specified boolean condition is true, e.g.:

# Example 1
while True:
    print("Stuck in an infinite loop.")

# Example 2
counter = 5
while counter > 2:
    print(counter)
    counter -= 1


the for loop executes a set of statements many times; it's used to iterate over a sequence (e.g., a list, a dictionary, a tuple, or a set - you will learn about them soon) or other objects that are iterable (e.g., strings). You can use the for loop to iterate over a sequence of numbers using the built-in range function. Look at the examples below:

# Example 1
word = "Python"
for letter in word:
    print(letter, end="*")

# Example 2
for i in range(1, 10):
    if i % 2 == 0:
        print(i)


2. You can use the break and continue statements to change the flow of a loop:

You use break to exit a loop, e.g.:

text = "OpenEDG Python Institute"
for letter in text:
    if letter == "P":
        break
    print(letter, end="")


You use continue to skip the current iteration, and continue with the next iteration, e.g.:

text = "pyxpyxpyx"
for letter in text:
    if letter == "x":
        continue
    print(letter, end="")

3. The while and for loops can also have an else clause in Python. The else clause executes after the loop finishes its execution as long as it has not been terminated by break, e.g.:

n = 0

while n != 3:
    print(n)
    n += 1
else:
    print(n, "else")

print()

for i in range(0, 3):
    print(i)
else:
    print(i, "else")


4. The range() function generates a sequence of numbers. It accepts integers and returns range objects. The syntax of range() looks as follows: range(start, stop, step), where:

start is an optional parameter specifying the starting number of the sequence (0 by default)
stop is an optional parameter specifying the end of the sequence generated (it is not included),
and step is an optional parameter specifying the difference between the numbers in the sequence (1 by default.)
Example code:

for i in range(3):
    print(i, end=" ")  # Outputs: 0 1 2

for i in range(6, 1, -2):
    print(i, end=" ")  # Outputs: 6, 4, 2
'''

'''
and is binary operator with a priority that is lower than the one expressed by the comparison operators
or is binary operator with a lower priority than and
not is unary operator performing a logical negation with priority very high, same as the unary + and -.

not (p and q) == (not p) or (not q)
not (p or q) == (not p) and (not q)

Bitwise Operators: arguments of these operators must be integers
& (ampersand) - bitwise conjunction;
| (bar) - bitwise disjunction;
~ (tilde) - bitwise negation;
^ (caret) - bitwise exclusive or (xor).

& requires exactly two 1s to provide 1 as the result;
| requires at least one 1 to provide 1 as the result;
^ requires exactly one 1 to provide 1 as the result.

x = x & y  =>   x &= y
x = x | y  =>   x |= y
x = x ^ y  =>   x ^= y
'''
Binary left shift and binary right shift is applied only to integer

shifting a value one bit to the left thus corresponds to multiplying it by two; respectively, shifting one bit to the right is like dividing by two (notice that the rightmost bit is lost).

value << bits
value >> bits

The left argument of these operators is an integer value whose bits are shifted. The right argument determines the size of the shift.

updated priority table, containing all the operators introduced so far:

Priority    Operator
1   ~, +, - unary
2   **
3   *, /, //, %
4   +, -    binary
5   <<, >>
6   <, <=, >, >=
7   ==, !=
8   &
9   |
10  =, +=, -=, *=, /=, %=, &=, ^=, |=, >>=, <<=

17 >> 1 → 17 // 2 (17 floor-divided by 2 to the power of 1) → 8 (shifting to the right by one bit is the same as integer division by two)
17 << 2 → 17 * 4 (17 multiplied by 2 to the power of 2) → 68 (shifting to the left by two bits is the same as integer multiplication by four)
'''

print(17, 17 << 2, 17 >> 1) # 17 68 8

'''
Key takeaways

1. Python supports the following logical operators:

and → if both operands are true, the condition is true, e.g., (True and True) is True,
or → if any of the operands are true, the condition is true, e.g., (True or False) is True,
not → returns false if the result is true, and returns true if the result is false, e.g., not True is False.
2. You can use bitwise operators to manipulate single bits of data. The following sample data:

x = 15, which is 0000 1111 in binary,
y = 16, which is 0001 0000 in binary.
will be used to illustrate the meaning of bitwise operators in Python. Analyze the examples below:

& does a bitwise and, e.g., x & y = 0, which is 0000 0000 in binary,
| does a bitwise or, e.g., x | y = 31, which is 0001 1111 in binary,
˜  does a bitwise not, e.g., ˜ x = 240*, which is 1111 0000 in binary,
^ does a bitwise xor, e.g., x ^ y = 31, which is 0001 1111 in binary,
>> does a bitwise right shift, e.g., y >> 1 = 8, which is 0000 1000 in binary,
<< does a bitwise left shift, e.g., y << 3 = , which is 1000 0000 in binary,

* -16 (decimal from signed 2's complement) -- read more about the Two's complement operation.
'''

x = 1
y = 0
z = ((x == y) and (x == y)) or not(x == y)
print(not(z)) # False


x = 4
y = 1
a = x & y
b = x | y
c = ~x  # tricky!
d = x ^ 5
e = x >> 2
f = x << 2
print(a, b, c, d, e, f) # 0 5 -5 1 1 16

'''
Lists: Elements may have different types, indexing starting from zero any expression can be index

You can't access an element which doesn't exist
'''

numbers = [10, 5, 7, 99, 17]
print(len([0, 1])) # 2
del numbers[1]
print(numbers[4]) # IndexError: list index out of range
print(numbers[-1]) # 17
print(numbers[-2]) # 99
print(numbers[-(len(numbers))]) # 10
numbers.append(4) # [10, 7, 99, 17, 4]
numbers.insert(0, 222) # [222, 10, 7, 99, 17, 4]

for i in range(5):
    print(i) # 1 2 3 4 5

for i in [1, 2, 3, 4, 5]:
    print(i) # 1 2 3 4 5

a = 1
b = 2
a, b = b, a

m = [10, 1, 8, 3, 5]
m[0], m[4] = m[4], m[0]
m[1], m[3] = m[3], m[1]
print(m)

my_list = [10, 1, 8, 3, 5]
for i in range(len(my_list) // 2):
    my_list[i], my_list[length - i - 1] = my_list[length - i - 1], my_list[i] # [5, 3, 8, 1, 10]

'''
1. The list is a type of data in Python used to store multiple objects. It is an ordered and mutable collection of comma-separated items between square brackets, e.g.:

my_list = [1, None, True, "I am a string", 256, 0]


2. Lists can be indexed and updated, e.g.:

my_list = [1, None, True, 'I am a string', 256, 0]
print(my_list[3])  # outputs: I am a string
print(my_list[-1])  # outputs: 0

my_list[1] = '?'
print(my_list)  # outputs: [1, '?', True, 'I am a string', 256, 0]

my_list.insert(0, "first")
my_list.append("last")
print(my_list)  # outputs: ['first', 1, '?', True, 'I am a string', 256, 0, 'last']


3. Lists can be nested, e.g.:

my_list = [1, 'a', ["list", 64, [0, 1], False]]

You will learn more about nesting in module 3.1.7 - for the time being, we just want you to be aware that something like this is possible, too.

4. List elements and lists can be deleted, e.g.:

my_list = [1, 2, 3, 4]
del my_list[2]
print(my_list)  # outputs: [1, 2, 4]

del my_list  # deletes the whole list


Again, you will learn more about this in module 3.1.6 - don't worry. For the time being just try to experiment with the above code and check how changing it affects the output.

5. Lists can be iterated through using the for loop, e.g.:

my_list = ["white", "purple", "blue", "yellow", "green"]

for color in my_list:
    print(color)


6. The len() function may be used to check the list's length, e.g.:

my_list = ["white", "purple", "blue", "yellow", "green"]
print(len(my_list))  # outputs 5

del my_list[2]
print(len(my_list))  # outputs 4


7. A typical function invocation looks as follows: result = function(arg), while a typical method invocation looks like this:result = data.method(arg).
'''
lst = [1, 2, 3, 4, 5]
lst.insert(1, 6)
del lst[0]
lst.append(1)
print(lst) # [6, 2, 3, 4, 5, 1]

lst = [1, 2, 3, 4, 5]
lst_2 = []
add = 0
for number in lst:
    add += number
    lst_2.append(add)
print(lst_2) # [1, 3, 6, 10, 15]

lst = []
del lst
print(lst) # NameError: name 'lst' is not defined

lst = [1, [2, 3], 4]
print(lst[1], len(lst)) # [2, 3] 3

'''
Bubble Sort: Iterate in bubbles swapping neighbors
'''

arr = [64, 34, 25, 12, 22, 11, 90]
for i in range(len(arr)-1):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j + 1] :
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
print(arr) # [11, 12, 22, 25, 34, 64, 90]


my_list = [8, 10, 6, 2, 4]
my_list.sort()
print(my_list) # [2, 4, 6, 8, 10]

lst = [5, 3, 1, 2, 4]
lst.reverse()
print(lst)  # outputs: [4, 2, 1, 3, 5]

lst = ["D", "F", "A", "Z"]
lst.sort()
print(lst) # ['A', 'D', 'F', 'Z']

a = 3
b = 1
c = 2
lst = [a, c, b]
lst.sort()
print(lst) # [1, 2, 3]

a = "A"
b = "B"
c = "C"
d = " "
lst = [a, b, c, d]
lst.reverse()
print(lst) # [' ', 'C', 'B', 'A']
lst.sort()
print(lst) # [' ', 'A', 'B', 'C']

list_1 = [1] # creates a one-element list named list_1;
list_2 = list_1 # assigns it to a new list named list_2;
list_1[0] = 2 # changes the only element of list_1;
print(list_2) # [2] # prints out list_2.

'''
name of a list is the name of a memory location where the list is stored.
assignment: list_2 = list_1 copies the name of the array, not its contents. In effect, the two names (list_1 and list_2) identify the same location in the computer memory. Modifying one of them affects the other, and vice versa.
'''

'''
A slice is an element of Python syntax that allows you to make a brand new copy of a list, or parts of a list.

my_list[start:end]

start is the index of the first element included in the slice;
end is the index of the first element not included in the slice.

new list will have end - start (ex 3 - 1 = 2) elements
'''

list_1 = [1]
list_2 = list_1[:]      # Copying the entire list.
list_1[0] = 2
print(list_2)

my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:3] # [8, 6]
new_list = my_list[0:5] # [10, 8, 6, 4, 2]
new_list = my_list[:] # [10, 8, 6, 4, 2] # my_list[0:len(my_list)]
new_list = my_list[0:] # [10, 8, 6, 4, 2] # my_list[0:len(my_list)]
new_list = my_list[:5] # [10, 8, 6, 4, 2] # my_list[0:5]
new_list = my_list[1:5] # [8, 6, 4, 2]
new_list = my_list[1:4] # [8, 6, 4]
print(new_list)

my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:-1] # [8, 6, 4]
new_list = my_list[-1:1] # []
print(new_list)

my_list = [10, 8, 6, 4, 2]
del my_list[1:3]   # [10, 4, 2]
del my_list[:]   # []
print(my_list) # [10, 4, 2]

my_list = [10, 8, 6, 4, 2]
del my_list # delete the list itself, not its content.
print(my_list) # NameError: name 'my_list' is not defined

'''
elem in my_list
elem not in my_list
'''

my_list = [0, 3, 12, 8, 2]
print(5 in my_list) # False
print(5 not in my_list) # True
print(12 in my_list) # True

my_list = [3, 11, 5, 1, 9, 17, 7, 15, 13]
largest = my_list[0]
for i in range(1, len(my_list)):
    if my_list[i] > largest:
        largest = my_list[i]
print(largest) # 17

my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]
largest = my_list[0]
for i in my_list[1:]:
    if i > largest:
        largest = i
print(largest) # 17

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
to_find = 5
found = False
for i in range(len(my_list)):
    found = my_list[i] == to_find
    if found:
        print("Element found at index", i) # Element found at index 4
        break

drawn = [5, 11, 9, 42, 3, 49]
bets = [3, 7, 11, 42, 34, 49]
hits = 0
for number in bets:
    if number in drawn:
        hits += 1
print(hits) # 4

'''
1. If you have a list l1, then the following assignment: l2 = l1 does not make a copy of the l1 list, but makes the variables l1 and l2 point to one and the same list in memory. For example:

vehicles_one = ['car', 'bicycle', 'motor']
print(vehicles_one) # outputs: ['car', 'bicycle', 'motor']

vehicles_two = vehicles_one
del vehicles_one[0] # deletes 'car'
print(vehicles_two) # outputs: ['bicycle', 'motor']


2. If you want to copy a list or part of the list, you can do it by performing slicing:

colors = ['red', 'green', 'orange']

copy_whole_colors = colors[:]  # copy the entire list
copy_part_colors = colors[0:2]  # copy part of the list


3. You can use negative indices to perform slices, too. For example:

sample_list = ["A", "B", "C", "D", "E"]
new_list = sample_list[2:-1]
print(new_list)  # outputs: ['C', 'D']


4. The start and end parameters are optional when performing a slice: list[start:end], e.g.:

my_list = [1, 2, 3, 4, 5]
slice_one = my_list[2: ]
slice_two = my_list[ :2]
slice_three = my_list[-2: ]

print(slice_one)  # outputs: [3, 4, 5]
print(slice_two)  # outputs: [1, 2]
print(slice_three)  # outputs: [4, 5]


5. You can delete slices using the del instruction:

my_list = [1, 2, 3, 4, 5]
del my_list[0:2]
print(my_list)  # outputs: [3, 4, 5]

del my_list[:]
print(my_list)  # deletes the list content, outputs: []


6. You can test if some items exist in a list or not using the keywords in and not in, e.g.:

my_list = ["A", "B", 1, 2]

print("A" in my_list)  # outputs: True
print("C" not in my_list)  # outputs: True
print(2 not in my_list)  # outputs: False
'''

list_1 = ["A", "B", "C"]
list_2 = list_1
list_3 = list_2
del list_1[0]
del list_2[0]
print(list_3) # ['C']

list_1 = ["A", "B", "C"]
list_2 = list_1
list_3 = list_2
del list_1[0]
del list_2
print(list_3) # ['B', 'C']

list_1 = ["A", "B", "C"]
list_2 = list_1
list_3 = list_2
del list_1[0]
del list_2[:]
print(list_3) # []

list_1 = ["A", "B", "C"]
list_2 = list_1[:]
list_3 = list_2[:]
del list_1[0]
del list_2[0]
print(list_3) # ['A', 'B', 'C']

my_list = [1, 2, "in", True, "ABC"]
print(1 ??? my_list)  # outputs True
print("A" ??? my_list)  # outputs True
print(3 ??? my_list)  # outputs True
print(False ??? my_list)  # outputs False

print([x ** 2 for x in range(10)]) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print([2 ** i for i in range(8)]) # [1, 2, 4, 8, 16, 32, 64, 128]
print([x for x in [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] if x % 2 != 0 ]) # [1, 9, 25, 49, 81]
print([[0.0 for h in range(2)] for d in range(3)]) # [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]]
print([[['Hi' for r in range(2)] for f in range(2)] for t in range(2)]) # [[['Hi', 'Hi'], ['Hi', 'Hi']], [['Hi', 'Hi'], ['Hi', 'Hi']]]

'''
1. List comprehension allows you to create new lists from existing ones in a concise and elegant way. The syntax of a list comprehension looks as follows:

[expression for element in list if conditional]


which is actually an equivalent of the following code:

for element in list:
    if conditional:
        expression


Here's an example of a list comprehension - the code creates a five-element list filled with with the first five natural numbers raised to the power of 3:

cubed = [num ** 3 for num in range(5)]
print(cubed)  # outputs: [0, 1, 8, 27, 64]


2. You can use nested lists in Python to create matrices (i.e., two-dimensional lists). For example:

Table - a two-dimensional array

# A four-column/four-row table - a two dimensional array (4x4)

table = [[":(", ":)", ":(", ":)"],
         [":)", ":(", ":)", ":)"],
         [":(", ":)", ":)", ":("],
         [":)", ":)", ":)", ":("]]

print(table)
print(table[0][0])  # outputs: ':('
print(table[0][3])  # outputs: ':)'

3. You can nest as many lists in lists as you want, and therefore create n-dimensional lists, e.g., three-, four- or even sixty-four-dimensional arrays. For example:

Cube - a three-dimensional array

# Cube - a three-dimensional array (3x3x3)

cube = [[[':(', 'x', 'x'],
         [':)', 'x', 'x'],
         [':(', 'x', 'x']],

        [[':)', 'x', 'x'],
         [':(', 'x', 'x'],
         [':)', 'x', 'x']],

        [[':(', 'x', 'x'],
         [':)', 'x', 'x'],
         [':)', 'x', 'x']]]

print(cube)
print(cube[0][0][0])  # outputs: ':('
print(cube[2][2][0])  # outputs: ':)'

'''

for i in range (-1, 1):
    print('@') # @ @

z = 10
y = 0
x = z > y or z ==y
print(x) # True

print("We start here.")
message()
print("We end here.")
def message():
    print("Enter a value: ") # NameError: name 'message' is not defined

'''
Python reads your code from top to bottom.
'''
def hi():
    print("hi")
hi(5) # TypeError: hi() takes 0 positional arguments but 1 was given

'''
specifying one or more parameters in a function's definition is also a requirement, and you have to fulfil it during invocation. You must provide as many arguments as there are defined parameters.

Failure to do so will cause an error.
'''
def message(number):
    print("Enter a number:", number)
message() # TypeError: message() missing 1 required positional argument: 'number'

def message(number):
    print("Enter a number:", number)
number = 1234
message(1) # 1
print(number) # 1234

def introduction(first_name, last_name):
    print("Hello, my name is", first_name, last_name)
introduction(first_name = "James", last_name = "Bond") # Hello, my name is James Bond
introduction(last_name = "Skywalker", first_name = "Luke") # Hello, my name is Luke Skywalker

def introduction(first_name, last_name):
    print("Hello, my name is", first_name, last_name)
introduction(surname="Skywalker", first_name="Luke") # TypeError: introduction() got an unexpected keyword argument 'surname'

# positional arguments go before keyword arguments.
def adding(a, b, c):
    print(a, "+", b, "+", c, "=", a + b + c)
adding(3, c = 1, b = 2) # 6
adding(3, a = 1, b = 2) # TypeError: adding() got multiple values for argument 'a'

def rating(rating, type="movie"): # default (predefined) values for arguments
    print(rating, type)
rating(2) # 2 movie

'''
1. You can pass information to functions by using parameters. Your functions can have as many parameters as you need.

An example of a one-parameter function:

def hi(name):
    print("Hi,", name)

hi("Greg")


An example of a two-parameter function:

def hi_all(name_1, name_2):
    print("Hi,", name_2)
    print("Hi,", name_1)

hi_all("Sebastian", "Konrad")


An example of a three-parameter function:

def address(street, city, postal_code):
    print("Your address is:", street, "St.,", city, postal_code)

s = input("Street: ")
p_c = input("Postal Code: ")
c = input("City: ")

address(s, c, p_c)


2. You can pass arguments to a function using the following techniques:

positional argument passing in which the order of arguments passed matters (Ex. 1),
keyword (named) argument passing in which the order of arguments passed doesn't matter (Ex. 2),
a mix of positional and keyword argument passing (Ex. 3).
Ex. 1
def subtra(a, b):
    print(a - b)

subtra(5, 2)    # outputs: 3
subtra(2, 5)    # outputs: -3


Ex. 2
def subtra(a, b):
    print(a - b)

subtra(a=5, b=2)    # outputs: 3
subtra(b=2, a=5)    # outputs: 3

Ex. 3
def subtra(a, b):
    print(a - b)

subtra(5, b=2)    # outputs: 3
subtra(5, 2)    # outputs: 3


It's important to remember that positional arguments mustn't follow keyword arguments. That's why if you try to run the following snippet:

def subtra(a, b):
    print(a - b)

subtra(5, b=2)    # outputs: 3
subtra(a=5, 2)    # Syntax Error

Python will not let you do it by signalling a SyntaxError.

3. You can use the keyword argument passing technique to pre-define a value for a given argument:

def name(first_name, last_name="Smith"):
    print(first_name, last_name)

name("Andy")    # outputs: Andy Smith
name("Betty", "Johnson")    # outputs: Betty Johnson (the keyword argument replaced by "Johnson")
'''
def add_numbers(a, b=2, c):
    print(a + b + c)
add_numbers(a=1, c=3) # SyntaxError: non-default argument follows default argument

print(None + 2) # TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

'''
None is a keyword.

If a function doesn't return a certain value using a return expression clause, it is assumed that it implicitly returns None.

There are only two kinds of circumstances when None can be safely used:

when you assign it to a variable (or return it as a function's result)
when you compare it with a variable to diagnose its internal state.
Just like here:
'''

value = None
if value is None:
    print("Sorry, you don't carry any value")

def strange_function(n):
    if(n % 2 == 0):
        return True
print(strange_function(2)) # True
print(strange_function(1)) # None

def list_sum(lst):
    s = 0
    for elem in lst:
        s += elem
    return s
print(list_sum([5, 4, 3])) # 12
print(list_sum(5)) # TypeError: 'int' object is not iterable

def strange_list_fun(n):
    strange_list = []
    for i in range(0, n):
        strange_list.insert(0, i)
    return strange_list
print(strange_list_fun(5)) # [4, 3, 2, 1, 0]

'''
1. You can use the return keyword to tell a function to return some value. The return statement exits the function, e.g.:

def multiply(a, b):
    return a * b

print(multiply(3, 4))    # outputs: 12


def multiply(a, b):
    return

print(multiply(3, 4))    # outputs: None


2. The result of a function can be easily assigned to a variable, e.g.:

def wishes():
    return "Happy Birthday!"

w = wishes()

print(w)    # outputs: Happy Birthday!

Look at the difference in output in the following two examples:

# Example 1
def wishes():
    print("My Wishes")
    return "Happy Birthday"

wishes()    # outputs: My Wishes


# Example 2
def wishes():
    print("My Wishes")
    return "Happy Birthday"

print(wishes())

# outputs: My Wishes
#          Happy Birthday


3. You can use a list as a function's argument, e.g.:

def hi_everybody(my_list):
    for name in my_list:
        print("Hi,", name)

hi_everybody(["Adam", "John", "Lucy"])


4. A list can be a function result, too, e.g.:

def create_list(n):
    my_list = []
    for i in range(n):
        my_list.append(i)
    return my_list

print(create_list(5))

def hi():
    return
    print("Hi!")
print(hi()) # None

def is_int(data):
    if type(data) == int:
        return True
    elif type(data) == float:
        return False
print(is_int(5)) # true
print(is_int(5.0)) # False
print(is_int("5")) # None

def hi():
    return
    print("Hi!")
print(hi()) # None

def is_int(data):
    if type(data) == int:
        return True
    elif type(data) == float:
        return False

print(is_int(5)) # True
print(is_int(5.0)) # False
print(is_int("5")) # None

def even_num_lst(ran):
    lst = []
    for num in range(ran):
        if num % 2 == 0:
            lst.append(num)
    return lst
print(even_num_lst(11)) # [0, 2, 4, 6, 8, 10]

def list_updater(lst):
    upd_list = []
    for elem in lst:
        elem **= 2
        upd_list.append(elem)
    return upd_list
foo = [1, 2, 3, 4, 5]
print(list_updater(foo)) # [1, 4, 9, 16, 25]

def scope_test():
    x = 123
scope_test()
print(x) # NameError: name 'x' is not defined

def my_function():
    print("Inside ", var) # Inside  1
var = 1
my_function()
print("Outside ", var) # Outside  1

'''
a variable existing outside a function has a scope inside the functions' bodies.
'''

def my_function():
    var = 2
    print("varInside", var) # varInside 2
var = 1
my_function()
print("varOutside", var) # varOutside 1

'''
A variable existing outside a function has a scope inside the functions' bodies, excluding those of them which define a variable of the same name.
'''

def my_function():
    global var
    var = 2
    print("varInside", var) # varInside 2
var = 1
my_function()
print("varOutside", var) # varOutside 2

def my_function(n):
    print("received", n) # received 1
    n += 1
    print("updated", n) # updated 2
var = 1
my_function(var)
print('original outside', var) # original outside 1

'''
changing the parameter's value doesn't propagate outside the function (in any case, not when the variable is a scalar, like in the example).
Function receives the argument's value, not the argument itself. This is true for scalars.
'''

def my_function(my_list_1):
    print("Print #1:", my_list_1) # Print #1: [2, 3]
    print("Print #2:", my_list_2) # Print #2: [2, 3]
    my_list_1 = [0, 1]
    print("Print #3:", my_list_1) # Print #3: [0, 1]
    print("Print #4:", my_list_2) # Print #4: [2, 3]
my_list_2 = [2, 3]
my_function(my_list_2)
print("Print #5:", my_list_2) # Print #5: [2, 3]

def my_function(my_list_1):
    print("Print #1:", my_list_1) # Print #1: [2, 3]
    print("Print #2:", my_list_2) # Print #2: [2, 3]
    del my_list_1[0]  # Pay attention to this line.
    print("Print #3:", my_list_1) # Print #3: [3]
    print("Print #4:", my_list_2) # Print #4: [3]
my_list_2 = [2, 3]
my_function(my_list_2)
print("Print #5:", my_list_2) # Print #5: [3]

'''
if the argument is a list, then changing the value of the corresponding parameter doesn't affect the list (remember: variables containing lists are stored in a different way than scalars),
but if you change a list identified by the parameter (note: the list, not the parameter!), the list will reflect the change.

1. A variable that exists outside a function has a scope inside the function body (Example 1) unless the function defines a variable of the same name (Example 2, and Example 3), e.g.:

Example 1:

var = 2


def mult_by_var(x):
    return x * var


print(mult_by_var(7))    # outputs: 14


Example 2:

def mult(x):
    var = 5
    return x * var


print(mult(7))    # outputs: 35


Example 3:

def mult(x):
    var = 7
    return x * var


var = 3
print(mult(7))    # outputs: 49


2. A variable that exists inside a function has a scope inside the function body (Example 4), e.g.:

Example 4:

def adding(x):
    var = 7
    return x + var


print(adding(4))    # outputs: 11
print(var)    # NameError


3. You can use the global keyword followed by a variable name to make the variable's scope global, e.g.:

var = 2
print(var)    # outputs: 2


def return_var():
    global var
    var = 5
    return var


print(return_var())    # outputs: 5
print(var)    # outputs: 5
'''

def message():
    alt = 1
    print("Hello, World!")
print(alt) # NameError: name 'alt' is not defined

a = 1
def fun():
    a = 2
    print(a) # 2
fun()
print(a) # 1

a = 1
def fun():
    global a
    a = 2
    print(a) # 2
fun()
a = 3
print(a) # 3

a = 1
def fun():
    global a
    a = 2
    print(a) # 2
a = 3
fun()
print(a) # 2

def bmi(weight, height):
    return weight / height ** 2
print(bmi(52.5, 1.65)) # 19.283746556473833

def is_a_triangle(a, b, c):
    if a + b <= c:
        return False
    if b + c <= a:
        return False
    if c + a <= b:
        return False
    return True
print(is_a_triangle(1, 1, 1))
print(is_a_triangle(1, 1, 3))

def is_a_triangle(a, b, c):
    if a + b <= c or b + c <= a or c + a <= b:
        return False
    return True
print(is_a_triangle(1, 1, 1)) # True
print(is_a_triangle(1, 1, 3)) # False

def is_a_triangle(a, b, c):
    return a + b > c and b + c > a and c + a > b
print(is_a_triangle(1, 1, 1)) # True
print(is_a_triangle(1, 1, 3)) # False

def is_a_triangle(a, b, c):
    return a + b > c and b + c > a and c + a > b
def is_a_right_triangle(a, b, c):
    if not is_a_triangle(a, b, c):
        return False
    if c > a and c > b:
        return c ** 2 == a ** 2 + b ** 2
    if a > b and a > c:
        return a ** 2 == b ** 2 + c ** 2
print(is_a_right_triangle(5, 3, 4)) # True
print(is_a_right_triangle(1, 3, 4)) # False

def factorial_function(n):
    if n < 0:
        return None
    if n < 2:
        return 1
    product = 1
    for i in range(2, n + 1):
        product *= i
    return product
for n in range(1, 6):  # testing
    print(n, factorial_function(n))
'''
1 1
2 2
3 6
4 24
5 120
'''

def fib(n):
    if n < 1:
        return None
    if n < 3:
        return 1
    elem_1 = elem_2 = 1
    the_sum = 0
    for i in range(3, n + 1):
        the_sum = elem_1 + elem_2
        elem_1, elem_2 = elem_2, the_sum
    return the_sum
for n in range(1, 10):  # testing
    print(n, "->", fib(n))
'''
1 -> 1
2 -> 1
3 -> 2
4 -> 3
5 -> 5
6 -> 8
7 -> 13
8 -> 21
9 -> 34
'''

'''
Key takeaways
1. A function can call other functions or even itself. When a function calls itself, this situation is known as recursion, and the function which calls itself and contains a specified termination condition (i.e., the base case - a condition which doesn't tell the function to make any further calls to that function) is called a recursive function.

2. You can use recursive functions in Python to write clean, elegant code, and divide it into smaller, organized chunks. On the other hand, you need to be very careful as it might be easy to make a mistake and create a function which never terminates. You also need to remember that recursive calls consume a lot of memory, and therefore may sometimes be inefficient.

When using recursion, you need to take all its advantages and disadvantages into consideration.

The factorial function is a classic example of how the concept of recursion can be put in practice:

# Recursive implementation of the factorial function.

def factorial(n):
    if n == 1:    # The base case (termination condition.)
        return 1
    else:
        return n * factorial(n - 1)


print(factorial(4)) # 4 * 3 * 2 * 1 = 24
'''

def factorial(n):
    return n * factorial(n - 1)
print(factorial(4)) # RecursionError: maximum recursion depth exceeded

def fun(a):
    if a > 30:
        return 3
    else:
        return a + fun(a + 3)
print(fun(25)) # 56