Identifiers

A name in Python program is called identifier.

It can be class name or function name or module name or variable name.
a = 10
Rules to define identifiers in Python:
1. The only allowed characters in Python are
alphabet symbols(either lower case or upper case)
digits(0 to 9)
underscore symbol(_)
By mistake if we are using any other symbol like $ then we will get syntax error.
cash = 10 √
ca$h =20
2. Identifier should not starts with digit
123total
total123 √
3. Identifiers are case sensitive. Of course Python language is case sensitive language.
total=10
TOTAL=999
print(total) #10
print(TOTAL) #999

1. Alphabet Symbols (Either Upper case OR Lower case)

2. If Identifier is start with Underscore (_) then it indicates it is private.
3. Identifier should not start with Digits.
4. Identifiers are case sensitive.
5. We cannot use reserved words as identifiers
Eg: def=10

Note:

1. If identifier starts with _ symbol then it indicates that it is private

2. If identifier starts with __(two under score symbols) indicating that strongly private
identifier.
3. If the identifier starts and ends with two underscore symbols then the identifier is language
defined special name, which is also known as magic methods.

Eg: __add__

Reserved Words
In Python some words are reserved to represent some meaning or functionality. Such type of
words are called Reserved words.
There are 33 reserved words available in Python.
True, False, None
and, or, not, is
if, elif, else
while, for, break, continue, return, in, yield
try, except, finally, raise, assert
import, from, as, class, def, pass, global, nonlocal, lambda, del, with

>>> import keyword

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']
 1. Data Type represent the type of data present inside a variable.
2. In Python we are not required to specify the type explicitly.
3. Based on value provided, the type will be assigned automatically. Hence Python is
Dynamically Typed Language.

Python contains the following inbuilt data types

1. int
2. float
3. complex
4. bool
5. str
6. bytes
7. bytearray
8. range
9. list
10. tuple
11. set
12. frozenset
13. dict
14. None

Note: Python contains several inbuilt functions

type()
to check the type of variable
id()
to get address of object
3. print()
to print the value
In Python everything is object
int data type:

We can use int data type to represent whole numbers (integral values)
Eg:
a=10
type(a) #int

We can represent int values in the following ways

1. Decimal form
2. Binary form
3. Octal form
4. Hexa decimal form

1. Decimal form(base-10):
It is the default number system in Python.
The allowed digits are: 0 to 9
2. Binary form(Base-2):
The allowed digits are : 0 & 1
Literal value should be prefixed with 0b or 0B
Octal Form(Base-8):
The allowed digits are : 0 to 7
Literal value should be prefixed with 0o or 0O.
4. Hexa Decimal Form(Base-16):
The allowed digits are : 0 to 9, a-f (both lower and upper cases are allowed)
Literal value should be prefixed with 0x or 0X
a=10
b=0o10
c=0X10
d=0B10
print(a)10
print(b)8
print(c)16
print(d)2

float data type:

We can use float data type to represent floating point values (decimal values)

Eg: f=1.234
type(f) float

We can also represent floating point values by using exponential form (scientific notation)

Eg: f=1.2e3
print(f) 1200.0
instead of 'e' we can use 'E'

The main advantage of exponential form is we can represent big values in less memory.

***Note:

We can represent int values in decimal, binary, octal and hexa decimal forms. But we can
represent float values only by using decimal form.

Complex Data Type:

A complex number is of the form

j2 = -1
a + bj

j=

Real Part Imaginary Part

a and b contain intergers or floating point values

Eg:
3+5j
10+5.5j
 0.5+0.1j

In the real part if we use int value then we can specify that either by decimal,octal,binary or
hexa decimal form.
But imaginary part should be specified only by using decimal form.

>>> a=0B11+5j
>>> a
(3+5j)
>>> a=3+0B11j
SyntaxError: invalid syntax

Even we can perform operations on complex type values.

>>> a=10+1.5j
>>> b=20+2.5j
>>> c=a+b
>>> print(c)
(30+4j)
>>> type(c)
<class 'complex'>

