Abstract Python Program Experiment Examples.py

# Abstract Python Program Experiment Examples:

# Created by Joseph C. Richardson, GitHub.com

# Unpack multiple values, using just one, single "=" sign.
# Not: You must use equal variables to equal values.

a,b,c = 1,2,3

print(a,b,c)

# Add the values together.

print(a+b+c)

# Example 2:

a,b,c,d,e,f = 1,2,3,4,5,6

print(a,b,c,d,e,f)

# Add the values together.

print(a+b+c+d+e+f)

# Example 3

name1,name2,name3 = 'Bob','Rob','John'

print(name1,'and',name2,'went to',name3+"'s",'house for dinner.')

# You can use the f' string format to make the above print statement
# read like this.

print(f"{name1} and {name2} went to {name3}'s house for dinner.")

# Old format example of the print statement from earlier Python versions.

print("{} and {} went to {}'s house for dinner.".format(name1,name2,name3))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Unpacking multi-list example:

list_1,list_2,list_3 = [
    [0,1,2,3,4,5,6,7,8,9],
    ['a','b','c','d','e','f','g','h','i','j','k','l','m',
     'n','o','p','q','r','s','t','u','v','w','x','y','z'],
    ['"Python',"Programmer's",'Glossary','Bible"']]

print(list_1[9])
print(list_2[0])
print(list_3[0],list_3[1],list_3[2],list_3[3])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Unpacking multi-list for-loop example:

list_1,list_2,list_3 = [
    [0,1,2,3,4,5,6,7,8,9],
    ['a','b','c','d','e','f','g','h','i','j','k','l','m',
     'n','o','p','q','r','s','t','u','v','w','x','y','z'],
    ['"Python',"Programmer's",'Glossary','Bible"']
    ]

for i in list_1,list_2,list_3:
    print(i[0],i[1],i[2],i[3])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Python scoping with strings and integer values

print(type('string'))

# <class 'str'>

print(type(2))

# <class 'int'>
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# View string fuctions and string methods.

print(dir('string'))

# View integer fuctions and integer methods.

print(dir(2))

# Get the id from a string.

print(id('string'))

# Get the id from an integer.

print(id(2))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# These two 'print' statements below use the dunder method 'add',
# which is the same as the 'print' statements 'print(2+3)' and 'print('a'+'b')'.
# The 'int' function adds only integer numbers together, whereas the
# str' function concatenates/joins character strings together.

print(int.__add__(2,3))

# Screen output:	5

print(str.__add__('a','b'))

# Screen output:	ab
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Dunder methods assure functionality inside class functions. For
# example, you wouldn't use a dunder '__str__' method with integer
# values; likewise, you wouldn't use a dunder '__add__' method
# with character string values.

# Take a close look at these two program examples below. You notice
# there are yellow highlighted variables. These variables indicate how
# these two, very same program examples can be written. Both program
# examples do exactly the same thing, even though they look a wee bit
# different. Type and execute/run these two program examples below
# and see what happens.

# Program example 1:

class Dunder_add:
    def __init__(self,num):
        self.num = num

    def __add__(self,plus):
        return self.num+plus

a = Dunder_add(6)
b = Dunder_add(8)
c = Dunder_add(12)

print(a.num+b.num+c.num)

# Program example 2:

class Dunder_add:
    def __init__(self,num):
        self.num = num

    def __add__(self,plus):
        return self.num+plus.num

a = Dunder_add(6)
b = Dunder_add(8)
c = Dunder_add(12)

print(a+b+c.num)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
x = {1,2,3,4,9,6,7,8,5,9}
y = {10,11,15,13,14,12,16,17,18,19,19}
z = {20,21,22,23,27,25,26,24,28,29,22}

unionize = x.union(y).union(z)

convert = list(unionize)

a = slice(20)

print(convert[a])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
x = {1,2,3,4,9,6,7,8,5,9}
y = {10,11,15,13,14,12,16,17,18,19,19}
z = {20,21,22,23,27,25,26,24,28,29,22}

unionize = x.union(y,z)

convert = list(unionize)

a = slice(20)

print(convert[a])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
a = list()
for i in range(10):
    a.append(i)

b = set()
for i in range(10):
    b.add(i)

print(a)
print(b)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
nums1 = {1,1,2,3,4,5,6}
nums2 = {1,2,2,3,4}

print(nums1 | nums2) # Union

print(nums1.union(nums2)) # Union

