Python Programming - Basics

Session – Objective

- Python Features and its Applications

- Python Basics
-Versions
-Variable and Types
-Conditional and Looping structures
-Module based Programming
-Container Objects – Data Storage Objects
-OOP Introduction
-File and Exception handling

INTERNAL
Python

Overview:
-High level , Interpreted, Object Oriented and scripting language
2.Version -Desktop:
Stable: 2.7
Latest: 3.x
Link:https://www.python.org/downloads/release/python-2710/
Desktop Modes:
-IDE
-Command Mode
Supports to code in interactive and scripting style
3.Online Editors:
https://www.onlinegdb.com/online_python_compiler
http://www.codeskulptor.org/

-3- INTERNAL
Variables – Whats New in Python?

• Variables are nothing but reserved memory locations to store values. This means
that when you create a variable you reserve some space in memory.

• Python variables do not have to be explicitly declared to reserve memory space.

The declaration happens automatically when you assign a value to a variable. The
equal sign (=) is used to assign values to variables.

#!/usr/bin/python
counter = 100 # An integer assignment
miles = 1000.0 # A floating point
name = "John" # A string

print counter
print miles
print name

INTERNAL
Python - I/O

How to accept the values from user?

Input statement:
-input() –best option
Output statement:
Print statement:
Note: If using 2.7 version then follow the below syntax
print variable/”string to display”
Ex: print a
print “Hi”
If version is 3.5 and above then use as below
print (variable / “String to display”)
Ex: print(a)
print(“Hi”)
print(“Hi”, variable)
In ppt some examples are covered with 2.7 and some are 3.5 above INTERNAL
 Conditional Statements - IF ELIF ELSE