Note: Complex data type has some inbuilt attributes to retrieve the real part and
imaginary part

c=10.5+3.6j

c.real==>10.5
c.imag==>3.6

We can use complex type generally in scientific Applications and electrical engineering
Applications.

4.bool data type:

We can use this data type to represent boolean values.

The only allowed values for this data type are:
True and False

Internally Python represents True as 1 and False as 0

b=True
type(b) =>bool

Eg:
a=10
b=20
c=a<b
print(c)==>True
True+True==>2
True-False==>1

str type:

str represents String data type.

A String is a sequence of characters enclosed within single quotes or double quotes.

s1='durga'
s1="durga"

By using single quotes or double quotes we cannot represent multi line string literals.

s1="durga

soft"

For this requirement we should go for triple single quotes(''') or triple double quotes(""")

s1='''durga
soft'''

s1="""durga
soft"""

We can also use triple quotes to use single quote or double quote in our String.

This is " character''' '

This i " Character '

We can embed one string in another string

'''This "Python class very helpful" for java students'''

Slicing of Strings:

slice means a piece

[ ] operator is called slice operator, which can be used to retrieve parts of String.
In Python Strings follows zero based index.
The index can be either +ve or -ve.

+ve index means forward direction from Left to Right -ve

index means backward direction from Right to Left

-5 -4 -3 -2 -1

d u r g a

0 1 2 3 4
bytes Data Type:

bytes data type represents a group of byte numbers just like an array.

Eg:

x = [10,20,30,40]
b = bytes(x)
type(b)==>bytes
print(b[0])==> 10
print(b[-1])==> 40
>>> for i in b : print(i)

10
20
30
40

Conclusion 1:

The only allowed values for byte data type are 0 to 256. By mistake if we are trying to
provide any other values then we will get value error.

Conclusion 2:

Once we creates bytes data type value, we cannot change its values, otherwise we will get
TypeError.

Eg:

>>> x=[10,20,30,40]
>>> b=bytes(x)
>>> b[0]=100
TypeError: 'bytes' object does not support item assignment

bytearray Data type:

bytearray is exactly same as bytes data type except that its elements can be modified.

Eg 1:

x=[10,20,30,40]
b = bytearray(x)
for i in b : print(i)
10
 20
30
40
b[0]=100
for i in b: print(i)
100
20
30
40

Eg 2:

>>> x =[10,256]
>>> b = bytearray(x)
ValueError: byte must be in range(0, 256)

frozenset Data Type:

It is exactly same as set except that it is immutable.

Hence we cannot use add or remove functions.

>>> s={10,20,30,40}
>>> fs=frozenset(s)
>>> type(fs)
<class 'frozenset'>
>>> fs
frozenset({40, 10, 20, 30})
>>> for i in fs:print(i)
...
40
10
20
30

13)

>>> fs.add(70)
AttributeError: 'frozenset' object has no attribute 'add'
>>> fs.remove(10)
AttributeError: 'frozenset' object has no attribute 'remove'

range Data Type:

range Data Type represents a sequence of numbers.

The elements present in range Data type are not modifiable. i.e range Data type is
immutable.
Form-1: range(10)

generate numbers from 0 to 9

Eg:
r=range(10)
for i in r : print(i) 0 to 9

Form-2: range(10,20)

generate numbers from 10 to 19

r = range(10,20)
for i in r : print(i) 10 to 19

Form-3: range(10,20,2)

2 means increment value

r = range(10,20,2)
for i in r : print(i) 10,12,14,16,18

We can access elements present in the range Data Type by using index.
r=range(10,20)
r[0]==>10
r[15]==>IndexError: range object index out of range

We cannot modify the values of range data type

Eg:
r[0]=100
TypeError: 'range' object does not support item assignment

We can create a list of values with range data type

Eg:

>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

None Data Type:

None means Nothing or No value associated.

If the value is not available,then to handle such type of cases None introduced.
It is something like null value in Java.