nums1 = {1,1,2,3,4,5,6}
nums2 = {1,2,2,3,4}

print(nums1 & nums2) # Intersection

print(nums1.intersection(nums2)) # Intersection

nums1 = {1,1,2,3,4,5,6}
nums2 = {1,2,2,3,4}

print(nums1 - nums2) # Difference

print(nums1.difference(nums2)) # Difference

nums1 = {1,1,2,3,4,5,6}
nums2 = {1,2,2,3,4}

print(nums1 ^ nums2) # Symmetric Difference
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
nums1 = {0,1,2,3,1,3,4,10,5,6,6,7,8,9,10,23}
nums2 = {1,2,7,1,3,4,10,5,6,6,7,8,9,10,11,22}

print(nums1 | nums2)
print(nums1 & nums2)
print(nums1 - nums2)
print(nums1 ^ nums2)

nums1 = [1,2,3,1,3,4,10,5,6,6,7,8,9,10]
nums2 = [1,2,3,1,3,4,10,5,6,6,7,8,9,10]

uniques1 = set(nums1)
uniques2 = set(nums2)

print(uniques1 | uniques2)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
nums = {0,1,2,3,1,3,4,10,5,6,6,7,8,9,10}

try:
    num = int(input('Enter a number: '))
    if num in nums:
        print(f'{num} is in nums.')
    elif num not in nums:
        print(f'{num} is not in nums.')
