Python ppt

What is Python
• Multi-purpose (Web, GUI, Scripting, etc.)
• Object Oriented
• Interpreted
• Strongly typed and Dynamically typed
• Focus on readability and productivity
• Everything is an Object
• Interactive Shell

Who Uses Python
• Google
• PBS
• NASA
• Library of Congress
• the ONION
• ...the list goes on...

C Program
#include <stdio.h>
int main()
{
printf("Hello, world!");
return 0;
}

Python program
print “Hello, world!”
# this will print "Hello, world!"
print "Hello, world!"

Python program
Script mode :
#!/usr/bin/python
print "Hello, Python!“
Python files have extension .py
print "Hello, Python!“
We assume that you have Python interpreter set in
PATH variable. Now, try to run this program as
follows −
$ python test.py

Identifiers
• A Python identifier is a name used to identify a
variable, function, class, module or other object.
• An identifier starts with a letter A to Z or a to z or an
underscore (_) followed by zero or more letters,
underscores and digits (0 to 9).
• Python does not allow punctuation characters such as
@, $, and % within identifiers.
• Python is a case sensitive programming language.
• Thus, Manpower and manpower are two different
identifiers in Python.

Lines and Indentation
• Python provides no braces to indicate blocks
of code for class and function definitions or
flow control. Blocks of code are denoted by
line indentation, which is rigidly enforced.
• The number of spaces in the indentation is
variable, but all statements within the block
must be indented the same amount.

• For example −
if True:
print "True"
else:
print "False“
However, the following block generates an error −
if True:
print "Answer"
print "True"
else:
print "Answer"
print "False"

• A group of individual statements, which make a single
code block are called suites in Python. Compound or
complex statements, such as if, while, def, and class
require a header line and a suite.
• Header lines begin the statement (with the keyword)
and terminate with a colon ( : ) and are followed by
one or more lines which make up the suite. For
example −
if expression :
suite
elif expression :
suite
else :
suite

Multi-Line Statements
• Statements in Python typically end with a new line. Python
does, however, allow the use of the line continuation
character () to denote that the line should continue. For
example −
total = item_one +
item_two +
item_three
• Statements contained within the [], {}, or () brackets do not
need to use the line continuation character. For example −
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday',
'Friday']

