Python Basics

python --version

python3 --version

import sys  # Import the sys module to work with system parameters

sys.path.append('grbin')  # Add the path to the directory with user modules

# The following line can be uncommented to view the current list of paths
# print(sys.path)  # Print the list of paths where Python searches for modules

'''
This is a multiline comment, where more complex logic can be described
or detailed instructions can be given.

Using multiline comments improves code readability and makes the code easier to maintain.
'''

import sys  # Import the sys module to work with system parameters

# Definition of a function in the grcodes.py module
def printx(name):
    """
    The function prints the variable name and its value.
    Example of use: name = 88.0; printx('name')
    """
    frame = sys._getframe(1)
    print(name, '=', repr(eval(name, frame.f_globals, frame.f_locals)))

import grcodes as gr  # Import the user module and assign it an alias for convenience

x = 1.0  # Assign a value to the variable

print(x)       # Standard output of the variable value
gr.printx('x') # Use the printx function from the gr module to print the variable name and value

# Get help for the printx function
help(gr.printx)

my_int = 48  # With this assignment, my_int becomes an integer
print(my_int)
printx('my_int')

48
my_int = 48

type(my_int)  # Check the type of the variable; print() is not needed
              # if this is the last line in the cell

int

my_int = 5.0  # Now my_int becomes a floating-point number
type(my_int)

float

my_complex = 8.0 + 5.0j  # Thus, my_complex is a complex number
print(my_complex)
printx('my_complex')

(8+5j)
my_complex = (8+5j)

my_int, my_float, my_string = 20, 10.0, "Hello!"

if my_string == "Hello!":  # comparison operators: ==, !=, <, <=, >, >=
    print("String: %s" % my_string)  # Indentation of 4 spaces

if isinstance(my_float, float) and my_float == 10.0:
    # isinstance(): returns whether an object is an instance of a class
    print("This is a floating-point number, and it is equal to %f" % my_float)

if isinstance(my_int, int) and my_int == 20:
    print("This is an integer, and it is equal to: %d" % my_int)

String: Hello!
This is a floating-point number, and it is equal to 10.000000
This is an integer, and it is equal to: 20

my_float = 5.0      # Assign the value 5.0 to my_float, making the variable a float
print(my_float)     # Print the value of my_float

my_float = float(6) # Create a floating-point number by converting an integer with float()
print(my_float)     # Print the value of my_float

print(int(7.0))     # Convert a float to an int and print it
print('int(7.0)')   # Print the string 'int(7.0)'

5.0
6.0
7
int(7.0)

a = 1.0
print('a =', a, 'at memory address:', id(a))

a = 1.0 at memory address: 140703208811472

b = a
print('b =', b, 'at memory address:', id(b))

b = 1.0 at memory address: 140703208811472

a, b = 2.0, 3.0
print('a =', a, 'at memory address:', id(a))
print('b =', b, 'at memory address:', id(b))

a = 2.0 at memory address: 4365829648
b = 3.0 at memory address: 4365829264

n1 = 100000000000
n_1 = 100_000_000_000  # for readability

# Ternary conditional expression
print('Yes, n1 is the same as n_1') if n1 == n_1 else print('No')

n2 = 1_000_000_000
print('Total =', n1 + n2)

# f-string (Python 3.6 or later)
print('Total =', f'{n1 + n2:,}')

# The following line prints the number using underscores as separators
print('Total =', f'{n1 + n2:_}')

Yes, n1 is the same as n_1
Total = 101000000000
Total = 101,000,000,000
Total = 101_000_000_000

my_string = "How are you? How is your mood?"
# A string has been defined; the characters in it can be indexed
print(my_string, my_string[13], my_string[14], my_string[15], my_string[16], my_string[17:])

my_string = 'Hello,' + " hello!" + " I am here."
# Note that the + operator performs concatenation for strings
print(my_string)

How are you? How is your mood? H o w   is your mood?
Hello, hello! I am here.

my_string = "Do not worry; just use double quotation marks to 'escape' apostrophes."
print(my_string)

Do not worry; just use double quotation marks to 'escape' apostrophes.

my_string = 'Do not worry about "double quotation marks".'
print(my_string)

Do not worry about "double quotation marks".

one, two, three = 1, 2, 3  # Assign values to variables
summation = one + two + three
print('sum =', summation)  # Print the sum

sum = 6

one, two, three = 1, 2, 3.0  # Variable types may differ
summation = one + two + three
print('Summation =', summation)  # Print the summation

Summation = 6.0

one3 = two3 = three3 = 3  # Assign the same value to variables
print(one3, two3, three3)

3 3 3

hello, world = "Hello,", "world!"

# Concatenate strings
helloworld = hello + " " + world + "!!"
print(helloworld, ' ', hello + " " + world)

# Get the length of the string, including spaces and punctuation marks
lhw = len(helloworld)
print('The length of the string "helloworld" is', lhw)

Hello, world!!!   Hello, world!
The length of the string "helloworld" is 15

hello, world = "Hello,", "world!"
helloworld = hello + " " + world + "!!"
the_words = helloworld.split(" ")  # Creates a list of strings
# Similar operations on lists will be discussed later
print("Splitting the words of the string: %s" % the_words)
print('Joining them back together using a space as the separator:', ' '.join(the_words))

Splitting the words of the string: ['Hello,', 'world!!!']
Joining them back together using a space as the separator: Hello, world!!!

my_string = "Helloworld!"
print('"o" is immediately after the', my_string.index("o"), 'th letter.')
print('The first letter "l" is immediately after the', my_string.index("l"), 'th letter.')

"o" is immediately after the 4 th letter.
The first letter "l" is immediately after the 2 th letter.

my_string = "Helloworld!"
# + performs concatenation
print('The position of the letter "o" is immediately after the ' + str(my_string.index("o")) + 'th letter.')
print('The first letter "l" is immediately after the ' + str(my_string.index("l")) + 'th letter.')

The position of the letter "o" is immediately after the 4th letter.
The first letter "l" is immediately after the 2th letter.

from collections import Counter  # Import the Counter module

my_list = ['a', 'a', 'b', 'b', 'b', 'c', 'd', 'd', 'd', 'd', 'd']
count = Counter(my_list)  # A Counter object is a dictionary

print(count)  # Print the frequency of each element in the list
# See also the later discussion of dictionaries

{'a': 2, 'b': 3, 'c': 1, 'd': 5}

print('The frequency of "b" is', count['b'])
# Frequency of the element indexed by its key

The frequency of "b" is 3

my_string = "Hello, world!"  # Define a string
print(my_string.upper(), my_string.lower(), my_string.title())  # Convert to uppercase, lowercase, and title case

HELLO, WORLD! hello, world! Hello, World!

my_string = "ABCDEFG"
reversed_string = my_string[::-1]
print(reversed_string)

GFEDCBA

my_string = "russia is a country of opportunity"
new_string = my_string.title()
print(new_string)

Russia Is A Country Of Opportunity

n = 8
my_list = [1] * n
print(my_list)

[1, 1, 1, 1, 1, 1, 1, 1]

# Declare the variable my_string and assign it the value "abcdefg"
my_string = "abcdefg"

# Print the string my_string repeated twice
print(my_string * 2)

abcdefgabcdefg

# Declare the variable lotsofhellos and assign it the value "Hello " repeated 5 times
lotsofhellos = "Hello " * 5

# Print the value of the variable lotsofhellos
print(lotsofhellos)

Hello Hello Hello Hello Hello

# Length of the string "ABCDE"
print("The length of the string \"ABCDE\" is", len("ABCDE"))

The length of the string "ABCDE" is 5

# Program for printing the length of a string
# Initialize the variable my_string
my_string = "Hello, world!"

# Print the length of the string my_string
print("The length of the string", my_string, "is", len(my_string))

The length of the string "Hello, world!" is 13

# Declare two variables containing lists
even_numbers, odd_numbers = [2, 4, 6, 8], [1, 3, 5, 7]

# Get the length of the list even_numbers using the len() function
length = len(even_numbers)

# Combine two lists using the + operator
all_numbers = odd_numbers + even_numbers

# Print the combined list, as well as the original and new lengths
print(all_numbers, 'The original length is', length, '. The new length is', len(all_numbers))

[1, 3, 5, 7, 2, 4, 6, 8] The original length is 4 . The new length is 8

# Create a list
all_numbers = [5, 3, 9, 1, 4]

# Print sorted characters and the characters of "ABCDE" in reverse order
print(sorted('DCBAE'), sorted('ABCDE', reverse=True))

# Print the list all_numbers sorted in ascending and descending order
print(sorted(all_numbers), sorted(all_numbers, reverse=True))

['A', 'B', 'C', 'D', 'E'] ['E', 'D', 'C', 'B', 'A']
[1, 3, 4, 5, 9] [9, 5, 4, 3, 1]

# Original list and variable
original_list, n = [1, 2, 3, 4], 2

# Create a new list using a list comprehension,
# where each element of the original list is multiplied by n
new_list = [n * x for x in original_list]

# Print the new list
print(new_list)

[2, 4, 6, 8]

my_list = ['a', 'b', 'c']  # Create a list with the elements 'a', 'b', and 'c'

# Iterate over the list, obtaining the index and value of each element
for index, value in enumerate(my_list):
    # Print the index (increased by 1) and the value of each list element
    print('{0}: {1}'.format(index + 1, value))

1: a
2: b
3: c

my_list = ['a', 'b', 'c']  # Create a list with the elements 'a', 'b', and 'c'

for index, value in enumerate(my_list):  # Generate indices and values
    print(f'{index + 1}: {value}')       # Print the index and value using an f-string

1: a
2: b
3: c

a, b = 1, 2  # Assign values to variables a and b

try:
    print(a / b)  # Try to perform division
except ZeroDivisionError:
    print("division by zero")  # Handle division-by-zero error
else:
    # The else block is executed if there were no exceptions in the try block
    print("no exceptions occurred")
finally:
    # The finally block is executed in any case
    print("Whatever happened, we always execute this")

0.5
no exceptions occurred
Whatever happened, we always execute this

import sys  # Import the sys module

num = "AAA"
print('The memory size is %d' % sys.getsizeof(num), 'bytes')
# Memory size of the string

The memory size is 52 bytes

num = 12345
print('The memory size is %d' % sys.getsizeof(num), 'bytes')
# Memory size of the integer

The memory size is 28 bytes

# Define a string
astring = "Hello, world!"

# Check whether the string starts with "Hello" and whether it ends with "abcde" or "!"
starts_with_hello = astring.startswith("Hello")
ends_with_abcde = astring.endswith("abcde")
ends_with_exclamation = astring.endswith("!")

print(starts_with_hello, ends_with_abcde, ends_with_exclamation)

True False True

# Check whether all characters are numbers or letters
# Check whether all characters are letters
# Check whether the string is written in uppercase

my_string = "Hello, world!"
my_string1 = "HelloWorld"
my_string2 = "HELLO WORLD!"

print(my_string.isalnum())  # whether all characters are letters or digits
print(my_string1.isalpha()) # whether all characters are letters
print(my_string2.isupper()) # whether everything is uppercase

False
True
True

n, x, s = 1234, 1234.0, 'this string'

print(type(n), type(x), type(s))          # Check the object type
print(len(s), len(str(n)), len(str(x)))   # Determine the length of the string and string representations of numbers

<class 'int'> <class 'float'> <class 'str'>
11 4 6

