Python 0.1

Hello, everyone! If you are reading this then I am really grateful that you are reading my write-up. Thank you. Let's start our very first lecture upon Python. Previous lecture- Python 0.0 was just a head start and now we will try to cover every topics related to Python Language Basics in the next few blogs. Here I will discuss about Variable and Basic operations and precedence. For coding I always use Google Colab but you can use anything, all are almost same.

Variable

In mathematics variables are usually expressed as x, y or z and the variables can have different values at a time. In Python, variable does not work like that. One have to express variable names by following the Variable Naming Conventions- https://www.python.org/dev/peps/pep-0008/#prescriptive-naming-conventions, and also they have to be sincere that they did not choose any Python reserved keywords- True, False, del, def, try, raise, None, return, if, else, elif, in, is, and, while, as, except, with, lambda, assert, finally, global, yield, break, for, not, class, from, pass, async, await, import, or, nonlocal, continue.
Variables are just like a container for storing different types of data as value.

stu_name = 'Sayeb'
print(stu_name)
print(type(stu_name)

Here the output will be Sayeb and .["stu_name" is the variable name and "'Sayeb'" is the value of that variable] But if I again write like this

stu_name = 123
print(stu_name)
print(type(stu_name)

Now the output will be 123 and . This makes clear that a similar variable can hold only one data type. If one uses the same variable name twice then the value will be changed. Python is also very case sensitive as it will detect stu_name
and Stu_name different variable names.
Values are always stored from the right side of the assignment(=) to the variable on the left side. Unlike other languages, in Python, we do not need to declare data types manually. The data type is decided by the interpreter during the run-time. If we follow the rules our code will become more understandable by the Human Readers (us).

Basic operations and precedence

You can use different operators in Python. Below the math operators precedence is given.

  Math Operators from Highest to Lowest Precedence

  Operator     Operation            Example      Evaluates to....

  **           Exponent               2 ** 3          8                            

  %            Modulus/remainder      22 % 8          6             

  //           Integer division/
             floored quotient       22 // 8         2

  /            Division               22 / 8          2.75

  *            Multiplication         3 * 5           15

  -            Subtraction            5 - 2           3

  +            Addition               5 + 2           7

The order of operations (also called precedence) of Python math operators is similar to that of mathematics. The ** operator is evaluated first; the *, /, // and % operators are evaluated next, from left to right; and the + and - operators are evaluated last (also from left to right). You can use parentheses to override the usual precedence if you need to. Whitespace in between the operators and values doesn't matter for Python except for the indentation at the beginning of the line, but a single space is convention.

A programming language uses ‘operations’ to manipulate the
data stored in variables to achieve the desired results. Basic operations in Python is divided into two parts: Unary (meaning it is done with one variable) and Binary (meaning it is done using two variables or one variable and a single value of data).
Note: You cannot do any operation with None type.

Let’s explore each type of operation and understand what they do.

Unary operations

1. Unary + (plus): We use unary + (plus) operation by adding a ‘+’ before a variable or data. It does not change the data. (Works with int, float, complex, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

 unary_p_1 = 1
 print(+unary_1)
 unary_p_2 = True
 print(+unary_2) 

1. Unary - (minus): We use unary - (minus) operation by adding a ‘-’ before a variable or data. It produces the negative value of the input (equivalent to the multiplication with -1). (Works with int, float, complex, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

unary_m_1 = 1.01
print(-unary_m_1)
unary_m_2 = False
print(-unary_m_2)

1. Unary ~ (invert): We use unary - (invert) operation by adding a ‘~’ before a variable or data. It produces a bitwise inverse of a given data. Simply, for any data x, a bitwise inverse is defined in python as -(x+1). (Works with int, and boolean. For booleans, True and False will be valued as 1 and 0 respectively.) For example:

unary_i_1 = 9
print(~unary_1)
unary_i_2 = -10
print(~unary_i_2)
unary_i_3 = True
print(~unary_i_3)

Binary operation:

Operators are symbols that represent any kind of computation such as addition, subtraction, and etc.
The values or the variables the operator works on are called Operands.
1 + 2
Here, 1 and 2 are operands, and + is the operator computing addition.

1. Arithmetic operation

    a. + (addition)
    b. - (subtraction)
    c. * (multiplication)

add = 6 + 1
add_1 = 6 + 2.0
subtrac = 6 - 1
subtrac_1 = 6 - 1.0
multi = 6 * 8
multi_1 = 6 * 8.0
print(add)
print(add_1)
print(subtrac)
print(subtrac_1)
print(multi)
print(multi_1)

d. / (division)
Division of numbers(float, int) yields a float results in float.

div_1 = 4 / 2
div_2 = -2 / 1
div_3 = 4 / 4.0
div_4 = -9.0 / 1
print( div_1 )
print( div_2 )
print( div_3 )
print( div_4 )


f. % (modulus)

g. ** (Exponentiation)
Basically it's the power operator (X**Y) = X^Y

1. Assignment operator
a. = (assign): It is used for putting value from the right
side of the equal sign(=) to a variable on the left side
of the equal sign(=).
For example: number = 123
print ( number ).
b. Compound Assignment Operators:
i. += (add and assign)
ii. -= (subtract and assign)
iii. = (multiply and assign)
iv. /= (divide and assign)
v. %= (modulus and assign)
vi. *= (exponent and assign)
vii. //= (floor division and assign)

2. Logical operator
a. and (logical AND)
b. or (logical OR)
c. not (Logical NOT)
Note: Details will be discussed in Branching.

3. Comparison or Relational operator

    a. == (equal)
    b. != (not equal)
    c. > (greater than)
    d. < (less than)
    e. >= (greater than or equal)
    f. <= (less than or equal)
       Note: Details will be discussed in _Branching_. 

4. Membership Operator
a. in: Returns True if the first value is in the second.
Otherwise, returns False.
b. not in: Returns True if the first value is not in the
second. Otherwise, returns False.
Example:

print('t' in 'cat')
print('t' in 'caT')
print('t' not in 'caT')
print( 4 in [345, 7, 89, 4 ])

5. Identity Operators
Identity operators check whether two values are identical or
not.
a. is: Returns True if the first value is identical or the
same as the second value.Otherwise, returns False.
b. is not: Returns False if the first value is identical or
the same as the second value. Otherwise, returns
True.
Example:

print( '123' is 123 )
print( '456' is '456' )
print( 234 is not '234' )
print( 1 is 1.0 )
print( 4 is not 4.0 )

7. Bitwise Operators

     a. & (Bitwise and)
     b. | (Bitwise or)
     c. ^ (Bitwise xor)
     d. ~ (Bitwise 1’s complement)
     e. << (Bitwise left-shift)
     f. >> (Bitwise right-shift)

Compound expression:

When we write an expression with two or more operations, it is called a compound expression. For example, we may write 7+9*3 where we have both addition and multiplication operations in a single expression. Determining the result of a compound expression is a little tricky. We need to think about what operation will be executed first. To determine that the computer follows Operator precedence, a set of rules that dictates the
computer should be done first. For our example, 7+9*3 the multiplication operation will have higher precedence and will be executed first. So the program will first calculate 9*3 which results in 27. Then it will calculate 7+27, which will result in 34.
Try the following examples and see what results in it shows:

5*3+2-1*2
1+7/7*7

Operator precedence:

In the table below precedence has been shown in descending order- highest to lowest. Highest precedence at the top, lowest at the bottom. Operators in the same precedence are evaluated from left to right.

 Operator                    Name of the operator/ Operation

   ()                           Parentheses (Grouping)

 f( args.... )                  Function call

 x[ index:index ]               Slicing

 x [ index ]                    Subscription

 x.attribute                    Attribute Reference

   **                           Exponentiation

   ~x                           Bitwise Not

  +x, -x                        Unary Plus, Unary Minus

  *, /, %, //                   Multiplication, Division, 
                                Modulus/ Remainder, Floor 
                                Quotient/ Integer Division 

  +, -                          Addition, Subtraction

  <<, >>                        Bitwise Shifts

   &                            Bitwise AND

   ^                            Bitwise XOR

   |                            Bitwise OR

  in, not in, is,               Comparisons, Membership,
  is not, <, <=,                Identity
  >, >=, <>, !=,
   ==

  not                           Boolean NOT

  and                           Boolean AND

  or                            Boolean OR

  lambda                        Lambda expression

Type Conversion:

Data types can be modified in two ways: Implicit (when the compiler changes the type of a data for you(user)) and Explicit (when you ( the user) change the type of a data using type changing functions, it is called “ Type-casting” )

Note: What is the compiler will be explained later. Assume it ( the compiler ) to be like a teacher who checks your code for any kind of mistakes and shows the problems/ errors and sometimes does type conversion
for you ( the user ) according to the computation need of a statement.

1. Implicit Type Conversion:
   If any of the operands are floating-point, then arithmetic 
   operation yields a floating-point value. If the result was 
   integer instead of floating-point, then removal of the 
   fractional part would lead to the loss of information.

2. Explicit Type Conversion:
   Conversion among different data types are possible by 
   using type conversion functions, though there are few 
   restrictions. Python has several functions for this 
   purpose among them below 3 are most used:
     a. str() : constructs a string from various data types 
        such as strings, integer numbers and float-point 
        numbers. 
        For example:
            `var = 12.4
             var_string = str(var)
             print(var_string)
             print(type(var))
             print(type(var_string))`

     b. int(): constructs an integer number from various data 
        types such as strings ( the input string has to 
        consist of numbers without any decimal points, 
        basically whole numbers), and float-point numbers ( 
        by rounding up to a whole number, basically it 
        truncates the decimal part). 
        For example:
            `var_str = '12'
             var_int = int(var_str)
             print(var_int)
             print(type(var_str))
             print(type(var_int))`

     c. float(): constructs a floating-point number from 
        various data types such as integer
        numbers, and strings (the input string has to be a 
        whole number or a floating point number). 
        For example:
            `var_str = '12'
             var_float = float(var_str)
             print(var_float)
             print(type(var_str))
             print(type(var_float))`

Input

For taking input from the user directly, Python has a special 
built-in function, input(). It takes a String as a prompt 
argument and it is optional. It is used to display 
information or messages to the user regarding the input. For 
example, “Please enter a number” is a prompt. After typing 
the data/input in the designated inbox box provided by the 
IDE ( Integrated Development Environment), the user needs to 
press the ENTER key, otherwise the program will be waiting 
for the user input indefinitely. The input() function 
converts it to a string and then returns the string to be 
assigned to the target variable.

             `val = input()
              print(val)
              print(type(val))`

Okay, that is the end of our today's lesson. In the next lesson, we will discuss about three data types integer, float and string.