Quotation in Python
• Python accepts single ('), double (") and triple ('''
or """) quotes to denote string literals, as long as
the same type of quote starts and ends the string.
• The triple quotes are used to span the string
across multiple lines. For example, all the
following are legal −
word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines
and sentences."""

Comments in Python
• A hash sign (#) that is not inside a string literal begins a
comment. All characters after the # and up to the end
of the physical line are part of the comment and the
Python interpreter ignores them.
#!/usr/bin/python
# First comment
print "Hello, Python!"
# second comment
#third comment
name = "Madisetti" # This is again comment

• Multi-line comments as such do not exist in
python.
• But conventionally, strings not assigned to
any variable might be considered as such.

Multiple Statements on a Single Line
• The semicolon ( ; ) allows multiple statements
on the single line given that neither statement
starts a new code block. Here is a sample snip
using the semicolon −
import sys; x = 'foo'; sys.stdout.write(x + 'n')

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

Assigning Values to Variables
• Python variables do not need explicit declaration
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.
• The operand to the left of the = operator is the
name of the variable and the operand to the right
of the = operator is the value stored in the
variable.

• For example −
#!/usr/bin/python
counter = 100 # An integer assignment
miles = 1000.0 # A floating point
name = "John" # A string
check = True # A Boolean
print counter
print miles
print name
print check

• Actual type of the variable can be checked
with type().
a = 3
type(a)
name = “john”
type(name)

Data types
• Python has five standard data types −
• Numbers
• String
• List
• Tuple
• Dictionary

Python Numbers
• Number data types store numeric values.
Number objects are created when you assign a
value to them. For example −
var1 = 1 var2 = 10
del var # it is used to delete the variable
• Python supports four different numerical types −
– int (signed integers)
– long (long integers, they can also be represented in
octal and hexadecimal)
– float (floating point real values)
– complex (complex numbers)

Mathematical Functions
Function Returns ( description )
abs(x) The absolute value of x: the (positive) distance between x and zero.
ceil(x) The ceiling of x: the smallest integer not less than x
cmp(x, y) -1 if x < y, 0 if x == y, or 1 if x > y
exp(x) The exponential of x: e
x
fabs(x) The absolute value of x.
floor(x) The floor of x: the largest integer not greater than x
log(x) The natural logarithm of x, for x> 0
log10(x) The base-10 logarithm of x for x> 0 .
max(x1, x2,...) The largest of its arguments: the value closest to positive infinity
min(x1, x2,...) The smallest of its arguments: the value closest to negative infinity
modf(x) The fractional and integer parts of x in a two-item tuple. Both parts
have the same sign as x. The integer part is returned as a float.
pow(x, y) The value of x**y.
round(x [,n]) x rounded to n digits from the decimal point. Python rounds away
from zero as a tie-breaker: round(0.5) is 1.0 and round(-0.5) is -1.0.
sqrt(x) The square root of x for x > 0

Trigonometric Functions
Function Description
acos(x) Return the arc cosine of x, in radians.
asin(x) Return the arc sine of x, in radians.
atan(x) Return the arc tangent of x, in radians.
atan2(y, x) Return atan(y / x), in radians.
cos(x) Return the cosine of x radians.
hypot(x, y) Return the Euclidean norm, sqrt(x*x + y*y).
sin(x) Return the sine of x radians.
tan(x) Return the tangent of x radians.
degrees(x) Converts angle x from radians to degrees.
radians(x) Converts angle x from degrees to radians.

Python Strings
• Strings in Python are identified as a contiguous set of
characters represented in the quotation marks.
• Python allows for either pairs of single or double
quotes.
• Subsets of strings can be taken using the slice operator
([ ] and [:] ) with indexes starting at 0 in the beginning
of the string and working their way from -1 at the end.
• The plus (+) sign is the string concatenation operator
and the asterisk (*) is the repetition operator.

• For example −
#!/usr/bin/python
str = 'Hello World!'
print str # Prints complete string
print str[0] # Prints first character of the string
print str[2:5] # Prints char starting from 3rd to5th
print str[2:] # Prints string starting from 3rd character
print str * 2 # Prints string two times
print str + "TEST" # Prints concatenated string
This will produce the following result −
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Accessing Values in Strings
• Python does not support a character type;
these are treated as strings of length one, thus
also considered a substring.
• To access substrings, use the square brackets
for slicing along with the index or indices to
obtain your substring.

• For example −
#!/usr/bin/python
var1 = 'Hello World!'
var2 = "Python Programming"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]
• When the above code is executed, it produces
the following result −
var1[0]: H
var2[1:5]: ytho

Updating Strings
• You can "update" an existing string by (re)assigning a
variable to another string. The new value can be
related to its previous value or to a completely
different string altogether. For example −
#!/usr/bin/python
var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python‘
When the above code is executed, it produces the
following result −
Updated String :- Hello Python

• Raw strings do not treat the backslash as a special
character at all. Every character you put into a raw string
stays the way you wrote it −
#!/usr/bin/python
print 'C:nowhere‘
• When the above code is executed, it produces the following
result −
C:nowhere
Now let's make use of raw string. We would put expression
in r'expression' as follows −
#!/usr/bin/python
print r'C:nowhere‘
result −
C:nowhere

String Special Operators
Operator Description Example
+ Concatenation - Adds values on either side of the
operator
a + b will give HelloPython
* Repetition - Creates new strings, concatenating
multiple copies of the same string
a*2 will give -HelloHello
[] Slice - Gives the character from the given index a[1] will give e
[ : ] Range Slice - Gives the characters from the given
range
a[1:4] will give ell
in Membership - Returns true if a character exists in the
given string
H in a will give 1
not in Membership - Returns true if a character does not
exist in the given string
M not in a will give 1
r/R Raw String - Suppresses actual meaning of Escape
characters. The syntax for raw strings is exactly the
same as for normal strings with the exception of the
raw string operator, the letter "r," which precedes the
quotation marks. The "r" can be lowercase (r) or
uppercase (R) and must be placed immediately
preceding the first quote mark.
print r'n' prints n and print
R'n'prints n
% Format - Performs String formatting See at next section

Python Lists
• Lists are the most versatile of Python's compound data
types.
• A list contains items separated by commas and enclosed
within square brackets ([]).
• To some extent, lists are similar to arrays in C. One
difference between them is that all the items belonging to
a list can be of different data type.
• The values stored in a list can be accessed using the slice
operator ([ ] and [:]) with indexes starting at 0 in the
beginning of the list and working their way to end -1.
• The plus (+) sign is the list concatenation operator, and the
asterisk (*) is the repetition operator.

• For example −
#!/usr/bin/python
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 3rd
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists
• This produce the following result −
['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

Accessing Values in Lists
• To access values in lists, use the square brackets for slicing
along with the index or indices to obtain value available at
that index.
• For example −
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
result −
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]

Updating Lists
• You can update single or multiple elements of lists by giving
the slice on the left-hand side of the assignment operator,
and you can add to elements in a list with the append()
method. For example −
#!/usr/bin/python
list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2]
list[2] = 2001;
print "New value available at index 2 : "
print list[2]
result −
Value available at index 2 : 1997
New value available at index 2 : 2001