a = 2  # Initialize the variable a with the value 2
print('a =', a, 'type of a:', type(a))  # Print the value and type of a

b = 3.0  # Initialize the variable b with the value 3.0
a = a + b  # Add the variables a and b; the result is stored in a

# Print the values and types of variables a and b
print('a =', a, 'type of a:', type(a))
print('b =', b, 'type of b:', type(b))

a = 2 type of a: <class 'int'>
a = 5.0 type of a: <class 'float'>
b = 3.0 type of b: <class 'float'>

n, x, s = 1234, 1234.5, 'this string'  # Initialize variables n, x, and s

sfn = str(n)  # Convert the integer n to a string
print(sfn, type(sfn))  # Print the value and type of sfn

sfx = str(x)  # Convert the floating-point number x to a string
print(sfx, type(sfx))  # Print the value and type of sfx

1234 <class 'str'>
1234.5 <class 'str'>

n, x, s = 1234, 1234.5, 'this string'  # Initialize variables n, x, and s

xfn = float(n)  # Convert the integer n to a floating-point number
print(xfn, type(xfn))  # Print the value and type of xfn

nfx = int(x)  # Convert the floating-point number x to an integer
print(nfx, type(nfx))  # Print the value and type of nfx

1234.0 <class 'float'>
1234 <class 'int'>

# a = int('Hello')  # Converting the string 'Hello' to an integer will cause an error
# ValueError

# a = int('2.5')    # Converting the string '2.5' to an integer will also cause an error
# ValueError

a = int('25')       # Converting the string '25' to an integer works correctly
print(a, type(a))   # Print the value and type of a after conversion

25 <class 'int'>

# Perform an addition operation
result = 8.0 + float("8.0")  # Add 8.0 and the string "8.0" converted to a float
print(result)  # Print the result

16.0

a = int(False)  # Convert the Boolean value False to an integer
print(a, type(a))  # Print the value and type of a after conversion

0 <class 'int'>

# Define a floating-point number and a string
my_float = 3.14
my_string = "This is an example string"

# Attempt to add them together
try:
    my_mix = my_float + my_string  # Attempt to add a floating-point number and a string
except TypeError as e:
    print(f"Error: {e}")  # Print the error

Error: unsupported operand type(s) for +: 'float' and 'str'

name = "Ivan"
print("Hello, %s! How are you?" % name)  # %s is used for strings

# For two or more arguments, use a tuple:
name, age = "Alexey", 23
print("%s is %d years old." % (name, age))  # %d is used for numbers

Hello, Ivan! How are you?
Alexey is 23 years old.

# Define variables
name = "Ivan"  # Name
age = 23       # Age

# Print a greeting and age information
# Use an f-string to insert variables directly into the string
print(f"{name} is {age} years old.")  # f-strings are available in Python 3.6 and later

Ivan is 23 years old.

list1, list2, x = [1, 2, 3], ['Anna', 'Maria'], 12.5  # Multiple assignment
print("List1:%s; List2:%s\nx=%s, x=%f, x=%.3f, x=%e" % (list1, list2, x, x, x, x))

List1:[1, 2, 3]; List2:['Anna', 'Maria']
x=12.5, x=12.500000, x=12.500, x=1.250000e+01

list1, list2, x = [1, 2, 3], ['Anna', 'Maria'], 12.5  # Multiple assignment

print(f"List1:{list1}; List2:{list2}; x={x}, x={x:.2f}, x={x:.3e}")
# This line prints the values of list1, list2, and x.
# Output formatting is performed using an f-string.

List1:[1, 2, 3]; List2:['Anna', 'Maria']; x=12.5, x=12.50, x=1.250e+01

name = "Ivan"
age = 30
height = 1.82
print(f"Hello, {name}! Your age is {age} years, and your height is {height:.2f} meters.")

Hello, Ivan! Your age is 30 years, and your height is 1.82 meters.

# Addition
print(1 + 2)  # 3

# Subtraction
print(5 - 3)  # 2

# Multiplication
print(2 * 3)  # 6

# Division
print(10 / 2)  # 5