Eg:
def m1():
a=10

print(m1())
None

Escape Characters:

In String literals we can use esacpe characters to associate a special meaning.

 >>> s="durga\nsoftware"
>>> print(s)
durga
software
>>> s="durga\tsoftware"
>>> print(s)
durga software
>>> s="This is " symbol"
File "<stdin>", line 1
s="This is " symbol"
^
SyntaxError: invalid syntax
>>> s="This is \" symbol"
>>> print(s)
This is " symbol

The following are various important escape characters in Python

\n==>New Line

\t===>Horizontal tab
\r ==>Carriage Return
\b===>Back space
\f===>Form Feed
\v==>Vertical tab
\'===>Single quote
\"===>Double quote
\\===>back slash symbol
....

Constants:

Constants concept is not applicable in Python.

But it is convention to use only uppercase characters if we don’t want to change value.

MAX_VALUE=10

It is just convention but we can change the value.

Control Structures
list data type:
1. group of values as a single entity and collection which is ordered and changeable
2. insertion order is preserved
3. heterogeneous objects are allowed
4. duplicates are allowed
5. values should be enclosed within square brackets.
List Methods
Python has a set of built-in methods that you can use on lists.
Method Description
Append() Adds an element at the end of the list
clear() Removes all the elements from the list
copy() Returns a copy of the list
count() Returns the number of elements with the specified value
extend() Add the elements of a list (or any iterable), to the end of the current list
index() Returns the index of the first element with the specified value
insert() Adds an element at the specified position
pop() Removes the element at the specified position
remove() Removes the item with the specified value
reverse() Reverses the order of the list
sort() Sorts the list

1.1 Tuple data type:

tuple data type is exactly same as list data type except that it is immutable.i.e we cannot
change values.
Tuple elements can be represented within parenthesis.
Note: tuple is the read only version of list
collection which is ordered and unchangeable.
Set Data Type:
A set is a collection which is unordered and unindexed. In Python sets are written with curly
brackets.
If we want to represent a group of values without duplicates where order is not important then
we should go for set Data Type.
1. insertion order is not preserved
2. duplicates are not allowed
3. heterogeneous objects are allowed
4. index concept is not applicable
5. It is mutable collection
6. Growable in nature
1.2 dict Data Type:

1. Duplicate keys are not allowed but values can be duplicated.

2. Heterogeneous objects are allowed for both key and values.
3. insertion order is not preserved
4. Dictionaries are mutable
5. Dictionaries are dynamic
6. indexing and slicing concepts are not applicable
Operators
Operator is a symbol that performs certain operations.
Python provides the following set of operators

1. Arithmetic Operators
2. Relational Operators or Comparison Operators
3. Logical operators
4. Bitwise operators
5. Assignment operators
6. Special operators
Arithmetic Operators
+ ==>Addition
- ==>Subtraction
* ==>Multiplication
/ ==>Division operator
% ===>Modulo operator
// ==>Floor Division operator
** ==>Exponent operator or power operator
Relational Operators:
>,>=,<,<=
Logical Operators:
and, or, not
equality operators:
== , !=
Conditional Statements
if
if condition : statement
or
if condition :
statement-1
statement-2
statement-3
If condition is true then statements will be executed.

if-else:
if condition :
Action-1
else :
Action-2
if condition is true then Action-1 will be executed otherwise Action-2 will be executed.

if-elif-else:
Syntax:
if condition1:
Action-1
elif condition2:
Action-2
elif condition3:
Action-3
elif condition4:
Action-4
...
else:
Default Action
Based condition the corresponding action will be executed.
Python Loops
Python has two primitive loop commands:

1. while loops
2. for loops

The while Loop

With the while loop we can execute a set of statements as long as a condition is true.
The break Statement

With the break statement we can stop the loop even if the while condition is true:
The continue Statement

With the continue statement we can stop the current iteration, and continue with the next:
The else Statement

With the else statement we can run a block of code once when the condition no longer is true:
Python For Loops