Delete List Elements
• To remove a list element, you can use either the del
statement if you know exactly which element(s) you are
deleting or the remove() method if you do not know. For
example −
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000];
print list1
del list1[2];
print "After deleting value at index 2 : "
print list1
• When the above code is executed, it produces following
result −
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 : ['physics', 'chemistry', 2000]

Basic List Operations
Python Expression Results Description
len([1, 2, 3]) 3 Length
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenation
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!',
'Hi!']
Repetition
3 in [1, 2, 3] True Membership
for x in [1, 2, 3]:
print x,
1 2 3 Iteration

Indexing, Slicing, and Matrixes
L[2] 'SPAM!' Offsets start at
zero
L[-2] 'Spam' Negative: count
from the right
L[1:] ['Spam', 'SPAM!'] Slicing fetches
sections
L = ['spam', 'Spam', 'SPAM!']

Built-in Functions and Methods
SN Function with Description
1 cmp(list1, list2)
Compares elements of both lists.
2 len(list)
Gives the total length of the list.
3 max(list)
Returns item from the list with max value.
4 min(list)
Returns item from the list with min value.
5 list(seq)
Converts a tuple into list.

Python Tuples
• A tuple is another sequence data type that is similar to
the list.
• A tuple consists of a number of values separated by
commas.
• Unlike lists, however, tuples are enclosed within
parentheses.
• The main differences between lists and tuples are: Lists
are enclosed in brackets ( [ ] ) and their elements and
size can be changed, while tuples are enclosed in
parentheses ( ( ) ) and cannot be updated.
• Tuples can be thought of as read-only lists.