# Integer division
print(10 // 2)  # 5

# Remainder after integer division
print(10 % 2)  # 0

# Exponentiation
print(2 ** 3)  # 8

3
2
6
5.0
5
0
8

# Declare the variable number and assign it the value 1 + 2 * 3 / 4.0
number = 1 + 2 * 3 / 4.0

# Print the value of the variable number to the screen
print(number)

2.5

# Declare two variables:
# numerator — the numerator
# denominator — the denominator
numerator, denominator = 11, 2

# Compute the quotient using integer division
# floor division
floor = numerator // denominator

# Print the result to the screen
print(str(numerator) + '//' + str(denominator) + '=', floor)

# Compute the remainder after division
remainder = numerator % denominator

# Print the result to the screen
print(str(numerator) + '%' + str(denominator) + '=', remainder)

# Compute the sum of the quotient and the remainder
print(floor * denominator + remainder)

11//2= 5
11%2= 1
11

# Declare two variables:
# squared — the square of the number 7
# cubed — the cube of the number 2
squared, cubed = 7 ** 2, 2 ** 3

# Print the values of the variables to the console
print('7 ** 2 =', squared, ', and 2 ** 3 =', cubed)

7 ** 2 = 49 , and 2 ** 3 = 8

# Bitwise exclusive OR (XOR) between the numbers 7 and 2
test72 = 7 ^ 2

# Print the result to the console
print(test72)

5

# Declare variables a and b and assign them the values 100 and 200, respectively
a, b = 100, 200

# Print the values of a and b
print('a=', a, 'b=', b)

# Swap the values of a and b using assignment operators
a, b = b, a

# Print the values of a and b
print('a=', a, 'b=', b)

a= 100 b= 200
a= 200 b= 100

# Prints True for all values except 0 and an empty value
print(bool(5), bool(-5), bool(0.2), bool(-0.1), bool(str('a')), bool(str('0')))
# True True True True True True

# Prints False for 0 and -0.0
print(bool(0), bool(-0.0))
# False False

# Prints False for empty values
print(bool(''), bool([]), bool({}), bool(()))
# False False False False

# The first line of code prints three values:
# - True and True — logical AND of two true values; the result is True
# - False or True — logical OR of two values, one of which is true; the result is True
# - True or True — logical OR of two true values; the result is True
print(True and True, False or True, True or True)

# The second line of code prints two values:
# - False and False — logical AND of two false values; the result is False
# - False and True — logical AND of two values, one of which is false; the result is False
print(False and False, False and True)

True True True
False False

# Declare the variable x_list of type list
x_list = []

# Print the contents of x_list to the screen
print(f"x_list={x_list}")

# Print the address of x_list in hexadecimal format
print(hex(id(x_list)))

x_list=[]
0x104983300

x_list = []
x_list.append(1)   # Adds the number 1 to the end of x_list
x_list.append(2)   # Adds the number 2 to the end of x_list
x_list.append(3.)  # Adds the number 3.0 (floating point) to the end of x_list

print(x_list[0])  # Prints the first element of the list (index 0), which is 1
print(x_list[1])  # Prints the second element of the list (index 1), which is 2
print(x_list[2])  # Prints the third element of the list (index 2), which is 3.0
print(x_list)     # Prints the entire list

1
2
3.0
[1, 2, 3.0]

for x in x_list:  # A for loop for iterating over the elements of x_list
    print(x, end=',')  # Print each element without a line break

print('\n')  # Print a new line after the loop

x_list2 = x_list * 2  # Create a new list x_list2 by concatenating x_list with itself
print(x_list2)        # Print the new list

1,2,3.0,

[1, 2, 3.0, 1, 2, 3.0]

print(id(x_list), id(x_list2))

4367086336 4367678592

# Returns the identifier (memory address) of the second element of x_list
id(x_list[1])

1594536160

x_list3 = x_list  # Assign the list x_list to the variable x_list3
print(x_list, ' ', x_list3)  # Print the values of both variables

[1, 2, 3.0]  [1, 2, 3.0]

print(id(x_list), id(x_list3))

1847992120648 1847992120648

x_list4 = x_list.copy()  # Create an independent copy of x_list using the copy() method
print(x_list, ' ', x_list4)  # Print the values of both lists

[1, 2, 3.0]  [1, 2, 3.0]

print(id(x_list), id(x_list4))

1847992120648 1847993186760

# Assign the value 4.0 to the first element of the list x_list
x_list[0] = 4.0

# Print the list to the screen
print(x_list)

[4.0, 2, 3.0]

# Create the list x_list
x_list = [1, 2, 3.0]

# Create the list x_list2, which is a copy of x_list
x_list2 = x_list.copy()

# Change the value of the first element of x_list
x_list[0] = 4.0

# Print x_list2 to the screen
print(x_list2)

[1, 2, 3.0]

num = 19345678

# Method 1: using the map() function and converting to a list
list_of_digits = list(map(int, str(num)))
print(list_of_digits)  # Output: [1, 9, 3, 4, 5, 6, 7, 8]

# Method 2: using list comprehension
list_of_digits = [int(x) for x in str(num)]
print(list_of_digits)  # Output: [1, 9, 3, 4, 5, 6, 7, 8]

# Declare two variables containing lists
list1, list2 = [20, 30, 40], [5, 6, 8]

# Print the original lists to the screen
print(list1, " ", list2, " ", list1 + list2)

# Print the original lists to the screen as strings
print("Original string 1: " + str(list1))
print("Original string 2: " + str(list2))

# Print a message saying that "+" is not addition
print('"+" is not addition, but concatenation:', list1 + list2)

[20, 30, 40]   [5, 6, 8]   [20, 30, 40, 5, 6, 8]
Original string 1: [20, 30, 40]
Original string 2: [5, 6, 8]
"+" is not addition, but concatenation: [20, 30, 40, 5, 6, 8]

# Declare two lists
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# Declare an empty list to store element sums
add_list = []

# Use a for loop for element-wise addition of lists
for i in range(0, len(list1)):
    add_list.append(list1[i] + list2[i])

# Print the result to the screen
print("Element-wise addition of two lists: " + str(add_list))

Element-wise addition of two lists: [7, 9, 11, 13, 15]

# Print the address of the first element of add_list
print("Address of the first element of the list:", id(add_list[0]))

Address of the first element of the list: 4363141552

# Print the address of the first element of list1
print("Address of the first element of the list:", id(list1[0]))

Address of the first element of the list: 4377526512

# Declare two lists
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# Declare an empty list for storing results
add_list = []

# A for loop that iterates over elements of two lists at the same time
for i1, i2 in zip(list1, list2):
    # Add element i2 to element i1
    add_list.append(i1 + i2)

# Print the results to the screen
print("Sum of the elements of two lists element by element: ", add_list)

Sum of the elements of two lists element by element:  [7, 9, 11, 13, 15]

my_string = "Every hut has its own rattles"

# Print the original string
print(my_string)

# Print the fifth character of the string
print('5th =', my_string[4])

# Print the seventh through eleventh characters of the string
print('from 7th to 11th =', my_string[6:11])

Every hut has its own rattles
5th =  y
from 7th to 11th =  hut

# Create a string variable
my_string = "Hello, world!"  # You can change the string to any other string

# Print string slices with explanations:
print('[6:-1]=', my_string[6:-1])  # Slice from the 7th element (inclusive) to the last, not including the last
print('[:]=', my_string[:])        # All characters of the string
print('[6:]=', my_string[6:])      # Slice from the 7th element (inclusive) to the end of the string
print('[:-1]=', my_string[:-1])    # All characters of the string except the last

[6:-1]=  world
[:]= Hello, world!
[6:]=  world!
[:-1]= Hello, world

# Declare the variable my_string and assign it the value "Hello world!"
my_string = "Hello world!"

# Print the text "Characters from the 4th to the 9th with step 2"
print("Characters from the 4th to the 9th with step 2")

# Use a slice to obtain a substring from my_string starting with the 4th character,
# ending with the 9th, with a step of 2.
# The result will be the string "l o".
print("[3:9:2]=", my_string[3:9:2])

# The string "Hello world!" consists of 12 characters:
#   H — 1st character
#   e — 2nd character
#   l — 3rd character
#   l — 4th character
#   o — 5th character
#     — 6th character (space)
#   w — 7th character
#   o — 8th character
#   r — 9th character
#   l — 10th character
#   d — 11th character
#   ! — 12th character

# Slice syntax: [start:stop:step]
# start — index of the first character in the substring
# stop — index of the character before which the slice stops
# step — interval in the sequence of characters in the substring

Characters from the 4th to the 9th with step 2
[3:9:2]= l o

my_string = "Here we go! (c)"

# Print the original string
print("string:", my_string)

# Print the string in reverse order
print("[::-1]=", my_string[::-1])

string: Here we go! (c)
[::-1]= )c( !og ew ereH

# Declare the variable my_string without assigning a value
# in order to demonstrate an error
my_string = ""

# Attempt to print the element with index 14, which is outside the string
print('[14]=', my_string[14])  # This will print an IndexError

# Create the list my_list containing mixed variable types:
my_list = [0, 1, 2, 3, "4E", 5, 6, 7, [8, 8], 9]

# Print the list my_list using the print() operator
# In the range from 0 to 9 with step 1
print(my_list[0:10:1])

# Print the list my_list using the print() operator
# From the beginning of the list to the end
print(my_list[:])

[0, 1, 2, 3, '4E', 5, 6, 7, [8, 8], 9]
[0, 1, 2, 3, '4E', 5, 6, 7, [8, 8], 9]

# Create a list with mixed values
nlist = [10, 20, 30, 40, 50, 6.0, '7H']

# Unpack the list elements, ignoring the first two and the fifth element
_, _, n3, _, *nn = nlist

# Print the third element and the remaining elements after the fifth, with text translation
print("n3=", n3, "remaining numbers", *nn)

# Create another list with numeric values
nlist = [10, 20, 30, 40, 50, 60, 70]

# Unpack elements, leaving the third, the last, and the rest in a separate list nn
_, _, n3, *nn, nlast = nlist

# Print the third element, the last element, and the remaining elements with text translation
print("n3=", n3, ", last=", nlast, ", and all other numbers", *nn)

n3= 30 remaining numbers 50 6.0 7H
n3= 30 , last= 70 , and all other numbers 40 50 60

# Create a nested list of mixed variable types
nested_list = [[11, 12], ['2B', 22], [31, [32, 3.2]]]

# Print the nested list to the screen
print('Nested list:')
print(nested_list)

# Print the number of nested lists
print('Number of nested lists:', len(nested_list))

Nested list:
[[11, 12], ['2B', 22], [31, [32, 3.2]]]
Number of nested lists: 3

# Print the first nested list
# nested_list[0] — the first element of nested_list

# Print the second nested list
# nested_list[1] — the second element of nested_list

# Print the third nested list
# nested_list[2] — the third element of nested_list

# Print the entire nested list
# print(nested_list) — the function for printing data to the screen
print(nested_list[0])
print(nested_list[1])
print(nested_list[2])
print(nested_list)

[11, 12]
['2B', 22]
[31, [32, 3.2]]
[[11, 12], ['2B', 22], [31, [32, 3.2]]]

print(nested_list[0][0])  # prints the first element (index 0) in the first nested list (also index 0). Thus, it accesses the number 11.
print(nested_list[0][1])  # prints the second element (index 1) in the first nested list (index 0). Thus, it accesses the number 12.

11
12

print(nested_list)        # prints the entire nested list
print(nested_list[1][0])  # prints the first element (index 0) in the second nested list (index 1). Thus, it prints the string '2B'.
print(nested_list[2][1])  # prints the second element (index 1) in the third nested list (index 2). This second element is itself a list: [32, 3.2].
print(nested_list[2][1][0])  # prints the first element (index 0) in the list located in the second element (index 1) of the third nested list (index 2). Thus, it prints the number 32.

[[11, 12], ['2B', 22], [31, [32, 3.2]]]
2B
[32, 3.2]
32

# Create a tuple
ttuple = (10, 20, 30, 40, 50, 6.0, '7H')

# Print the tuple
print('ttuple =', ttuple)

# Assign the first value of the tuple to the variable `aa`
aa = ttuple[0]

# Print the value of the variable `aa`
print('aa =', aa)

# Print the values of tuple elements with indices 1, 6, and -1
print(ttuple[1], ' ', ttuple[6], ' ', ttuple[-1])

ttuple = (10, 20, 30, 40, 50, 6.0, '7H')
aa = 10
20   7H   7H

# Declare a tuple
ttuple = ('a', 'b', 'c', 'd', 'e')

# A for loop using the enumerate() function
# The enumerate() function returns a tuple of the element index and value
for i, data in enumerate(ttuple):
    # Check whether the index is less than 3
    if i < 3:
        # Print the index and the element value
        print(i, ':', data)

0 : a
1 : b
2 : c

# Create a tuple
ttuple = (1, 2, 3)

# Print the tuple
print("Terminal output:", ttuple)

# Try to change the value of a tuple element
try:
    ttuple[2] = 300
except TypeError:
    print("Error: the value of a tuple element cannot be changed")

# Create the dictionary phonebook1
phonebook1 = {}

# Add entries to the dictionary
phonebook1["Masha"] = 513476565
phonebook1["Lyosha"] = 513387234
phonebook1["Nastya"] = 513682762
phonebook1["Ded Moroz"] = 513387234

# Print the dictionary to the screen
print(phonebook1)

{'Masha': 513476565, 'Lyosha': 513387234, 'Nastya': 513682762, 'Ded Moroz': 513387234}

# Create the dictionary phonebook2
phonebook2 = {'Lera': 656477456, 'Nastya': 656377243, 'Timofey': 656662798}

# Print the dictionary to the screen
print(phonebook2)

{'Lera': 656477456, 'Nastya': 656377243, 'Timofey': 656662798}

# Declare the dictionary phonebook0
phonebook0 = {
    "Kostya": [788567837, 788347278],  # Kostya has two phone numbers
    # this is a list
    "Inna": 513683222,
    "Vladik": 656477456
}

# Print phonebook0 to the screen
print("Phone book:")
print(phonebook0)

Phone book:
{'Kostya': [788567837, 788347278], 'Inna': 513683222, 'Vladik': 656477456}

# Create a phone-book dictionary
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

# Iterate over the dictionary
for name, number in phonebook1.items():
    # Print the subscriber's name and phone number
    print("The phone number of %s is %d" % (name, number))

The phone number of Ivanov Ivan is 1234567
The phone number of Petrov Petr is 89012345678
The phone number of Sidorov Sidor is 7890123456

# Create a phone-book dictionary
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

# Iterate over the dictionary
for key, value in phonebook1.items():
    print(key, value)

Ivanov Ivan 1234567
Petrov Petr 89012345678
Sidorov Sidor 7890123456

# Create a phone-book dictionary
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

# Iterate over the dictionary
for key in phonebook1.keys():
    print(key)

Ivanov Ivan
Petrov Petr
Sidorov Sidor

# Create a phone-book dictionary
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

# Iterate over the dictionary
for value in phonebook1.values():
    print(value)

1234567
89012345678
7890123456

phonebook = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

del phonebook["Ivanov Ivan"]

print(phonebook)

{'Petrov Petr': 89012345678, 'Sidorov Sidor': 7890123456}

phonebook = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}

number = phonebook.pop("Ivanov Ivan")
print(phonebook)
print(number)

{'Petrov Petr': 89012345678, 'Sidorov Sidor': 7890123456}
1234567

# Create two phone books
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}
phonebook2 = {
    "Vasilyev Vasily": 9123456789,
    "Pupkin Pupkin": 4567890123
}

# Update phone book 1
# Use the `update()` method to merge two dictionaries
phonebook1.update(phonebook2)

# Print the updated phone book 1
print(phonebook1)

{'Ivanov Ivan': 1234567, 'Petrov Petr': 89012345678, 'Sidorov Sidor': 7890123456, 'Vasilyev Vasily': 9123456789, 'Pupkin Pupkin': 4567890123}

# Create two phone books
phonebook1 = {
    "Ivanov Ivan": 1234567,
    "Petrov Petr": 89012345678,
    "Sidorov Sidor": 7890123456
}
phonebook0 = {
    "Vasilyev Vasily": 9123456789,
    "Pupkin Pupkin": 4567890123
}

# Create a new phone book 3
# Use the `**` operator to merge two dictionaries
phonebook3 = {**phonebook1, **phonebook0}

# Print the new phone book 3
print(phonebook3)

{'Ivanov Ivan': 1234567, 'Petrov Petr': 89012345678, 'Sidorov Sidor': 7890123456, 'Vasilyev Vasily': 9123456789, 'Pupkin Pupkin': 4567890123}

# Create two dictionaries
dict_1 = {
    "Apple": 7,
    "Banana": 5
}
dict_2 = {
    "Banana": 3,
    "Orange": 4
}

# Merge two dictionaries
# Use the `**` operator
combined_dict = {**dict_1, **dict_2}

# Print the merged dictionary
print(combined_dict)

{'Apple': 7, 'Banana': 3, 'Orange': 4}

# Create the variable sentence1 and assign it a string with repeated words
sentence1 = "His name is Semyon and Semyon is his name"

# Use the split() method to convert the string to a list of words
# The default separator is a space, so it splits the string into words
words1 = sentence1.split()

# Print the list of words for clarity
# The output should show all words, including duplicates
print(words1)

# Convert the list of words to a set, which automatically removes all duplicates
word_set1 = set(words1)

# Print the set of words to see that duplicates have been removed
print(word_set1)

['His', 'name', 'is', 'Semyon', 'and', 'Semyon', 'is', 'his', 'name']
{'His', 'his', 'and', 'name', 'is', 'Semyon'}

# Define the first set of words
word_set1 = {'hello', 'world', 'name', 'is', 'first', 'python', 'and'}

# Define the second set of words
word_set2 = {'this', 'is', 'a', 'test', 'name', 'first', 'and'}

# Use the intersection() method to find the intersection between two sets.
# The intersection of sets returns a new set that contains all elements
# that are present in both original sets.
common_elements = word_set1.intersection(word_set2)

# Print the common elements of the sets to the screen
print(common_elements)  # Prints a set with common elements

{'name', 'is', 'and', 'first'}

# Define two sets with different words
word_set1 = {'hello', 'his', 'Her', 'His', 'Nastya'}
word_set2 = {'hello', 'Her', 'her', 'Anya'}

# Get and print the words that are in word_set1 but not in word_set2
# Expected output: {'his', 'His', 'Nastya'}
print(word_set1.difference(word_set2))

{'his', 'His', 'Nastya'}