A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set,
or a string).

This is less like the for keyword in other programming languages, and works more like an
iterator method as found in other object-orientated programming languages.

With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.

The range() Function

To loop through a set of code a specified number of times, we can use the range() function,

The range() function returns a sequence of numbers, starting from 0 by default, and
increments by 1 (by default), and ends at a specified number.
Else in For Loop

The else keyword in a for loop specifies a block of code to be executed when the loop is
finished:

Nested Loops

A nested loop is a loop inside a loop.

The "inner loop" will be executed one time for each iteration of the "outer loop":

The pass Statement

for loops cannot be empty, but if you for some reason have a for loop with no content, put in
the pass statement to avoid getting an error.

Function

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

2. You can pass data, known as parameters, into a function.
3. A function can return data as a result.

Creating a Function

In Python a function is defined using the def keyword:

Calling a Function
To call a function, use the function name followed by parenthesis:
Parameters
Information can be passed to functions as parameter.
Parameters are specified after the function name, inside the parentheses. You can add as many
parameters as you want, just separate them with a comma.
The following example has a function with one parameter (fname). When the function is called,
we pass along a first name, which is used inside the function to print the full name:

Default Parameter Value

The following example shows how to use a default parameter value.
If we call the function without parameter, it uses the default value:

Passing a List as a Parameter

You can send any data types of parameter to a function (string, number, list, dictionary etc.),
and it will be treated as the same data type inside the function.
E.g. if you send a List as a parameter, it will still be a List when it reaches the function:

Return Values
To let a function return a value, use the return statement:

Keyword Arguments
You can also send arguments with the key = value syntax.
This way the order of the arguments does not matter.

Arbitrary Arguments
If you do not know how many arguments that will be passed into your function, add a * before
the parameter name in the function definition.
This way the function will receive a tuple of arguments, and can access the items accordingly:
If the number of arguments are unknown, add a * before the parameter name:

The pass Statement

function definitions cannot be empty, but if you for some reason have a function definition with
no content, put in the pass statement to avoid getting an error.

Recursion
Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls
itself. This has the benefit of meaning that you can loop through data to reach a result.
The developer should be very careful with recursion as it can be quite easy to slip into writing a
function which never terminates, or one that uses excess amounts of memory or processor
power. However, when written correctly recursion can be a very efficient and mathematically-
elegant approach to programming.
In this example, tri_recursion() is a function that we have defined to call itself ("recurse"). We
use the k variable as the data, which decrements (-1) every time we recurse. The recursion
ends when the condition is not greater than 0 (i.e. when it is 0).
To a new developer it can take some time to work out how exactly this works, best way to find
out is by testing and modifying it.

Module
A group of functions, variables and classes saved to a file, which is nothing but module.
Every Python file (.py) acts as a module.

Consider a module to be the same as a code library.

A file containing a set of functions you want to include in your application.
Create a Module
To create a module just save the code you want in a file with the file extension .py:

Create a Module

To create a module just save the code you want in a file with the file extension .py:

Save this code in a file named mymodule.py

Use a Module

Now we can use the module we just created, by using the import statement:

Import the module named mymodule, and call the greeting function:

Note: When using a function from a module, use the syntax: module_name.function_name.

Variables in Module

The module can contain functions, as already described, but also variables of all types (arrays,
dictionaries, objects etc):

Save this code in the file mymodule.py

Built-in Modules

There are several built-in modules in Python, which you can import whenever you like.

Import and use the platform module:

Using the dir() Function

There is a built-in function to list all the function names (or variable names) in a module. The
dir() function:

List all the defined names belonging to the platform module:

Import From Module

You can choose to import only parts from a module, by using the from keyword.

The module named mymodule has one function and one dictionary:

def greeting(name):

Import only the person1 dictionary from the module:

from mymodule import person1

print (person1["age"])
Note: When importing using the from keyword, do not use the module name when referring to
elements in the module. Example: person1["age"], not mymodule.person1["age"]