• For example −
#!/usr/bin/python
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print tuple # Prints complete list
print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 2nd till 3rd
print tuple[2:] # Prints elements starting from 3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated lists.
('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

The following code is invalid with tuple, because we
attempted to update a tuple, which is not allowed.
Similar case is possible with lists −
#!/usr/bin/python
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000
# Invalid syntax with tuple
list[2] = 1000
# Valid syntax with list

Accessing Values in Tuples
• To access values in tuple, use the square brackets for
slicing along with the index or indices to obtain value
available at that index. For example −
#!/usr/bin/python
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
• When the above code is executed, it produces the
tup1[0]: physics
tup2[1:5]: [2, 3, 4, 5]

Updating Tuples
• Tuples are immutable which means you cannot update or change
the values of tuple elements. You are able to take portions of
existing tuples to create new tuples as the following example
demonstrates −
#!/usr/bin/python
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
• Following action is not valid for tuples
tup1[0] = 100;
• So let's create a new tuple as follows
tup3 = tup1 + tup2;
print tup3
• When the above code is executed, it produces the following result −
(12, 34.56, 'abc', 'xyz')

Delete Tuple Elements
• Removing individual tuple elements is not possible. There is, of course,
nothing wrong with putting together another tuple with the undesired
elements discarded.
• To explicitly remove an entire tuple, just use the del statement. For
example:
#!/usr/bin/python
tup = ('physics', 'chemistry', 1997, 2000);
print tup
del tup;
print "After deleting tup : “
print tup
• This produces the following result. Note an exception raised, this is
because after del tup tuple does not exist any more −
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last): File "test.py", line 9, in <module> print
tup; NameError: name 'tup' is not defined

Basic Tuples Operations
len((1, 2, 3)) 3 Length
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenation
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!',
'Hi!')
Repetition
3 in (1, 2, 3) True Membership
for x in (1, 2, 3):
print x,
1 2 3 Iteration

Built-in Functions
S
N
Function with Description
1 cmp(tuple1, tuple2)
Compares elements of both tuples.
2 len(tuple)
Gives the total length of the tuple.
3 max(tuple)
Returns item from the tuple with max value.
4 min(tuple)
Returns item from the tuple with min value.
5 tuple(seq)
Converts a list into tuple.

Python Dictionary
• Python's dictionaries are kind of hash table type.
• They work like associative arrays or hashes found in
Perl and consist of key-value pairs.
• A dictionary key can be almost any Python type, but
are usually numbers or strings. Values, on the other
hand, can be any arbitrary Python object.
• Dictionaries are enclosed by curly braces ({ }) and
values can be assigned and accessed using square
braces ([]).
• Dictionaries have no concept of order among
elements. It is incorrect to say that the elements are
"out of order"; they are simply unordered.

• For example −
#!/usr/bin/python
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # Prints value for 'one' key
print dict[2] # Prints value for 2 key
print tinydict # Prints complete dictionary
print tinydict.keys() # Prints all the keys
print tinydict.values() # Prints all the values
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Accessing Values in Dictionary
• To access dictionary elements, you can use the familiar
square brackets along with the key to obtain its value.
Following is a simple example −
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']
dict['Name']: Zara
dict['Age']: 7

• If we attempt to access a data item with a key, which is
not part of the dictionary, we get an error as follows −
#!/usr/bin/python
print "dict['Alice']: ", dict['Alice']
dict['Alice']:
Traceback (most recent call last): File "test.py",
line 4, in <module> print "dict['Alice']: ",
dict['Alice']; KeyError: 'Alice'

Updating Dictionary
• You can update a dictionary by adding a new entry or a
key-value pair, modifying an existing entry, or deleting
an existing entry as shown below in the simple
example −
#!/usr/bin/python
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print "dict['School']: ", dict['School']
dict['Age']: 8 dict['School']: DPS School

Delete Dictionary Elements
• You can either remove individual dictionary elements or clear the entire
contents of a dictionary. You can also delete entire dictionary in a single
operation.
• To explicitly remove an entire dictionary, just use the del statement.
Following is a simple example −
#!/usr/bin/python
del dict['Name']; # remove entry with key 'Name'
dict.clear(); # remove all entries in dict
del dict ; # delete entire dictionary
print "dict['School']: ", dict['School']
• This produces the following result. Note that an exception is raised because
after del dict dictionary does not exist any more −
dict['Age']: Traceback (most recent call last): File "test.py", line 8, in <module>
print "dict['Age']: ", dict['Age']; TypeError: 'type' object is unsubscriptable