# Print the symmetric difference between word_set1 and word_set2
# Expected output: {'his', 'His', 'her', 'Anya', 'Nastya'}
print(word_set1.symmetric_difference(word_set2))

{'his', 'His', 'her', 'Anya', 'Nastya'}

# Create two lists of words
words1 = ['hello', 'his', 'Her', 'His', 'Nastya']
words2 = ['hello', 'Her', 'her', 'Anya']

# Attempting to use the intersection method will raise an error because lists do not have such a method.
# This code, if uncommented, will raise AttributeError:
# print(words1.intersection(words2))  # AttributeError: 'list' object has no attribute 'intersection'

# Create two sets with unique words
word_set1 = {'hello', 'his', 'Her', 'His', 'Nastya'}
word_set2 = {'hello', 'Her', 'her', 'Anya'}

# Print the difference between word_set1 and word_set2.
# The difference method returns a set containing elements that are in word_set1 but not in word_set2.
# Expected output: {'his', 'His', 'Nastya'}
print('Difference between word_set1 and word_set2:', word_set1.difference(word_set2))

# Print the symmetric difference between word_set1 and word_set2.
# The symmetric_difference method returns a set containing elements that are in only one of the sets.
# Expected output: {'his', 'His', 'her', 'Anya', 'Nastya'}
print('Symmetric difference between word_set1 and word_set2:', word_set1.symmetric_difference(word_set2))

# Lists in Python do not support set operations directly, so we cannot use methods like intersection.
# However, we can convert lists to sets, perform the operation, and then convert the result back to a list if needed.

# Create two lists of words
words1 = ['hello', 'his', 'Her', 'His', 'Nastya']
words2 = ['hello', 'Her', 'her', 'Anya']

# Convert the lists to sets and find their symmetric difference,
# then convert the result back to a list.
sym_diff_list = list(set(words1).symmetric_difference(set(words2)))

# Print the result of the symmetric difference of the lists
# Expected output: ['his', 'His', 'her', 'Anya', 'Nastya']
print('Symmetric difference of the lists words1 and words2:', sym_diff_list)

Difference between word_set1 and word_set2: {'His', 'his', 'Nastya'}
Symmetric difference between word_set1 and word_set2: {'Nastya', 'Anya', 'His', 'his', 'her'}
Symmetric difference of the lists words1 and words2: ['Nastya', 'Anya', 'His', 'his', 'her']

# Assign the value 2 to the variable x
x = 2

# Compare x with 2; we expect True because x is indeed equal to 2
print(x == 2)  # Result: True

# Compare x with 3; we expect False because x is not equal to 3
print(x == 3)  # Result: False

# Check whether x is less than 3; we expect True because 2 is less than 3
print(x < 3)   # Result: True

# Assign the value 2 to the variable x
x = 2

# Check whether x is equal to 2
if x == 2:
    # If the condition is true, print the message "x is equal to 2!"
    print("x is equal to 2!")  # Expected output: x is equal to 2!
else:
    # If the condition is false, print the message "x is not equal to 2."
    print("x is not equal to 2.")  # This code will not be executed because the condition is true

# Declare two string variables
name1, name2 = "Sasha", "Lyosha"

# Create the list groupA with names
groupA = ["Sasha", "Masha"]

# Check whether name1 (Sasha) is in the groupA list
if name1 in groupA:
    print(name1, "found in group A")

# Check whether name2 (Lyosha) is in the groupA list
if name2 in groupA:
    print(name2, "found in group A")
else:
    # The else branch is executed if name2 (Lyosha) is not found in groupA
    print(name2, "not found in group A")

# Add one more name for demonstration
name3 = "Lena"

# Check whether name3 (Lena) is in the groupA list
if name3 in groupA:
    print(name3, "found in group A")
else:
    # The else branch is executed if name3 (Lena) is not found in groupA
    print(name3, "not found in group A")

Sasha found in group A
Lyosha not found in group A
Lena not found in group A

x, y = ['a', 'b'], ['a', 'b']
z = y  # Assign z a reference to the same object as y

print(x == y, ' x=', x, 'y=', y, hex(id(x)), hex(id(y)))  # Prints True because the values in x and y are equal
print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))   # Prints False because x and y are different objects (different IDs)
print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z)))  # Prints True; y and z refer to the same object

# Change the second element in the list y
y[1] = 'x'
print('After changing one value in y')
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))  # Prints False; now their values are not equal
print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))  # Prints False; x and y are different objects
print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z))) # Prints True; y and z still refer to the same object

# Add list x to list y
y.append(x)
print('After adding list x to list y')
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))  # Prints False; the values of x and y differ
print(x is y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))  # Prints False; x and y are different objects
print(y is z, ' y=', y, 'z=', z, hex(id(y)), hex(id(z))) # Prints True; y and z still refer to the same object

True  x= ['a', 'b'] y= ['a', 'b'] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'b'] 0x100a77300 0x100b07c80
True  y= ['a', 'b'] z= ['a', 'b'] 0x100b07c80 0x100b07c80
After changing one value in y
False x= ['a', 'b'] y= ['a', 'x'] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'x'] 0x100a77300 0x100b07c80
True  y= ['a', 'x'] z= ['a', 'x'] 0x100b07c80 0x100b07c80
After adding list x to list y
False x= ['a', 'b'] y= ['a', 'x', ['a', 'b']] 0x100a77300 0x100b07c80
False x= ['a', 'b'] y= ['a', 'x', ['a', 'b']] 0x100a77300 0x100b07c80
True  y= ['a', 'x', ['a', 'b']] z= ['a', 'x', ['a', 'b']] 0x100b07c80 0x100b07c80

# Example 1: simple use of `not`
print(not False)  # Prints True because `not` inverts False to True

# Example 2: comparison using `not`
print(not False == False)  # Prints False; equivalent to the expression True == False

# Example 3: working with the == and is operators in combination with not
x, y = [1, 2, 3], [1, 2, 3]
z = y  # Assign z a reference to the same object as y

