Chapter 1: Review of Python basic

Fundamental of Python

Introduction of Python
Python is an interpreter, interactive, object-oriented, and high-level
programming language. It was created by Guido van Rossum in 1991 at
National Research Institute for Mathematics and Computer Science
Netherlands.

Features of Python

 It is loosely typed Programming Language or Dynamically typed language with few keywords and
simple English-like structure and is easy to learn.
 It is free open-source and portable language having a large repository of libraries.
 It take less time to develop as python programs are typically 3-5 times shorter than equivalent java
programs.
 It is easily compatible with other languages like c, c++, java, etc.
 Python is a Case-sensitive language.

Python IDLE
The python IDLE tool offers an interactive and a more efficient platform to write your code in python.
(Integrated Development Learning Environment)

Python IDLE comprise Python Shell (Interactive mode) and Python Editor (Script mode).

Python Modes or Modes of Python IDLE

● Interactive Mode: The Python commands are directly typed at >>> command prompt and as soon
as we press the enter key, the interpreter displays the results immediately, which is known as
displaying. (We cannot save file or command)
>>>10+50
60
● Script Mode: We can write multiple line of code here and get output and errors are running code.
We can open script mode using CTRL+N
Syntax of print () in python:
print(value1,value1,…………,sep=’ ‘, end=’ ‘)
Displaying Vs Printing: Getting output without using print function in interactive mode is called displaying,
And getting output using print () in interactive or script mode.
Different types of files in python:
.py, .pyw, .pyc, .pyd, .pyo, .pyz

-------------------------------------------------------------------------------------------------------------------------