except ValueError:
    print('Sorry! I cannot do that.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
nums1 = {1,1,2,3,4,5,6}
nums2 = {1,2,2,3,4}

print(nums1 | nums2) # Union
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
my_set = ['Fast','Fast','Frog','Fish','Frog','Fog','Floor']

print('This unsorted list',my_set,'has duplicates in it.')

duplicate = set(my_set)

print('\nThis converted set from a list',duplicate,'has no \
duplicates in it, but is always in random order.')

duplicate = sorted(duplicate)
my_set = list(duplicate)

print('\nThis random set order converts back into a sorted, \
non-duplicated list.',duplicate,)

print(f'\nNow you can call up a sorted, non-duplicate list item \
like this "{duplicate[4]}"')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
x = tuple('123456789')

print(x)

x = tuple(('123456789','abcdefghij'))

print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
num1,num2 = 0,1
fib = {num1,num2}

y,a,b = 100,'is in the Fibonacci Number \
Sequence.','is not in the Fibonacci Number Sequence.'

for i in range(y):
    fib_num = num1+num2
    fib.add(fib_num)
    num1 = num2
    num2 = fib_num

while True:
    try:
        x = int(input('Please enter a correct Fibonacci Sequence Number: '))
        if x in fib:
            print(x,a)
        elif x not in fib:
            print(x,b)
    except ValueError:
        print('Sorry! Numbers only please.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# input Fibonacci Number Sequence example, using a set{}

num1,num2 = 0,1

fib = {num1,num2}

words = (
    'is in the Fibonacci Sequence.',
    'is not in the Fibonacci Sequence.',
    'Please enter a correct Fibonacci Sequence Number: ',
    'Sorry! Numbers only.',
    'Memory Error!'
    )

try:
    x = int(input(words[2]).strip())

    for i in range(x):
        fib_num = num1+num2
        fib.add(fib_num)
        num1 = num2
        num2 = fib_num

    if x in fib:
        print(x,words[0])

    elif x not in fib:
        print(x,words[1])

except ValueError:
    print(words[3])

except MemoryError:
    print(words[4])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import os,time;os.system('')

text_colours = (
    '\x1b[31m', # index 0 = red
    '\x1b[32m', # index 1 = green
    '\x1b[33m', # index 2 = yellow
    '\x1b[34m', # index 3 = blue
    '\x1b[35m', # index 4 = purple
    '\x1b[36m', # index 5 = cyan
    '\x1b[37m'  # index 6 = white
    )

text_words = (
    f'\n"Python Programmer\'s Glossary Bible" by Joseph \
C. Richardson','cls'
    )

length = 0
while length <= len(text_words[0]):
    for i in text_colours:
        print(i+text_words[0][:length])
        time.sleep(.05)
        os.system(text_words[1])
        length += 1

print(i+text_words[0])

input('\nPress Enter to exit.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Random Generator Examples:

import random

print(random.randint(1,9))

print(random.randrange(1,9))

print(random.randrange(3,9,2))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

print(random.random())

print(random.uniform(20,60))

print(random.triangular(20,60,30))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

random_list = ['Random 1','Random 2','Random 3','Random 4']

print(random.choice(random_list))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

random_list = [
    'Random 1','Random 2',
    'Random 3','Random 4'
    ]

random.shuffle(random_list)

print(random_list[0])
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

random_list = [
    'Random Least1','Random Least2',
    'Random Less','Random Most'
    ]

print(random.choices(random_list,weights = [5,10,25,50],k = 8))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

random.seed(10)

print(random.random())
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

random.seed(10)

print(random.getstate())
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

print(random.getrandbits(4))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import random

print(random.random())

# capture the state:

state = random.getstate()

# print another random number:

print(random.random())

# restore the state:

random.setstate(state)

# and the next random number should be
# the same as when you captured the state:

print(random.random())
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.randint(100)
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.rand()
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.randint(100,size = (5))
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.randint(100,size = (3,5))
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.rand(5)
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.rand(3,5)
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.choice([3,5,7,9])
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.choice([3,5,7,9], size = (3,5))
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.choice([3,5,7,9],p = [0.1,0.3,0.6,0.0],size = (100))
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random

x = random.choice([3,5,7,9],p = [0.1,0.3,0.6,0.0],size = (3,5))
print(x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random
import numpy as np

arr = np.array([1,2,3,4,5])

random.shuffle(arr)
print(arr)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
from numpy import random
import numpy as np

arr = np.array([1,2,3,4,5])
print(random.permutation(arr))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import os,math,random
from time import sleep

while True:
    random_num = random.randint(1,10)
    if  random_num == 10:
        print(f'{random_num} is equal to 10. The loop breaks')
        break
    elif random_num != 10:
        print(f'{random_num} is not equal to 10. The loop repeats')
        sleep(1)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This conditional while-loop example compares a random number
# against user input data. If the user picks the right number by luck
# alone, the while-loop will break out and the program ends. If the
# user picks the wrong number, the less (<) than or greater (>) than
# 'random_num' variable gets conditioned and the while-loop keeps
# on iterating until the right number is picked, via user input data.

# Note: Python executes/runs programs starting from the top, downward.
# Be very careful on how you place statements. Some statements cannot
# execute right, even if they work. This is simply because of the order
# that Python executes/runs its program statements.

# Note: The 'import random' module must be imported first.

import random

random_num = random.randint(1,10)

while True:
    try:
        pick_num = int(input('\nWhat number am I thinking of? Hint! It\'s \
between 1 and 10: ').strip())

        if pick_num < random_num:
            print('\nThe number I\'m thinking of is too low!')

        elif pick_num > random_num:
            print('\nThe number I\'m thinking of is too high!')

        elif pick_num==random_num:
            print(f'\nCongratulations! You won. "{random_num}" was the \
number I was thinking of.')
            break

    except ValueError:
        print('\nYou must type integers only please!')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This very same program example as above works exactly the same
# way, but with one major difference; the while loop will only iterate three
# times. If the user picks the right number, the while loop breaks. If the
# user doesn't pick the right number after three times, the 'else' statement
# executes and says 'Sorry! You lost.', which ends the program.

# Note: the 'import random' module must be imported first.

import random

random_num = random.randint(1,10)

i = 0

while i < 3:
    try:
        pick_num = int(input('\nWhat number am I thinking of? Hint! It\'s \
between 1 and 10: ').strip())

        i += 1

        if pick_num < random_num:
            print('\nThe number I\'m thinking of is too low!')

        elif pick_num > random_num:
            print('\nThe number I\'m thinking of is too high!')

        elif pick_num==random_num:
            print(f'\nCongratulations. You won! "{random_num}" was the number \
I was thinking of.')
            break

    except ValueError:
        print('\nYou must type integers only please!')

else:
    print('\nSorry. You lost!')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Once again, this is the very same program example as above before.
# However, this time the loop iterates in reverse instead of forward and
# the user is shown how many guesses they have left before they win
# or lose.

# Note: the 'import random' module must be imported first.

import random

random_num = random.randint(1,10)

i = 3

while i > 0:
    try:
        pick_num = int(input(f'\nWhat number am I thinking of? Hint! It\'s \
between 1 and 10:\n\nYou have {i} gesses left. ').strip())

        i-=1

        if pick_num < random_num:
            print('\nThe number I\'m thinking of is too low!')

        elif pick_num > random_num:
            print('\nThe number I\'m thinking of is too high!')

        elif pick_num==random_num:
            print(f'\nCongratulations. You won! "{random_num}" was the number \
I was thinking of.')
            break

    except ValueError:
        print('\nYou must type integers only please!')

else:
    print('\nSorry. You lost!')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
x = 10**1
print(f'{x:,}') #  = 10 (TEN)

x  =  10**2
print(f'{x:,}') #  = 100 (ONE HUNDRED)

x = 10**3
print(f'{x:,}') #  = 1,000 (ONE THOUSAND)

x = 10**4
print(f'{x:,}') #  = 10,000 (TEN THOUSAND)

x = 10**5
print(f'{x:,}') #  = 100,000 (ONE HUNDRED THOUSAND)

x = 10**6
print(f'{x:,}') #  = 1,000,000 (ONE MILLION)

x = 10**9
print(f'{x:,}') #  = 1,000,000,000 (ONE BILLION)

x = 10**12
print(f'{x:,}') #  = 1,000,000,000,000 (ONE TRILLION)

x = 10**15
print(f'{x:,}') #  = 1,000,000,000,000,000 (ONE QUADRILLION)

x = 10**18
print(f'{x:,}') #  = 1,000,000,000,000,000,000 (ONE QUINTILLION)

x = 10**21
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000 (ONE SEXTILLION)

x = 10**24
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000 (ONE SEPTILLION)

x = 10**27
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000 (ONE OCTILLION)

x = 10**30
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000 (ONE NONILLION)

x = 10**33
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000 (ONE DECILLION)

x = 10**36
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000 (ONE UNDECILLION)

x = 10**39
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE DUODECILLION)

x = 10**42
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE TREDECILLION)

x = 10**45
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE QUATTTUOR-DECILLION)

x = 10**48
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE QUINDECILLION)