# Comparing list values
# Use the `==` operator to check equality of values in lists
print(x == y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# Prints True because the values in x and y are identical even though they are different objects

# Comparing object identity with `is not`
# Use `is not` to check whether variables point to different objects
print(x is not y, 'x=', x, 'y=', y, hex(id(x)), hex(id(y)))
# Prints True because x and y, although they have identical values, are different objects

# Using `is` to check object identity
print(y is z, 'y=', y, 'z=', z, hex(id(y)), hex(id(z)))
# Prints True because y and z point to the same object

True
False
True x= [1, 2, 3] y= [1, 2, 3] 0x104b5b300 0x104bebc80
True x= [1, 2, 3] y= [1, 2, 3] 0x104b5b300 0x104bebc80
True y= [1, 2, 3] z= [1, 2, 3] 0x104bebc80 0x104bebc80

# Set a comfortable temperature in degrees Celsius.
temp_good = 22.0

# Current temperature; this value can be changed for experimentation.
temp_now1 = 48.0

# Define conditions for different temperature states.
statement1 = (temp_now1 <= (temp_good + 10.0)) & (temp_now1 >= (temp_good - 10.0))  # comfortable
statement2 = temp_now1 < (temp_good - 10.0)  # cold
statement3 = temp_now1 > (temp_good + 10.0)  # hot

# Apply conditional operators to print the corresponding messages.
if statement1:  # Do not forget the colon.
    print("Okay, it is", temp_now1, "degrees Celsius. Comfortable. Let's go.")
    pass  # Additional actions can be added here.
elif statement2:  # Do not forget the colon.
    print("No, it is", temp_now1, "degrees Celsius. Too cold. We cannot go.")
    pass  # Additional actions can be added here.
elif statement3:
    print("No, it is", temp_now1, "degrees Celsius. Too hot. We cannot go.")
    pass  # Additional actions can be added here.
else:
    print("Let's check the temperature.")  # Perform another action
    pass

No, it is 48.0 degrees Celsius. Too hot. We cannot go.

for variable in sequence:
    # code block to execute
    pass

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

for number in range(10):
    print(number)

primes = [2, 3, 5]  # Define a list of prime numbers
for prime in primes:  # Loop over the list of prime numbers
    print(prime, end=' ')  # Print each prime number on one line

print('\nElements in range(10) are')
for n in range(10):  # Create a range from 0 to 9
    print(n, end=',')  # Print each number on one line, separated by commas

print('\nElements in range(3, 8) are')
for n in range(3, 8):  # Create a range from 3 to 7
    print(n, end=',')  # Print each number on one line

print('\nElements in range(-3, 10, 2) are')
for n in range(-3, 10, 2):  # Create a range from -3 to 9 with step 2
    print(n, end=',')  # Print each number on one line

print('\nElements in range(10, -3, -2) are')
for n in range(10, -3, -2):  # Create a reverse range from 10 to -2 with step -2
    print(n, end=',')  # Print each number on one line

2 3 5
Elements in range(10) are
0,1,2,3,4,5,6,7,8,9,
Elements in range(3, 8) are
3,4,5,6,7,
Elements in range(-3, 10, 2) are
-3,-1,1,3,5,7,9,
Elements in range(10, -3, -2) are
10,8,6,4,2,0,-2,

while condition:
    # code block to execute
    pass

while limit_not_reached:
    # perform some operations
    pass

while True:
    # perform operations
    if exit_condition:
        break

# Initialize the counter
count = 0

# The loop continues while count is less than 10
while count < 10:
    print(count, end=',')
    count += 1  # This is equivalent to count = count + 1

0,1,2,3,4,5,6,7,8,9,

# Print all numbers up to a specified limit
count = 0
while True:
    print(count, end=',')
    count += 1
    if count >= 10:  # If the limit has been reached, interrupt the loop
        break

print('\n')  # Move to a new line after the loop is completed

0,1,2,3,4,5,6,7,8,9,

# Print only even numbers: 0, 2, 4, 6, 8
for n in range(10):
    if n % 2 != 0:  # If the number is odd, skip it
        continue
    print(n, end=',')

0,2,4,6,8,

# Print numbers from 0 to 4 and then a message that the limit has been reached
count = 0
nlimit = 5

while count < nlimit:
    print(count, end=',')
    count += 1
else:
    print("the counter value has reached %d" % (nlimit))

0,1,2,3,4,the counter value has reached 5

if condition:
    variable = value_1
else:
    variable = value_2

variable = value_1 if condition else value_2

# Define variables for demonstration
value_1 = "Value when the condition is true"
value_2 = "Value when the condition is false"

# Define the condition to check
# In this case, the condition checks whether the number is even
number = 10  # This can be changed to test different conditions

# Use the ternary conditional operator to assign a value to the variable 'result'
# If 'number' is even (number % 2 equals 0), assign 'value_1'; otherwise, assign 'value_2'
result = value_1 if number % 2 == 0 else value_2

# Print the result
# Prints 'value_1' if the number is even and 'value_2' if it is odd
print(result)

Value when the condition is true

def hi():
    # Prints a welcome message to the screen
    print("Hello, welcome to this simple function!")

# Calling the greeting function
hi()

Hello, welcome to this simple function!

# Define a function with two parameters: username and greeting
def greeting_student(username, greeting):
    # Print a greeting message using an f-string to insert variables
    print(f"Hello, {username}, congratulations! We wish you {greeting}")

# Call the function and pass two string arguments
greeting_student("Stepan", "an exciting journey in using functions!")

Hello, Stepan, congratulations! We wish you an exciting journey in using functions!

# Define a function for adding two numbers
def sum_two_numbers(a, b):
    return a + b  # Return the sum of the two function arguments

# Assign values to two variables and call the function to add them
x, y = 2.0, 8.0
apb = sum_two_numbers(x, y)
print(f'{x} + {y} = {apb}')  # Output: "2.0 + 8.0 = 10.0"

# Change the variable values and call the function again
x, y = 20, 80
apb = sum_two_numbers(x, y)
print(f'{x} + {y} = {apb}, excellent!')  # Output: "20 + 80 = 100, excellent!"

2.0 + 8.0 = 10.0
20 + 80 = 100, excellent!

# Define a function with a local change to the argument value
def sum_two_numbers(a, b):
    a += 1  # Locally increase the value of argument a by 1
    print('Inside the function, a =', a)  # Print the local value of a
    return a + b  # Return the sum of the modified a and b

x, y = 2.0, 8.0
print('Before calling the function, x =', x, 'y =', y)  # Print x and y before the function call
apb = sum_two_numbers(x, y)  # Call the function and save the result
print('After calling the function, %f + %f = %f' % (x, y, apb))  # Print the results after the call

Before calling the function, x = 2.0 y = 8.0
Inside the function, a = 3.0
After calling the function, 2.000000 + 8.000000 = 11.000000

result = (lambda x, y: x + y)(10, 20)
print(result)

30

linear_function = lambda x, a, b: a * x + b
print("Linear function: f(x) = 2x + 3 at x = 5 gives", linear_function(5, 2, 3))

Linear function: f(x) = 2x + 3 at x = 5 gives 13

quadratic_function = lambda x, a, b, c: a * x**2 + b * x + c
print("Quadratic function: f(x) = 2x^2 + 3x + 1 at x = 2 gives", quadratic_function(2, 2, 3, 1))

Quadratic function: f(x) = 2x^2 + 3x + 1 at x = 2 gives 15

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print("Squares of numbers:", squared_numbers)  # Output: [1, 4, 9, 16, 25]

Squares of numbers: [1, 4, 9, 16, 25]

class C:
    '''The simplest possible class named "C".'''

    ca = "class attribute"  # Define a class attribute

# Use the help() function to obtain information about class C
help(C)

# Create two instances of class C
i1 = C()  # Instance i1 of class C is created
i2 = C()  # Instance i2 of class C is created

# Demonstrate access to the class attribute through instances and through the class itself
print('i1.ca =', i1.ca)  # Access the class attribute through instance i1
print('i2.ca =', i2.ca)  # Access the class attribute through instance i2
print('C.ca =', C.ca)    # Access the class attribute directly through the class itself

# Change the class attribute and observe its effect on the instances
C.ca = "This is the modified class attribute 'ca'"
print('After the change:')
print('C.ca =', C.ca)    # Shows the modified value of the class attribute
print('i1.ca =', i1.ca)  # Instance i1 reflects the change to the class attribute
print('i2.ca =', i2.ca)  # Instance i2 reflects the change to the class attribute

class C:
    ca = "Initial value of the class attribute 'ca'"

# Create instances of class C
i1 = C()
i2 = C()

# Change the class attribute 'ca'
C.ca = "Second modification of the class attribute 'ca'"

# Print the dictionary of class C
print("Dictionary of class C:", C.__dict__)

# Change the instance attribute 'ca' for i1
i1.ca = "This is the modified instance attribute 'ca'"

# Print the dictionary of instance i1
print("Dictionary of instance i1:", i1.__dict__)

# Print the dictionary of instance i2 before changes
print("Dictionary of instance i2 before changes:", i2.__dict__)

# Change the instance attribute 'ca' for i2
i2.ca = "Now we modify the instance attribute 'ca'"

# Print the dictionary of instance i2 after changes
print("Dictionary of instance i2 after changes:", i2.__dict__)

Dictionary of class C: {'__module__': '__main__', 'ca': "Second modification of the class attribute 'ca'", '__dict__': <attribute '__dict__' of 'C' objects>, '__weakref__': <attribute '__weakref__' of 'C' objects>, '__doc__': None}
Dictionary of instance i1: {'ca': "This is the modified instance attribute 'ca'"}
Dictionary of instance i2 before changes: {}
Dictionary of instance i2 after changes: {'ca': "Now we modify the instance attribute 'ca'"}

class Circle:
    """
    The Circle class is intended for computations related to a circle.
    In particular, it allows the area of a circle to be computed for a given radius.
    """
    pi = 3.14159  # Class attribute containing the value of pi used by all class instances

    def __init__(self, radius):
        """
        Class constructor that initializes a new Circle instance with a given radius.
        :param radius: circle radius
        """
        self.radius = radius  # Instance attribute containing the radius of the circle

    def circle_area(self):
        """
        Method for computing the area of a circle.
        :return: circle area
        """
        return self.pi * self.radius**2  # Return the circle area using the formula πr²

# Create an instance of class Circle with radius 10
r = 10
c10 = Circle(r)

# Print initial values
print('Circle.pi before change:', Circle.pi)
print('Radius:', c10.radius)
print('c10.pi before change:', c10.pi)

# Change the value of pi only for the c10 instance
c10.pi = 3.14

# Print values after the change
print('c10.pi after change through c10.pi:', c10.pi)
print('Circle.pi after change through c10.pi:', Circle.pi)
print('Area of circle c10 =', c10.circle_area())
print('Area of a circle with radius 100 =', Circle(100).circle_area())

Circle.pi before change: 3.14159
Radius: 10
c10.pi before change: 3.14159
c10.pi after change through c10.pi: 3.14
Circle.pi after change through c10.pi: 3.14159
Area of circle c10 = 314.0
Area of a circle with radius 100 = 31415.899999999998

class PartialCircle(Circle):
    '''Subclass "PartialCircle" based on class "Circle": computes the area of a circle sector.'''

    def __init__(self, radius, portion):
        '''Initialization with the attributes: radius and portion.'''
        super().__init__(radius)  # Inherit attributes from the base class "Circle".
        self.portion = portion    # Subclass attribute that defines the fraction of the circle.

    def sector_area(self):
        '''Compute the area of a circle sector.'''
        return self.portion * self.circle_area()  # Use the base-class method to compute the circle area.

pc10 = PartialCircle(10., 0.5)  # Create a subclass object instance with radius 10 and a 50% fraction.

print(pc10.pi)            # Use an attribute from the base class
print(pc10.radius)        # Also an attribute from the base class
print(pc10.sector_area()) # Compute the area of a 50% circle sector

pc10.pi = 3.14
print(pc10.pi)  # The value changed to 3.14

print(c10.pi)  # The value remains unchanged. Changes in the subclass do not affect the base class.

# Define the base class Circle
class Circle:
    '''Class "Circle" for representing a circle and computing its area.'''

    def __init__(self, radius):
        '''Initialize a class instance with one attribute: radius.'''
        self.radius = radius  # Instance attribute storing the radius of the circle.
        self.pi = 3.14159     # Attribute storing the value of π.

    def circle_area(self):
        '''Method for computing the area of a circle.'''
        return self.pi * (self.radius ** 2)  # Return the area of the circle using the formula πr^2.

# Define the subclass PartialCircle, which inherits Circle
class PartialCircle(Circle):
    '''Subclass "PartialCircle" based on class "Circle": computes the area of a circle sector.'''

    def __init__(self, radius, portion):
        '''Initialization with the attributes: radius and portion (fraction of the circle).'''
        super().__init__(radius)  # Call the base-class initializer to set the radius.
        self.portion = portion    # Subclass attribute defining the circle fraction for which the area must be computed.

    def sector_area(self):
        '''Compute the area of a circle sector.'''
        return self.portion * super().circle_area()  # Use the base-class method and multiply by the fraction.

# Create an instance of the base class Circle
c10 = Circle(10)  # Instance of class Circle with radius 10
print("Area of the circle:", c10.circle_area())  # Compute and print the area of the circle

# Create an instance of the subclass PartialCircle
pc10 = PartialCircle(10, 0.5)  # Instance of class PartialCircle with radius 10 and a 50% fraction
print("Area of a 50% circle sector:", pc10.sector_area())  # Compute and print the area of the sector

# Change the value of π through the subclass instance
pc10.pi = 3.14
print("Modified value of pi in the subclass:", pc10.pi)

# Check whether the value of π changed in the base class
print("Value of pi in the base class:", c10.pi)  # The value of π in the base class remains unchanged

Area of the circle: 314.159
Area of a 50% circle sector: 157.0795
Modified value of pi in the subclass: 3.14
Value of pi in the base class: 3.14159

import numpy as np  # Import the NumPy module and give it the alias np

x1 = np.array([28, 3, 28, 0])  # Create a one-dimensional NumPy array
print('x1 =', x1)              # Print array x1
# A NumPy array is similar to a list

x1 = [28  3 28  0]

import numpy as np
# Import the NumPy module and give it the alias np

x2 = np.array([[51, 22.0], [0, 0], (18 + 9j, 3.)])  # Mixed types
# Create array x2 from three rows and two columns. The first two rows contain integers,
# and the third row contains a complex number and a real number.

print('x2 =', x2)  # All elements become complex numbers
# Since complex numbers are present in the array, all numbers in the array become complex numbers.

x2 = [[51.+0.j 22.+0.j]
      [ 0.+0.j  0.+0.j]
      [18.+9.j  3.+0.j]]

# List of people's weights (in kg)
list_w = [57.5, 64.3, 71.6, 68.2]
# List of people's heights (in m)
list_h = [1.5, 1.6, 1.7, 1.65]
# Print the list of weights
print('People’s weights:', list_w)
# Print the list of heights
print('People’s heights:', list_h)

People’s weights: [57.5, 64.3, 71.6, 68.2]
People’s heights: [1.5, 1.6, 1.7, 1.65]

# Import the NumPy library
import numpy as np

# Declare lists of people’s weights and heights
list_w = [57.5, 64.3, 71.6, 68.2]
list_h = [1.5, 1.6, 1.7, 1.65]

# Convert the lists to NumPy arrays
narray_w = np.array(list_w)
narray_h = np.array(list_h)

# Print the arrays
print('Array of weights:', narray_w)
print('Array of heights:', narray_h)

Array of weights: [57.5 64.3 71.6 68.2]
Array of heights: [1.5  1.6  1.7  1.65]

def getArrayInfo(a):
    """Get information about a given array: getArrayInfo(array)."""
    # Print the elements of the first axis of the array
    print('Elements of the first array axis:', a[0])
    # Print the array type
    print('Type:', type(a))
    # Print the number of array dimensions
    print('Number of dimensions, a.ndim:', a.ndim)
    # Print the array shape (sizes along each axis)
    print('Array shape, a.shape:', a.shape)
    # Print the total number of elements in the array
    print('Number of elements, a.size:', a.size)
    # Print the data type of the array elements
    print('Data type of elements, a.dtype:', a.dtype)
    # Print the memory address where the array is stored (debugging information)
    print('Memory address:', a.data)

narray_w = np.array([57.5, 64.3, 71.6, 78.9])
getArrayInfo(narray_w)

Elements of the first array axis: 57.5
Type: <class 'numpy.ndarray'>
Number of dimensions, a.ndim: 1
Array shape, a.shape: (4,)
Number of elements, a.size: 4
Data type of elements, a.dtype: float64
Memory address: <memory at 0x102f5a680>

import numpy as np

list_w = [57.5, 64.3, 71.6, 68.2]
list_h = [1.5, 1.6, 1.7, 1.65]
narray_w = np.array([57.5, 64.3, 71.6, 78.9])

print(list_w[1:3])    # Slice between the second and third elements
print(narray_w[1:3])  # Slice between the second and third elements

[64.3, 71.6]
[64.3 71.6]

list_w.append(59.8)
print(list_w)

# For a NumPy array, we use:
print(np.append(narray_w, 59.8))

[57.5, 64.3, 71.6, 68.2, 59.8]
[57.5 64.3 71.6 78.9 59.8]

print(list_w, ', ', narray_w)
print(type(list_w), ', ', type(narray_w))
print(len(list_w), ', ', narray_w.ndim)  # Use len() to get the length

[57.5, 64.3, 71.6, 68.2, 59.8] ,  [57.5 64.3 71.6 78.9]
<class 'list'> ,  <class 'numpy.ndarray'>
5 ,  1

nwh = (narray_w, narray_h)  # This forms a tuple of NumPy arrays
print(nwh)
# (array([57.5, 64.3, 71.6, 68.2]), array([1.5, 1.6, 1.7, 1.65]))

# To form a multidimensional array, we can use the following (more on this later):
arr = np.array([narray_w, narray_h])
# array([[57.5, 64.3, 71.6, 68.2 ],
#        [ 1.5,  1.6,  1.7,  1.65]])

import numpy as np

# Original array
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [ 1.5,  1.6,  1.7,  1.65]])

# Transpose the array
arrT = arr.T

# Print the transposed array
print(arrT)

[[57.5   1.5 ]
 [64.3   1.6 ]
 [71.6   1.7 ]
 [68.2   1.65]]

import numpy as np

# Create a NumPy array with two rows and four columns
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# Create a second variable that refers to the same array
arrb = arr

# Print the contents of arrb
print(arrb)

# Change the first element of arr
arr[0, 0] = 888.0

# Print the contents of arrb again and see that it has changed
print(arrb)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
[[888.    64.3   71.6   68.2 ]
 [  1.5    1.6    1.7    1.65]]

arrc = arr.copy()

import numpy as np

# Create a two-dimensional array
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# Try to create a "copy" by assignment
arrc = arr

# Create an independent copy of the array
arrc = arr.copy()

# Change an element in the original array
arr[0, 0] = 77.0

# Print both arrays for comparison
print('arr:', arr)
print('arrc:', arrc)

import numpy as np  # Import the NumPy library under the alias np

# Create a two-dimensional array arr using np.array
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [1.5, 1.6, 1.7, 1.65]])

# Create an independent copy of array arr using the copy method
arrc = arr.copy()

# Print the contents of array arrc
print('arrc', arrc)

# Change the element at position [0, 0] of array arr to 77.0
arr[0, 0] = 77.0

# Print the modified array arr
print('arr', arr)

# Print array arrc to show that it has not changed
print('arrc', arrc)

arrc [[57.5  64.3  71.6  68.2 ]
      [ 1.5   1.6   1.7   1.65]]
arr [[77.   64.3  71.6  68.2 ]
     [ 1.5   1.6   1.7   1.65]]
arrc [[57.5  64.3  71.6  68.2 ]
      [ 1.5   1.6   1.7   1.65]]

np.stack(sequence_of_arrays, axis=axis_number)

import numpy as np  # Import the NumPy library under the alias np

# Assumed one-dimensional arrays to combine
narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])

# Combine arrays along axis 0 (vertically)
arr = np.stack([narray_w, narray_h], axis=0)

# Print the result
print(arr)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]

import numpy as np  # Import the NumPy library under the alias np

# Assumed one-dimensional arrays to combine
narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])

# Combine arrays along axis 0 (vertically)
arr = np.stack([narray_w, narray_h], axis=0)

# Print the original two-dimensional array
print(arr)

# Transform the two-dimensional array into a one-dimensional array
rarr = np.ravel(arr)

# Print the result
print(rarr)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
[57.5  64.3  71.6  68.2   1.5   1.6   1.7   1.65]

import numpy as np  # Import the NumPy library under the alias np

# Suppose we have the following two-dimensional array:
arr = np.array([[57.5, 64.3, 71.6, 68.2],
                [ 1.5,  1.6,  1.7,  1.65]])

# Print the original array for clarity
print(arr)

# Sum array elements by columns (axis=0)
column_sum = np.sum(arr, axis=0)
print('Sum by columns:', column_sum, column_sum.shape)

# Sum array elements by rows (axis=1)
row_sum = np.sum(arr, axis=1)
print('Sum by rows:', row_sum, row_sum.shape)

[[57.5  64.3  71.6  68.2 ]
 [ 1.5   1.6   1.7   1.65]]
Sum by columns: [59.   65.9  73.3  69.85] (4,)
Sum by rows: [261.6    6.45] (2,)

list_w = [57.5, 64.3, 71.6, 68.2, 59.8]
list_h = [1.5, 1.6, 1.7, 1.65]

listwh = list_w + list_h
print('Concatenated list:', listwh)

Concatenated list: [57.5, 64.3, 71.6, 68.2, 59.8, 1.5, 1.6, 1.7, 1.65]

import numpy as np  # Import the NumPy library under the alias np

narray_w = np.array([57.5, 64.3, 71.6, 68.2])
narray_h = np.array([1.5, 1.6, 1.7, 1.65])
narraywh = narray_w + narray_h
print('Element-wise added array:', narraywh)

Element-wise added array: [59.   65.9  73.3  69.85]

import numpy as np  # Import the NumPy library under the alias np

weights_kg = np.array([57.5, 64.3, 71.6, 68.2])
weights_lbs = weights_kg * 2.20462
print('Weight in pounds:', weights_lbs)

Weight in pounds: [126.76565  141.757066 157.850792 150.355084]

import numpy as np

# Example of using ordinary lists to compute the sum of elements of two lists
list1 = [20, 30, 40, 50, 60]
list2 = [4, 5, 6, 2, 8]
sum_lists = [x + y for x, y in zip(list1, list2)]
print('Sum of lists:', sum_lists)

# Now perform the same operation using NumPy arrays
sum_arrays = (np.array(list1) + np.array(list2)).tolist()
print('Sum of NumPy arrays:', sum_arrays)

Sum of lists: [24, 35, 46, 52, 68]
Sum of NumPy arrays: [24, 35, 46, 52, 68]

np.arange(2, 8, 0.5, dtype=np.float)

array([2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. , 7.5])

np.linspace(1., 4., 6)

array([1. , 1.6, 2.2, 2.8, 3.4, 4. ])

import numpy as np

a = np.array([1., 2., 3.])
a.fill(9.9)  # Fill all elements with the same value
print(a)

[9.9 9.9 9.9]

import numpy as np

x = np.empty((3, 4))  # Shape (dimension) (3, 4) is specified, without value initialization
print(x)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

import numpy as np

x = np.zeros((6, 6))  # Initialized with zeros
print(x)

[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]

import numpy as np

y = np.ones((2, 2)) * 2  # A 2x2 array with 1.0 in all elements
print(y)

[[2. 2.]
 [2. 2.]]

import numpy as np  # Import the NumPy library

# Create the first 6x6 array initialized with zeros
x = np.zeros((6, 6))
print("Original array x:")
print(x)

# Create the second 2x2 array initialized with ones
y = np.ones((2, 2))
print("\nArray y:")
print(y)

# Multiply each element of array y by 2
y *= 2
print("\nArray y after multiplication by 2:")
print(y)

# Assign array y to a slice of array x.
# Here we take a slice from the 3rd to the 5th row (not including 5)
# and from the 3rd to the 5th column (not including 5)
# and assign the values of array y to it.
x[3:5, 3:5] = y
print("\nArray x after assigning array y to the slice:")
print(x)

Original array x:
[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]
Array y:
[[1. 1.]
 [1. 1.]]
Array y after multiplication by 2:
[[2. 2.]
 [2. 2.]]
Array x after assigning array y to the slice:
[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 2. 2. 0.]
 [0. 0. 0. 2. 2. 0.]
 [0. 0. 0. 0. 0. 0.]]

pip install tensorflow

import tensorflow as tf  # Import TensorFlow under the alias tf for convenience

import tensorflow.experimental.numpy as tfnp  # Import the module for working with arrays

# Create a 3-by-4 array filled with zeros
x = tfnp.zeros((3, 4))  # Use the zeros function to create an array filled with zeros

# Convert the TensorFlow NumPy array to a standard NumPy array for output
x_np = x.numpy()  # Conversion to a standard NumPy array

# Print the array using standard NumPy output-formatting options
print(x_np)

# Print the size of the array; it should be 12, since there are 3 rows and 4 columns
print(tfnp.size(x))

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
12

import tensorflow as tf

y = tf.random.normal([3, 4], mean=0.0, stddev=1.0)

x = tf.exp(y)

y_transposed = tf.transpose(y)

result_matrix = tf.matmul(x, y_transposed)

import tensorflow as tf

# Initialize a 3x4 tensor with values from the standard normal distribution
y = tf.random.normal([3, 4], mean=0.0, stddev=1.0)

# Print the value of tensor y
print('y')
print(y.numpy())

# Exponentiate each element of tensor y
x = tf.exp(y)  # Compute e raised to the power of each element of tensor y
print(x.numpy())

# Transpose tensor y
y_transposed = tf.transpose(y)  # Transpose tensor y
print(y_transposed.numpy())

# Multiply tensor x by the transposed tensor y
result_matrix = tf.matmul(x, y_transposed)  # Compute the matrix product
print(result_matrix.numpy())

y
[[ 0.71528995  2.1142166  -1.1875231  -0.16214192]
 [-0.1809633  -0.21809964  1.1487513  -0.02445018]
 [ 1.6564487   0.6891605   1.2565229   1.3516059 ]]
[[2.0447795  8.283093   0.30497572 0.8503205 ]
 [0.834466   0.8040453  3.1542516  0.9758463 ]
 [5.240667   1.9920425  3.5131845  3.863625  ]]
[[ 0.71528995 -0.1809633   1.6564487 ]
 [ 2.1142166  -0.21809964  0.6891605 ]
 [-1.1875231   1.1487513   1.2565229 ]
 [-0.16214192 -0.02445018  1.3516059 ]]
[[18.474825  -1.847019  10.62796  ]
 [-1.6071612  3.273221   7.218715 ]
 [ 3.161762   2.5584767 19.690228 ]]

# Import the required libraries
import tensorflow as tf  # Import TensorFlow for working with tensors
import numpy as np  # Import NumPy for working with NumPy arrays

# Create tensors in TensorFlow
x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)  # Create a 2x2 tensor x
y = tf.constant([[5, 6], [7, 8]], dtype=tf.float32)  # Create a 2x2 tensor y

# Convert TensorFlow tensors to NumPy arrays
x_np = x.numpy()  # Convert tensor x to a NumPy array
y_np_transposed = tf.transpose(y).numpy()  # Transpose tensor y and convert it to a NumPy array

# Compute the dot product between NumPy arrays
result = np.dot(x_np, y_np_transposed)  # Compute the dot product between x_np and y_np_transposed

# Print the dot-product result
print("Dot product of x and transposed y:")
print(result)

Dot product of x and transposed y:
[[17. 23.]
 [39. 53.]]

# Step 1: Import the required libraries
# Import TensorFlow and NumPy
import tensorflow as tf
import numpy as np

