Download to read offline
![a
m
p
l
e
v
a
r
1
=
'
P
y
t
h
o
n'
p
ri
n
t
(
v
a
r
1
*
3
)
# PythonPythonPython
Slicing [ ]:The slice operator prints the character at a given index.
#
examp
le
var1
=
'Pytho
n'
print (var1[2]) # t
Range Slicing [x:y]
It prints the characters present in the given range.
#
example
var1 =
'Python'
print
(var1[2:
5]) # tho
Membership (in):This operator returns ‘True’ value if the character is present in the given
String.](https://image.slidesharecdn.com/aintroductionbookofpythonforbeginners-250613145832-83400372/85/A-Introduction-Book-of-python-For-Beginners-docx-9-320.jpg)
![EXAMPLE1:
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
EXAMPLE2:
var1 = 'Hello World!'
print "Updated String :- ", var1[:6] +
'Python'
When the above code is executed, it produces the following
result − Updated String :- Hello Python
5. Comments:
Comments are of two types .
Single-line comments
Multi line Comments
Single-line comments are created simply by beginning a line with the hash
(#) character, and they are automatically terminated by the end of line. For
Ex: #This would be a comment in Python
Multi Line Comments that span multiple lines and are created by adding a
delimiter (“””) on each end of the comment For Ex:
"""
This would be a multiline comment in Python that spans several lines and describes
your code, your day, or anything you want it to """
Chapter-3 Functions
What is a Function in Python?
A Function in Python is used to utilize the code in more than one place in a
program. It is also called method or procedures. Python provides you many
inbuilt functions like print(), but it also gives freedom to create your own
functions.
Functions:
A function is a named sequence of statements that performs a computation.
How to define and call a function in Python
Function in Python is defined by the "def " statement followed by the
function name and parentheses ( () ) Example:](https://image.slidesharecdn.com/aintroductionbookofpythonforbeginners-250613145832-83400372/85/A-Introduction-Book-of-python-For-Beginners-docx-15-320.jpg)
![Arguments in Functions
The argument is a value that is passed to the function when it's called.In other words on
the calling side, it is an argument and on the function side it is a parameter. Let see how
Python Args works - Step 1) Arguments are declared in the function definition. While
calling the function, you can pass the values for that args as shown below
Step 2) To declare a default value of an argument, assign it a value at function definition.
Example: x has no default values. Default values of y=0. When we supply only
one argument while calling multiply function, Python assigns the supplied value
to x while keeping the value of y=0. Hence the multiply of x*y=0
Step 3) This time we will change the value to y=2 instead of the default value y=0,
and it will return the output as (4x2)=8.
Step 4) You can also change the order in which the arguments can be passed in
Python. Here we have reversed the order of the value x and y to x=4 and y=2.
Step 5) Multiple Arguments can also be passed as an array. Here in the example
we call the multiple args (1,2,3,4,5) by calling the (*args) function.
Example: We declared multiple args as number (1,2,3,4,5) when we call the
(*args) function; it prints out the output as (1,2,3,4,5)
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, but it is optional
Syntax:
def functionname( parameters ):
functio
n_suite
return
[expres
sion]
Creati
ng a
Functi
on
In Python a function is defined using the
def keyword: Example def
my_function():
print("Hello from a function")
Calling a Function
To call a function, use the function name followed
by parenthesis: Example def my_function():
print("Hello from a function")
my_function() #calling function](https://image.slidesharecdn.com/aintroductionbookofpythonforbeginners-250613145832-83400372/85/A-Introduction-Book-of-python-For-Beginners-docx-17-320.jpg)
![4 inf - Returns the infinite
5 nan - Not a number type.
Numbers and Numeric Representation
These functions are used to represent numbers in different forms. The methods are
like below −
Sr.No. Function & Description
1 ceil(x)
Return the Ceiling value. It is the smallest integer, greater or equal to the number
x.
3 fabs(x)
Returns the absolute value of x.
4 factorial(x)
Returns factorial of x. where x ≥ 0
5 floor(x)
Return the Floor value. It is the largest integer, less or equal to the number x.
6 fsum(iterable)
Find sum of the elements in an iterable object
7 gcd(x, y)
Returns the Greatest Common Divisor of x and y
8 isfinite(x)
Checks whether x is neither an infinity nor nan.
9 isinf(x)
Checks whether x is infinity
10 isnan(x)
Checks whether x is not a number.
11 remainder(x, y)
Find remainder after dividing x by y
Example program:
import math
print(math.ceil(23.56) )
my_list = [12, 4.25, 89, 3.02, -65.23, -7.2, 6.3]
print(math.fsum(my_list))
print('The GCD of 24 and 56 : ' +
str(math.gcd(24, 56))) x = float('nan') if
math.isnan(x):
print('It is not a number')](https://image.slidesharecdn.com/aintroductionbookofpythonforbeginners-250613145832-83400372/85/A-Introduction-Book-of-python-For-Beginners-docx-19-320.jpg)
![x =
float('i
nf')
y = 45
if
math.i
sinf(x)
:
print('
It is
Infinit
y')
print(math.isfinite(x)) #x is not a finite number
print(math.isfinite(y)) #y is a finite number
O/P:
24
42.13999999999999
The GCD of 24 and 56 : 8
It is not a number
It is Infinity
False
True
>>>
Power and Logarithmic Functions
These functions are used to calculate different power related and logarithmic related
tasks.
Sr.No. Function & Description
1 pow(x, y)
Return the x to the power y value.
2 sqrt(x)
Finds the square root of x
3 exp(x)
Finds xe, where e = 2.718281
4 log(x[, base])
Returns the Log of x, where base is given. The default base is e
5 log2(x)
Returns the Log of x, where base is 2
6 log10(x)
Returns the Log of x, where base is 10
Example
Code
import
math](https://image.slidesharecdn.com/aintroductionbookofpythonforbeginners-250613145832-83400372/85/A-Introduction-Book-of-python-For-Beginners-docx-20-320.jpg)
![a
m
p
l
e
v
a
r
1
=
'
P
y
t
h
o
n'
p
ri
n
t
(
v
a
r
1
*
3
)
# PythonPythonPython
Slicing [ ]:The slice operator prints the character at a given index.
#
examp
le
var1
=
'Pytho
n'
print (var1[2]) # t
Range Slicing [x:y]
It prints the characters present in the given range.
#
example
var1 =
'Python'
print
(var1[2:
5]) # tho
Membership (in):This operator returns ‘True’ value if the character is present in the given
String.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-9-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![EXAMPLE1:
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
EXAMPLE2:
var1 = 'Hello World!'
print "Updated String :- ", var1[:6] +
'Python'
When the above code is executed, it produces the following
result − Updated String :- Hello Python
5. Comments:
Comments are of two types .
Single-line comments
Multi line Comments
Single-line comments are created simply by beginning a line with the hash
(#) character, and they are automatically terminated by the end of line. For
Ex: #This would be a comment in Python
Multi Line Comments that span multiple lines and are created by adding a
delimiter (“””) on each end of the comment For Ex:
"""
This would be a multiline comment in Python that spans several lines and describes
your code, your day, or anything you want it to """
Chapter-3 Functions
What is a Function in Python?
A Function in Python is used to utilize the code in more than one place in a
program. It is also called method or procedures. Python provides you many
inbuilt functions like print(), but it also gives freedom to create your own
functions.
Functions:
A function is a named sequence of statements that performs a computation.
How to define and call a function in Python
Function in Python is defined by the "def " statement followed by the
function name and parentheses ( () ) Example:](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-15-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Arguments in Functions
The argument is a value that is passed to the function when it's called.In other words on
the calling side, it is an argument and on the function side it is a parameter. Let see how
Python Args works - Step 1) Arguments are declared in the function definition. While
calling the function, you can pass the values for that args as shown below
Step 2) To declare a default value of an argument, assign it a value at function definition.
Example: x has no default values. Default values of y=0. When we supply only
one argument while calling multiply function, Python assigns the supplied value
to x while keeping the value of y=0. Hence the multiply of x*y=0
Step 3) This time we will change the value to y=2 instead of the default value y=0,
and it will return the output as (4x2)=8.
Step 4) You can also change the order in which the arguments can be passed in
Python. Here we have reversed the order of the value x and y to x=4 and y=2.
Step 5) Multiple Arguments can also be passed as an array. Here in the example
we call the multiple args (1,2,3,4,5) by calling the (*args) function.
Example: We declared multiple args as number (1,2,3,4,5) when we call the
(*args) function; it prints out the output as (1,2,3,4,5)
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, but it is optional
Syntax:
def functionname( parameters ):
functio
n_suite
return
[expres
sion]
Creati
ng a
Functi
on
In Python a function is defined using the
def keyword: Example def
my_function():
print("Hello from a function")
Calling a Function
To call a function, use the function name followed
by parenthesis: Example def my_function():
print("Hello from a function")
my_function() #calling function](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-17-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![4 inf - Returns the infinite
5 nan - Not a number type.
Numbers and Numeric Representation
These functions are used to represent numbers in different forms. The methods are
like below −
Sr.No. Function & Description
1 ceil(x)
Return the Ceiling value. It is the smallest integer, greater or equal to the number
x.
3 fabs(x)
Returns the absolute value of x.
4 factorial(x)
Returns factorial of x. where x ≥ 0
5 floor(x)
Return the Floor value. It is the largest integer, less or equal to the number x.
6 fsum(iterable)
Find sum of the elements in an iterable object
7 gcd(x, y)
Returns the Greatest Common Divisor of x and y
8 isfinite(x)
Checks whether x is neither an infinity nor nan.
9 isinf(x)
Checks whether x is infinity
10 isnan(x)
Checks whether x is not a number.
11 remainder(x, y)
Find remainder after dividing x by y
Example program:
import math
print(math.ceil(23.56) )
my_list = [12, 4.25, 89, 3.02, -65.23, -7.2, 6.3]
print(math.fsum(my_list))
print('The GCD of 24 and 56 : ' +
str(math.gcd(24, 56))) x = float('nan') if
math.isnan(x):
print('It is not a number')](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-19-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![x =
float('i
nf')
y = 45
if
math.i
sinf(x)
:
print('
It is
Infinit
y')
print(math.isfinite(x)) #x is not a finite number
print(math.isfinite(y)) #y is a finite number
O/P:
24
42.13999999999999
The GCD of 24 and 56 : 8
It is not a number
It is Infinity
False
True
>>>
Power and Logarithmic Functions
These functions are used to calculate different power related and logarithmic related
tasks.
Sr.No. Function & Description
1 pow(x, y)
Return the x to the power y value.
2 sqrt(x)
Finds the square root of x
3 exp(x)
Finds xe, where e = 2.718281
4 log(x[, base])
Returns the Log of x, where base is given. The default base is e
5 log2(x)
Returns the Log of x, where base is 2
6 log10(x)
Returns the Log of x, where base is 10
Example
Code
import
math](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-20-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![The value of cos(pi): -1.0
The value of tan(90 degree): 1.633123935319537e+16
The angle of sin(0.8660254037844386): 59.99999999999999
3. Composition:
So far, we have looked at the elements of a program—variables, expressions, and
statements—in isolation, without talking about how to combine(Composition)
them.For example, the argument of a function can be any kind of expression, including
arithmetic operators: x = math.sin(degrees / 360.0 * 2 * math.pi) And even function
calls:
x = math.exp(math.log(x+1))
4. Adding new functions:
Pass by reference vs value: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. For example −
#!/usr/bin/python
# Function
definition is here
def changeme(
mylist ):
"This changes a passed list into this
function" mylist.append([1,2,3,4]);
print "Values inside the function: ",
mylist return
# Now you can call changeme function
mylist =
[10,20,30];
changeme( mylist
);
print "Values outside the function: ",
mylist
Here, we are maintaining reference of the passed object and appending
values in the same object. So, this would produce the following result −
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]
Scope of Variables:All variables in a program may not be accessible at all
locations in that program. This depends on where you have declared a
variable.The scope of a variable determines the portion of the program where
you can access a particular identifier. There are two basic scopes of variables
in Python −
Global
variables
Local
variables
Global vs. Local variables:Variables that are defined inside a function body have a
local scope, and those defined outside have a global scope.This means that local
variables can be accessed only inside the function in which they are declared,](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-22-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![whereas global variables can be accessed throughout the program body by all
functions. When you call a function, the variables declared inside it are brought into
scope. Following is a simple example −
#!/usr/bin/python
total = 0; # This is
global variable. #
Function definition is
here def sum( arg1,
arg2 ):
# Add both the parameters and
return them." total = arg1 + arg2; #
Here total is local variable. print
"Inside the function local total : ",
total return total;
# Now you can call sum function
sum( 10, 20 );
print "Outside the function global
total : ", total
When the above code is executed, it produces the following result −
Inside the function local total : 30
Outside the function global total : 0
The import Statement
You can use any Python source file as a module by executing an import statement in
some other Python source file. The import has the following syntax −
import module1[, module2[,... moduleN]
When the interpreter encounters an import statement, it imports the module if
the module is present in the search path. A search path is a list of directories that
the interpreter searches before importing a module. For example, to import the
module support.py, you need to put the following command at the top of the
script − #!/usr/bin/python
# Import module
support import
support
# Now you can call defined function that module as follows
support.print_func("Zara")
When the above code is executed, it produces the following
result − Hello : Zara
5. Flow of Execution
The order in which statements are executed is called the
flow of execution Execution always begins at the first
statement of the program.
Statements are executed one at a time, in order, from top to
bottom.
Function definitions do not alter the flow of execution of the program, but
remember that statements inside the function are not executed until the function
is called.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-23-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![# Now you can call printinfo
function printinfo( age=50,
name="miki" ) printinfo(
name="miki" )
When the above code is executed, it produces the following
result − Name: miki
Age 50
Name: miki
Age 35
Variable-length arguments
You may need to process a function for more arguments than you specified
while defining the function. These arguments are called variable-length
arguments and are not named in the function definition, unlike required and
default arguments.Syntax for a function with non- keyword variable arguments
is this − def functionname([formal_args,] *var_args_tuple ):
"functi
on_doc
string"
functio
n_suite
return
[expres
sion]
An asterisk (*) is placed before the variable name that holds the values of all
nonkeyword variable arguments. This tuple remains empty if no additional
arguments are specified during the function call. Following is a simple example
−
#!/usr/bin/python
# Function
definition is here
def printinfo(
arg1, *vartuple ):
"This prints a variable passed
arguments"
print
"Out
put
is: "
print
arg1
for
var in
vartu
ple:
print
var
retur
n;
# Now you can call printinfo function](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-26-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![printinfo(
10 )
printinfo(
70, 60, 50
)
When the above code is executed, it produces the following
result − Output is:
10
Output is:
70
60
50
Example
def
my_functio
n(fname):
print(fname + " krishna") my_function("Rama") my_function("Siva")
my_function("Hari") o/p: Ramakrishna Sivakrishna
Harikrishna.
Parameters Vs Arguments
A parameter is the variable listed inside the parentheses in the function
definition. An argument is the value that is sent to the function when it
is called.
Number of Arguments
A function must be called with the correct number of arguments. Meaning that if
your function expects 2 arguments, you have to call the function with 2
arguments, not more, and not less.
Example
This function expects 2 arguments, and gets 2 arguments:
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Srinu", "vasulu")
Arbitrary Arguments( *args)
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:
Example
If the number of arguments is unknown, add a * before the
parameter name: def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("raju", "somu", "vijay) O/p: vijay
Default Parameter Value:
When we call the function without argument, it uses the default value:
Example
def my_function(country = "Norway"): #default value is Norway
print("I am from " + country) my_function("Sweden")](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-27-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![my_function("India") my_function() #o/p:
Norway my_function("Brazil")
Passing a List as an Argument:
You can send any data types of argument to a function (string, number, list,
dictionary etc.) E.g. if you send a List as an argument, it will still be a List
when it reaches the function: Example def my_function(food):
for x in
food:
prin
t(x)
fruits =
my_function(fruits)
Return Values:
To return a value, we use the return statement:
Example def my_function(x):
["apple", "banana", "cherry"]
return 5 * x
print(my_function(3)) # o/p: 15
print(my_function(5)) # o/p: 25
print(my_function(9)) # o/p: 45
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. Example def myfunction(): pass
7. Variables and Parameters Are Local
When you create a variable inside a function, it is local, which means that
it only exists inside the function.
For example:
def cat_twice(part1, part2):
cat = part1 + part2
print_twice(cat)
line1 =
'Bing
tiddle '
line2 =
'tiddle
bang.'
cat_twice(
line1,
line2)
print(cat)
#error
here cat_twice terminates, the variable cat is destroyed. If we try to
print it, we get an exception:
>>> NameError: name 'cat' is not defined](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-28-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![square roots).Some kinds of knowledge are not algorithmic. For example,
learning dates from history or your multiplication tables involves
memorization of specific solutions.But the techniques you learned for
addition with carrying, subtraction with borrowing, and long division are
all algorithms. Or if you are an avid Sudoku puzzle solver, you might
have some specific set of steps that you alwaysfollow.
One of the characteristics of algorithms is that they do not require any
intelligence to carry out. They are mechanical processes in which each
step follows from the last according to a simple set of rules. And they’re
designed to solve a general class or category of problems, not just a single
problem.Understanding that hard problems can be solved by step-by-step
algorithmic processes (and having technology to execute these algorithms
for us) is one of the major breakthroughs that has had enormous benefits.
So while the execution of the algorithm may be boring and may require
no intelligence, algorithmic or computational thinking — i.e. using
algorithms and automation as the basis for approaching problems — is
rapidly transforming our society. Some claim that this shift towards
algorithmic thinking and processes is going to have even more impact on
our society than the invention of the printing press. And the process of
designing algorithms is interesting, intellectually challenging, and a
central part of what we call programming.
Some of the things that people do naturally, without difficulty or
conscious thought, are the hardest to express algorithmically.
Understanding natural language is a good example. We all do it, but so far
no one has been able to explain how we do it, at least not in the form of
astep- by-step mechanical algorithm.
Chapter-2
S
trings A string is a sequence
A string is a sequence of characters. You can access the characters one
at a time with the bracket operator: >>> fruit = 'banana'
>>> letter = fruit[1]
The second statement selects character number 1 from fruit and assigns
it to letter.The expression in brackets is called an index. The index
indicates which character in the sequence you want len. len is a built-in
function that returns the number of characters in a string: >>> fruit =
'banana'
>>>
l
e
n
(
f
r
u
i
t
)
6](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-54-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![To get the last letter of a string, you might be tempted to try something
like this: >>> length = len(fruit)
>>> last = fruit[length]
IndexError: string index out of range
The reason for the IndexError is that there is no letter in 'banana' with the index 6.
Since we started counting at zero, the six letters are numbered 0 to 5. To get the
last character, you have to subtract 1 from length:
>>> last = fruit[length-1]
>
>
>
l
a
s
t
'
a
'
Or you can use negative indices, which count backward from the end of the string.
The expression fruit[-1] yields the last letter, fruit[-2] yields the second to last,and
so on.
2. Traversal With A For Loop:
Traversal : visiting each character in the string is called string
traversal. We can do string traversing with either while or for
statements. For ex: for letter in 'Python': # First Example print
'Current
Letter
:',
letter
out
put: P
Y
T
H
O
n
3. String Slicing In Python:
Python slicing is about obtaining a sub-string from the given string by slicing it
respectively from start to end.
Python slicing can be done in two ways.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-55-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![slice()
Constructor
E
xt
en
di
ng
In
de
xi
ng
sli
ce
()
Constructor
The slice() constructor creates a slice object representing the set of indices
specified by range(start, stop, step).
Syntax: slice(stop) slice(start, stop, step) Parameters: start: Starting index
where the slicing of object starts. stop: Ending index
where the slicing of object stops. step: It is an optional argument that
determines the increment between each index for slicing. Return Type: Returns
a sliced object containing elements in the given range only. Example
# Python program to
demonstrate # string
slicing
# String slicing String ='ASTRING'
# Using
slice
constructor
s1
=slice(3)
s2 =
slice(1, 5,
2) s3 =
slice(-1, -
12, -2)
print("Stri
ng
slicing")
print(Strin
g[s1])
print(Strin
g[s2])
print(Strin
g[s3])
Output:
String
slicing
AST
S](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-56-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![R
G
I
T
A
Extending indexing
In Python, indexing syntax can be used as a substitute for the slice object.
This is an easy and convenient way to slice a string both syntax wise and
execution wise. Syntax string[start:end:step] start, end and step have the
same mechanism as slice() constructor.
Example
# Python program to
demonstratestring slicing
String ='ASTRING' #
Using indexing sequence
print(String[:3])
print(String[1:5:2])
print(String[-1:-12:-2]) #
Prints string in reverse
print("nReverse String")
print(String[::-1]) Output:
A
S
T
S
R
G
I
T
A
Reverse
String
GNIRT
SA
4. Strings Are Immutable :
In python, the string data types are immutable. Which means a string
value cannot be updated. We can verify this by trying to update a part of
the string which will led us to an error. # Can not reassign t= "Tutorialsp
oint" print type(t) t[0] = "M"
When we run the above program, we get the following output −
t[0] = "M"
TypeError: 'str' object does not support item assignment
5. Searching: Traversing in sequence and returning a character when we find what we are
looking
for—is called a search.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-57-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![For ex:
def
find(wo
rd,
letter):
index = 0
while index
<
len(word):
if
word[index
] == letter:
return
index
index =
ind
ex
+
1
ret
ur
n -
1
String functions for
searching: find():
The find() method finds the first occurrence of the specified value. The find()
method returns -1 if the value is not found.
Syntax
string.find(value,
start, end)
Parameter Values
Parameter Description
Value Required. The value to search for
Start Optional. Where to start the search.
Default is 0
End Optional. Where to end the search.
Default is to the end of the string
More Examples
Example
Where in the text is the first occurrence of the letter "e"?:
txt = "Hello, welcome to my world."
x = txt.find("e")
p
r
i](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-58-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![previous = word[0]
f
or
c
in
w
or
d:
if
c
<
pr
e
vi
o
us
:
re
tu
rn
F
al
se
previous = c
return True
An alternative is to use recursion:
def is_abecedarian(word):
if
len(word
) <= 1:
return
True
if word[0] > word[1]:
return False return
is_abecedarian(word[1:])
Another option is to use a
while loop:
def
is_abecedari
an(word): i
= 0 while i
<
len(word)-
1: if
word[i+1] <
word[i]:
return False
i = i+1
return True
The loop starts at i=0 and ends when i=len(word)-1. Each time through the loop, it
compares the ith character (which you can think of as the current character) to the
i+1th character (which you can think of as the next).](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-66-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![If the next character is less than (alphabetically before) the current one, then we have
discovered a break in the abecedarian trend, and we return False.
If we get to the end of the loop without finding a fault, then the word passes the test.
To convince yourself that the loop ends correctly, consider an example like 'flossy'.
The length of the word is 6, so the last time the loop runs is when i is 4, which is the
index of the second- to-last character. On the last iteration, it compares the second-
to-last character to the last, which is what we want.
Here is a version of is_palindrome (see Exercise 6.6) that uses two indices; one starts at
the beginning and goes up; the other starts at the end and goes down.
def is_palindrome(word):
i = 0
j = len(word)-1
while i<j:
if word[i] !=
word[j]:
return False
i
=
i
+
1
j
=
j
-
1
True
Or, if you noticed that this is an instance of a previously-solved problem, you might
have written: def is_palindrome(word):
return is_reverse(word,
word)
Chapter-4
LIST
Python offers a range of compound datatypes often referred to as sequences. List is one of the
most frequently used and very versatile datatype used in Python.
How to create a list?](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-67-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![In Python programming, a list is created by placing all the items (elements) inside a
square bracket [ ], separated by commas.It can have any number of items and they may
be of different types (integer, float, string etc.).
#
empt
y list
my_
list =
[] #
list
of
integ
ers
my_
list =
[1,
2, 3]
# list with mixed
datatypes my_list =
[1, "Hello", 3.4]
Also, a list can even have another list as an item. This is called nested
list. # nested list
my_list = ["mouse", [8, 4, 6], ['a']]
How to access elements from a list?
There are various ways in which we can access the elements
of a list. List Index
We can use the index operator [] to access an item in a list. Index starts from 0. So,
a list having 5 elements will have index from 0 to 4.
Trying to access an element other that this will raise an IndexError. The index must be an
integer.
We can't use float or other types, this will result into TypeError.
Nested list are accessed using nested indexing.
my_list = ['p','r','o','b','e']
# Output: p print(my_list[0])
# Output: o print(my_list[2])
# Output: e
print(my_list[4])
# Error! Only integer can be used for indexing
# my_list[4.0]
# Nested List n_list =
["Happy", [2,0,1,5]]
# Nested indexing
# Output: a print(n_list[0]
[1])
# Output: 5 print(n_list[1]
[3])](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-68-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Negative indexing
Python allows negative indexing for its sequences. The index of -1 refers to the last
item, -2 to the second last item and so on.
my_list =
['p','r','o','b','e']
# Output: e
print(my_list[-
1])
# Output: p
print(my_list[-
5])
4. List Slices:
How to slice lists in Python?
We can access a range of items in a list by using the slicing operator (colon).
my_list =
['p','r','o','g','r','a
','m','i','z']
# elements 3rd
to 5th
print(my_list[2
:5])
# elements
beginning to
4th
print(my_list[:-
5])
# elements 6th
to end
print(my_list[5
:])
# elements
beginning to
end
print(my_list[:]
)
Slicing can be best visualized by considering the index to be between the elements
as shown below. So if we want to access a range, we need two index that will slice
that portion from the list.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-69-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![1.List is a sequence:
The most basic data structure in Python is the sequence. Each element of a sequence
is assigned a number - its position or index. The first index is zero, the second index
is one, and so forth. Python has six built-in types of sequences, but the most common
ones are lists and tuples, which we would see in this tutorial.
There are certain things you can do with all sequence types. These operations
include indexing, slicing, adding, multiplying, and checking for membership. In
addition, Python has built-in functions for finding the length of a sequence and for
finding its largest and smallest elements.
Python Lists
The list is a most versatile datatype available in Python which can be written as a list
of comma- separated values (items) between square brackets. Important thing about
a list is that items in a list need not be of the same type.
Creating a list is as simple as putting different comma-separated values between
square brackets. For example − list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2,
3, 4, 5 ];
list3 = ["a",
"b", "c",
"d"]
Similar to string indices, list indices start at 0, and lists can be sliced, concatenated and so on.
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] When
the above code
is executed, it
produces the
following result
− list1[0]:
physics
list2[1:5]: [2, 3,
4, 5]](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-70-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![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]
Note − append() method is discussed in subsequent
section. When the above code is executed, it produces
the following result −
Value available at index 2 :1997
New value available at index 2 :2001
Lists are Mutable
Unlike strings, lists are mutable. This means we can change an item in a
list by accessing it directly as part of the assignment statement. Using the
indexing operator (square brackets) on the left side of an assignment, we
can update one of the list items. fruit = ["banana", "apple", "cherry"]
print(fruit)
fruit[0] =
"pear"
fruit[-1] =
"orange"
print
(fruit
)
outp
ut:
['banana', 'apple', 'cherry']
['pear', 'apple', 'orange']
An assignment to an element of a list is called item assignment. Item
assignment does not work for strings. Recall that strings are immutable.
Here is the same example in codelens so that you can step through the
statements and see the changes to the list elements.
By combining assignment with the slice operator we can update
several elements at once. alist = ['a', 'b', 'c', 'd', 'e', 'f']
alist[1:3] = ['x',
'y'] print(alist)
output:
['a', 'x', 'y', 'd', 'e', 'f']
We can also remove elements from a list by assigning the empty list
to them. alist = ['a', 'b', 'c', 'd', 'e', 'f']
alist[1:3] = []](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-71-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![print(alist)
output:
['a', 'd', 'e', 'f']
6.map(), filter(), and reduce() in Python
Introduction
The map(), filter() and reduce() functions bring a bit of functional
programming to
Python. All three of these are convenience functions that can be replaced
with List Comprehensions or loops, but provide a more elegant and short-
hand approach to some problems.
Before continuing, we'll go over a few things you should be familiar with
before reading about the aforementioned methods:
What is an anonymous function/method or lambda?
An anonymous method is a method without a name, i.e. not bound to an
identifier like when we define a method using def method:.
Note: Though most people use the terms "anonymous function" and
"lambda function" interchangeably - they're not the same. This mistake
happens because in most programming languages lambdas are
anonymous and all anonymous functions are lambdas. This is also the
case in Python. Thus, we won't go into this distinction further in this
article.
What is the syntax of a lambda function (or lambda
operator)? lambda arguments: expression
Think of lambdas as one-line methods without a name. They work
practically the same as any other method in Python, for example:
def
add(x,y):
return x + y
Can be
translated to:
lambda x, y: x
+ y
Lambdas differ from normal Python methods because they can have only
one expression, can't contain any statements and their return type is a
function object. So the line of code above doesn't exactly return the value
x + y but the function that calculates x + y.
Why are lambdas relevant to map(), filter() and
reduce()?
All three of these methods expect a function object as the first argument.
This function object can be a pre-defined method with a name (like def
add(x,y)).Though, more often than not, functions passed to map(), filter(),
and reduce() are the ones you'd use only once, so there's often no point in
defining a referenceable function.
To avoid defining a new function for your different map()/filter()/reduce()
needs - a more elegant solution would be to use a short, disposable,
anonymous function that you will only use once and never again - a
lambda.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-72-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![The map() Function
The map() function iterates through all items in the given iterable and
executes the function we passed as an argument on each of them.
The syntax is:
map(function, iterable(s))
We can pass as many iterable objects as we want after passing the
function we want to use:
# Without
using
lambda
s def
starts_
with_A
(s):
return s[0] == "A"
fruit = ["Apple", "Banana", "Pear", "Apricot",
"Orange
"]
map_object = map(starts_with_A,
fruit)
print(list(map_o
bject)
)
This code will result in:
[True, False, False, True, False]
As we can see, we ended up with a new list where the function
starts_with_A() was evaluated for each of the elements in the list fruit.
The results of this function were added to the list sequentially.
A prettier way to do this exact same thing is by using lambdas:
fruit = ["Apple", "Banana", "Pear", "Apricot", "Orange"]
map_object = map(lambda s: s[0] == "A",
fruit)
print(list(map_o
b
ject))
We get the same output:
[True, False, False, True, False]
Note: You may have noticed that we've cast map_object to a list to print
each element's value. We did this because calling print() on a list will print
the actual values of the elements. Calling print() on map_object would
print the memory addresses of the values instead.
The map() function returns the map_object type, which is an iterable and
we could have printed the results like this as well:
for value in
map_object:
print(value
)
If you'd like the map() function to return a list instead, you can just cast it
when calling the function: result_list = list(map(lambda s: s[0] == "A",
fruit)) The filter() Function](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-73-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Similar to map(), filter() takes a function object and an iterable and
creates a new list. As the name suggests, filter() forms a new list that
contains only elements that satisfy a certain condition, i.e. the function
we passed returns True.
The syntax is:
filter(function, iterable(s))
Using the previous example, we can see that the new list will only contain
elements for which the starts_with_A() function returns True:
# Without
using
lambda
s def
starts_
with_A
(s):
return
s[0] ==
"A"
fruit = ["Apple", "Banana", "Pear", "Apricot",
"Orange
"]
filter_object = filter(starts_with_A,
fruit)
print(list(filter_object))
Running this code will result in a shorter list:
['Apple', 'Apricot']
Or, rewritten using a lambda:
fruit = ["Apple", "Banana", "Pear", "Apricot",
filter_object = filter(lambda s: s[0] ==
print(list(filt
er_object))
Printing
gives us the
same output:
['Apple',
'Apricot']
The reduce() Function
reduce() works differently than map() and filter(). It does not return a new
list based on the function and iterable we've passed. Instead, it returns a
single value.Also, in Python reduce() isn't a built-in function anymore,
and it can be found in the functools module.
The syntax is:
reduce(function,
sequence[, initial])
reduce() works by calling the function we passed for the first two items in
the sequence. The result returned by the function is used in another call to
function alongside with the next (third in this case), element.
"Orange
"]
"A",
fruit)](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-74-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![This process repeats until we've gone through all the elements in the
sequence.
The optional argument initial is used, when present, at the beginning of
this "loop" with the first element in the first call to function. In a way, the
initial element is the 0th element, before the first one, when provided.
reduce() is a bit harder to understand than map() and filter(), so let's look
at a step by step example:
We start with a list [2, 4, 7, 3] and pass the add(x, y) function to reduce()
alongside this list, without an initial value calls add(2, 4), and
add() returns 6
calls add(6, 7) (result of the previous call to add() and the next element in the
list as parameters), and
add() returns 13 reduce() calls
add(13, 3), and add() returns 16
Since no more elements are left in the sequence, reduce() returns 16
The only difference, if we had given an initial value would have been an additional step -
1.5. where reduce() would call add(initial, 2) and use that return
value in step 2. Let's go ahead and use the reduce() function:
from functools import reduce
def
add(x,
y):
return
x + y
list = [2, 4, 7, 3]
print(reduce(add, list))
Running this code would yield: 16
Again, this could be written using lambdas:
from functools import reduce
list = [2, 4, 7, 3]
print(reduce(lambda x, y: x + y, list))
print("With an initial value: " + str(reduce(lambda x,
y: x + y, list, 10)))
And the code would result in:16
With an initial value: 26
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,
reduce()
reduce()](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-75-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![2000] After deleting value at index 2 : ['physics',
'chemistry', 2000]
Note − remove() method is discussed in subsequent section.
4. Basic List Operations
Lists respond to the + and * operators much like strings; they mean concatenation
and repetition here too, except that the result is a new list, not a string.
In fact, lists respond to all of the general sequence operations we used on
strings in the prior chapter.
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
List Operations:
How to change or add elements to a list?
List are mutable, meaning, their elements can be changed unlike string or tuple.
We can use assignment operator (=) to change an item or a range of items.
# mistake values
odd = [2, 4, 6, 8]
# change the 1st item
odd[0] = 1
# Output: [1, 4, 6, 8]
print(odd)
# change 2nd to 4th items
odd[1:4] = [3, 5, 7]
# Output: [1, 3, 5, 7]
print(odd)
We can add one item to a list using append() method or
add several items using extend()method. odd = [1, 3, 5]
odd.ap
pend(7
) #
Output
: [1, 3,
5, 7]
print(o
dd)](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-76-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![odd.ex
tend([9
,
11, 13])
# Output: [1, 3, 5, 7, 9, 11, 13]
print(odd)
We can also use + operator to combine two lists. This is also called
concatenation. The * operator repeats a list for the given number of
times.
odd = [1, 3, 5]
# Output: [1, 3, 5, 9, 7, 5] print(odd + [9, 7, 5])
#Output: ["re", "re", "re"] print(["re"] * 3)
Furthermore, we can insert one item at a desired location by using the method insert() or
insert multiple items by squeezing it into an empty slice of a list.
odd = [1, 9]
odd.insert(1,3)
# Output: [1, 3,
9] print(odd)
odd[2:2] = [5,
7]
# Output: [1, 3,
5, 7, 9]
print(odd)
How to delete or remove elements from a list?
We can delete one or more items from a list using the keyword del. It can even delete
the list entirely.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-77-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![my_list = ['p','r','o','b','l','e','m']
# delete one item
del my_list[2]
# Output: ['p', 'r', 'b', 'l', 'e', 'm']
print(my_list)
# delete multiple items
del my_list[1:5]
# Output: ['p', 'm']
print(my_list)
# delete entire list
del my_list
# Error: List not defined
print(my_list)
We can use remove() method to remove the given item or pop() method to remove
an item at the given index. The pop() method removes and returns the last item if
index is not provided. This helps us implement lists as stacks (first in, last out data
structure).
We can also use the clear() method to empty a list.
my_list = ['p','r','o','b','l','e','m']
my_list.remove('p')
# Output: ['r', 'o', 'b', 'l', 'e', 'm']
print(my_list)
# Output: 'o'
print(my_list.pop(1))
# Output: ['r', 'b', 'l', 'e', 'm']
print(my_list)
# Output: 'm'
print(my_list.pop())
# Output: ['r', 'b', 'l', 'e']
print(my_list)
my_list.clear()
# Output: [] print(my_list)
Finally, we can also delete items in a list by assigning an empty list to a slice of
elements.
>>> my_list =
['p','r','o','b','l','e
','m']](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-78-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![>>>
my_list[2:3] =
[]
>>> my_list
['p', 'r', 'b', 'l',
'e', 'm']
>>>
my_list[2:5] =
[]
>>> my_list
['p', 'r', 'm']
5.Indexing, Slicing, and Matrixes
Because lists are sequences, indexing and slicing work the same way for lists as they do for
strings.
Assuming following input − L = ['spam', 'Spam', 'SPAM!']
Python Expression Results Description
L[2] SPAM! Offsets start at zero
L[-2] Spam Negative: count from the right
L[1:] ['Spam', 'SPAM!'] Slicing fetches sections
6.Python List Methods
Methods that are available with list object in Python programming are tabulated
below.They are accessed as list.method(). Some of the methods have already been used
above.
Python List Methods
append() - Add an element to the end of the list
extend() - Add all elements of a list to the another list
insert() - Insert an item at the defined index
remove() - Removes an item from the list
pop() - Removes and returns an element at the given index
clear() - Removes all items from the list
index() - Returns the index of the first matched item
count() - Returns the count of number of items passed as an argument
sort() - Sort items in a list in ascending order](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-79-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![reverse() - Reverse the order of items in the list
copy() - Returns a shallow copy of the list
Some examples of Python list methods:
my_list = [3, 8,
1, 6, 0, 8, 4]
# Output: 1
print(my_list.in
dex(8))
# Output: 2
print(my_list.c
ount(8))
my_list.sort()
# Output: [0, 1,
3, 4, 6, 8, 8]
print(my_list)
my_list.reverse
()
# Output: [8, 8,
6, 4, 3, 1, 0]
print(my_list)
Built-in Functions with List
Built-in functions like all(), any(), enumerate(), len(), max(), min(), list(), sorted() etc.
are commonly used with list to perform different tasks.
Built-in Functions with List
Function Description
all() Return True if all elements of the list are true (or if the list is empty).
any() Return True if any element of the list is true. If the list is empty, return False.
enumerate()
Return an enumerate object. It contains the index and value of all the items of
list as a tuple.
len() Return the length (the number of items) in the list.
list() Convert an iterable (tuple, string, set, dictionary) to a list.
max() Return the largest item in the list.
min() Return the smallest item in the list](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-80-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![sorted() Return a new sorted list (does not sort the list itself).
sum() Return the sum of all elements in the list.
Strings in Python A string is a sequence of characters. It can be declared in
python by using double-quotes. Strings are immutable, i.e., they cannot be
changed. # Assigning string to a variable a = "This is a string" print (a)
Lists in Python Lists are one of the most powerful tools in python. They are just
like the arrays declared in other languages. But the most powerful thing is that list
need not be always homogeneous. A single list can contain strings, integers, as well
as objects. Lists can also be used for implementing stacks and queues. Lists are
mutable, i.e., they can be altered once declared.
# Declaring a list
L = [1, "a" , "string" , 1+2]
print L
L.a
ppe
nd(
6)
prin
t L
L.p
op()
prin
t L
prin
t
L[1
]
The output is :
[1, 'a', 'string', 3]
[1, 'a', 'string', 3, 6]
[1, 'a', 'string', 3] a
Objects and values
Objects are Python's abstraction for data. All data in a Python program is represented by objects
or by relations between objects. (In a sense, and in conformance to Von Neumann's model of a
``stored program computer,'' code is also represented by objects.)
Every object has an identity, a type and a value. An object's identity never changes once it has
been created; you may think of it as the object's address in memory. The `is' operator compares
the identity of two objects; the id() function returns an integer representing its identity (currently
implemented as its address). An object's type is also unchangeable. It determines the operations
that an object supports (e.g., ``does it have a length?'') and also defines the possible values for
objects of that type. The type() function returns an object's type (which is an object itself). The
value of some objects can change. Objects whose value can change are said to be mutable;
objects whose value is unchangeable once they are created are called immutable. (The value of an
immutable container object that contains a reference to a mutable object can change when the
latter's value is changed; however the container is still considered immutable, because the](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-81-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![collection of objects it contains cannot be changed. So, immutability is not strictly the same as
having an unchangeable value, it is more subtle.) An object's mutability is determined by its type;
for instance, numbers, strings and tuples are immutable, while dictionaries and lists are mutable.
Objects are never explicitly destroyed; however, when they become unreachable they may be
garbage- collected. An implementation is allowed to postpone garbage collection or omit it
altogether -- it is a matter of implementation quality how garbage collection is implemented, as
long as no objects are collected that are still reachable. (Implementation note: the current
implementation uses a reference-counting scheme which collects most objects as soon as they
become unreachable, but never collects garbage containing circular references.)
Note that the use of the implementation's tracing or debugging facilities may keep objects alive
that would normally be collectable. Also note that catching an exception with a try...except'
statement may keep objects alive.
Some objects contain references to ``external'' resources such as open files or windows. It is
understood that these resources are freed when the object is garbage-collected, but since garbage
collection is not guaranteed to happen, such objects also provide an explicit way to release the
external resource, usually a close() method. Programs are strongly recommended to explicitly
close such objects. The `try...finally' statement provides a convenient way to do this.
Some objects contain references to other objects; these are called containers. Examples of
containers are tuples, lists and dictionaries. The references are part of a container's value. In most
cases, when we talk about the value of a container, we imply the values, not the identities of the
contained objects; however, when we talk about the mutability of a container, only the identities
of the immediately contained objects are implied. So, if an immutable container (like a tuple)
contains a reference to a mutable object, its value changes if that mutable object is changed.
Aliasing
Since variables refer to objects, if we assign one variable to another, both variables refer to the
same object: a = [81, 82, 83]
b = a print(a is b)
o
u
t
p
u
t
:
T
r
u
e
In this case, the reference diagram looks like this:](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-82-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Because the same list has two different names, a and b, we say that it is aliased. Changes made
with one alias affect the other. In the codelens example below, you can see that a and b
refer to the same list after executing the assignment statement b = a.
1 a = [81, 82, 83]
2 b = [81, 82, 83]
4 print(a == b)
5 print(a is b)
7 b = a
8 print(a == b)
9 print(a is b)
b[0] = 5
12 print(a)
Using Lists as Parameters
Functions which take lists as arguments and change them during execution are called
modifiers and the changes they make are called side effects. Passing a list as an argument
actually passes a reference to the list, not a copy of the list. Since lists are mutable, changes made
to the elements referenced by the parameter change the same list that the argument is referencing.
For example, the function below takes a list as an argument and multiplies each element in the
list by 2: def doubleStuff(aList):
""" Overwrite each element in aList with double its
value. """ for position in range(len(aList)):
aList[position] = 2 * aList[position]
things = [2, 5, 9]
print(th
ings)
double
Stuff(th
ings)
print(th
ings)
output
:
[2,5,9]
[4, 10, 18]
The parameter aList and the variable things are aliases for the same object.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-83-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Since the list object is shared by two references, there is only one copy. If a function
modifies the elements of a list parameter, the caller sees the change since the change
is occurring to the original. This can be easily seen in codelens. Note that after the
call to doubleStuff, the formal parameter aList refers to the same object as the actual
parameter things. There is only one copy of the list object itself.
UNIT-IV
Chapter-1 Dictionaries
1.Dictionary in mapping:
Dictionary in Python is an unordered collection of data values, used to store data values like a map,
which unlike other Data Types that hold only single value as an element, Dictionary holds
key:value pair. Key value is provided in the dictionary to make it more optimized.
2.Dictionary as a Counter:
Suppose you are given a string and you want to count how many times each letter appears. There are
several ways you could do it:
You could create 26 variables, one for each letter of the alphabet. Then you could traverse the string
and, for each character, increment the corresponding counter, probably using a chained conditional.
You could create a list with 26 elements. Then you could convert each character to a number (using
the built-in function ord), use the number as an index into the list, and increment the appropriate
counter.
You could create a dictionary with characters as keys and counters as the corresponding values. The
first time you see a character, you would add an item to the dictionary. After that you would
increment the value of a existing item.
Each of these options performs the same computation, but each of them implements that
computation in a different way.
An implementation is a way of performing a computation; some implementations are better than
others. For example, an advantage of the dictionary implementation is that we don’t have to know
ahead of time which letters appear in the string and we only have to make room for the letters that
do appear.
Here is what the code might look like:
word = 'brontosaurus'd = dict()for c in word: if c not in d: d[c] = 1 else: d[c] = d[c] +
1print d We are effectively computing a histogram, which is a statistical term for a set of
counters (or frequencies).
The for loop traverses the string. Each time through the loop, if the character c is not in the
dictionary, we create a new item with key c and the initial value 1 (since we have seen this letter
once). If c is already in the dictionary we increment d[c].
Here’s the output of the program:
{'a': 1, 'b': 1, 'o': 2, 'n': 1, 's': 2, 'r': 2, 'u': 2, 't': 1}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-84-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![The histogram indicates that the letters ’a’ and 'b' appear once; 'o' appears twice, and so on.
Dictionaries have a method called get that takes a key and a default value. If the key appears in the
dictionary, get returns the corresponding value; otherwise it returns the default value. For example:
>>> counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}>>> print counts.get('jan', 0)100>>> print
counts.get('tim', 0)0
We can use get to write our histogram loop more concisely. Because the get method automatically
handles the case where a key is not in a dictionary, we can reduce four lines down to one and
eliminate the if statement.
word = 'brontosaurus'd = dict()for c in word: d[c] = d.get(c,0) + 1print d
The use of the get method to simplify this counting loop ends up being a very commonly used
“idiom” in Python and we will use it many times the rest of the book. So you should take a moment
and compare the loop using
the if statement and in operator with the loop using the get method. They do exactly the same thing,
but one is more succinct.
3. Looping and Dictionary:
If you use a dictionary as the sequence in a for statement, it traverses the keys of the dictionary.
This loop prints each key and the corresponding value: counts = { 'chuck' : 1 , 'annie' : 42, 'jan':
100}for key in counts: print key, counts[key] Here’s what the output looks like: jan 100chuck
1annie 42
Again, the keys are in no particular order.
We can use this pattern to implement the various loop idioms that we have described earlier. For
example if we wanted to find all the entries in a dictionary with a value above ten, we could write
the following code: counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}for key in counts: if
counts[key] > 10 : print key, counts[key] The for loop iterates through the keys of the dictionary,
so we must use the index operator to retrieve the corresponding value for each key. Here’s what the
output looks like:
jan 100annie 42
We see only the entries with a value above 10.
If you want to print the keys in alphabetical order, you first make a list of the keys in the dictionary
using the keys method available in dictionary objects, and then sort that list and loop through the
sorted list, looking up each key printing out key/value pairs in sorted order as follows as follows:
counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}lst = counts.keys()print lstlst.sort()for key in lst: print
key, counts[key]
Here’s what the output looks like:
['jan', 'chuck', 'annie']annie 42chuck 1jan 100
First you see the list of keys in unsorted order that we get from the keys
method. Then we see the key/value pairs in order from the for loop.
4. Reverse dictionary lookup in Python
Doing a reverse dictionary lookup returns a list containing each key in the dictionary that maps to
a specified value.
U S E dict.items() T O D O A R E V E R S E D I C T I O N A R Y L O O K U P
Use the syntax for key, value in dict.items() to iterate over each key, value pair in the dictionary
dict. At each iteration, if value is the lookup value, add key to an initially empty list.
print(a_dictionary)
O U T P U T
{'a': 1, 'b': 3, 'c': 1, 'd': 2}
lookup_value = 1](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-85-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![all_keys = [] for key,
value
ina_dictionary.items():
if(value == lookup_value):
all_keys.append(key)
print(all_keys)
O U T P U T
['a', 'c']
Use a dictionary comprehension for a more compact
implementation. all_keys = [key for key, value
ina_dictionary.items() if value == lookup_value]
print(all_keys)
O U T P U T
['a', 'c']
5. Dictionaries and Lists:
Lists are just like the arrays, declared in other languages. Lists need not be homogeneous always
which makes it a most powerful tool in Python. A single list may contain DataTypes like Integers,
Strings, as well as Objects.
Lists are mutable, and hence, they can be altered even after their
creation. Example:
# Python program to demonstrate
# Lists
# Creating a List with
# the use of multiple
values List=["Geeks",
"For", "Geeks"] print("List
containing multiple values:
") print(List[0])
print(List[2])
# Creating a Multi-Dimensional List
# (By Nesting a list
inside a List)
List=[['Geeks', 'For'] ,
['Geeks']] print("
nMulti-Dimensional
List: ") print(List)
Output:
List containing multiple values:
Geeks
Geeks
Multi-Dimensional List:
[['Geeks', 'For'], ['Geeks']]
Dictionary in Python on the other hand is an unordered collection of data values, used to store data
values like a map, which unlike other Data Types that hold only single value as an element,](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-86-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Dictionary holds key:value pair. Key-value is provided in the dictionary to make it more optimized.
Each key-value pair in a Dictionary is
separated by a colon :, whereas each key is separated by a
‘comma’. Example:
# Python program to demonstrate
# dictionary
# Creating a Dictionary
# with Integer Keys
Dict={1: 'Geeks', 2: 'For', 3: 'Geeks'}
print("Dictionary with the use of Integer Keys:
") print(Dict)
# Creating a Dictionary
# with Mixed keys
Dict={'Name': 'Geeks', 1: [1, 2, 3, 4]}
print("nDictionary with the use of
Mixed Keys: ") print(Dict) Output:
Dictionary with the use of Integer Keys:
{1: 'Geeks', 2: 'For', 3: 'Geeks'}
Dictionary with the use of Mixed Keys:
{1: [1, 2, 3, 4], 'Name': 'Geeks'}
Difference between List and Dictionary:
LIST DICTIONARY
List is a collection of index values pairs Dictionary is a hashed structure of key and value pairs.
LIST DICTIONARY
as that of array in c++.
List is created by placing elements in [
] seperated by commas “, “
Dictionary is created by placing elements in { } as “key”:”value”,
each key value pair is seperated by commas “, ”
The indices of list are integers starting
from 0. The keys of dictionary can be of any data type.
The elements are accessed via indices. The elements are accessed via key-values.
The order of the elements entered are
maintained. There is no guarantee for maintaining order.
6. MEMO: memoize and keyed-memoize decorators.
memo: The classical memoize decorator. It keeps a cache so you don’t continue to
perform the
same computations. keymemo(key): This decorator factory act as but it permits to
specify a key function that takes the args of
the decorated function and computes a value to use as key in the cache dictionary. This
way you can for example use a single value of a dictionary as key of the cache, or
apply a function before passing something to the cache.
args ->
result
mem
o
ke
y](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-87-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![The classical memoize decorator that can be applied to class functions. It
keeps a cache tinue to perform the same computations. The cache is kept in
the class namespace.
: This decorator factory works like a combination of and
keymemo, so it
allows to specify a function that generate the cache key based on the function arguments and can be
applied to class functions.
Usage
From memo import memo
@memo
de
ffi
bo
na
cci
(n)
:
ifn
<=
2:
ret
ur
n1
returnfibonacci(n-1)
+fibonacci(n-2)
frommemoimportkeym
emo
@keymemo(lambdatu
p: tup[0])
deffunction(tup):
# build a cache based on the first value of a tuple
...
The package has been uploaded to PyPI, so you can install it with pip:
pip install python-memo
7. Python Global Variables
In this tutorial, you’ll learn about Python Global variables, Local variables, Nonlocal
variables and where to use them. Global Variables
In Python, a variable declared outside of the function or in global scope is known as a global
variable. This means that a global variable can be accessed inside or outside of the function.
Let's see an example of how a global variable is
created in Python. Example 1: Create a Global
Variable x = "global"
deffoo():
print("x inside:",
x)
foo()
print("x outside:",
x)
args
-
instancememo :
so you don’t
co
> result
instancekeymemo(key
)
instancememo](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-88-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Cha
pter-
2
Tupl
es
1. Tuples are lists that are immutable.
I like Al Sweigart's characterization of a tuple as being the "cousin" of the list. The tuple is so
similar to the list that I am tempted to just skip covering it, especially since it's an object that other
popular languages – such as Ruby, Java, and JavaScript – get by just fine without having. However,
the tuple is an object that is frequently used in Python programming, so it's important to at least be
able to recognize its usage, even if you don't use it much yourself.
Syntax for declaring a tuple
Like a list, a tuple is a collection of other objects. The main visual difference, in terms of syntax, is
that instead of enclosing the values in we use parentheses, not square brackets, to enclose the
values of a tuple:
List Tuple
[1, 2,
"hello"]
(1, 2,
"hello")
Otherwise, the process of iterating through a tuple, and using square bracket notation to access or
slice a tuple's contents is the same as it is for lists (and pretty much for every other
Python sequence object, such as range…but we'll gloss over that detail for now).
Word of warning: if you're relatively new to programming and reading code, the use of
parentheses as delimiters might seem like a potential syntactic clusterf—, as parentheses are
already used in various other contexts, such as function calls. What differentiates a tuple declaration,
e.g.
mytuple=("hello","world")
– from the parentheses-enclosed values of a function call, e.g.
print("hello","world")
Well, that's easy – the latter set of parentheses-enclosed objects immediately follows a function name,
i.e.
The potential confusion from the similar notation isn't too terrible, in
practice. One strange thing you might come across is this:
>>>mytup
le=("hello
",)
>>>type(
mytuple)
tuple
print .](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-89-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![>>>len(mytuple)
1
Having a trailing comma is the only way to denote a tuple of length 1. Without that trailing comma,
would be pointing to a plain string object that happens to be enclosed in parentheses:
>>>mytuple=("hello")
>>>type(mytuple)
str
2. Tuples are immutable
Besides the different kind of brackets used to delimit them, the main difference between a tuple and a
list is that the tuple object is immutable. Once we've declared the contents of a tuple, we can't modify
the contents of that tuple.
For example, here's how we modify the 0th member of a list:
>>>m
ylist=
[1,2,3
]
>>>m
ylist[0
]=999
print(
mylist
)
[999,2,3]
That will not work with a tuple:
>>>mytuple=(1,2,3)
>>>mytuple[0]=999
TypeError:'tuple'objectdoesnotsupportitemassignment
And while the list object has several methods for adding new members, the tuple has no such
methods.
In other words, "immutability" == "never-changing".
Similarly, when a program alters the contents of a mutable object, it's often described as "mutating"
that object.
3. Tuple Assignment
Python has a very powerful tuple assignment feature that allows a tuple of variables on the left of
an assignment to be assigned values from a tuple on the right of the assignment.
(name, surname, birth_year, movie, movie_year, profession, birth_place) =julia
This does the equivalent of seven assignment statements, all on one easy line. One requirement is
that the number of variables on the left must match the number of elements in the tuple.
Once in a while, it is useful to swap the values of two variables. With conventional assignment
statements, we have to use a temporary variable. For example, to swap a and b:
t
e
m
p
=
a
a
=
b
mytupl
e](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-90-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![b
=
t
e
m
p
Tuple assignment solves this problem neatly:
(a, b) = (b, a)
The left side is a tuple of variables; the right side is a tuple of values. Each value is assigned to its
respective variable. All the expressions on the right side are evaluated before any of the
assignments. This feature makes tuple assignment quite versatile.
Naturally, the number of variables on the left and the number of values on the right have to be the
same. >>>(a, b, c, d) = (1, 2, 3)
ValueError: need more than 3 values to unpack.
4. Tuples as Return Values
Functions can return tuples as return values. This is very useful — we often want to know some
batsman’s highest and lowest score, or we want to find the mean and the standard deviation, or we
want to know the year, the month, and the day, or if we’re doing some ecological modeling we may
want to know the number of rabbits and the number of wolves on an island at a given time. In each
case, a function (which can only return a single value), can create a single tuple holding multiple
elements.
For example, we could write a function that returns both the area and the circumference of a circle
of radius r.
def circleInfo(r):
""" Return (circumference, area) of a circle
of radius r """ c = 2 * 3.14159 * r a =
3.14159 * r * r return (c, a)
print(circleInfo(10))
5. List and Tuple
The main difference between lists and tuples is the fact that lists are mutable whereas tuples are
immutable.
What does that even mean, you say?
A mutable data type means that a python object of this type can be modified.
An immutable object can’t.
Let’s create a list and assign it to a
variable. >>> a
=["apples","bananas","oranges"]
Now let’s see what happens when we try to modify the first item of the list.
Let’s change to “berries”.
>>>a[0]="berries"
>>> a
['berries','bananas','oranges']
Perfect! the first item of a has changed.
Now, what if we want to try the same thing with a tuple instead of a list?
Let’s see. >>> a =("apples","bananas","oranges")
>>>a[0]="berries"
Traceback(most recent call last):
File"", line 1,in
“apples
”](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-91-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![TypeError:'tuple'object does not support item assignment
We get an error saying that a tuple object doesn’t support item assignment.
The reason we get this error is because tuple objects, unlike lists, are immutable which means you
can’t modify a tuple object after it’s created.
But you might be thinking, Karim, my man, I know you say you can’t do assignments the way you
wrote it but how about this, doesn’t the following code modify a?
>>> a =("apples","bananas","oranges")
>>> a =("berries","bananas","oranges")
>>> a
('berries','bananas','oranges') Fair question! Let’s see, are we
actually modifying the first item in tuple a with the code above?
The answer is No, absolutely not.
6. Variable-length argument tuples:
To understand why, you first have to understand the difference between a variable and a python
object.
Syntax
Syntax for a function with non-keyword variable
arguments is this − def functionname([formal_args,]
*var_args_tuple ):
"functi
on_doc
string"
functio
n_suite
return
[expres
sion]
An asterisk (*) is placed before the variable name that holds the values of all nonkeyword variable
arguments. This tuple remains empty if no additional arguments are specified during the function
call.
Example
#!/usr/bin/python
# Function definition is here
defprintinfo( arg1,*vartuple
):
"This prints a variable
passed arguments"
print"Output is: " print arg1
forvarinvartuple: printvar
return;
# Now you can call printinfo function
printinfo(10)
printinfo(70,60,50) Output When the above code is
executed, it produces the following result − Output is:
10
Output is:
70
60
50
7. Dictionaries and Tuples](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-92-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Besides lists, Python has two additional data structures that can store multiple objects. These data
structures are dictionaries and tuples. Tuples will be discussed first.
Tuples
Tuples are immutable lists. Elements of a list can be modified, but elements in a tuple can only be
accessed, not modified. The name tuple does not mean that only two values can be stored in this
data structure.
Tuples are defined in Python by enclosing elements in parenthesis ( ) and separating elements with
commas. The command below creates a tuple containing the numbers 3, 4, and 5. >>>t_var =
(3,4,5)
>>>t_var
(3, 4, 5)
Note how the elements of a list can be modified:
>>>l_var = [3,4,5] # a list
>>>l_var[0]= 8
>>>l_var
[8, 4, 5]
The elements of a tuple can not be modified. If you try to assign a new value to one of the elements
in a tuple, an error is returned.
>>>t_var = (3,4,5) # a tuple
>>>t_var[0]= 8
>>>t_var
TypeError: 'tuple' object does not support item assignment
To create a tuple that just contains one numerical value, the number must be followed by a comma.
Without a comma, the variable is defined as a number.
>>>n
um =
(5)
>>>
type(
num)
int
When a comma is included after the number, the variable is
defined as a tuple. >>>t_var = (5,) >>> type(t_var)
tuple
Dictionaries
Dictionaries are made up of key: value pairs. In Python, lists and tuples are organized and accessed
based on position. Dictionaries in Python are organized and accessed using keys and values. The
location of a pair of keys and values stored in a Python dictionary is irrelevant.
Dictionaries are defined in Python with curly braces { }. Commas separate the key-value pairs that
make up the dictionary. Each key-value pair is related by a colon :.
Let's store the ages of two people in a dictionary. The two
people are Gabby and Maelle. Gabby is 8 and Maelle is 5. Note the name Gabby is a string and the age
8 is an integer. >>>age_dict = {"Gabby": 8 , "Maelle": 5}
>>>
type(age_
dict) dict
The values stored in a dictionary are called and assigned using the following syntax:
dict_name[key] = value
>>>age_dict = {"Gabby": 8 , "Maelle": 5}
>>>age_dict["Gabby"]
8](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-93-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![We can add a new person to our age_dict with the following command:
>>>age_dict = {"Gabby": 8 , "Maelle": 5}
>>>age_dict["Peter"]= 40
>>>age_dict
{'Gabby': 8, 'Maelle': 5, 'Peter': 40}
Dictionaries can be converted to lists by calling the .items(), .keys(), and .values() methods.
>>>age_dict = {"Gabby": 8 , "Maelle": 5}
>>>whole_list = list(age_dict.items())
>>>whole_list
[('Gabby', 8), ('Maelle', 5)]
>>>name_list = list(age_dict.keys())
>>>name_list
['Gabby', 'Maelle']
>>>age_list = list(age_dict.values())
>>>age_list
[8, 5]
Items can be removed from dictionaries by calling the .pop() method. The dictionary key (and that
key's associated value) supplied to the .pop() method is removed from the dictionary.
>>>age_dict = {"Gabby": 8 , "Maelle": 5}
>>>age_dict.pop("Gabby")
>>>age_dict
{'Maelle': 5}
8. Sequences of Sequences:
Some basic sequence type classes in python are, list, tuple, range. There are some additional
sequence type objects, these are binary data and text string.
Some common operations for the sequence type object can work on both mutable and immutable
sequences.
Some of the operations are as follows −
Sr.No. Operation/Functions & Description
1 x in seq
True, when x is found in the sequence seq, otherwise False
2 x not in seq
False, when x is found in the sequence seq, otherwise True
3 x + y
Concatenate two sequences x and y
4 x * n or n * x
Add sequence x with itself n times
5 seq[i] ith item of the
sequence.
6 seq[i:j]
Slice sequence from index i to j](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-94-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![7 seq[i:j:k]
Slice sequence from index i to j with step k
8 len(seq)
Length or number of elements in the sequence
9 min(seq)
Minimum element in the sequence
10 max(seq)
Maximum element in the sequence
11 seq.index(x[, i[, j]])
Index of the first occurrence of x (in the index range i and j)
12 seq.count(x)
Count total number of elements in the sequence
13 seq.append(x)
Add x at the end of the sequence
14 seq.clear()
Clear the contents of the sequence
15 seq.insert(i, x)
Insert x at the position i
16 seq.pop([i])
Return the item at position i, and also remove it from sequence.
Default is last element.
17 seq.remove(x)
Remove first occurrence of item x
18 seq.reverse() Reverse
the list
Example Code
myList1
=[10,20,30,40,50]
myList2
=[56,42,79,42,85,9
6,23]
if30in myList1:
print('30 is present')
if120notin myList1:
print('120 is not present')
print(myList1 + myList2)#Concatinate lists
print(myList1 *3)#Add myList1 three times
with itself print(max(myList2))
print(myList2.count(42))#42 has two times in the list](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-95-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![print(myList2[2:7])
print(myList2[2:7:2])
myList1.append(60)
print(myList1)
myList2.insert(5,17)
print(myList2)
myLis
t2.pop
(3)
print(
myLis
t2)
myLis
t1.rev
erse()
print(myList1)
myLis
t1.cle
ar()
print(
myLis
t1)
Outpu
t
30 is present
120 is not present
[10, 20, 30, 40, 50, 56, 42, 79, 42, 85, 96, 23]
[10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50]
96
2
[79, 42, 85, 96, 23]
[79, 85, 23]
[10, 20, 30, 40, 50, 60]
[56, 42, 79, 42, 85, 17, 96, 23]
[56, 42, 79, 85, 17, 96, 23]
[60, 50, 40, 30, 20, 10]
[]](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-96-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![Write and Read (‘w+’) : Open the file for reading and writing. For existing file, data is truncated
and over- written. The handle is positioned at the beginning of the file.
Append Only (‘a’) : Open the file for writing. The file is created if it does not exist. The handle is
positioned at the end of the file. The data being written will be inserted at the end, after the existing
data.
Append and Read (‘a+’) : Open the file for reading and writing. The file is created if it does not
exist. The handle is positioned at the end of the file. The data being written will be inserted at the
end, after the existing data.
Opening a File
It is done using the open() function. No module is required to be imported for this function.
File_object = open(r"File_Name","Access_Mode")
The file should exist in the same directory as the python program file else, full address of the file
should be written on place of filename.
Note: The r is placed before filename to prevent the characters in filename string to be treated as
special character. For example, if there is temp in the file address, then t is treated as the tab
character and error is raised of invalid address. The r makes the string raw, that is, it tells that the
string is without any special characters. The r can be ignored if the file is in same directory and
address is not being placed.
# Open function to open the file
"MyFile1.txt" # (same directory)
in append mode and file1
=open("MyFile.txt","a")
# store its reference in the
variable file1 # and
"MyFile2.txt" in D:Text in
file2 file2 =open(r"D:Text
MyFile2.txt","w+")
Here, file1 is created as object for MyFile1 and file2 as object for MyFile2 Closing a file close()
function closes the file and frees the memory space acquired by that file. It is used at the time
when the file is no longer needed or if it is to be opened in a different file mode.
File_object.close()
# Opening and Closing a file
"MyFile.txt" # for object
name file1.
file1 =open("MyFile.txt","a")
file1.close()
Writing to a file
There are two ways to write in a file.
write() : Inserts the string str1 in a single line in the text file.
File_object.write(str1)
writelines() : For a list of string elements, each string is inserted in the text file.Used to insert
multiple strings at a single time.
File_object.writelines(L) for L = [str1, str2, str3]
Reading from a file
There are three ways to read data from a text file.
read() : Returns the read bytes in form of a string. Reads n bytes, if no n specified, reads
the entire file. File_object.read([n]) readline() : Reads a line of the file and returns in form
of a string.For specified n, reads at most n bytes. However, does not reads more than one
line, even if n exceeds the length of the line. File_object.readline([n]) readlines() : Reads
all the lines and return them as each line a string element in a list.](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-98-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![File_object.readlines()
Note: ‘n’ is treated as a special character
of two bytes filter_none edit play_arrow
brightness_4
# Program to show various ways
to read and # write data in a file.
file1 =open("myfile.txt","w")
L =["This is Delhi n","This is Paris n","This is London n"]
# n is placed to indicate EOL
(End of Line)
file1.write("Hello n")
file1.writelines(L)
file1.close() #to change file
access modes file1
=open("myfile.txt","r+")
print"Output of Read function is "
printfile
1.read()
print
# seek(n) takes the file
handle to the nth # bite
from the beginning.
file1.seek(0)
print"Output of Readline function is "
printfi
le1.re
adline
()
print
file1.s
eek(0)
# To show difference between read
and readline print"Output of
Read(9) function is "
printfile1.read(9) print
file1.seek(0)
print"Output of Readline(9) function is "
printfile1.readline(9)
file1.seek(0) # readlines
function print"Output of
Readlines function is "](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-99-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
![printfil
e1.read
lines()
print
file1.cl
ose()
Output
:
Output of Read function is
Hello
This is Delhi
This is Paris
This is London
Output of Readline function is
Hello
Output of Read(9) function is
Hello
Th
Output of Readline(9)
function is Hello
Output of Readlines function is
['Hello n', 'This is Delhi n', 'This is Paris n', 'This is London n']
Appending to a file
filter_none
ed
it
pl
ay
_a
rr
o
w
br
ig
ht
ne
ss
_4
# Python
program to
illustrate #
Append vs write
mode file1
=open("myfile.t
xt","w")
L =["This is Delhi n","This is Paris n","This is London
n"] file1.close()](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Faintroductionbookofpythonforbeginners-250613145832-83400372%2F85%2FA-Introduction-Book-of-python-For-Beginners-docx-100-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fa-introduction-book-of-python-for-beginners-docx%2F280518358&__type=image)
Uploaded bykumarrabinderkumar77
DOCX, PDF90 views
A Introduction Book of python For Beginners.docx
Unit I: Basics of Python Programming Introduction to Programming: What is a program, how to run Python code. Core Concepts: Arithmetic operations, types of values (int, float, str), and variables. Statements: Assignment, script mode vs interactive mode, operator precedence. Strings: Basic string operations and usage of comments. Functions: Calling and defining functions. Math module usage. Flow of execution. Understanding parameters, local variables, stack diagrams. Fruitful (returns value) vs void (no return) functions.
Related topics:
