The Sieve of Eratosthenes is an algorithm used to find all prime numbers up to a specified integer n. It works by initially listing consecutive integers starting from 2 to n, and progressively marking as composite (not prime) the multiples of each prime number. The remaining numbers are all prime. The algorithm uses the fact that every composite number can be written as a product of prime numbers.
This document describes sets and operations on sets related to numbers on a roulette wheel. It defines six sets - A (red numbers), B (black numbers), C (green numbers), D (even numbers), E (odd numbers), and F (numbers 1-12). It provides the elements of each set based on a standard American roulette wheel. It then calculates the unions and intersections of these sets according to the given operations. Tables and diagrams are provided to represent the set operations and relationships.
This presentation is the full application of discrete mathematics throughout a course and includes Set Theory, Functions nd Sequences, Automata Theory, Grammars and algorithm building.
The document discusses algorithms and their analysis. It defines an algorithm as a step-by-step procedure for solving a problem and analyzes the time complexity of various algorithms. Key points made include:
1) Algorithms are analyzed based on how many times their basic operation is performed as a function of input size n.
2) Common time complexities include O(n) for sequential search, O(n^3) for matrix multiplication, and O(log n) for binary search.
3) Recursive algorithms like fibonacci are inefficient and iterative versions improve performance by storing previously computed values.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and commonly used string and list methods.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
This document provides an introduction to the Python language and discusses Python data types. It covers how to install Python, interact with the Python interpreter through command line and IDLE modes, and learn basic Python parts like data types, operators, functions, and control structures. The document discusses numeric, string, and other data types in Python and how to manipulate them using built-in functions and operators. It also introduces Python library modules and the arcpy package for geoprocessing in ArcGIS.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and commonly used string and list methods.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
This document describes sets and operations on sets related to numbers on a roulette wheel. It defines six sets - A (red numbers), B (black numbers), C (green numbers), D (even numbers), E (odd numbers), and F (numbers 1-12). It provides the elements of each set based on a standard American roulette wheel. It then calculates the unions and intersections of these sets according to the given operations. Tables and diagrams are provided to represent the set operations and relationships.
This presentation is the full application of discrete mathematics throughout a course and includes Set Theory, Functions nd Sequences, Automata Theory, Grammars and algorithm building.
The document discusses algorithms and their analysis. It defines an algorithm as a step-by-step procedure for solving a problem and analyzes the time complexity of various algorithms. Key points made include:
1) Algorithms are analyzed based on how many times their basic operation is performed as a function of input size n.
2) Common time complexities include O(n) for sequential search, O(n^3) for matrix multiplication, and O(log n) for binary search.
3) Recursive algorithms like fibonacci are inefficient and iterative versions improve performance by storing previously computed values.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and commonly used string and list methods.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
This document provides an introduction to the Python language and discusses Python data types. It covers how to install Python, interact with the Python interpreter through command line and IDLE modes, and learn basic Python parts like data types, operators, functions, and control structures. The document discusses numeric, string, and other data types in Python and how to manipulate them using built-in functions and operators. It also introduces Python library modules and the arcpy package for geoprocessing in ArcGIS.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and commonly used string and list methods.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
This document provides an introduction to the Python language and discusses Python data types. It covers how to install Python, interact with the Python interpreter through command line and IDLE modes, and learn basic Python parts like data types, operators, functions, and control structures. The document discusses numeric, string, and other data types in Python and how to manipulate them using built-in functions and operators. It also introduces Python library modules and the arcpy package for geoprocessing in ArcGIS.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
The document discusses various sorting algorithms including exchange sorts like bubble sort and quicksort, selection sorts like straight selection sort, and tree sorts like heap sort. For each algorithm, it provides an overview of the approach, pseudocode, analysis of time complexity, and examples. Key algorithms covered are bubble sort (O(n2)), quicksort (average O(n log n)), selection sort (O(n2)), and heap sort (O(n log n)).
The document discusses various topics related to numbers including:
1) Perfect numbers which are numbers whose factors sum to the number.
2) Classification of numbers as natural, whole, integers, rational, and irrational.
3) Rules for divisibility including by 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15.
4) Formulas for finding cubes of two-digit numbers and number of zeros in expressions.
Modern cryptography relies heavily on abstract algebra and number theory. Modular arithmetic involves dividing numbers and taking the remainder. The multiplicative cipher encrypts messages by multiplying them by an encryption key, and decrypts them by multiplying the cipher by the inverse of the key. The affine cipher combines the additive and multiplicative ciphers, applying one then the other, to further strengthen security.
introduction to data structures and typesankita946617
A ppt on primitive and non primitive data structures, abstract data types , performance analysis(time and space complexity) using asymptotic notations-(Big O, Theta, Omega), introduction to arrays and their memory representation, types of arrays- single dimension, two dimension, multi-dimensions, basic operations on arrays- insertion, deletion, searching, sorting, sparse matrix and its representation, applications of array
This document discusses the string data type in Python. It explains that strings are sequences of characters that can be indexed, sliced, concatenated, and operated on using various string methods. Lists are also introduced as mutable sequences that can contain heterogeneous data types. Common string and list operations like indexing, slicing, length calculation, and concatenation are demonstrated through examples.
This document outlines divide and conquer algorithms for linear space sequence alignment. It discusses MergeSort as an example divide and conquer algorithm, and describes using a divide and conquer approach to solve the longest common subsequence (LCS) problem. It explains how to find the "middle vertex" between the source and sink for the LCS problem by dividing the problem space in half at each step. The document also covers using block alignment and the Four Russians speedup technique to solve sequence alignment problems in sub-quadratic time.
Effective Algorithm for n Fibonacci Number By: Professor Lili SaghafiProfessor Lili Saghafi
Understand the definition of the Fibonacci numbers.
Understand the definition of the Recursive / Recursive Functions
Show that the naive algorithm for computing them is slow.
Efficiently create algorithms to compute large Fibonacci numbers.
The right algorithm makes all the difference.
Hi friends these array series presentation gives you clear cut knowledge in array in c++ programming, array in c++ tutorial, array in c++ syntax, array in c++ example
The document discusses algorithms and their use for solving problems expressed as a sequence of steps. It provides examples of common algorithms like sorting and searching arrays, and analyzing their time and space complexity. Specific sorting algorithms like bubble sort, insertion sort, and quick sort are explained with pseudocode examples. Permutations, combinations and variations as examples of combinatorial algorithms are also covered briefly.
This document discusses arithmetic sequences and series. Some key points include:
- An arithmetic sequence has a constant difference between consecutive terms called the common difference.
- The nth term of an arithmetic sequence can be written as an = a1 + (n-1)d, where a1 is the first term and d is the common difference.
- The sum of the first n terms of an arithmetic sequence is Sn = n/2(2a1 + (n-1)d).
- Several problems are presented involving calculating terms, sums, and common differences of arithmetic sequences.
In this chapter we will learn about arrays as a way to work with sequences of elements of the same type. We will explain what arrays are, how we declare, create, instantiate and use them. We will examine one-dimensional and multidimensional arrays. We will learn different ways to iterate through the array, read from the standard input and write to the standard output. We will give many example exercises, which can be solved using arrays and we will show how useful they really are.
This document discusses asymptotic notations and their use in analyzing the time complexity of algorithms. It introduces the Big-O, Big-Omega, and Big-Theta notations for describing the asymptotic upper bound, lower bound, and tight bound of an algorithm's running time. The document explains that asymptotic notations allow algorithms to be compared by ignoring lower-order terms and constants, and focusing on the highest-order term that dominates as the input size increases. Examples are provided to illustrate the different orders of growth and the notations used to describe them.
asymptotic analysis and insertion sort analysisAnindita Kundu
This document discusses asymptotic analysis of algorithms. It introduces key concepts like algorithms, data structures, best/average/worst case running times, and asymptotic notations like Big-O, Big-Omega, and Big-Theta. These notations are used to describe the long-term growth rates of functions and provide upper/lower/tight bounds on the running time of algorithms as the input size increases. Examples show how to analyze the asymptotic running time of algorithms like insertion sort, which is O(n^2) in the worst case but O(n) in the best case.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and optionally returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then tells the processor to execute the program. Functions allow code to be reused by defining operations that take in arguments and return values. Strings are sequences of characters that can be accessed by index and manipulated with methods like upper() that return new strings.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
This document provides an introduction to the Python language and discusses Python data types. It covers how to install Python, interact with the Python interpreter through command line and IDLE modes, and learn basic Python parts like data types, operators, functions, and control structures. The document discusses numeric, string, and other data types in Python and how to manipulate them using built-in functions and operators. It also introduces Python library modules and the arcpy package for geoprocessing in ArcGIS.
This document provides an introduction to the Python programming language. It discusses installing Python and interacting with it through command line and IDLE modes. It covers basic Python data types like numbers, strings, lists, and booleans. It demonstrates how to perform operations and call functions on these data types. It also discusses Python modules, getting input from users, and assigning values to variables.
The document discusses various sorting algorithms including exchange sorts like bubble sort and quicksort, selection sorts like straight selection sort, and tree sorts like heap sort. For each algorithm, it provides an overview of the approach, pseudocode, analysis of time complexity, and examples. Key algorithms covered are bubble sort (O(n2)), quicksort (average O(n log n)), selection sort (O(n2)), and heap sort (O(n log n)).
The document discusses various topics related to numbers including:
1) Perfect numbers which are numbers whose factors sum to the number.
2) Classification of numbers as natural, whole, integers, rational, and irrational.
3) Rules for divisibility including by 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15.
4) Formulas for finding cubes of two-digit numbers and number of zeros in expressions.
Modern cryptography relies heavily on abstract algebra and number theory. Modular arithmetic involves dividing numbers and taking the remainder. The multiplicative cipher encrypts messages by multiplying them by an encryption key, and decrypts them by multiplying the cipher by the inverse of the key. The affine cipher combines the additive and multiplicative ciphers, applying one then the other, to further strengthen security.
introduction to data structures and typesankita946617
A ppt on primitive and non primitive data structures, abstract data types , performance analysis(time and space complexity) using asymptotic notations-(Big O, Theta, Omega), introduction to arrays and their memory representation, types of arrays- single dimension, two dimension, multi-dimensions, basic operations on arrays- insertion, deletion, searching, sorting, sparse matrix and its representation, applications of array
This document discusses the string data type in Python. It explains that strings are sequences of characters that can be indexed, sliced, concatenated, and operated on using various string methods. Lists are also introduced as mutable sequences that can contain heterogeneous data types. Common string and list operations like indexing, slicing, length calculation, and concatenation are demonstrated through examples.
This document outlines divide and conquer algorithms for linear space sequence alignment. It discusses MergeSort as an example divide and conquer algorithm, and describes using a divide and conquer approach to solve the longest common subsequence (LCS) problem. It explains how to find the "middle vertex" between the source and sink for the LCS problem by dividing the problem space in half at each step. The document also covers using block alignment and the Four Russians speedup technique to solve sequence alignment problems in sub-quadratic time.
Effective Algorithm for n Fibonacci Number By: Professor Lili SaghafiProfessor Lili Saghafi
Understand the definition of the Fibonacci numbers.
Understand the definition of the Recursive / Recursive Functions
Show that the naive algorithm for computing them is slow.
Efficiently create algorithms to compute large Fibonacci numbers.
The right algorithm makes all the difference.
Hi friends these array series presentation gives you clear cut knowledge in array in c++ programming, array in c++ tutorial, array in c++ syntax, array in c++ example
The document discusses algorithms and their use for solving problems expressed as a sequence of steps. It provides examples of common algorithms like sorting and searching arrays, and analyzing their time and space complexity. Specific sorting algorithms like bubble sort, insertion sort, and quick sort are explained with pseudocode examples. Permutations, combinations and variations as examples of combinatorial algorithms are also covered briefly.
This document discusses arithmetic sequences and series. Some key points include:
- An arithmetic sequence has a constant difference between consecutive terms called the common difference.
- The nth term of an arithmetic sequence can be written as an = a1 + (n-1)d, where a1 is the first term and d is the common difference.
- The sum of the first n terms of an arithmetic sequence is Sn = n/2(2a1 + (n-1)d).
- Several problems are presented involving calculating terms, sums, and common differences of arithmetic sequences.
In this chapter we will learn about arrays as a way to work with sequences of elements of the same type. We will explain what arrays are, how we declare, create, instantiate and use them. We will examine one-dimensional and multidimensional arrays. We will learn different ways to iterate through the array, read from the standard input and write to the standard output. We will give many example exercises, which can be solved using arrays and we will show how useful they really are.
This document discusses asymptotic notations and their use in analyzing the time complexity of algorithms. It introduces the Big-O, Big-Omega, and Big-Theta notations for describing the asymptotic upper bound, lower bound, and tight bound of an algorithm's running time. The document explains that asymptotic notations allow algorithms to be compared by ignoring lower-order terms and constants, and focusing on the highest-order term that dominates as the input size increases. Examples are provided to illustrate the different orders of growth and the notations used to describe them.
asymptotic analysis and insertion sort analysisAnindita Kundu
This document discusses asymptotic analysis of algorithms. It introduces key concepts like algorithms, data structures, best/average/worst case running times, and asymptotic notations like Big-O, Big-Omega, and Big-Theta. These notations are used to describe the long-term growth rates of functions and provide upper/lower/tight bounds on the running time of algorithms as the input size increases. Examples show how to analyze the asymptotic running time of algorithms like insertion sort, which is O(n^2) in the worst case but O(n) in the best case.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and optionally returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then tells the processor to execute the program. Functions allow code to be reused by defining operations that take in arguments and return values. Strings are sequences of characters that can be accessed by index and manipulated with methods like upper() that return new strings.
A program is a sequence of instructions that are run by the processor. To run a program, it must be compiled into binary code and given to the operating system. The OS then gives the code to the processor to execute. Functions allow code to be reused by defining operations and returning values. Strings are sequences of characters that can be manipulated using indexes and methods. Common string methods include upper() and concatenation using +.
Batteries -Introduction – Types of Batteries – discharging and charging of battery - characteristics of battery –battery rating- various tests on battery- – Primary battery: silver button cell- Secondary battery :Ni-Cd battery-modern battery: lithium ion battery-maintenance of batteries-choices of batteries for electric vehicle applications.
Fuel Cells: Introduction- importance and classification of fuel cells - description, principle, components, applications of fuel cells: H2-O2 fuel cell, alkaline fuel cell, molten carbonate fuel cell and direct methanol fuel cells.
Introduction- e - waste – definition - sources of e-waste– hazardous substances in e-waste - effects of e-waste on environment and human health- need for e-waste management– e-waste handling rules - waste minimization techniques for managing e-waste – recycling of e-waste - disposal treatment methods of e- waste – mechanism of extraction of precious metal from leaching solution-global Scenario of E-waste – E-waste in India- case studies.
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...IJECEIAES
Climate change's impact on the planet forced the United Nations and governments to promote green energies and electric transportation. The deployments of photovoltaic (PV) and electric vehicle (EV) systems gained stronger momentum due to their numerous advantages over fossil fuel types. The advantages go beyond sustainability to reach financial support and stability. The work in this paper introduces the hybrid system between PV and EV to support industrial and commercial plants. This paper covers the theoretical framework of the proposed hybrid system including the required equation to complete the cost analysis when PV and EV are present. In addition, the proposed design diagram which sets the priorities and requirements of the system is presented. The proposed approach allows setup to advance their power stability, especially during power outages. The presented information supports researchers and plant owners to complete the necessary analysis while promoting the deployment of clean energy. The result of a case study that represents a dairy milk farmer supports the theoretical works and highlights its advanced benefits to existing plants. The short return on investment of the proposed approach supports the paper's novelty approach for the sustainable electrical system. In addition, the proposed system allows for an isolated power setup without the need for a transmission line which enhances the safety of the electrical network
International Conference on NLP, Artificial Intelligence, Machine Learning an...gerogepatton
International Conference on NLP, Artificial Intelligence, Machine Learning and Applications (NLAIM 2024) offers a premier global platform for exchanging insights and findings in the theory, methodology, and applications of NLP, Artificial Intelligence, Machine Learning, and their applications. The conference seeks substantial contributions across all key domains of NLP, Artificial Intelligence, Machine Learning, and their practical applications, aiming to foster both theoretical advancements and real-world implementations. With a focus on facilitating collaboration between researchers and practitioners from academia and industry, the conference serves as a nexus for sharing the latest developments in the field.
Redefining brain tumor segmentation: a cutting-edge convolutional neural netw...IJECEIAES
Medical image analysis has witnessed significant advancements with deep learning techniques. In the domain of brain tumor segmentation, the ability to
precisely delineate tumor boundaries from magnetic resonance imaging (MRI)
scans holds profound implications for diagnosis. This study presents an ensemble convolutional neural network (CNN) with transfer learning, integrating
the state-of-the-art Deeplabv3+ architecture with the ResNet18 backbone. The
model is rigorously trained and evaluated, exhibiting remarkable performance
metrics, including an impressive global accuracy of 99.286%, a high-class accuracy of 82.191%, a mean intersection over union (IoU) of 79.900%, a weighted
IoU of 98.620%, and a Boundary F1 (BF) score of 83.303%. Notably, a detailed comparative analysis with existing methods showcases the superiority of
our proposed model. These findings underscore the model’s competence in precise brain tumor localization, underscoring its potential to revolutionize medical
image analysis and enhance healthcare outcomes. This research paves the way
for future exploration and optimization of advanced CNN models in medical
imaging, emphasizing addressing false positives and resource efficiency.
3. Prime Numbers and
Composite Numbers
• A prime number is a number that has exactly
two factors: 1 and itself.
– Smallest prime number is 2.
• 1 is not a prime number.
– Examples: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, etc.
• A composite number is a number that has a
factor other than 1 and itself.
• 1 is not a composite number.
5. • Prime numbers have a long and interesting history
❖ a number is prime if it cannot be written as the product of two smaller numbers
❖ non-prime numbers are called composite numbers
❖ these are primes: 5, 11, 73, 9967, ...
❖ these are composite: 10 (2 × 5), 99 (3 × 3 × 11), ...
• Ancient Greek, Persian, and Chinese philosophers all studied properties of prime
numbers
❖ the Sieve of Eratosthenes, the algorithm
we’re looking at today, is one of the
oldest known algorithms
❖ dates to at least 200 BC
History
6. Eratosthenes and the Primes
• Eratosthenes of Cyrene (276 B.C. - 194 B.C.,
Greece) was a Greek mathematician, poet,
athlete, geographer and astronomer.
• Eratosthenes was the librarian at Alexandria,
Egypt.
• He made several discoveries and inventions
including a system of latitude and longitude. He
was the first person to calculate the
circumference of the Earth, and the tilt of the
earth's axis.
• Eratosthenes devised a 'sieve' to discover prime
numbers.
8. The Sieve of Eratosthenes
• Algorithm to enumerate primes ≤ n :
1. Generate the sequence 2 to n
2. Print the smallest number in the remaining
sequence, which is the new prime p.
3. Remove all the multiples of p.
4. Repeat 3 and 4 until the sequence is
exhausted.
9. • Sieve of Eratosthenes is used to get all prime number in a given
range and is a very efficient algorithm.
• It follows the following steps to get all the prime numbers from up
to n:
• Make a list of all numbers from 2 to n.
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …….,
n]
• Starting from 2, delete all of its multiples in the list, except itself.
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,……., n]
• Repeat the step 2 till square root of n.
For 3 – [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20……., n]
For 5 – [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20……., n]
Till sqrt(n)
• The remaining list only contains prime numbers.
11. • For 5 – [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61,
67, 71, 73, 77, 79, 83, 89, 91, 97]
•
For 6 – (Not in list, deleted during deletion of multiples of 2)
•
For 7 – [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 89, 97]
•
For 8 – (Not in list, deleted during deletion of multiples of 2)
•
For 9 – (Not in list, deleted during deletion of multiples of 3)
• For 10 [last] (Square root of 100 is 10) – (Not in list, deleted during
deletion of multiples of 2)
• Final list – [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97]
12. The Sieve
• The basic idea is simple:
make a list of numbers, starting with 2
repeat:
the first unmarked number in the list is
prime
cross off multiples of the most recent prime
initial list
round 1
round 2
round 3
13. Technology
• The method described on the previous slide works well for short lists
• But what if you want to find prime numbers between 2 and 100? 1000?
❖ it’s a tedious process to write out a list of 100 numbers
❖ takes a lot of paper to make a list of 1000 numbers
❖ chances are you will make a few arithmetic mistakes (this is a boring job)
• You could improve accuracy by using an abacus or calculator
❖ but it’s still very boring....
14. Technology (cont’d)
• Can we turn this method into a computation?
❖ detailed specification of starting and ending conditions are there
• What about the steps?
❖ “cross off” and “next number” need to be defined if we’re going to use Python
❖ when do we stop the process? when all the numbers are crossed off?
15. A Python Function
• The project for this chapter shows how to create a Python program that
implements the Sieve of Eratosthenes
• When we’re done we will have a function named sieve
❖ pass it a number n
❖ it will return a list of prime numbers less than n
>>> sieve(20)
[2, 3, 5, 7, 11, 13, 17, 19]
>>> sieve(2000)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, …, 1987, 1993, 1997,
1999]
16. Sieve of Eratosthenes
• Given a number n, print all primes smaller than or equal to n. It is also
given that n is a small number.
• Example:
• Input : n =10
• Output : 2 3 5 7
• Input : n = 20
• Output: 2 3 5 7 11 13 17 19
• The sieve of Eratosthenes is one of the most efficient ways to find all
primes smaller than n when n is smaller than 10 million or so .
17. • Following is the algorithm to find all the prime numbers less
than or equal to a given integer n by Eratosthenes’ method:
• 1. Create a list of consecutive integers from 2 to n: (2, 3, 4, …,
n).
• 2. Initially, let p equal 2, the first prime number.
• 3. Starting from p2, count up in increments of p and mark
each of these numbers greater than or equal to p2 itself in the
list. These numbers will be p(p+1), p(p+2), p(p+3), etc..
• 4. Find the first number greater than p in the list that is not
marked. If there was no such number, stop. Otherwise, let p
now equal this number (which is the next prime), and repeat
from step 3.
• When the algorithm terminates, all the numbers in the list
that are not marked are prime.
18. Explanation with Example:
• Let us take an example when n = 50. So we need to print all print numbers smaller
than or equal to 50.
• We create a list of all numbers from 2 to 50.
19. According to the algorithm we will mark all the
numbers which are divisible by 2 and are
greater than or equal to the square of it.
20. Now we move to our next unmarked number 3 and
mark all the numbers which are
multiples of 3 and are greater than or equal to the
square of it.
21. Now we move to our next unmarked number 3 and
mark all the numbers which are
multiples of 3 and are greater than or equal to the
square of it.
22. We continue this process and our final table
will look like below:
• So the prime numbers are the unmarked ones: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31,
37, 41, 43, 47.
23. Python Program for Sieve of Eratosthenes
• Given a number n, print all primes smaller than or equal to n. It is also given that n is a small
number.
• For example, if n is 10, the output should be “2, 3, 5, 7”. If n is 20, the output should be “2, 3, 5, 7,
11, 13, 17, 19”.
# Python program to print all primes smaller than or equal to
# n using Sieve of Eratosthenes
def SieveOfEratosthenes(n):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
24. Program continue....
prime[0]= False
prime[1]= False
# Print all prime numbers
for p in range(n + 1):
if prime[p]:
print p, #Use print(p) for python 3
# driver program
if __name__=='__main__':
n = 30
print "Following are the prime numbers smaller",
#Use print("Following are the prime numbers smaller") for Python 3
print "than or equal to", n
#Use print("than or equal to", n) for Python 3
SieveOfEratosthenes(n)
Output:
Following are the prime numbers below 30 2 3 5 7 11 13 17 19 23 29
25. Python File Handling
• Till now, we were taking the input from the console and writing it
back to the console to interact with the user.
• Sometimes, it is not enough to only display the data on the console.
The data to be displayed may be very large, and only a limited
amount of data can be displayed on the console, and since the
memory is volatile, it is impossible to recover the programmatically
generated data again and again.
• However, if we need to do so, we may store it onto the local file
system which is volatile and can be accessed every time. Here,
comes the need of file handling.
• In this section of the tutorial, we will learn all about file handling in
python including, creating a file, opening a file, closing a file, writing
and appending the file, etc.
26. Files
• Files are named locations on disk to store related information. They
are used to permanently store data in a non-volatile memory (e.g.
hard disk).
• Since Random Access Memory (RAM) is volatile (which loses its
data when the computer is turned off), we use files for future use
of the data by permanently storing them.
• When we want to read from or write to a file, we need to open it
first. When we are done, it needs to be closed so that the resources
that are tied with the file are freed.
• Hence, in Python, a file operation takes place in the following order:
Open a file
Read or write (perform operation)
Close the file
27. Opening Files in Python
• Python provides the open() function which accepts two
arguments, file name and access mode in which the file is
accessed.
• The function returns a file object which can be used to
perform various operations like reading, writing, etc.
• Python has a built-in open() function to open a file.
• This function returns a file object, also called a handle, as it is
used to read or modify the file accordingly.
>>> f = open("test.txt") # open file in current directory
>>> f = open("C:/Python38/README.txt") # specifying full path
28. • We can specify the mode while opening a file.
• In mode, we specify whether we want to read r, write w or
append a to the file.
• We can also specify if we want to open the file in text mode or
binary mode.
• The default is reading in text mode. In this mode, we get
strings when reading from the file.
• On the other hand, binary mode returns bytes and this is the
mode to be used when dealing with non-text files like images
or executable files.
• The syntax to use the open() function is given below.
file object = open(<file-name>, <access-mode>, <buffering>)
29. • Here are parameter details −
• file_name − The file_name argument is a string value that
contains the name of the file that you want to access.
• access_mode − The access_mode determines the mode in
which the file has to be opened, i.e., read, write, append, etc.
This is optional parameter and the default file access mode is
read (r).
• buffering − If the buffering value is set to 0, no buffering takes
place. If the buffering value is 1, line buffering is performed
while accessing a file.
If you specify the buffering value as an integer greater than 1,
then buffering action is performed with the indicated buffer
size.
If negative, the buffer size is the system default(default
behavior).
30. The file Object Attributes
• Once a file is opened and you have one file object, you can get various information
related to that file.
• Here is a list of all attributes related to file object −
32. • Let's look at the simple example to open a file named "file.txt"
(stored in the same directory) in read mode and printing its
content on the console.
• Example
1. #opens the file file.txt in read mode
2. fileptr = open("file.txt","r")
3. if fileptr:
4. print("file is opened successfully")
Output:
<class '_io.TextIOWrapper'>
file is opened successfully
33. The close() method
• Once all the operations are done on the file, we must close it
through our python script using the close() method.
• Any unwritten information gets destroyed once the close()
method is called on a file object.
• We can perform any operation on the file externally in the file
system is the file is opened in python, hence it is good
practice to close the file once all the operations are done.
• The syntax to use the close() method is given below.
fileobject.close()
34. Example
1. # opens the file file.txt in
read mode
2. fileptr = open("file.txt","r")
3. if fileptr:
4. print("file is opened
successfully")
5. #closes the opened file
fileptr.close()
35. Reading and Writing Files
• The file to object provides a set of access methods to make
our lives easier.
• We would see how to use use read() and write() methods to
read and write files.
36. The write() Method
• The write() method writes any string to an open file. It is
important to note that Python strings can have binary data
and not just text.
• The write() method does not add a newline character ('n') to
the end of the string −
• Syntax
• fileObject.write(string)
• Here, passed parameter is the content to be written into the
opened file.
37. • To write some text to a file, we need to open the file
using the open method with one of the following access
modes.
• a: It will append the existing file. The file pointer is at the
end of the file. It creates a new file if no file exists.
• w: It will overwrite the file if any file exists. The file
pointer is at the beginning of the file.
38. Example
#!/usr/bin/python
# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language.nYeah its great!!n")
# Close opend file
fo.close()
• The above method would create foo.txt file and would write given content in that
file and finally it would close that file. If you would open this file, it would have
following content.
Python is a great language.
Yeah its great!!
39. The read() Method
• The read() method reads a string from an open file. It is
important to note that Python strings can have binary data
apart from text data.
• Syntax:
• fileObject.read([count])
• Here, passed parameter is the number of bytes to be read
from the opened file.
• This method starts reading from the beginning of the file and
if count is missing, then it tries to read as much as possible,
maybe until the end of file.
40. Example
• Let's take a file foo.txt,
#!/usr/bin/python
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print "Read String is : ", str
# Close opend file
fo.close()
This produces the following result −
Read String is : Python is
41. Example
1. #open the file.txt in read mode. causes error if no such file exists.
2. fileptr = open("file.txt","r");
3. #stores all the data of the file into the variable content
4. content = fileptr.read(9);
5. # prints the type of the data stored in the file
6. print(type(content))
7. #prints the content of the file
8. print(content)
9. #closes the opened file
10. fileptr.close()
Output:
<class 'str'>
Hi, I am
42. How to Read Lines of the file?
• Python facilitates us to read the file line by line by using a
function readline().
• The readline() method reads the lines of the file from the
beginning, i.e., if we use the readline() method two times,
then we can get the first two lines of the file.
• Consider the following example which contains a function
readline() that reads the first line of our file "file.txt"
containing three lines.
43. Example
1. #open the file.txt in read mode. causes error if no such file exists.
2. fileptr = open("file.txt","r");
3. #stores all the data of the file into the variable content
4. content = fileptr.readline();
5. # prints the type of the data stored in the file
6. print(type(content))
7. #prints the content of the file
8. print(content)
9. #closes the opened file
10. fileptr.close()
Output:
<class 'str'>
Hi, I am the file and being used as
44. The Looping through the file
• By looping through the lines of the file, we can read the whole file.
• Example
1. #open the file.txt in read mode. causes an error if no such file exists.
2. fileptr = open("file.txt","r");
3. #running a for loop
4. for i in fileptr:
5. print(i) # i contains each line of the file
Output:
Hi, I am the file and being used as
an example to read a
file in python.
45. • Example 1
1. #open the file.txt in append mode. Creates a new file if no such file
exists.
2. fileptr = open("file.txt","a");
3. #appending the content to the file
4. fileptr.write("Python is the modern day language. It makes things so
simple.")
5. #closing the opened file
6. fileptr.close();
• Now, we can see that the content of the file is modified.
• File.txt:
1. Hi, I am the file and being used as
2. an example to read a
3. file in python.
4. Python is the modern day language. It makes things so simple.
46. • Example 2
1. #open the file.txt in write mode.
2. fileptr = open("file.txt","w");
3. #overwriting the content of the file
4. fileptr.write("Python is the modern day language. It makes things so
simple.")
5. #closing the opened file
6. fileptr.close();
• Now, we can check that all the previously written content of the file
is overwritten with the new text we have passed.
• File.txt:
1. Python is the modern day language. It makes things so simple.
47. Creating a new file
• The new file can be created by using one of the following access
modes with the function open().
• x: it creates a new file with the specified name. It causes an error a
file exists with the same name.
• a: It creates a new file with the specified name if no such file exists.
It appends the content to the file if the file already exists with the
specified name.
• w: It creates a new file with the specified name if no such file exists.
It overwrites the existing file.
48. Example
• Example
1. #open the file.txt in read mode. causes error if no such file
exists.
2. fileptr = open("file2.txt","x");
3. print(fileptr)
4. if fileptr:
5. print("File created successfully");
• Output:
• File created successfully
49. Using ‘with’ statement with files
• The with statement was introduced in python 2.5.
• The with statement is useful in the case of manipulating the
files.
• The with statement is used in the scenario where a pair of
statements is to be executed with a block of code in between.
• The syntax to open a file using with statement is given
below.
1. with open(<file name>, <access mode>) as <file-pointer>:
2. #statement suite
50. • The advantage of using with statement is that it provides the
guarantee to close the file regardless of how the nested block
exits.
• It is always suggestible to use the with statement in the case
of file s because, if the break, return, or exception occurs in
the nested block of code then it automatically closes the file.
• It doesn't let the file to be corrupted.
• Example
1. with open("file.txt",'r') as f:
2. content = f.read();
3. print(content)
• Output:
• Python is the modern day language. It makes things so simple.
51. File Pointer positions
• Python provides the tell() method which is used to print the
byte number at which the file pointer exists.
Or
• The tell() method tells you the current position within the file;
in other words, the next read or write will occur at that many
bytes from the beginning of the file.
52. Consider the following example.
• Example
1. # open the file file2.txt in read mode
2. fileptr = open("file2.txt","r")
3. #initially the filepointer is at 0
4. print("The filepointer is at byte :",fileptr.tell())
5. #reading the content of the file
6. content = fileptr.read();
7. #after the read operation file pointer modifies. tell() returns the location of
the fileptr.
8. print("After reading, the filepointer is at:",fileptr.tell())
Output:
The filepointer is at byte : 0
After reading, the filepointer is at 26
53. Modifying file pointer position
• In the real world applications, sometimes we need to change the file
pointer location externally since we may need to read or write the content
at various locations.
• For this purpose, the python provides us the seek() method which enables
us to modify the file pointer position externally.
• The syntax to use the seek() method is given below.
<file-ptr>.seek(offset[, from)
• The seek() method accepts two parameters:
• offset: It refers to the new position of the file pointer within the file.
• from: It indicates the reference position from where the bytes are to be
moved.
• If it is set to 0, the beginning of the file is used as the reference position.
• If it is set to 1, the current position of the file pointer is used as the
reference position.
• If it is set to 2, the end of the file pointer is used as the reference position.
54. or
• The seek(offset[, from]) method changes the current file
position.
• The offset indicates argument indicates the the number of
bytes to be moved.
• The from argument specifies the reference position from
where the bytes are to be moved.
• If from means is set to 0, it means use the beginning of the file
as the reference position and 1 means use file use the current
position as the reference position and if it is set to 2 then the
end of the file would be taken as the reference position.
55. Consider the following example.
• Example
1. # open the file file2.txt in read mode
2. fileptr = open("file2.txt","r")
3. #initially the filepointer is at 0
4. print("The filepointer is at byte :",fileptr.tell())
5. #changing the file pointer location to 10.
6. fileptr.seek(10);
7. #tell() returns the location of the fileptr.
8. print("After reading, the filepointer is at:",fileptr.tell())
• Output:
The filepointer is at byte : 0
After reading, the filepointer is at 10
56. Example
Let us take a file foo.txt,, which we created before.
• This produces the following result −
Read String is : Python is
Current file position : 10
Again read String is : Python is
57. Python os module
• The os module provides us the functions that are
involved in file processing operations like
• renaming,
• deleting, etc
• Let's look at some of the os module functions.
58. Renaming and Deleting Files
• Python os module provides methods that help you perform
file-processing operations, such as renaming deleting files.
• To use this module you need to import it first and then you
can call any related functions.
• The rename() Method
• The os module provides us the rename() method which is
used to rename the specified file to a new name.
• The rename() method takes two arguments, the current
filename and the new filename.
• Syntax:
os.rename(current_file_name, new_file_name)
59. Example
1. import os;
2. #rename file2.txt to file3.txt
3. os.rename("file2.txt","file3.txt")
• Following is the example to rename an existing file test1.txt −
#!/usr/bin/python
import os
# Rename a file from test1.txt to test2.txt os
os.rename( "test1.txt", "test2.txt" )
60. The remove() Method
• The os module provides us the remove() method which is
used to remove the specified file.
• You can use the remove() method to delete files by
supplying the name of the file to be deleted as the
argument.
• Syntax
os.remove(file_name)
61. Example
1. import os;
2. #deleting the file named file3.txt
3. os.remove("file3.txt")
• Following is the example to delete an existing file test2.txt−
#!/usr/bin/python
import os
# Delete file test2.txt
os.remove("text2.txt")
62. Directories in Python
• All files are contained within various directories, and Python has no
problem handling these too.
• The os module has several methods that help you create, remove,
and change directories.
• The mkdir() Method
• You can use the mkdir() method of the os module to create
directories in the current directory.
• You need to supply an argument to this method which contains the
name of the directory to be created.
• Syntax
os.mkdir("newdir")
63. Example
1. import os;
2. #creating a new directory with the name new
3. os.mkdir("new")
• Following is the example to create a directory test in the
current directory
#!/usr/bin/python
import os
# Create a directory "test"
os.mkdir("test")
64. The chdir() Method
• You can use the chdir() method to change the current
directory.
• The chdir() method takes an argument, which is the name of
the directory that you want to make the current directory.
• Syntax
os.chdir("newdir")
• Following is the example to go into "/home/newdir"
directory −
#!/usr/bin/python
import os
# Changing a directory to "/home/newdir"
os.chdir (“/home/newdir")
65. The getcwd() Method
• The getcwd() method displays the current working
directory.
• Syntax
os.getcwd()
• Example
• Following is the example to give current directory −
#!/usr/bin/python
import os
# This would give location of the current directory
os.getcwd()
66. The rmdir() Method
• The rmdir() method deletes the directory, which is passed as
an argument in the method.
• Before removing a directory, all the contents in it should be
removed.
• Syntax
os.rmdir('dirname')
67. Example
• Following is the example to remove "/tmp/test"
directory. It is required to give fully qualified name of the
directory, otherwise it would search for that directory in
the current directory.
• #!/usr/bin/python
• import os
• # This would remove "/tmp/test" directory.
• os.rmdir( "/tmp/test" )
68. Writing python output to the files
• In python, there are the requirements to write the
output of a python script to a file.
• The check_call() method of module subprocess is used to
execute a python script and write the output of that
script to a file.
• The following example contains two python scripts.
• The script file1.py executes the script file.py and writes
its output to the text file output.txt
69. file1.py:
1. temperatures=[10,-20,-289,100]
2. def c_to_f(c):
3. if c< -273.15:
4. return "That temperature doesn't make sense!"
5. else:
6. f=c*9/5+32
7. return f
8. for t in temperatures:
9. print(c_to_f(t))
70. file.py:
1. import subprocess
2. with open("output.txt", "wb") as f:
3. subprocess.check_call(["python", "file.py"], stdout=f)
Output:
50
-4
That temperature doesn't make sense!
212
71. File & Directory Related Methods
• There are some important sources, which provide a wide
range of utility methods to handle and manipulate files &
directories on Windows and Unix operating systems.
• They are as follows −
• File Object Methods: The file object provides functions to
manipulate files.
• OS Object Methods: This provides methods to process files as
well as directories.
73. Python Modules
• A python module can be defined as a python program
file which contains a python code including python
functions, class, or variables.
• In other words, we can say that our python code file
saved with the extension (.py) is treated as the module.
• We may have a runnable code inside the python
module.
• Modules in Python provides us the flexibility to
organize the code in a logical way.
• To use the functionality of one module into another,
we must have to import the specific module.
74. • Modules refer to a file containing Python
statements and definitions.
• A file containing Python code, for
example: example.py, is called a module, and its
module name would be example.
• We use modules to break down large programs
into small manageable and organized files.
Furthermore, modules provide reusability of
code.
• We can define our most used functions in a
module and import it, instead of copying their
definitions into different programs.
75. Create a Module
• To create a module just save the code you want in a file
with the file extension .py:
• Example:
• Let us create a module.
• Type the following and save it as example.py.
# Python Module example
def add(a, b):
"""This program adds two numbers and return the
result"""
result = a + b
return result
76. Example
• In this example, we will create a module named as
file.py which contains a function func that contains a
code to print some message on the console.
• Let's create the module named as file.py.
1. #displayMsg prints a message to the name being
passed.
2. def displayMsg(name)
3. print("Hi "+name);
• Here, we need to include this module into our main
module to call the method displayMsg() defined in the
module named file.
77. Loading the module in our python
code
• We need to load the module in our python
code to use its functionality.
• Python provides two types of statements as
defined below.
1. The import statement
2. The from-import statement
78. The import statement
• The import statement is used to import all the
functionality of one module into another.
• Here, we must notice that we can use the
functionality of any python source file by
importing that file as the module into another
python source file.
• We can import multiple modules with a single
import statement, but a module is loaded once
regardless of the number of times, it has been
imported into our file.
79. • The syntax to use the import statement is given
below.
import module1,module2,........ module n
• Hence, if we need to call the function displayMsg()
defined in the file file.py, we have to import that file as
a module into our module as shown in the example
below.
• Example:
1. import file;
2. name = input("Enter the name?")
3. file.displayMsg(name)
• Output:
• Enter the name?John
• Hi John
80. The from-import statement
• Instead of importing the whole module into the
namespace, python provides the flexibility to
import only the specific attributes of a module.
• This can be done by using from? import
statement.
• The syntax to use the from-import statement is
given below.
from < module-name> import <name 1>, <name
2>..,<name n>
81. • Consider the following module named as
calculation which contains three functions as
summation, multiplication, and divide.
• calculation.py:
1. #place the code in the calculation.py
2. def summation(a,b):
3. return a+b
4. def multiplication(a,b):
5. return a*b;
6. def divide(a,b):
7. return a/b;
82. • Main.py:
1. from calculation import summation
2. #it will import only the summation() from
calculation.py
3. a = int(input("Enter the first number"))
4. b = int(input("Enter the second number"))
5. print("Sum = ",summation(a,b)) #we do not
need to specify the module name while
accessing summation()
83. • Output:
• Enter the first number10
• Enter the second number20
• Sum = 30
• The from...import statement is always better to use if
we know the attributes to be imported from the
module in advance.
• It doesn't let our code to be heavier.
• We can also import all the attributes from a module by
using *.
• Consider the following syntax.
from <module> import *
84. Import all names
• We can import all names(definitions) from a module
using the following construct:
• # import all names from the standard module math
from math import *
print("The value of pi is", pi)
• Here, we have imported all the definitions from the
math module.
• This includes all names visible in our scope except
those beginning with an underscore(private
definitions).
85. • Importing everything with the asterisk (*)
symbol is not a good programming practice.
• This can lead to duplicate definitions for an
identifier.
• It also hampers the readability of our code.
86. Variables in Module
• The module can contain functions, as already
described, but also variables of all types (arrays,
dictionaries, objects etc):
• Example
• Save this code in the file mymodule.py
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
87. • Example
• Import the module named mymodule, and
access the person1 dictionary:
import mymodule
a = mymodule.person1["age"]
print(a)
Output:
36
88. Naming a Module
• You can name the module file whatever you
like, but it must have the file extension .py
89. Re-naming a Module
• You can create an alias when you import a
module, by using the as keyword:
• Example
• Create an alias for mymodule called mx:
import mymodule as mx
a = mx.person1["age"]
print(a)
Output:
36
90. Built-in Modules
• There are several built-in modules in Python,
which you can import whenever you like.
• Example
• Import and use the platform module:
import platform
x = platform.system()
print(x)
Output:
Windows
91. Using the dir() Function
• There is a built-in function to list all the function names
(or variable names) in a module. The dir() function:
• Example
• List all the defined names belonging to the platform
module:
import platform
x = dir(platform)
print(x)
• Note: The dir() function can be used on all modules,
also the ones you create yourself.
93. Reloading a module
• The Python interpreter imports a module only
once during a session.
• This makes things more efficient. Here is an
example to show how this works.
• Suppose we have the following code in a module
named my_module.
• # This module shows the effect of
• # multiple imports and reload
print("This code got executed")
94. • Now we see the effect of multiple imports.
>>> import my_module
This code got executed
>>> import my_module
>>> import my_module
• We can see that our code got executed only
once. This goes to say that our module was
imported only once.
95. • Now if our module changed during the course of the
program, we would have to reload it.
• One way to do this is to restart the interpreter. But this
does not help much.
• Python provides a more efficient way of doing this.
• We can use the reload() function inside
the imp module to reload a module.
• We can do it in the following ways:
>>> import imp
>>> import my_module
This code got executed
>>> import my_module
>>> imp.reload(my_module)
This code got executed
<module 'my_module' from '.my_module.py'>
96. Scope of variables
• In Python, variables are associated with two types of
scopes.
• All the variables defined in a module contain the global
scope unless or until it is defined within a function.
• All the variables defined inside a function contain a
local scope that is limited to this function itself.
• We can not access a local variable globally.
• If two variables are defined with the same name with
the two different scopes, i.e., local and global, then the
priority will always be given to the local variable.
97. Example
1. name = "john"
2. def print_name(name):
3. print("Hi",name) #prints the name that is
local to this function only.
4. name = input("Enter the name?")
5. print_name(name)
Output:
Hi David
98. Python packages
• We don't usually store all of our files on our computer in
the same location.
• We use a well-organized hierarchy of directories for easier
access.
• Similar files are kept in the same directory, for example, we
may keep all the songs in the "music" directory.
• Analogous to this, Python has packages for directories
and modules for files.
• As our application program grows larger in size with a lot of
modules, we place similar modules in one package and
different modules in different packages.
• This makes a project (program) easy to manage and
conceptually clear.
99. • Suppose you have developed a very large
application that includes many modules.
• As the number of modules grows, it becomes
difficult to keep track of them all if they are
dumped into one location.
• This is particularly so if they have similar
names or functionality.
• You might wish for a means of grouping and
organizing them.
• Packages allow for a hierarchical structuring of
the module namespace using dot notation.
100. • Packages are namespaces which contain multiple
packages and modules themselves.
• They are simply directories, but with a twist.
• Each package in Python is a directory
which MUST contain a special file called __init__.py.
• This file can be empty, and it indicates that the
directory it contains is a Python package, so it can be
imported the same way a module can be imported.
• If we create a directory called foo, which marks the
package name, we can then create a module inside
that package called bar.
• We also must not forget to add the __init__.py file
inside the foo directory.
101. • To use the module bar, we can import it in two ways:
import foo.bar
• or:
from foo import bar
• In the first method, we must use the foo prefix
whenever we access the module bar. In the second
method, we don't, because we import the module to
our module's namespace.
• The __init__.py file can also decide which modules the
package exports as the API, while keeping other
modules internal, by overriding the __all__ variable,
like so:
__init__.py:
__all__ = ["bar"]
102. • Similarly, as a directory can contain subdirectories
and files, a Python package can have sub-
packages and modules.
• A directory must contain a file named __init__.
py in order for Python to consider it as a package.
• This file can be left empty but we generally place
the initialization code for that package in this file.
• Here is an example.
• Suppose we are developing a game.
• One possible organization of packages and
modules could be as shown in the figure on the
next slide.
104. Let's create a package named Employees in your
home directory. Consider the following
steps.
1. Create a directory with name Employees on path
/home.
2. Create a python source file with name ITEmployees.py
on the path /home/Employees.
TEmployees.py
1. def getITNames():
2. List = ["John", "David", "Nick", "Martin"]
3. return List;
3. Similarly, create one more python file with name
BPOEmployees.py and create a function
getBPONames().
105. 4. Now, the directory Employees which we have
created in the first step contains two python
modules. To make this directory a package, we
need to include one more file here, that is
__init__.py which contains the import statements
of the modules defined in this directory.
__init__.py
1. from ITEmployees import getITNames
2. from BPOEmployees import getBPONames
5. Now, the directory Employees has become the
package containing two python modules. Here
we must notice that we must have to create
__init__.py inside a directory to convert this
directory to a package.
106. • 6. To use the modules defined inside the
package Employees, we must have to import
this in our python source file. Let's create a
simple python source file at our home
directory (/home) which uses the modules
defined in this package.
• Test.py
• 1. import Employees
• 2. print(Employees.getNames())
• Output:
• ['John', 'David', 'Nick', 'Martin']
107. • We can have sub-packages inside the
packages.
• We can nest the packages up to any level
depending upon the application requirements.
• The sub-packages contain the python
modules.
108. Importing module from a package
• We can import modules from packages using the
dot (.) operator.
• For example, if we want to import
the start module in the above example, it can be
done as follows:
import Game.Level.start
• Now, if this module contains
a function named select_difficulty(), we must use
the full name to reference it.
Game.Level.start.select_difficulty(2)
109. • If this construct seems lengthy, we can import the
module without the package prefix as follows:
from Game.Level import start
• We can now call the function simply as follows:
start.select_difficulty(2)
• Another way of importing just the required
function (or class or variable) from a module
within a package would be as follows:
from Game.Level.start import select_difficulty
• Now we can directly call this function.
select_difficulty(2)
110. Python OOPs Concepts
• Like other general purpose languages, python
is also an object-oriented language since its
beginning.
• Python is an object-oriented programming
language.
• It allows us to develop applications using an
Object Oriented approach.
• In Python, we can easily create and use classes
and objects.
111. Major principles of object-oriented
programming system are given below.
o Object
o Class
o Method
o Inheritance
o Polymorphism
o Data Abstraction
o Encapsulation
112. Object
• The object is an entity that has state and
behaviour.
• It may be any real-world object like the
mouse, keyboard, chair, table, pen, etc.
• Everything in Python is an object, and almost
everything has attributes and methods.
• All functions have a built-in attribute __doc__,
which returns the doc string defined in the
function source code.
113. Class
• The class can be defined as a collection of objects.
• It is a logical entity that has some specific attributes and
methods.
• For example: if you have an employee class then it should
contain an attribute and method, i.e. an email id, name,
age, salary, etc.
Syntax
1. class ClassName:
2. <statement-1>
3. .
4. .
5. <statement-N>
114. Method
• The method is a function that is associated
with an object.
• In Python, a method is not unique to class
instances.
• Any object type can have methods.
115. Inheritance
• Inheritance is the most important aspect of object-
oriented programming which simulates the real world
concept of inheritance.
• It specifies that the child object acquires all the
properties and behaviors of the parent object.
• By using inheritance, we can create a class which uses
all the properties and behavior of another class.
• The new class is known as a derived class or child class,
and the one whose properties are acquired is known as
a base class or parent class.
• It provides re-usability of the code.
116. Polymorphism
• Polymorphism contains two words "poly" and
"morphs".
• Poly means many and Morphs means form, shape. By
polymorphism, we understand that one task can be
performed in different ways.
• For example You have a class animal, and all animals
speak. But they speak differently.
• Here, the "speak" behavior is polymorphic in the sense
and depends on the animal.
• So, the abstract "animal" concept does not actually
"speak", but specific animals (like dogs and cats) have a
concrete implementation of the action "speak".
117. Encapsulation
• Encapsulation is also an important aspect of
object-oriented programming.
• It is used to restrict access to methods and
variables.
• In encapsulation, code and data are wrapped
together within a single unit from being
modified by accident.
118. Data Abstraction
• Data abstraction and encapsulation both are
often used as synonyms.
• Both are nearly synonym because data
abstraction is achieved through encapsulation.
• Abstraction is used to hide internal details and
show only functionalities.
• Abstracting something means to give names
to things so that the name captures the core
of what a function or a whole program does.
120. Creating classes
• In python, a class can be created by using the keyword class
followed by the class name.
• The syntax to create a class is given below.
• Syntax
1. class ClassName:
2. #statement_suite
• In python, we must notice that each class is associated with
a documentation string which can be accessed by using
<class-name>.__doc__.
• A class contains a statement suite including fields,
constructor, function, etc. definition.
• Consider the following example to create a class Employee
which contains two fields as Employee id, and name.
• The class also contains a function display() which is used to
display the information of the Employee.
121. Example
1. class Employee:
2. id = 10;
3. name = "ayush"
4. def display (self):
5. print(self.id,self.name)
• Here, the self is used as a reference variable which
refers to the current class object.
• It is always the first argument in the function
definition.
• However, using self is optional in the function call.
122. Creating an instance of the class
• A class needs to be instantiated if we want to use
the class attributes in another class or method.
• A class can be instantiated by calling the class
using the class name.
• The syntax to create the instance of the class is
given below.
<object-name> = <class-name>(<arguments>)
• The following example creates the instance of the
class Employee defined in the above example.
123. Example
1. class Employee:
2. id = 10;
3. name = "John"
4. def display (self):
5. print("ID: %d nName: %s"%(self.id,self.name))
6. emp = Employee()
7. emp.display()
Output:
ID: 10
Name: ayush
124. Python Constructor
• A constructor is a special type of method
(function) which is used to initialize the instance
members of the class.
• Constructors can be of two types.
1. Parameterized Constructor
2. Non-parameterized Constructor
• Constructor definition is executed when we
create the object of this class.
• Constructors also verify that there are enough
resources for the object to perform any start-up
task.
125. Creating the constructor
• In python, the method __init__ simulates the
constructor of the class.
• This method is called when the class is
instantiated.
• We can pass any number of arguments at the
time of creating the class object, depending upon
__init__ definition.
• It is mostly used to initialize the class attributes.
• Every class must have a constructor, even if it
simply relies on the default constructor.
126. Consider the following example to initialize the
Employee class attributes.
1. class Employee:
2. def __init__(self,name,id):
3. self.id = id;
4. self.name = name;
5. def display (self):
6. print("ID: %d nName: %s"%(self.id,self.name))
7. emp1 = Employee("John",101)
8. emp2 = Employee("David",102)
9. #accessing display() method to print employee 1 information
10. emp1.display();
11. #accessing display() method to print employee 2 information
12. emp2.display();
128. Example
• Counting the number of objects of a class
1. class Student:
2. count = 0
3. def __init__(self):
4. Student.count = Student.count + 1
5. s1=Student()
6. s2=Student()
7. s3=Student()
8. print("The number of students:",Student.count)
Output:
The number of students: 3
129. Python Non-Parameterized
Constructor Example
1. class Student:
2. # Constructor - non parameterized
3. def __init__(self):
4. print("This is non parametrized constructor")
5. def show(self,name):
6. print("Hello",name)
7. student = Student()
8. student.show("John")
Output:
This is non parametrized constructor
Hello John
130. Python Parameterized Constructor
Example
1. class Student:
2. # Constructor - parameterized
3. def __init__(self, name):
4. print("This is parametrized constructor")
5. self.name = name
6. def show(self):
7. print("Hello",self.name)
8. student = Student("John")
9. student.show()
Output:
This is parametrized constructor
Hello John
131. Python In-built class functions
• The in-built functions defined in the class are
described in the following table.
132. Example
1. class Student:
2. def __init__(self,name,id,age):
3. self.name = name;
4. self.id = id;
5. self.age = age
6. #creates the object of the class Student
7. s = Student("John",101,22)
8. #prints the attribute name of the object s
133. 9. print(getattr(s,'name'))
10. # reset the value of attribute age to 23
11. setattr(s,"age",23)
12. # prints the modified value of age
13. print(getattr(s,'age'))
14. # prints true if the student contains the
attribute with name id
15. print(hasattr(s,'id'))
16. # deletes the attribute age
17. delattr(s,'age')
18. # this will give an error since the attribute age
has been deleted
19. print(s.age)
134. • Output:
• John
• 23
• True
• AttributeError: 'Student' object has no
attribute 'age'
135. Built-in class attributes
• Along with the other attributes, a python class also
contains some built-in class
• attributes which provide information about the class.
• The built-in class attributes are given in the below table.
137. Python Inheritance
• Inheritance is an important aspect of the object-oriented
paradigm. Inheritance provides code reusability to the
program because we can use an existing class to create a
new class instead of creating it from scratch.
• In inheritance, the child class acquires the properties and
can access all the data members and functions defined in
the parent class.
• A child class can also provide its specific implementation to
the functions of the parent class. In this section of the
tutorial, we will discuss inheritance in detail.
• In python, a derived class can inherit base class by just
mentioning the base in the bracket after the derived class
name.
• Consider the following syntax to inherit a base class into
the derived class.
138. • Syntax
1. class derived-class(base class):
2. <class-suite>
• A class can inherit multiple classes by mentioning
all of them inside the bracket.
• Consider the following syntax.
• Syntax
1. class derive-class(<base class 1>, <base class 2>,
..... <base class n>):
2. <class - suite>
139. Example
1. class Animal:
2. def speak(self):
3. print("Animal Speaking")
4. #child class Dog inherits the base class Animal
5. class Dog(Animal):
6. def bark(self):
7. print("dog barking")
8. d = Dog()
9. d.bark()
10. d.speak()
Output:
dog barking
Animal Speaking
140. Multi-Level inheritance
• Multi-Level inheritance is possible
in python like other object-oriented
languages.
• Multi-level inheritance is archived
when a derived class inherits
another derived class.
• There is no limit on the number of
levels up to which, the multi-level
inheritance is archived in python.
141. • The syntax of multi-level inheritance is given
below.
• Syntax
1. class class1:
2. <class-suite>
3. class class2(class1):
4. <class suite>
5. class class3(class2):
6. <class suite>
142. Example
1. class Animal:
2. def speak(self):
3. print("Animal Speaking")
4. #The child class Dog inherits the base class Animal
5. class Dog(Animal):
6. def bark(self):
7. print("dog barking")
8. #The child class Dogchild inherits another child class Dog
9. class DogChild(Dog):
10. def eat(self):
11. print("Eating bread...")
12. d = DogChild()
13. d.bark()
14. d.speak()
15. d.eat()
145. • The syntax to perform multiple inheritance is
given below.
• Syntax
1. class Base1:
2. <class-suite>
3. class Base2:
4. <class-suite>
5. class BaseN:
6. <class-suite>
7. class Derived(Base1, Base2, ...... BaseN):
8. <class-suite>
146. Example
1. class Calculation1:
2. def Summation(self,a,b):
3. return a+b;
4. class Calculation2:
5. def Multiplication(self,a,b):
6. return a*b;
7. class Derived(Calculation1,Calculation2):
8. def Divide(self,a,b):
9. return a/b;
10. d = Derived()
11. print(d.Summation(10,20))
12. print(d.Multiplication(10,20))
13. print(d.Divide(10,20))
• Output:
• 30
• 200
• 0.5
147. issubclass(sub,sup) method
• The issubclass(sub, sup) method is used to
check the relationships between the specified
classes.
• It returns true if the first class is the subclass
of the second class, and false otherwise.
148. Example
1. class Calculation1:
2. def Summation(self,a,b):
3. return a+b;
4.
5. class Calculation2:
6. def Multiplication(self,a,b):
7. return a*b;
8. class Derived(Calculation1,Calculation2):
9. def Divide(self,a,b):
10. return a/b;
11. d = Derived()
12. print(issubclass(Derived,Calculation2))
13. print(issubclass(Calculation1,Calculation2))
Output:
True
False
149. The isinstance (obj, class) method
• The isinstance() method is used to check the
relationship between the objects and classes.
• It returns true if the first parameter, i.e., obj is
the instance of the second parameter, i.e.,
class.
150. Example
1. class Calculation1:
2. def Summation(self,a,b):
3. return a+b;
4. class Calculation2:
5. def Multiplication(self,a,b):
6. return a*b;
7. class Derived(Calculation1,Calculation2):
8. def Divide(self,a,b):
9. return a/b;
10. d = Derived()
11. print(isinstance(d,Derived))
Output:
True
151. Method Overriding
• We can provide some specific implementation of
the parent class method in our child class.
• When the parent class method is defined in the
child class with some specific implementation,
then the concept is called method overriding.
• We may need to perform method overriding in
the scenario where the different definition of a
parent class method is needed in the child class.
152. Example
1. class Animal:
2. def speak(self):
3. print("speaking")
4. class Dog(Animal):a
5. def speak(self):
6. print("Barking")
7. d = Dog()
8. d.speak()
Output:
Barking
153. Real Life Example of method
overriding
1. class Bank:
2. def getroi(self):
3. return 10;
4. class SBI(Bank):
5. def getroi(self):
6. return 7;
7. class ICICI(Bank):
8. def getroi(self):
9. return 8;
10. b1 = Bank()
11. b2 = SBI()
12. b3 = ICICI()
13. print("Bank Rate of interest:",b1.getroi());
14. print("SBI Rate of interest:",b2.getroi());
15. print("ICICI Rate of interest:",b3.getroi());
154. Output:
Bank Rate of interest: 10
SBI Rate of interest: 7
ICICI Rate of interest: 8
155. Data abstraction
• Abstraction is an important aspect of object-
oriented programming.
• In python, we can also perform data hiding by
adding the double underscore (___) as a prefix
to the attribute which is to be hidden.
• After this, the attribute will not be visible
outside of the class through the object.
156. Example
1. class Employee:
2. __count = 0;
3. def __init__(self):
4. Employee.__count = Employee.__count+1
5. def display(self):
6. print("The number of employees",Employee.__count)
7. emp = Employee()
8. emp2 = Employee()
9. try:
10. print(emp.__count)
11. finally:
12. emp.display()
Output:
The number of employees 2
AttributeError: 'Employee' object has no attribute '__count'