Properties of Dictionary Keys
• Dictionary values have no restrictions. They can be any
arbitrary Python object, either standard objects or user-
defined objects. However, same is not true for the keys.
• There are two important points to remember about
dictionary keys −
– (a) More than one entry per key not allowed. Which means no
duplicate key is allowed. When duplicate keys encountered
during assignment, the last assignment wins. For example −
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
result −
dict['Name']: Manni

– (b) Keys must be immutable. Which means you can
use strings, numbers or tuples as dictionary keys but
something like ['key'] is not allowed. Following is a
simple example:
#!/usr/bin/python
dict = {['Name']: 'Zara', 'Age': 7}
Traceback (most recent call last): File "test.py",
line 3, in <module> dict = {['Name']: 'Zara', 'Age':
7}; TypeError: list objects are unhashable

Built-in Dictionary Functions &
Methods
SN Function with Description
1 cmp(dict1, dict2)
Compares elements of both dict.
2 len(dict)
Gives the total length of the dictionary. This would be equal to
the number of items in the dictionary.
3 str(dict)
Produces a printable string representation of a dictionary
4 type(variable)
Returns the type of the passed variable. If passed variable is
dictionary, then it would return a dictionary type.

Datatype conversion
• Sometimes, you may need to perform conversions between
the built-in types. To convert between types, you simply use
the type name as a function.
• There are several built-in functions to perform conversion
from one data type to another.
• These functions return a new object representing the
converted value.

Function Description
int(x [,base]) Converts x to an integer. base specifies the base if x is a string.
long(x [,base] ) Converts x to a long integer. base specifies the base if x is a string.
float(x) Converts x to a floating-point number.
complex(real [,imag]) Creates a complex number.
str(x) Converts object x to a string representation.
repr(x) Converts object x to an expression string.
eval(str) Evaluates a string and returns an object.
tuple(s) Converts s to a tuple.
list(s) Converts s to a list.
set(s) Converts s to a set.
dict(d) Creates a dictionary. d must be a sequence of (key,value) tuples.
frozenset(s) Converts s to a frozen set.
chr(x) Converts an integer to a character.
unichr(x) Converts an integer to a Unicode character.
ord(x) Converts a single character to its integer value.
hex(x) Converts an integer to a hexadecimal string.
oct(x) Converts an integer to an octal string.

Building Complex Strings
a = 3
b = 5
# to print 3 times 5 is 15
result = a + " times " + b + " is " + a*b
• This will produce an error
TypeError: unsupported operand type(s)

Building Complex Strings
• This can be done as :
a = 3
b = 5
# 3 times 5 is 15
• result = str(a) + " times " + str(b) + " is " +
str(a*b)
• result = "%d times %d is %d" %(a, b, a*b)
• result = "{} times {} is {}".format(a, b, a*b)

Getting Input
print "How old are you?"
age = raw_input() # age is a string
• To make age a number
age = int(raw_input())

Operators
• Operators are the constructs which can manipulate the
value of operands.
• Consider the expression 4 + 5 = 9. Here, 4 and 5 are
called operands and + is called operator.
• Types of Operator :
• Python language supports the following types of
operators.
– Arithmetic Operators
– Comparison (Relational) Operators
– Assignment Operators
– Logical Operators
– Bitwise Operators
– Membership Operators
– Identity Operators

Python Membership Operators
Operat
or
Description Example
in Evaluates to true if it finds
a variable in the specified
sequence and false
otherwise.
x in y, here in results in
a 1 if x is a member of
sequence y.
not in Evaluates to true if it does
not finds a variable in the
specified sequence and
false otherwise.
x not in y, here not in
results in a 1 if x is not
a member of sequence
y.