x = 10**51
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE SEXDECILLION)

x = 10**54
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE SEPTEN-DECILLION)

x = 10**57
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE OCTODECILLION)

x = 10**60
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE NOVEMDECILLION)

x = 10**63
print(f'{x:,}') #  = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 (ONE VIGINTILLION)

x = 10**303
print(f'{x:,}') #  = 303 0's (ONE CENTILLION)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
import math

print(min(3,6,9))

print(max(3,6,9))

print(pow(2,3))

print(abs(-10))

print(math.sqrt(9))

print(math.floor(45.17))

print(math.ceil(45.17))
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
def myfunc():
  global x
  x = 'fantastic.'

myfunc()

print('Python is '+x)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
class Super_class:
    def super1(self):
        print('Super1')

    def super2(self):
        print('Super2')

    def super3(self):
        print('Super3')

class Class_all(Super_class):
    def get_values(self):
        super().super1()
        super().super2()
        super().super3()

Class_all().get_values()
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
class A:
    def __init__(self):
        super().__init__()
        print('first')

class B:
    def __init__(self):
        super().__init__()
        print('second')

class C:
    def __init__(self):
        super().__init__()
        print('third')

class D:
    def __init__(self):
        super().__init__()
        print('forth')

class All(A,B,C,D):
    def __init__(self):
        super().__init__()

All()
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This conditional while-loop will loop as long as the value is less (<)
# than 3, then it will stop its iteration no matter what wrong keys the
# user tries to type.

chance = 0

name = input('\nWhat is your name please? ').strip()

while chance < 3:
    try:
        age = int(input(f'\nHow old are you {name}? ').strip())
        print(f'\n{name}. You are {age} years old.')
        break

    except ValueError:
        print(f'\nYou have 3 chances left before the while-loop breaks out anyway!')

        chance += 1
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This for-loop example does exactly the same thing, the above while
# -loop example shows. The only difference is, the while-loop is a
# conditional loop, whereas the for- loop is an iterate. While-loops can
# also be 'True:' or 'False:', depending on the outcome of a program's
# excution run. While-loops also compare data greater than or less
# than other data, as shown in the examples above.

name = input('\nWhat is your name please? ').strip()

for chance in range(3):
    try:
        age = int(input(f'\nHow old are you {name}? ').strip())
        print(f'\n{name}. You are {age} years old.')
        break

    except ValueError:
        print('\nYou have 3 chances left before the while-loop breaks out anyway!')

        chance += 1
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This program example has three, separate conditional while-loops,
# each of them compares data against user input data. The first while
# -loop asks for the user's first name. The second while-loop asks
# for the user's last name, and the third while-loop asks for the user's
# age. In the first and second while-loop, the user's first name and
# user's last name are compared by how many letters the user types.
# The 'str([first_name])' statement makes the user type in text only,
# not integers.