Python character set: Character set is a set of valid characters recognized by python. A character by letter,
digit or any other special symbol.
1. Letters: A-Z, a-z 2. Digits: 0-9 3. Special Symbols:+-/*&=!@_ etc.
4. Whitespaces: Blank space, tabs (‘\t’), carriage return (Enter key), newline, form feed (skips to the start
of the next page.)
5. Other Characters: All ASCII code and Unicode character.

Tokens: A token is the smallest element of a python script that is meaningful to the interpreter.

Types of Tokens are:

 Identifiers: Name of variables, constant and function or module is called an identifier.

 Keywords: The reserved words of python. No keyword can be used as an identifier.
 Literals: A fixed numeric or non-numeric value which stored in any variable is called Literals.
 Operators: It is a symbol that performs some kind of operation on given values like: +,-,*, **, /, etc.
 Delimiters/ Punctuators: Delimiters are symbols which can be used as separators of values or to
enclose some values. Like: {} [] , : ;

Structure of a python program:

● Expressions: Expression is a combination of symbols, operators and operands. Like: a+b

● Statements: Statements is defined as any programming instruction given in python as per the
syntax , Like print(‘hello’), a=10
● Comments: Comments are additional information provided for a statement. (#) is used for single
line comment and (‘’’ ‘’’) used for multiple line comments.
● Function: A function is a block of code which only runs when it is called.
● Blocks: A block is a piece of Python program text that is executed as a unit.

Expressions Statements
Expression is a combination of symbols, operators Statements is defined as any programming
and operands instruction given in python as per the syntax
An expression represents some value. Statement is given to execute a task.
The outcome of an expression is always a value. Statement may or may not return a value as the
result.
Ex: 3*7+10 Print(‘hello’), a=10, if 10>5 etc.
Variable:
A Variable is like a container that stores any value. x=3, age=30

Rules for valid Variable name:

● A variable name must start with a letter or the underscore character

● A variable name cannot start with a number
● A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )
 ● Variable names are case-sensitive (age, Age and AGE are three different variables)
● A variable name cannot contain spaces.

Components of Variable/Object:
A). Identity of the Variable / Object: It refers to the Variable’s memory location address which is
unchanged once it has been created. We can check memory location using this method:
id()

B). Type of the Variable / Object (data type):

int float Complex Str(seq.) Boolean None

5 5.5 2+5j “hello” True/False(0/1) None

*(None is a datatype with single value. It is used to signify the absence of value / Condition evaluating to
false in a situation.)

We can seen any data type by: type()

y=”Hello”
type(y)

C). Value of the Variable/Object:

The value stored in Variable like: age=20, so 20 is the value of the variable.
L-value is age, and R-Value is 20

Multiple Assignments:
1) Assigning multiple values to multiple variables: x,y,z=2,3,4
2) Assigning same value to multiple variable: a=b=c=10

What is Dynamic Typing:

It refers to declaring a variable multiple times with values of different data types. And variable
automatically changes its data types according to data.
a=10
a=”Hello”
Keywords
Keywords are words that are already reserved for some particular purpose. The names of these keywords
should not be used as identifiers/Variable. Keywords are also called reserved words.

False, None, True, and, as, assert, break, class, continue, def, del, elif, else, except, finally, for, from, global,
if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield.

Mutable and Immutable Types:

Mutable: A mutable object can be changed after it is created. Example: List, dictionary etc.
Immutable: A immutable object cannot be changed after it is created. Example: int, float, complex, bool,
string, tuple etc.

Taking input by input() (Python built in functions)

1. input(): Its used to get user input in string format. ex: input(“Enter any number”)
2. int(): This function converts the inputted string value into numeric value if possible.
3. eval(): Its used to evaluate string as a number if possible. eval(“10+50”)
Type Casting
The process of converting the value of one data type (integer, string, float, etc.) to another data type is
called type conversion. Python has two types of type conversion.

1. Implicit Type Conversion: Python automatically converts one data type to another data type. This
process doesn't need any user involvement. Ex: type(5/2)
2. Explicit (forced) Type Conversion: In Explicit Type Conversion, users convert the data type of an
object to required data type. Ex: float(5), str(5),int(‘5’)

Operators and Operands

An operator is a symbol that performs an operation. +,-,*,/
An operator acts on some variables called operands.
For example, if we write a + b, the operator + is acting on two operands a and b. Python provides some
useful operators for performing various operations.

Binary Operators: Operators that operate on two operands are known as binary operators. Ex: 3+3
Unary Operators: Operators that operate on one operand are known as unary operators. Ex: -3
Types of Operators:
Arithmetic operators:

Example: 12 + ( 3 ** 4 – 6 ) / 2

Comparison operators
Logical operators,

Shorthand /Augmented Assignment operators,

Membership operators.

Identity operators,

Precedence of Python Operators

Operators Meaning
() Parentheses
** Exponent (Power)
* , /, //, % Multiplication, Division, Floor division, Modulus
+- Addition, Subtraction
==, !=, >, >=, <, <=, is, is not, in, not in Comparisons, Identity, Membership operators
Not Logical NOT
And Logical AND
or Logical OR
*What will be the output of given Expressions:
(5<10) and (10<5) or (3<18) and not 8<18

What is Functions?

A function is a block of code which only runs when it is called/invoke.

Advantages of Functions:

1. We can avoid rewriting the same logic/code again and again in a program.
2. We can call Python functions multiple times in a program.
3. Code becomes reusable.

How to define and call a function in python function:

def function_name():
statement
print(value)

Function Calling/invoking

function_name()

What is Debugging?

Debugging is the process of finding and fixing errors or bugs in the source code of any software.

Errors are of three types – • Compile Time Error • Run Time Error • Logical Error
1. Compile time error: These errors are basically of 2 types –

1. Syntax Error: Violation of formal rules of a programming language results in syntax error.
print(“hello)
2. Semantics Error: Semantics refers to the set of rules which sets the meaning of statements. A
meaningless statement results in semantics error.
x*y=z

2. Run time Error: These errors are generated during a program execution due to resource limitation. Such
type of error are also termed as exceptions.
Ex: Division by zero, using variable which has not been defined, accessing a list element which doesn’t
exist, try to access a file which doesn’t exit.

3. Logical Error: If a program is not showing any compile time error or run time error but not producing
desired output, it may be possible that program is having a logical error.
ex: Using wrong operators like using // in place of /, giving wrong operator precedence.