Python Identity Operators
Operat
or
Description Example
is Evaluates to true if the
variables on either side of
the operator point to the
same object and false
otherwise.
x is y, here is results in
1 if id(x) equals id(y).
is not Evaluates to false if the
variables on either side of
the operator point to the
same object and true
otherwise.
x is not y, here is
not results in 1 if id(x)
is not equal to id(y).

Python Operators Precedence
Operator Description
** Exponentiation (raise to the power)
~ + - Complement, unary plus and minus (method names
for the last two are +@ and -@)
* / % // Multiply, divide, modulo and floor division
+ - Addition and subtraction
>> << Right and left bitwise shift
& Bitwise 'AND'
^ | Bitwise exclusive `OR' and regular `OR'
<= < > >= Comparison operators
<> == != Equality operators
= %= /= //= -= += *= **= Assignment operators
is is not Identity operators
in not in Membership operators
not or and Logical operators

If-statement
• If the suite of an if clause consists only of a single line,
it may go on the same line as the header statement.
• Here is an example of a one-line if clause −
#!/usr/bin/python
var = 100
if ( var == 100 ) : print "Value of expression is 100“
• This is same as :
if ( var == 100 ) :
print "Value of expression is 100“
Value of expression is 100

While loop
• Syntax :
while expression:
statement(s)
• Example :
#!/usr/bin/python
count = 0
while (count < 9):
print 'The count is:',
count count = count + 1
print "Good bye!"
Output :
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

Using else Statement with Loops
#!/usr/bin/python
count = 0
while count < 5:
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5“
• Output :
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

For Loop
• Syntax :
for iterating_var in sequence:
statements(s)
• Example :
#!/usr/bin/python
for letter in 'Python': # First Example
print 'Current Letter :', letter
• Output :
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n

#!/usr/bin/python
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # Second Example
print 'Current fruit :', fruit
print "Good bye!"
• Output :
Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

for x in range (10) : # 0-9
print x
Output :
0
1
2
3
4
5
6
7
8
9

Use the reversed() built-in function
a = ["foo", "bar", "baz"]
for i in reversed(a):
print i
• Output :
baz
bar
foo

Loop Control Statements
Control Statement Description
break statement Terminates the loop statement and transfers execution to the
statement immediately following the loop.
continue
statement
Causes the loop to skip the remainder of its body and
immediately retest its condition prior to reiterating.
pass statement The pass statement in Python is used when a statement is
required syntactically but you do not want any command or
code to execute.

Modules
• A module allows you to logically organize your
Python code. Grouping related code into a
module makes the code easier to understand and
use. A module is a Python object with arbitrarily
named attributes that you can bind and
reference.
• Simply, a module is a file consisting of Python
code. A module can define functions, classes and
variables. A module can also include runnable
code.