# Step 2: Work with tensors in TensorFlow
# Tensors are the main data type in TensorFlow for storing and processing numerical data

# Create a tensor with uninitialized values of size 3x4
x = tf.Variable(tf.zeros((3, 4)))
print("Uninitialized tensor X:\n", x.numpy())

# Initialize another tensor with random values from a normal distribution
y = tf.random.normal((3, 4))
print("Tensor Y with random values:\n", y.numpy())

# Step 3: Elementwise operations
# Exponentiate all elements of tensor y
x_exp = tf.exp(y)
print("x_exp = e^y:\n", x_exp.numpy())

# Step 4: Transposition and matrix multiplication
# Transpose tensor y
y_transposed = tf.transpose(y)
print("Transposed Y:\n", y_transposed.numpy())

# Multiply x_exp by the transposed y
result_matrix = tf.matmul(x_exp, y_transposed)
print("Result of matrix multiplication of x_exp by transposed Y:\n", result_matrix.numpy())

# Step 5: Interaction with NumPy
# Convert tensors to NumPy arrays to perform NumPy-compatible operations
x_np = x_exp.numpy()
y_np_transposed = y_transposed.numpy()

# Perform a dot product with NumPy
np_result = np.dot(x_np, y_np_transposed)
print("Result of the dot product with NumPy:\n", np_result)

Uninitialized tensor X:
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
Tensor Y with random values:
[[ 0.4931968  -0.31107786  1.0522738  -0.91028893]
 [ 0.7813833  -0.3026102  -1.2939718   0.28406715]
 [ 0.6851111  -1.1481444  -0.64575064 -0.14548281]]
x_exp = e^y:
 [[1.6375427  0.73265684 2.864156   0.40240794]
 [2.1844919  0.7388871  0.27417964 1.3285221 ]
 [1.9839922  0.3172249  0.52426887 0.8646048 ]]
Transposed Y:
[[ 0.4931968   0.7813833   0.6851111 ]
 [-0.31107786 -0.3026102  -1.1481444 ]
 [ 1.0522738  -1.2939718  -0.64575064]
 [-0.91028893  0.28406715 -0.14548281]]
Result of matrix multiplication of x_exp by transposed Y:
[[ 3.227286   -2.5339868  -1.6273712 ]
 [-0.07329397  1.5059394   0.27794188]
 [ 0.6444511   1.0214796   0.53070307]]
Result of the dot product with NumPy:
[[ 3.227286   -2.5339868  -1.6273712 ]
 [-0.07329397  1.5059394   0.27794188]
 [ 0.6444511   1.0214796   0.53070307]]

import tensorflow as tf

# Create two variables in TensorFlow
x = tf.Variable([1, 2, 3], dtype=tf.float32)
y = tf.Variable([4, 5, 6], dtype=tf.float32)

# Print object identifiers before the operation
print('id(x) before the operation:', id(x))
print('id(y) before the operation:', id(y))

# A standard addition operation that creates a new tensor
temp_y = y + x  # In TensorFlow this creates a new tensor
# If you want to keep using y as a variable, create a new variable with the result
y = tf.Variable(temp_y)
print('id(y) after the standard addition operation:', id(y))

# In-place operation using the assign_add method
y.assign_add(x)  # This adds x to y in place without changing the identifier of y
print('id(y) after the in-place operation using assign_add:', id(y))

# In-place operation using the += operator
x.assign_add(y)  # This adds y to x in place, using the += operator
print('id(x) after the in-place operation using the += operator:', id(x))

id(x) before the operation: 6079315920
id(y) before the operation: 6069364304
id(y) after the standard addition operation: 6069363968
id(y) after the in-place operation using assign_add: 6069363968
id(x) after the in-place operation using the += operator: 6079315920

import numpy as np  # Import the NumPy library for working with arrays

# Create a two-dimensional floating-point array (matrix) for the example
x = np.array([[1.343, 3.358, 6.210, 6.438],
              [7.653, -2.504, 12.811, 1.550],
              [26.785, 0.124, 4.275, -2.182]])

# Print the original array
print("Original array x:")
print(x)

# Read the second and third rows from array x
print("\nSecond and third rows of array x:")
second_and_third_rows = x[1:3]  # Slice from the second row (index 1) to the third row (index 2)
print(second_and_third_rows)

# Read the elements of the second row from the second to the third column
print("\nElements of the second row from the second to the third column:")
second_row_second_to_third_column = x[1:2, 1:3]  # Slice for the second row and columns with indices 1 and 2
print(second_row_second_to_third_column)

# Change the value in the second row, third column to 88.0
x[1, 2] = 88.0  # Assign the value 88.0 to the element with index [1, 2]

# Print the array after the change
print("\nArray x after changing one value:")
print(x)

# Change the values in the second row from the second to the third column to 88.0
x[1, 1:3] = 88.0  # Slice for changing values in the second row and columns with indices 1 and 2

# Print the array after changing a slice of values
print("\nArray x after changing a slice of values:")
print(x)

print(x)  # Print the entire array for clarity
x[1:3]    # Obtain a slice for the second and third rows

x[1:2, 1:3]  # Select the second row and a slice of columns with indices from 1 to 2

x[1, 2] = 88.0  # Assign a new value to the element
print(x)        # Print the modified array

x[1:2, 1:3] = 88.0  # Assign a new value to several elements at once
print(x)            # Print the array with updated values

import numpy as np

# Create a one-dimensional array y
y = np.arange(6)
print('y = ', y, 'Shape of y:', y.shape)

# Create a one-dimensional array x and reshape it
x = np.arange(24).reshape((4, 6))
print('X = \n', x, 'Shape of X:', x.shape)

# Perform addition using broadcasting operations
result = x + y
print('X + y = \n', result)

# Import the NumPy library under the alias np
import numpy as np

# Create a one-dimensional array y using the arange function, which generates a sequence of numbers from 0 to n-1
y = np.arange(6)
# Print array y and its shape
print('y = ', y, 'Shape of y:', y.shape)

# Create a one-dimensional array x of the same length as y, but with numbers from 0 to 23
x = np.arange(24)
# Change the shape of array x with the reshape method to obtain a two-dimensional array
# with 4 rows and 6 columns, which matches the shape of array y for broadcasting
x = x.reshape((4, 6))
# Print array x and its new shape
print('X = \n', x, 'Shape of X:', x.shape)

# Perform the addition of x and y. Thanks to broadcasting operations, y is automatically
# expanded to the shape of x, and the addition is performed elementwise.
result = x + y
# Print the addition result
print('X + y = \n', result)

# Import the NumPy library
import numpy as np

# Suppose arrays X and y have been defined earlier
# Print the shapes of arrays X and y
print('Shape of X:', X.shape, 'Shape of y:', y.shape)

# Compute the dot product of arrays X and y
# The np.dot() function returns the sum of the products of corresponding array elements
print(np.dot(X, y))

# Change the shape of array X to the three-dimensional array Z using the np.reshape() method
# The parameters (2, 3, 4) define the new array shape
Z = np.reshape(X, (2, 3, 4))

# Print the new three-dimensional array Z
print(Z)

# Create a two-dimensional array a using arange and reshape
# The array is filled with consecutive numbers from 0 to 11 and reshaped to (3, 4)
a = np.arange(12).reshape(3, 4)

# Fill the entire array a with the value 100 using the fill method
a.fill(100)

# Print array a after filling
print(a)

# It is assumed that array Z was defined earlier as a three-dimensional array
# Adding arrays a and Z demonstrates broadcasting operations
# Array a is expanded to the shape of array Z, and elementwise addition is performed
print(Z + a)

# Create and fill a one-dimensional array a
a = np.arange(4)
a.fill(100)

# Print the one-dimensional array a
print(a)

# Add the one-dimensional array a to the three-dimensional array Z
# This shows NumPy's ability to perform broadcasting operations when arrays of different shapes
# can be added through automatic expansion of the smaller arrays
print(Z + a)

# Import the NumPy library
import numpy as np

# Create a one-dimensional array y with consecutive numbers from 0 to 5
y = np.arange(6)
# Print information about array y
print('y = ', y, 'Shape of y:', y.shape)

# Create a one-dimensional array x with consecutive numbers from 0 to 23
x = np.arange(24)
# Reshape array x into a two-dimensional array (4, 6)
x = x.reshape((4, 6))
# Print information about array x
print('x = ', x, 'Shape of x:', x.shape)

# Compute the dot product of arrays x and y using the np.dot function
# It is important to note that the arrays must have compatible dimensions for such an operation
dot_product = np.dot(x, y)
print('Dot product of x and y:', dot_product)

# Reshape array x into a three-dimensional array z (2, 3, 4)
z = x.reshape((2, 3, 4))
# Print the three-dimensional array z
print('z =\n', z)

# Create a two-dimensional array a with arange and reshape it to (3, 4)
a = np.arange(12).reshape((3, 4))
# Fill array a with the value 100
a.fill(100)
# Print the two-dimensional array a after filling
print('a =\n', a)

# Demonstrate broadcasting operations when adding array a and the three-dimensional array z
# Array a is automatically “expanded” to the shape of array z for elementwise addition
broadcasted_sum = z + a
# Print the addition result
print('Result of adding z and a:\n', broadcasted_sum)

# Create and fill a one-dimensional array a with the value 100
a = np.arange(4)
a.fill(100)
# Print the one-dimensional array a
print('a =', a)

# Add the one-dimensional array a to the three-dimensional array z
# NumPy automatically “expands” array a to perform the addition operation
broadcasted_sum = z + a
# Print the addition result
print('Result of adding z and a:\n', broadcasted_sum)

import numpy as np

# Example 1: Adding one-dimensional and two-dimensional arrays
# Create a one-dimensional array
one_d_array = np.array([1, 2, 3])
# Create a two-dimensional array
two_d_array = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]])
# Broadcasting operations allow these two arrays to be added despite the difference in their shapes
broadcasted_sum_1 = one_d_array + two_d_array
print("Example 1: Adding one-dimensional and two-dimensional arrays")
print(broadcasted_sum_1)

# Example 2: Adding two one-dimensional arrays of different lengths
# Create a one-dimensional array with one element
single_element_array = np.array([100])
# Broadcasting “expands” the smaller array so that it can be added to one_d_array
broadcasted_sum_2 = single_element_array + one_d_array
print("\nExample 2: Adding two one-dimensional arrays of different lengths")
print(broadcasted_sum_2)

# Example 3: Adding a one-dimensional array consisting of one column to a two-dimensional array
# Create a one-dimensional array representing a column
column_array = np.array([[0], [10], [20], [30]])
# Broadcasting “expands” the column horizontally so that addition can be performed
broadcasted_sum_3 = column_array + one_d_array
print("\nExample 3: Adding a one-dimensional array consisting of one column to a two-dimensional array")
print(broadcasted_sum_3)

# Import the NumPy library under the alias np for working with arrays
import numpy as np
# Import TensorFlow for working with tensors and deep learning
import tensorflow as tf

# Create a one-dimensional array of 24 numbers, starting with 0 and ending with 23
x = np.arange(24)
# Transform the one-dimensional array into a two-dimensional array (matrix) of size 4x6
x = x.reshape(4, 6)

# Print matrix x to the screen for checking
print("NumPy matrix x:")
print(x)

# Convert the NumPy array x into a TensorFlow tensor
tfx = tf.convert_to_tensor(x, dtype=tf.float32)