Syntax: Example:
if expression: #!/usr/bin/python
statement(s) var1,var2 = 1,100
elif expression: if var1:
statement(s) print("var1 value is:",var1)
else: elif var1:
statement(s) print("var2 value is:",var2)
else:
print("var1 and var2 are not
defined");

INTERNAL
 Nested IF

Syntax: Example:
if expression1: #!/usr/bin/python
statement(s) Var1,var2 = 100,200
if expression2: if var1:
statement(s) print ("var1 value is:”,var1)
elif expression3: if var2:
statement(s) print ("var2 value is:”,var2)
else: else:
statement(s) print ("var2 is not defined“)
elif expression4: else:
statement(s) print ("var1 is not defined“)
else:
statement(s) OUTPUT:
var1 value is:100
var2 value is:200
INTERNAL
How Block is identified - Whats new in Python?

INTERNAL
 Looping statements

While: Example:
#!/usr/bin/python
while expression: count = 0
statement(s) while count < 9:
count = count + 1
else:
while expression: print “count is not less than 9”
statement(s) print 'The count is:', count
else: print "Good bye!"
statement(s)
OUTPUT:
count is not less than 9
The count is:8
Good bye!

INTERNAL
Looping Statements - Contnd...

For: Example:
#!/usr/bin/python
for iterating_var in sequence: for letter in 'TCSHYD':
statements(s) print( 'Current Letter :', letter)
print ("Good bye!“)

OUTPUT:
for iterating_var in sequence:
Current Letter :T
statements(s)
Current Letter :C
else:
Current Letter :S
statement(s)
Current Letter :H
Current Letter :Y
Current Letter :D
Good bye!

INTERNAL
 Loop control statements

Break: Continue:

#!/usr/bin/python #!/usr/bin/python
for letter in 'Python': for letter in 'Python':
if letter == 'h': if letter == 'h':
break ; continue
print 'Current Letter :', letter ; print ('Current Letter :', letter ;)
print "over"; print( "over“)

OUTPUT: OUTPUT:
Current Letter :P Current Letter : P
Current Letter :y Current Letter : y
Current Letter :t Current Letter : t
over Current Letter : o
Current Letter : n
over INTERNAL
Show Loops Ex – with User defined types

Show – DoctorEx without class

INTERNAL
 Functions -
Brief the concept with Example
A function is a block of organized, reusable code that is used
to perform a single, related action.

Functions provide better modularity for your application and a

high degree of code reusing.

Python gives you many built-in functions like print(), etc. but
you can also create your own functions. These functions are
called user-defined functions

INTERNAL
 Functions
Defining a Function:

Here are simple rules to define a function in Python.

Function blocks begin with the keyword def followed by the function name and
parentheses ( ( ) ).

Any input parameters or arguments should be placed within these parentheses.

You can also define parameters inside these parentheses.

The code block within every function starts with a colon (:) and is indented.

The statement return [expression] exits a function, optionally passing back an

expression to the caller. A return statement with no arguments is the same as
return None.

INTERNAL
 Functions
Syntax:

def functionname( parameters ):

“documentation”
function_suite
return [expression]

Example:

def sample( str ):

“This is my first function”
print (str)
return

INTERNAL
 Functions
Calling a Function:

Defining a function only gives it a name, specifies the parameters that are to
be included in the function and structures the blocks of code.

#!/usr/bin/python
# Function definition is here
def sample( str ):
“This is my first function”
print (str);
return;

# Now you can call printme function

sample("I'm first call to user defined function!");
sample("Again second call to the same function");
docstring=sample.__doc__ INTERNAL
 Functions

When the python script is executed, it produces the following result:

I'm first call to user defined function!

Again second call to the same function
This is my first function

INTERNAL
 Functions
Pass by reference:

All parameters (arguments) in the Python language are passed by reference. It

means if you change what a parameter refers to within a function, the change
also reflects back in the calling function.

INTERNAL
 Functions
#!/usr/bin/python

def changeme( mylist ):

mylist.append([1,2,3,4]);
print ("Values inside the function: ", mylist)
return

mylist = [10,20,30];
changeme( mylist );
print ("Values outside the function: ", mylist)

Output:
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

INTERNAL
 Functions
Function Arguments:

You can call a function by using the following types of formal arguments:

Required arguments

Keyword arguments

Default arguments

INTERNAL
 Functions
Required arguments:

Required arguments are the arguments passed to a function in correct

positional order. Here, the number of arguments in the function call should
match exactly with the function definition.

#!/usr/bin/python
def printme( str ):
print (str);
return;

# Now you can call printme function

printme();

INTERNAL
 Functions

Traceback (most recent call last):

File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)

INTERNAL
 Functions
Keyword arguments:

Keyword arguments are related to the function calls. When you use
Keyword arguments in a function call, the caller identifies the arguments by
the parameter name.

This allows you to skip arguments or place them out of order because the
Python interpreter is able to use the keywords provided to match the values
with parameters.

#!/usr/bin/python
def printme( str ):
print (str);
return;
printme( str = "My string");
INTERNAL
 Functions
#!/usr/bin/python

# Function definition is here

def printinfo( name, age ):
print "Name: ", name;
print "Age ", age;
return;

# Now you can call printinfo function

printinfo( age=50, name="miki" );

INTERNAL
 Functions
Default arguments:

A default argument is an argument that assumes a default value if a value is

not provided in the function call for that argument.

#!/usr/bin/python
def printinfo( name, age = 35 ):
print "Name: ", name;
print "Age ", age;
return;

# Now you can call printinfo function

printinfo( age=50, name="miki" );
printinfo( name="miki" );

INTERNAL
 Functions
The return Statement:

The statement return [expression] exits a function, optionally passing back

an expression to the caller. A return statement with no arguments is the
same as return None.

#!/usr/bin/python

def sum( arg1, arg2 ):

total = arg1 + arg2
print "Inside the function : ", total
return total;

total = sum( 10, 20 );

print "Outside the function : ", total
INTERNAL
Python - Data Storage Objects – Why?

➢ Lists
➢ Tuples
➢ Dictionary
➢ Set

- 27
INTERNAL
-
Lists

The list type is a container that holds a number of other objects, in a given
order.

Syntax to Create List:-

L = [ ] (or)
L = [expression, …]

Ex:-
L=[1,2,3,4,5,6,7,8]

L1 = ['Java', 'Python', 2015, 2016]

L3=[1,2,[3,4,5],4,5]

Accessing Elements in a List:- L[0] returns 1

List functions: len,max,min, insert, append, reverse, sort etc

- 28
INTERNAL
-
Lists – Ex

INTERNAL
Lists – How to Apply in Real Time –

Show Ex -

INTERNAL
Tuple

A tuple is a sequence of immutable Python objects. Tuples are sequences, just

like lists. The only difference is that tuples can't be changed.

Creating Tuples:-
T = ()
T = (expression, …)

Ex:-
T=(1,2,3,4,5,6,7,8)
T1 = ('Java', 'Python', 2015, 2016)
T2=(1,2,[3,4,5],4,5)

Accessing Elements in a Tuples:- T[0] returns 1

Tuple also has similar kind of operations as list has .

Execute the programs implemented on list using Tuple?

Note:
Explore the functions on tuple with examples?

- 31
INTERNAL
-
Tuple - Ex

INTERNAL
Tuple – How to Apply in Real Time ?

Show Ex

INTERNAL
Set

A set is a dictionary with no values. It has only unique keys. Its syntax is similar to that for
a dictionary. But we omit the values.

Syntax for Creating Set:-

S = set()
S = {expression, …}

Ex:-
s={1,2,3,4,5,6,7,8}
S1 = {'Java', 'Python', 2015, 2016}
S2=set([1,2,3])

Accessing Elements in a Set:- Using For loop

- 34
INTERNAL
-
Set – How to Apply in Real Time ?

INTERNAL
Dictionary
A dictionary is mutable that can store any number of objects. Dictionaries consist
of pairs (called items) of keys and their corresponding values.

Keys of a particular dictionary are unique while values may not be.

The values of a dictionary can be of any type, but the keys must be of an
immutable data type such as strings, numbers, or tuples.

Creating Dictionaries:-
D={}
D={1:'Java',2:'Python',3:'HTML'}

Accessing Elements in a Dictionary:-

D[1] returns 'Java'
D[2] returns 'Python'

Create a dictionary in such a way that, if I give the week day in number I should
be in a position to get Week Day Name, Similarly for Month

- 36
INTERNAL
-
Example

INTERNAL
Dictionary – Ex2

INTERNAL
Dictionary – How to Apply in Real Time ?

Demo on its applications

INTERNAL
Exception Handling

What is an Exception?

What are the issues when an Exception occurs?

How to mitigate the Issue – raised by an Exception?

Examples context for an Exception to get raised? – Who should

aware of this?

INTERNAL
Exception Handling - Ex:

INTERNAL
File Handling - Ex:

INTERNAL
INTERNAL
 OOPs Intro
Why OOP Programming?

OOP Features?
-Abstraction
-Technical Implementation of Abstraction :-Encapsulation
-Inheritance
-Polymorphism etc..

Note: Explain the above feature Vs any OOP Program

INTERNAL
 OOPs Intro with Classes/Objects
Python has been an object-oriented language from day one. Because of
this, creating and using classes and objects are downright easy.

Creating Classes:

The class statement creates a new class definition. The name of the class
immediately follows the keyword class followed by a colon as follows:

class ClassName:
'Optional class documentation string'
class_suite

The class has a documentation string, which can be accessed via

ClassName.__doc__.

The class_suite consists of all the component statements defining class

INTERNAL
 Classes/Objects
Python has been an object-oriented language from day one. Because of
this, creating and using classes and objects are downright easy.

Creating Classes:

The class statement creates a new class definition. The name of the class
immediately follows the keyword class followed by a colon as follows:

class ClassName:
'Optional class documentation string'
class_suite

The class has a documentation string, which can be accessed via

ClassName.__doc__.
The class_suite consists of all the component statements defining class
members, data attributes and functions.
INTERNAL
 Classes/Objects
class Employee:
'Common base class for all employees'
empCount = 0

def __init__(self, name, salary):

self.name = name
self.salary = salary
Employee.empCount += 1

def displayCount(self):
print "Total Employee %d" % Employee.empCount

def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary

INTERNAL
 Classes/Objects
The variable empCount is a class variable whose value would be shared
among all instances of a this class. This can be accessed as
Employee.empCount from inside the class or outside the class.

The first method __init__() is a special method, which is called class

constructor or initialization method that Python calls when you create a
new instance of this class.

You declare other class methods like normal functions with the exception
that the first argument to each method is self. Python adds the self
argument to the list for you; you don't need to include it when you call the
methods.

INTERNAL
 Classes/Objects

Creating instance objects:

To create instances of a class, you call the class using class name and
pass in whatever arguments its __init__ method accepts.

"This would create first object of Employee class"

emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

INTERNAL
 Classes/Objects

Show Example?

INTERNAL
https://dev.mysN.com/downloads/connecto
Python My SQL connectors – Database connectivity
r/python/?os=31

https://dev.mysql.com/downloads/connector/python/?os=31

INTERNAL
https://dev.mysN.com/downloads/connecto
Python My SQL connectors – Database connectivity
r/python/?os=31

https://dev.mysql.com/downloads/connector/python/?os=31

INTERNAL
Python My SQL connectors – Database connectivity

- Run the rpm’s for the installation and verify

Refer the document, “steps to follow - MySQL connectivity.docx”, shared

INTERNAL
Applications - Snapshot

INTERNAL
Applications – Snapshot2

INTERNAL
Applications – Snapshot3

Python's standard library supports many Internet

Python's standard library supports many Internet protocols:
protocols:
HTML and XML
• HTML and XML
JSON
• JSON
E-mail processing.
Python's
Support for FTP, standard
IMAP, and otherlibrary supports
Internet many
protocols.
• E-mail processing.
Easy-to-use Internet
socket protocols:
interface.
HTML and XML
• Support for FTP, IMAP, and other Internet protocols.
JSON
• Easy-to-use socket interface.
E-mail processing.
Support for FTP, IMAP, and other Internet
protocols.
Easy-to-use socket interface.

INTERNAL
Applications – Snapshot4

Scientific and Numeric

Python is widely used in scientific and numeric computing:
• SciPy is a collection of packages for mathematics, science, and
engineering.
• Pandas is a data analysis and modeling library.
• IPython is a powerful interactive shell that features easy editing and
recording of a work session, and supports visualizations and parallel
computing.
• The Software Carpentry Course teaches basic skills for scientific
computing, running bootcamps and providing open-access teaching
materials.

INTERNAL
Applications – Snapshot5

DJango : Tool To design webpages using Python ,rich set of libraries

Python can be used to code for IOT devices : Rasberry PI , Robotics

DJango : Tool To design webpages using

Python Scripting : Python
To interact and perform operations on cloud using AWB

Python can be used to code for IOT

devices : RasberiPI , Robotics

Python Scripting : To interact and perform

operations on cloud using AWB

INTERNAL
Thank You