• Syntax :
import module1[, module2[,... moduleN]
#!/usr/bin/python
import support
support.print_func("Zara")
Hello : Zara

The from...import Statement
from modname import name1[, name2[, ...
nameN]]
For example, to import the function fibonacci
from the module fib, use the following
statement −
• from fib import fibonacci

The dir( ) Function
• The dir() built-in function returns a sorted list of strings
containing the names defined by a module.
• The list contains the names of all the modules, variables
and functions that are defined in a module. Following is a
simple example −
#!/usr/bin/python # Import built-in module math
import math
content = dir(math)
print content
result −
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs',
'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10',
'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Regular Expressions
• Regular expressions are a powerful string manipulation
tool
• All modern languages have similar library packages for
regular expressions
• Use regular expressions to:
– Search a string (search and match)
– Replace parts of a string (sub)
– Break strings into smaller pieces (split)
• Really clever "wild card" expressions for matching
and parsing strings.

Understanding Regular Expressions
• Very powerful and quite cryptic
• Fun once you understand them
• Regular expressions are a language unto
themselves
• A language of "marker characters" -
programming with characters
• It is kind of an "old school" language -
compact

http://xkcd.com/208/

Regular Expression Quick Guide
^ Matches the beginning of a line
$ Matches the end of the line
. Matches any character
s Matches whitespace
S Matches any non-whitespace character
* Repeats a character zero or more times
*? Repeats a character zero or more times (non-greedy)
+ Repeats a chracter one or more times
+? Repeats a character one or more times (non-greedy)
[aeiou] Matches a single character in the listed set
[^XYZ] Matches a single character not in the listed set
[a-z0-9] The set of characters can include a range
( Indicates where string extraction is to start
) Indicates where string extraction is to end

Python’s Regular Expression Syntax
• Most characters match themselves
The regular expression “test” matches the
string ‘test’, and only that string
• [x] matches any one of a list of characters
“[abc]” matches ‘a’,‘b’,or ‘c’
• [^x] matches any one character that is not
included in x
“[^abc]” matches any single character except
‘a’,’b’,or ‘c’

Python’s Regular Expression Syntax
• “.” matches any single character
• Parentheses can be used for grouping
“(abc)+” matches ’abc’, ‘abcabc’,
‘abcabcabc’, etc.
• x|y matches x or y
“this|that” matches ‘this’ and ‘that’,
but not ‘thisthat’.

Python’sRegular Expression Syntax
• x* matches zero or more x’s
“a*” matches ’’, ’a’, ’aa’, etc.
• x+ matches one or more x’s
“a+” matches ’a’,’aa’,’aaa’, etc.
• x? matches zero or one x’s
“a?” matches ’’ or ’a’
• x{m, n} matches i x‘s, where m<i< n
“a{2,3}” matches ’aa’ or ’aaa’

Regular Expression Syntax
• “d” matches any digit; “D” any non-digit
• “s” matches any whitespace character; “S” any
non-whitespace character
• “w” matches any alphanumeric character; “W” any
non-alphanumeric character
• “^” matches the beginning of the string; “$” the end
of the string
• “b” matches a word boundary; “B” matches a
character that is not a word boundary

Search and Match
• The two basic functions are re.search and re.match
– Search looks for a pattern anywhere in a string
– Match looks for a match staring at the beginning
• Both return None (logical false) if the pattern isn’t found
and a “match object” instance if it is
>>> import re
>>> pat = "a*b”
>>> re.search(pat,"fooaaabcde")
<_sre.SRE_Match object at 0x809c0>
>>> re.match(pat,"fooaaabcde")
>>>

Q: What’s a match object?
• A: an instance of the match class with the details of
the match result
>>> r1 =
re.search("a*b","fooaaabcde")
>>> r1.group() # group returns
string matched
'aaab'
>>> r1.start() # index of the
match start
3
>>> r1.end() # index of the
match end

What got matched?
• Here’s a pattern to match simple email addresses
w+@(w+.)+(com|org|net|edu)
>>> pat1 = "w+@(w+.)+(com|org|net|edu)"
>>> r1 = re.match(pat,"finin@cs.umbc.edu")
>>> r1.group()
'finin@cs.umbc.edu’
• We might want to extract the pattern parts, like the
email name and host

More re functions
• re.split() is like split but can use patterns
>>> re.split("W+", “This... is a test,
short and sweet, of split().”)
['This', 'is', 'a', 'test', 'short’,
'and', 'sweet', 'of', 'split’, ‘’]
• re.sub substitutes one string for a pattern
>>> re.sub('(blue|white|red)', 'black', 'blue
socks and red shoes')
'black socks and black shoes’
• re.findall() finds al matches
>>> re.findall("d+”,"12 dogs,11 cats, 1
egg")
['12', '11', ’1’]

Summary
• Regular expressions are a cryptic but
powerful language for matching strings and
extracting elements from those strings
• Regular expressions have special characters
that indicate intent

Python ppt

More Related Content

What's hot (20)

Similar to Python ppt (20)

Recently uploaded (20)

Python ppt