# Note: Python executes/runs programs starting from the top, downward.
# Be very careful on how you place statements. Some statements cannot
# execute right, even if they work. This is simply because of the order
# that Python executes/runs its program statements.

while True:
    first_name = input('\nWhat is your name please? ').strip()

    if first_name < str([first_name]):
        print('\nError: text only please!')

    elif len(first_name) < 3:
        print('\nYour first name must be over 2 characters long.')

    elif len(first_name) > 10:
        print('Your first name must be under 10 characters long.')

    else:
        break

while True:
    last_name = input(f'\nNice to meet you {first_name.title()}. \
What is your last name please? ').strip()

    if last_name < str([last_name]):
        print('\nError: text only please!')

    elif len(last_name) < 3:
        print('\nYour last name must be over 2 characters long.')

    elif len(last_name) > 10:
        print('\nYour last name must be under 10 characters long.')

    else:
        break

while True:
    try:
        age = int(input(f'\nHow old are you {first_name.title()}? ').strip())
        break

    except ValueError:
        print('\nError: integers only please!')

print(f'\nYour first name = {first_name.title()}:\nYour last name = \
{last_name.title()}:\nYour age = {age}:\n')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Here's a fun, simple program example, which tells you how many
# seconds you have been on Earth for. Type and execute/run the
# program example below and see what happens when you type your
# age, then press the 'Enter' key. Note: this program example also
# uses the 'finally' statement to illustrate the use of the how the 'finally'
# command works. The 'finally' command will always execute, no
# matter the outcome. Also note that the 'finally' command only works
# with the 'try' and 'except' command blocks.

months = 12
weeks = 52
days = 365

hours_per_day = 24
minuts_per_hour = 60
seconds_per_minute = 60

string_tuple = (
    months,weeks,days,
    hours_per_day,
    minuts_per_hour,
    seconds_per_minute
    )