# Print tensor tfx to the screen for checking
print("\nTensorFlow tensor tfx:")
print(tfx)

# Convert the TensorFlow tensor back into a NumPy array
npa = tfx.numpy()

# Check that npa is indeed a NumPy array
print("\nArray npa converted back to NumPy:")
print(npa)
print("Type of npa:", type(npa))

NumPy matrix x:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

TensorFlow tensor tfx:
tf.Tensor(
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]], shape=(4, 6), dtype=float32)

Array npa converted back to NumPy:
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
Type of npa: <class 'numpy.ndarray'>

# Import the required libraries
import numpy as np
import tensorflow as tf

# Create a NumPy array with consecutive numbers from 0 to 23
npa = np.arange(24).reshape(4, 6)  # Change the shape of the array to 4x6

# Print the original NumPy array
print("Original NumPy array:")
print(npa)

# Convert the NumPy array into a TensorFlow tensor
tfy = tf.convert_to_tensor(npa, dtype=tf.float32)

# Print the TensorFlow tensor
print("\nConverted into a TensorFlow tensor:")
print(tfy)

# Convert the TensorFlow tensor back into a NumPy array
npa_from_tfy = tfy.numpy()

# Print the NumPy array obtained from the TensorFlow tensor
print("\nConverted back into a NumPy array:")
print(npa_from_tfy)

# To check whether the original and resulting NumPy arrays match,
# you can use the np.array_equal() function
print("\nThe NumPy arrays are identical:", np.array_equal(npa, npa_from_tfy))

Original NumPy array:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

Converted into a TensorFlow tensor:
tf.Tensor(
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]], shape=(4, 6), dtype=float32)

Converted back into a NumPy array:
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]

The NumPy arrays are identical: True

print(bmi[bmi > 25])  # Print only those values whose BMI is greater than 25

[ 25.556 25.117 25.051]

import numpy as np  # Import the NumPy library

# Create a bmi array with test data
# For demonstration, we will use random numbers from 20 to 30
bmi = np.random.uniform(20, 30, 10)

# Print the original bmi array
print("Original BMI array:", bmi)

# Apply Boolean indexing to filter values greater than 25
# This works by creating a Boolean array in which each element is checked against the condition > 25
# and then this Boolean array is used to select elements from the original array.
filtered_bmi = bmi[bmi > 25]

# Print the filtered values
print("Filtered BMI values > 25:", filtered_bmi)

import numpy as np  # Import the NumPy library

# Create a bmi array with test data
# For demonstration, use an array with fixed values from 20 to 30
bmi = np.array([21.3, 24.5, 27.9, 30.1, 23.4, 25.6, 27.4, 22.0, 28.5, 26.1])

# Print the original bmi array
print("Original BMI array:", bmi)

# Apply Boolean indexing to filter values greater than 25
# A Boolean array is created in which each element is checked against the condition > 25
# This Boolean array is used to select elements from the original array
filtered_bmi = bmi[bmi > 25]

# Print the filtered values
print("Filtered BMI values > 25:", filtered_bmi)

Original BMI array: [21.3 24.5 27.9 30.1 23.4 25.6 27.4 22.  28.5 26.1]
Filtered BMI values > 25: [27.9 30.1 25.6 27.4 28.5 26.1]

import numpy as np  # Import the NumPy library

# Create a one-dimensional array with three elements
a = np.array([1, 2, 3])

# Print the array, its shape, the transposed array, and its shape
# For a one-dimensional array, transposition does not change the shape of the array
print("Original array:", a)
print("Shape of the original array:", a.shape)
print("Transposed array:", a.T)
print("Shape of the transposed array:", a.T.shape)

# Add a new axis to transform the array into a two-dimensional array
# This is done to create a column vector
an = a[:, np.newaxis]

# Print the new two-dimensional array and its shape
print("\nTwo-dimensional column vector:", an)
print("Shape of the column vector:", an.shape)

# Now we can transpose the two-dimensional array
# Transposition turns the column vector into a row vector
print("\nTransposed two-dimensional array (row vector):", an.T)
print("Shape of the row vector:", an.T.shape)

Original array: [1 2 3]
Shape of the original array: (3,)
Transposed array: [1 2 3]
Shape of the transposed array: (3,)

Two-dimensional column vector: [[1]
 [2]
 [3]]
Shape of the column vector: (3, 1)
Transposed two-dimensional array (row vector): [[1 2 3]]
Shape of the row vector: (1, 3)

a = np.array([1, 2, 3])

print(a, a.T, a.shape, a.T.shape)

an = a[:, np.newaxis]

print(an, an.shape)

print(an.T, an.T.shape)

import numpy as np

# Original one-dimensional array
a = np.array([1, 2, 3])

# Add a new dimension to the end of array `a`
a1 = a.reshape(a.shape + (1,))
print(a1, a1.shape)  # Prints a two-dimensional array and its shape (3, 1)

[[1]
 [2]
 [3]] (3, 1)

# Add a new dimension without specifying elements
aN = a[:, None]
print(aN, aN.shape)  # Similar to the previous output: a two-dimensional array and its shape (3, 1)

import numpy as np

# Add a new axis to the beginning of array `a`
a0 = a[np.newaxis, :]
print(a0, a0.shape)  # Prints a two-dimensional array in the form of a row vector (1, 3)

# Import the NumPy library under the alias np
import numpy as np

# Create a one-dimensional array of three elements
a = np.array([1, 2, 3])

# Add a new dimension to the end of array `a` to turn it into a two-dimensional array
# This is done by changing the array shape with the reshape method
a1 = a.reshape(a.shape + (1,))

# Print the result and the shape of the resulting array
# Expected output: a two-dimensional array with three rows and one column
print("Adding a dimension to the end of the array:")
print(a1, a1.shape)

# Add a new dimension using the None object
# This is equivalent to adding a new axis to the end of the array
aN = a[:, None]

# Print the result and the shape of the resulting array
# Expected output: similar to the previous one, a two-dimensional array with three rows and one column
print("\nAdding a dimension using None:")
print(aN, aN.shape)

# Add a new axis to the beginning of array `a` with np.newaxis
# This creates a row vector
a0 = a[np.newaxis, :]

# Print the result and the shape of the resulting array
# Expected output: a two-dimensional array as a row vector with one row and three columns
print("\nAdding an axis to the beginning of the array:")
print(a0, a0.shape)

Adding a dimension to the end of the array:
[[1]
 [2]
 [3]] (3, 1)

Adding a dimension using None:
[[1]
 [2]
 [3]] (3, 1)

Adding an axis to the beginning of the array:
[[1 2 3]] (1, 3)

# Import the NumPy library under the alias np
import numpy as np

# Create a one-dimensional array of three elements
a = np.array([1, 2, 3])

# Add a new dimension using the None object
aN = a[:, None]
print("\nAdding a dimension using None:")
print(aN, aN.shape)

# Add a new axis to the beginning of array `a` with np.newaxis
a0 = a[np.newaxis, :]
print("\nAdding an axis to the beginning of the array:")
print(a0, a0.shape)

# Apply a trick for creating a Hankel matrix by adding aN and a0
# Broadcasting is used here: a NumPy mechanism that allows arithmetic operations
# on arrays with different shapes. The result is a Hankel matrix.
print("\nAn interesting trick for creating a Hankel matrix:")
hankel_matrix = aN + a0
print(hankel_matrix)

Adding a dimension using None:
[[1]
 [2]
 [3]] (3, 1)

Adding an axis to the beginning of the array:
[[1 2 3]] (1, 3)

An interesting trick for creating a Hankel matrix:
[[2 3 4]
 [3 4 5]
 [4 5 6]]

import numpy as np  # Module for working with arrays
import matplotlib.pyplot as plt  # Module for creating plots

n = 80  # Number of points
x = np.random.rand(n)  # Randomly generated coordinates along the X axis
y = np.random.rand(n)  # Randomly generated coordinates along the Y axis
colors = np.random.rand(n)  # Randomly generated colors for each point
areas = np.pi * (18 * np.random.rand(n))**2  # Circle areas randomly generated in the radius range from 0 to 20

plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # Create a plot with circles
plt.show()  # Display the plot

# Import the required libraries
import numpy as np  # For working with arrays and performing mathematical operations
import matplotlib.pyplot as plt  # For data visualization

# Generate data for the plot
n = 80  # Number of circles
x = np.random.rand(n)  # Random X-axis coordinates for the centers of the circles
y = np.random.rand(n)  # Random Y-axis coordinates for the centers of the circles
colors = np.random.rand(n)  # Random colors for the circles
areas = np.pi * (18 * np.random.rand(n))**2  # Random radii for the circles, converted into areas

# Create the plot
plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # Use the scatter function to draw circles
# where x and y are the coordinates of the centers of the circles, s is the circle size specified by areas,
# c is the circle color, and alpha is the transparency of the circles.

plt.show()  # Display the plot

import numpy as np
import matplotlib.pyplot as plt

# Import the NumPy library for working with arrays and matplotlib.pyplot for data visualization.
n = 80  # Number of points to generate

# Generate random coordinates for n points.
x = np.random.rand(n)  # Random coordinates along the X axis
y = np.random.rand(n)  # Random coordinates along the Y axis

# Generate random colors and sizes for the points.
colors = np.random.rand(n)  # Random colors for each point
areas = np.pi * (18 * np.random.rand(n))**2  # Random point sizes, representing circle areas

# Create a scatter plot using the generated data.
plt.scatter(x, y, s=areas, c=colors, alpha=0.8)  # 's' denotes size, 'c' denotes color, 'alpha' denotes point transparency
plt.show()  # Display the scatter plot

# Generate data for plotting a curve.
x = range(1000)  # Generate a sequence of numbers from 0 to 999
y = [i ** 2 for i in x]  # Create a list of y values, where each value is the square of the corresponding x value

# Plot the function y = x^2
plt.plot(x, y)  # 'plot' is used to draw a line graph
plt.show()  # Display the graph

# Generate data for a histogram.
x = np.linspace(0, 1, 1000)**1.5  # Create 1000 points between 0 and 1 and raise the values to the power of 1.5 to distort the distribution

# Plot a histogram of the distribution of x values.
plt.hist(x)  # 'hist' is used to draw a histogram
plt.show()  # Display the histogram

import time
import numpy as np

# Create a large list of integers
g = list(range(10_000_000))

# Convert the list into a NumPy array with the float64 data type
q = np.array(g, 'float64')

# Measure the execution time of summation using the built-in Python sum function
start = time.process_time()  # Record the start time
sg = sum(g)  # Sum the list elements
t_elapsed = (time.process_time() - start)  # Compute the elapsed time
print(f'Sum: {sg}, Elapsed time: {t_elapsed}')

# Measure the execution time of summation using the np.sum function for a NumPy array
start = time.process_time()  # Record the start time again
sq = np.sum(q)  # Sum the NumPy array elements
t_elapsed = (time.process_time() - start)  # Compute the elapsed time
print(f'Sum: {sq}, Elapsed time: {t_elapsed}')

# Use the %%timeit magic command to automatically measure the execution time of code in a cell
# %%timeit
# sg = sum(g)  # This line demonstrates how to use timeit in interactive environments such as Jupyter

Sum: 49999995000000, Elapsed time: 0.030974000000000057
Sum: 49999995000000.0, Elapsed time: 0.006296999999999997