while True:

    try:
        age = int(input('How old are you? ').strip())

        print(f'\nYou have been on Earth for {age} years.')

        print(f'\nYou have been on Earth for {age*string_tuple[0]:,} months.')

        print(f'\nYou have been on Earth for {age*string_tuple[1]:,} weeks.')

        print(f'\nYou have been on Earth for {age*string_tuple[2]:,} days.')

        print(f'\nYou have been on Earth for {age*string_tuple[2]*string_tuple[3]:,} hours.')

        print(f'\nYou have been on Earth for \
{age*string_tuple[2]*string_tuple[3]*string_tuple[4]:,} minutes.')

        print(f'\nYou have been on Earth for \
{age*days*string_tuple[3]*string_tuple[4]*string_tuple[5]:,} seconds.')

        break

    except ValueError:
        print('\nSorry! Numbers only please.\n')

    finally:
        print('Finally will always execute no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# This conditional while-loop example types out the words "Python
# Programmer\'s Glossary Bible". As long as 'length' is less (<) than
# 'len' starting at "0", the while-loop will keep on looping until  'length'
# is equal to 'len'. The 'os.system('cls')' function clears the screen
# each cycle through the while-loop, and the 'time.sleep(.05)' function
# delays the while-loop in between cycles. This fun, little program
# example makes the printout on the screen appear as if it were
# actualy typing letters.

# Note: Python executes/runs programs starting from the top, downward.
# Be very careful on how you place statements. Some statements cannot
# execute right, even if they work. This is simply because of the order
# that Python executes/runs its program statements.

# Note: The 'import os' module and the 'import time' module must be
# imported first.

import os
import time

letters = '\n"Python Programmer\'s Glossary Bible"'
length = 0

while length <= len(letters):
    os.system('cls')
    print(letters[:length])
    time.sleep(.05)
    length += 1
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# See what happens when you type and execute/run this guessing game
# program example below. Note: you must execute/run the program from
# the OS output screen, via double-clicking the Python program file itself.

# Save the Python file as 'Know Your Stuff'

import os

tc = (
    '\x1b[31m',
    '\x1b[32m',
    '\x1b[33m',
    '\x1b[34m',
    '\x1b[35m',
    '\x1b[36m',
    '\x1b[37m',
    'cls'
    )

question_prompts1 = (
    f'{tc[2]}How many sides does a Triangle have?\n\n{tc[1]}(a) {tc[2]}four sides\n\
{tc[1]}(b) {tc[2]}three sides\n{tc[1]}(c) {tc[2]}two sides',

    f'{tc[2]}How many sides does a Square have?\n\n{tc[1]}(a) {tc[2]}Two sides\n\
{tc[1]}(b) {tc[2]}Three sides\n{tc[1]}(c) {tc[2]}Four sides',

    f'{tc[2]}How many sides does a Pentagon have?\n\n{tc[1]}(a) {tc[2]}four sides\n\
{tc[1]}(b) {tc[2]}five sides\n{tc[1]}(c) {tc[2]}Three sides',

    f'{tc[2]}How many sides does a Hexagon have?\n\n{tc[1]}(a) {tc[2]}six sides\n\
{tc[1]}(b) {tc[2]}five sides\n{tc[1]}(c) {tc[2]}two sides',

    f'{tc[2]}How many sides does a Octagon have?\n\n{tc[1]}(a) {tc[2]}four sides\n\
{tc[1]}(b) {tc[2]}six sides\n{tc[1]}(c) {tc[2]}eight sides',

    f'{tc[2]}How many sides does a Dodecagon have?\n\n{tc[1]}(a) {tc[2]}eight \
sides\n{tc[1]}(b) {tc[2]}three sides\n{tc[1]}(c) {tc[2]}twelve sides',

    f'{tc[2]}How many sides does a Hexadecagon have?\n\n{tc[1]}(a) {tc[2]}sixteen \
sides\n{tc[1]}(b) {tc[2]}eight sides\n{tc[1]}(c) {tc[2]}six sides'
    )

prompt = ('b','c','b','a','c','c','a')

score = 0
loop = 0

while loop <= 6:

    os.system(tc[7])
    button = input((tc[1])+'\nKnow Your Stuff!\n\n'+(tc[2])+'Know Your Polygons\n\n'+\
    question_prompts1[loop]+'\n\n'+(tc[0])+'READY:'+(tc[1])).strip()

    if button==(prompt[loop]):
        score += 1

    loop += 1

    os.system(tc[7])

print(f'\n{tc[2]}Know Your Polygons\n\n{tc[2]}You got \
{score}/{len(question_prompts1)} questions correct.\nCongratulations! Your total \
Prize Winnings: {tc[1]}${score*100*score:,}.00 {tc[2]}Dollars.\n\n{tc[0]}READY:')

input('\nEND OF PROGRAM! Press Enter to quit.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Let's have fun and learn how to raise some errors to test in Python
# programs.

try:
    print('Raising an Exception:')
    raise Exception
except Exception:
    print('Exception:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
try:
    print('Raising a ValueError:')
    raise ValueError
except ValueError:
    print('ValueError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
try:
    print('Raising a TypeError:')
    raise TypeError
except TypeError:
    print('TypeError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
try:
    print('Raising a NameError:')
    raise NameError
except NameError:
    print('NameError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
try:
    print('Raising a IndexError:')
    raise IndexError
except IndexError:
    print('IndexError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
try:
    print('Raising a MemoryEorror:')
    raise MemoryError
except MemoryError:
    print('MemoryError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Raise a list of possible errors to test in Python programs.

try:
    print('Raising a list of possible errors to test:')
    raise Exception
    raise ValueError
    raise TypeError
    raise NameError
    raise IndexError
    raise MemoryError
except Exception:
    print('Exception:')
except ValueError:
    print('ValueError:')
except TypeError:
    print('TypeError:')
except NameError:
    print('NameError:')
except IndexError:
    print('IndexError:')
except MemoryError:
    print('MemoryError:')
finally:
    print('finally always executes no matter the outcome.')
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
# Here is a basic, skeletal structure of a Try: and Except: block. The 'Pass'
# statement ignores any empty code blocks, which are not used for now.
# In this case, only the skeletal structure of the program is clearly shown.
# Note:  you do not need to invoke the 'finally' statement into try: and
# Except: blocks, but they can be quite handy when you want to show
# any output on the screen, no matter the outcome of the program's
# execution/run.

try:
    pass
except Exception:
    pass
finally:
    pass

try:
    num = int(input('Type a Number: ').strip())
except ValueError:
    print('Sorry! Numbers only please.')
finally:
    print('finally always executes no matter the outcome.')

# I am almost a complete Walking Human Computer Science Research
# Laboratory Machine on Two Legs... 😁