Unit 2

Numbers

2.1 Algorithm and Flowchart

Algorithm

What is an Algorithm?

An algorithm is a process or a set of rules required to perform calculations or some other problem-solving operations especially by a computer. The formal definition of an algorithm is that it contains the finite set of instructions which are being carried in a specific order to perform the specific task. It is not the complete program or code; it is just a solution (logic) of a problem, which can be represented either as an informal description using a Flowchart or Pseudocode.

Characteristics of an Algorithm

The following are the characteristics of an algorithm:

• Input: An algorithm has some input values. We can pass 0 or some input value to an algorithm.
• Output: We will get 1 or more output at the end of an algorithm.
• Unambiguity: An algorithm should be unambiguous which means that the instructions in an algorithm should be clear and simple.
• Finiteness: An algorithm should have finiteness. Here, finiteness means that the algorithm should contain a limited number of instructions, i.e., the instructions should be countable.
• Effectiveness: An algorithm should be effective as each instruction in an algorithm affects the overall process.
• Language independent: An algorithm must be language-independent so that the instructions in an algorithm can be implemented in any of the languages with the same output.

Dataflow of an Algorithm

• Problem: A problem can be a real-world problem or any instance from the real-world problem for which we need to create a program or the set of instructions. The set of instructions is known as an algorithm.
• Algorithm: An algorithm will be designed for a problem which is a step by step procedure.
• Input: After designing an algorithm, the required and the desired inputs are provided to the algorithm.
• Processing unit: The input will be given to the processing unit, and the processing unit will produce the desired output.
• Output: The output is the outcome or the result of the program.

Why do we need Algorithms?

We need algorithms because of the following reasons:

• Scalability: It helps us to understand the scalability. When we have a big real-world problem, we need to scale it down into small-small steps to easily analyze the problem.
• Performance: The real-world is not easily broken down into smaller steps. If the problem can be easily broken into smaller steps means that the problem is feasible.

Let's understand the algorithm through a real-world example. Suppose we want to make a lemon juice, so following are the steps required to make a lemon juice:

Step 1: First, we will cut the lemon into half.

Step 2: Squeeze the lemon as much you can and take out its juice in a container.

Step 3: Add two tablespoon sugar in it.

Step 4: Stir the container until the sugar gets dissolved.

Step 5: When sugar gets dissolved, add some water and ice in it.

Step 6: Store the juice in a fridge for 5 to minutes.

Step 7: Now, it's ready to drink.

The above real-world can be directly compared to the definition of the algorithm. We cannot perform the step 3 before the step 2, we need to follow the specific order to make lemon juice. An algorithm also says that each and every instruction should be followed in a specific order to perform a specific task.

Now we will look an example of an algorithm in programming.

We will write an algorithm to add two numbers entered by the user.

The following are the steps required to add two numbers entered by the user:

Step 1: Start

Step 2: Declare three variables a, b, and sum.

Step 3: Enter the values of a and b.

Step 4: Add the values of a and b and store the result in the sum variable, i.e., sum=a+b.

Step 5: Print sum

Step 6: Stop

Factors of an Algorithm

The following are the factors that we need to consider for designing an algorithm:

• Modularity: If any problem is given and we can break that problem into small-small modules or small-small steps, which is a basic definition of an algorithm, it means that this feature has been perfectly designed for the algorithm.
• Correctness: The correctness of an algorithm is defined as when the given inputs produce the desired output, which means that the algorithm has been designed algorithm. The analysis of an algorithm has been done correctly.
• Maintainability: Here, maintainability means that the algorithm should be designed in a very simple structured way so that when we redefine the algorithm, no major change will be done in the algorithm.
• Functionality: It considers various logical steps to solve the real-world problem.
• Robustness: Robustness means that how an algorithm can clearly define our problem.
• User-friendly: If the algorithm is not user-friendly, then the designer will not be able to explain it to the programmer.
• Simplicity: If the algorithm is simple then it is easy to understand.
• Extensibility: If any other algorithm designer or programmer wants to use your algorithm then it should be extensible.

Importance of Algorithms

1. Theoretical importance: When any real-world problem is given to us and we break the problem into small-small modules. To break down the problem, we should know all the theoretical aspects.
2. Practical importance: As we know that theory cannot be completed without the practical implementation. So, the importance of algorithm can be considered as both theoretical and practical.

Issues of Algorithms

The following are the issues that come while designing an algorithm:

• How to design algorithms: As we know that an algorithm is a step-by-step procedure so we must follow some steps to design an algorithm.
• How to analyze algorithm efficiency

Approaches of Algorithm

The following are the approaches used after considering both the theoretical and practical importance of designing an algorithm:

• Brute force algorithm: The general logic structure is applied to design an algorithm. It is also known as an exhaustive search algorithm that searches all the possibilities to provide the required solution. Such algorithms are of two types:
  1. Optimizing: Finding all the solutions of a problem and then take out the best solution or if the value of the best solution is known then it will terminate if the best solution is known.
  2. Sacrificing: As soon as the best solution is found, then it will stop.
• Divide and conquer: It is a very implementation of an algorithm. It allows you to design an algorithm in a step-by-step variation. It breaks down the algorithm to solve the problem in different methods. It allows you to break down the problem into different methods, and valid output is produced for the valid input. This valid output is passed to some other function.
• Greedy algorithm: It is an algorithm paradigm that makes an optimal choice on each iteration with the hope of getting the best solution. It is easy to implement and has a faster execution time. But, there are very rare cases in which it provides the optimal solution.
• Dynamic programming: It makes the algorithm more efficient by storing the intermediate results. It follows five different steps to find the optimal solution for the problem:
  1. It breaks down the problem into a subproblem to find the optimal solution.
  2. After breaking down the problem, it finds the optimal solution out of these subproblems.
  3. Stores the result of the subproblems is known as memorization.
  4. Reuse the result so that it cannot be recomputed for the same subproblems.
  5. Finally, it computes the result of the complex program.
• Branch and Bound Algorithm: The branch and bound algorithm can be applied to only integer programming problems. This approach divides all the sets of feasible solutions into smaller subsets. These subsets are further evaluated to find the best solution.
• Randomized Algorithm: As we have seen in a regular algorithm, we have predefined input and required output. Those algorithms that have some defined set of inputs and required output, and follow some described steps are known as deterministic algorithms. What happens that when the random variable is introduced in the randomized algorithm?. In a randomized algorithm, some random bits are introduced by the algorithm and added in the input to produce the output, which is random in nature. Randomized algorithms are simpler and efficient than the deterministic algorithm.
• Backtracking: Backtracking is an algorithmic technique that solves the problem recursively and removes the solution if it does not satisfy the constraints of a problem.

The major categories of algorithms are given below:

• Sort: Algorithm developed for sorting the items in a certain order.
• Search: Algorithm developed for searching the items inside a data structure.
• Delete: Algorithm developed for deleting the existing element from the data structure.
• Insert: Algorithm developed for inserting an item inside a data structure.
• Update: Algorithm developed for updating the existing element inside a data structure.

Algorithm Analysis

The algorithm can be analyzed in two levels, i.e., first is before creating the algorithm, and second is after creating the algorithm. The following are the two analysis of an algorithm:

• Priori Analysis: Here, priori analysis is the theoretical analysis of an algorithm which is done before implementing the algorithm. Various factors can be considered before implementing the algorithm like processor speed, which has no effect on the implementation part.
• Posterior Analysis: Here, posterior analysis is a practical analysis of an algorithm. The practical analysis is achieved by implementing the algorithm using any programming language. This analysis basically evaluate that how much running time and space taken by the algorithm.

Algorithm Complexity

The performance of the algorithm can be measured in two factors:

• Time complexity: The time complexity of an algorithm is the amount of time required to complete the execution. The time complexity of an algorithm is denoted by the big O notation. Here, big O notation is the asymptotic notation to represent the time complexity. The time complexity is mainly calculated by counting the number of steps to finish the execution. Let's understand the time complexity through an example.

1. Sum=0;  
2. // Suppose we have to calculate the sum of n numbers.  
3. For i=1 to n  
4. Sum=sum+i;  
5. // when the loop ends then sum holds the sum of the n numbers  
6. Return sum;  

In the above code, the time complexity of the loop statement will be atleast n, and if the value of n increases, then the time complexity also increases. While the complexity of the code, i.e., return sum will be constant as its value is not dependent on the value of n and will provide the result in one step only. We generally consider the worst-time complexity as it is the maximum time taken for any given input size.

• Space complexity: An algorithm's space complexity is the amount of space required to solve a problem and produce an output. Similar to the time complexity, space complexity is also expressed in big O notation.

For an algorithm, the space is required for the following purposes:

1. To store program instructions
2. To store constant values
3. To store variable values
4. To track the function calls, jumping statements, etc.

Auxiliary space: The extra space required by the algorithm, excluding the input size, is known as an auxiliary space. The space complexity considers both the spaces, i.e., auxiliary space, and space used by the input.

So,

Space complexity = Auxiliary space + Input size.

Types of Algorithms

The following are the types of algorithm:

• Search Algorithm
• Sort Algorithm

Search Algorithm

On each day, we search for something in our day to day life. Similarly, with the case of computer, huge data is stored in a computer that whenever the user asks for any data then the computer searches for that data in the memory and provides that data to the user. There are mainly two techniques available to search the data in an array:

• Linear search
• Binary search

Linear Search

Linear search is a very simple algorithm that starts searching for an element or a value from the beginning of an array until the required element is not found. It compares the element to be searched with all the elements in an array, if the match is found, then it returns the index of the element else it returns -1. This algorithm can be implemented on the unsorted list.

Binary Search

A Binary algorithm is the simplest algorithm that searches the element very quickly. It is used to search the element from the sorted list. The elements must be stored in sequential order or the sorted manner to implement the binary algorithm. Binary search cannot be implemented if the elements are stored in a random manner. It is used to find the middle element of the list.

Sorting Algorithms

Sorting algorithms are used to rearrange the elements in an array or a given data structure either in an ascending or descending order. The comparison operator decides the new order of the elements.

Why do we need a sorting algorithm?

• An efficient sorting algorithm is required for optimizing the efficiency of other algorithms like binary search algorithm as a binary search algorithm requires an array to be sorted in a particular order, mainly in ascending order.
• It produces information in a sorted order, which is a human-readable format.
• Searching a particular element in a sorted list is faster than the unsorted list.

Flowchart

Flowchart could be a delineate illustration of sequence of logical steps of a program. Flowcharts use easy geometric shapes to depict processes and arrows to indicate relationships and process/data flow.

Flowchart Symbols

Here is a chart for some of the common symbols used in drawing flowcharts.

Symbol	Symbol Name	Purpose
	Start/Stop	Used at the beginning and end of the algorithm to show start and end of the program.
	Process	Indicates processes like mathematical operations.
	Input/ Output	Used for denoting program inputs and outputs.
	Decision	Stands for decision statements in a program, where answer is usually Yes or No.
	Arrow	Shows relationships between different shapes.
	On-page Connector	Connects two or more parts of a flowchart, which are on the same page.
	Off-page Connector	Connects two parts of a flowchart which are spread over different pages.

Guidelines for Developing Flowcharts

These area unit some points to stay in mind whereas developing a flow chart flow chart

• Flowchart will have only 1 begin and one stop image

• On-page connectors area unit documented victimization numbers

• Off-page connectors area unit documented victimization alphabets

• General flow of processes is prime to bottom or left to right

• Arrows mustn't cross one another

Example Flowcharts

Here is the flowchart for going to the market to purchase a pen.

Here is a flowchart to calculate the average of two numbers.

2.2 Introduction to Python and Setting up the Python development environment

What is Python?

Python may be a programing language that's straightforward to find out, nonetheless powerful and versatile. Several skilled code engineers use Python daily to try and do their job, for each giant comes and little ones. Python is free, open supply, and it runs on Windows, Mac, and Linux, in addition as several different operational systems. It is a nice language if you would like to start out learning the way to write pc programs.

What Do I Need?

To effectively use Python on Windows, you would like some items of software:

• Python

• Cygwin

• Sublime Text or another text editor

Let's handle them one at a time.

Installing Python

Download the version of Python that you simply wish. In these examples, i am downloading Python three.2.3.

Run the installer, and let it install to the default location: in this case, C:\Python32\.

That was easy!

Installing Cygwin

This is a bit more complicated. First, go to the Cygwin homepage, download setup.exe, and run it.

Cygwin may be a program that may transfer and install different programs from the web for you. You'll have to relinquish it some info regarding your web association, though most of the time you'll simply settle for the defaults and keep going.

Next, Cygwin can show you a protracted list of transfer sites. Each is precisely the same: you'll decide one randomly. You are doing not ought to decide an equivalent transfer web site shown within the screenshot. Once you have picked one and clicked the "next" button, you will see Associate in Nursing upgrade warning, however that solely applies to folks upgrading from Associate in Nursing older version of Cygwin. Since this is often a replacement installation, we will ignore it.

Now, we have a tendency to get to pick out what code we would like to put in from the transfer web site. We would like to put in 3 code packages: openssh, git, and curl. For every one, use the search box to search out the package, so click on the word "Skip" in order that it changes to a version range. Install the newest on the market version for every of those packages.

Next, Cygwin can tell you that you simply ought to install sure different packages as dependencies. Basically, this suggests that if you would like to use an explicit package named A, and A depends on another package named B so as to run properly, then Cygwin can discover this and raise to put in package B in addition. You'll simply hit "Next". At that time, Cygwin can begin downloading and putting in all the packages that you've got requested, in addition as all their dependencies. Counting on the speed of your web association, this might take a bit whereas. Once the center of the 3 progress bars (the one marked "Total") is full, Cygwin is finished.

If you raise Cygwin to put in Associate in Nursing icon on your desktop, it'll do thus, making a road named "Cygwin Terminal". You will use this icon to run your Python code, in addition on access the openssh, git, and curl packages that you simply put in. Double-click the icon to run Cygwin Terminal, and you will see a window like this pop up:

The exact text in your terminal window are a bit completely different, since it depends on the name of your pc, and also the name of your user account. Currently we will begin victimisation the terminal: if you do not knowledge. First, let's use the that command to search out out wherever those packages area unit that we have a tendency to installed:

So it's just like the terminal will realize ssh and so-and-so, however not python. That is apprehensible, since we have a tendency to did not use Cygwin to put in Python. To inform Cygwin the way to realize Python, run the subsequent command:

Echo "PATH=$PATH:/cygdrive/c/Python32" >> .bash_profile

Note that you simply're victimisation an equivalent directory that you put in Python into: if you are putting in a unique version of Python, then replace Python32 with the version of Python you have got put in. You ought to solely ought to do that once: once you have run that command, the terminal can invariably be able to realize Python once more.

You're finally done installing and setting up Cygwin!

Installing Sublime Text

Lastly, you'll have a text editor. There area unit several smart choices, however I counsel chic Text it's totally powerful and helpful, and it's an infinite free trial. Please note that Microsoft Word may be a application, not a text editor: you can not use Microsoft Word for writing pc programs.

Installing chic Text is easy: simply visit grandeur Text homepage, transfer the installer, and install it. Chic Text isn't free code, however you'll strive it for as long as you wish before you get it. If you finish up writing several programs victimisation chic Text, I encourage you to shop for a license.

Verify that it all works

Now that you are equipped up, let's verify that everything is functioning properly! the primary program that any coder writes is termed "Hello, World!", and every one it will is write that text bent the terminal. So, let's write "Hello, World!" in Python! If your pc is ready up properly, this could work properly:

$ python -c 'print("Hello, World!")'

Hello, World!

If that works, lets advance to writing a program into a file. Open up chic Text, and sort within the following:

#!/usr/bin/env python

Print("Hello, World!")

Save the move into your home directory (inside of C:cygwinhome) as hullo.py. Then open up the Terminal, cd to it directory, and run:

$ chmoda+x hullo.py

$ ./hello.py

Hello, World!

And you ought to see an equivalent hullo, World! output that you simply saw before.

2.3 Basic syntax

The Python language has several similarities to Perl, C, and Java. However, there square measure some definite variations between the languages.

First Python Program

Let us execute programs in several modes of programming.

Interactive Mode Programming

Invoking the interpreter while not passing a script file as a parameter brings up the subsequent the subsequent

$ python

Python 2.4.3 (#1, Nov eleven 2010, 13:34:43)

[GCC 4.1.2 a pair of0080704 (Red Hat four.1.2-48)] on linux2

Type "help", "copyright", "credits" or "license" for a lot of info.

>>>

Type the subsequent text at the Python prompt and press the Enter −

>>> print "Hello, Python!"

If you're running new edition of Python, then you'd have to be compelled to use print statement with parenthesis as in print ("Hello, Python!");.but in Python version a pair of.4.3, this produces the subsequent the subsequent

Hello, Python!

Script Mode Programming

Invoking the interpreter with a script parameter begins execution of the script and continues till the script is finished. Once the script is finished, the interpreter isn't any longer active.

Let us write a straightforward Python program during a script. Python files have extension .py. Kind the subsequent ASCII text file during a take a look at.py file −

Print "Hello, Python!"

We assume that you just have Python interpreter set in PATH variable. Now, attempt to run this program as follows −

$ python take a look at.py

This produces the subsequent the subsequent

Hello, Python!

Let us attempt otherwise to execute a Python script. Here is that the changed take a look at.py file −

#!/usr/bin/python

Print "Hello, Python!"

We assume that you just have Python interpreter obtainable in /usr/bin directory. Now, attempt to run this program as follows −

$ chmod +x take a look at.py     # this is often to create file practicable

$./test.py

This produces the subsequent the subsequent

Hello, Python!

Python Identifiers

A Python symbol may be a name wont to determine a variable, function, class, module or different object. Associate degree symbol starts with a letter A to Z or a to z or associate degree underscore (_) followed by zero or a lot of letters, underscores and digits (0 to 9).

Python doesn't permit punctuation characters like @, $, and a pair of among identifiers. Python may be a case sensitive artificial language. Thus, force and force square measure 2 completely different identifiers in Python.

Here square measure naming conventions for Python identifiers −

• Class names begin with associate degree capital letter. All different identifiers begin with a lowercase  letter.

• Starting associate degree symbol with one leading underscore indicates that the symbol is non-public.

• Starting associate degree symbol with 2 leading underscores indicates a powerfully non-public symbol.

• If the symbol additionally ends with 2 trailing underscores, the symbol may be a language-defined special name.

Reserved Words

The following list shows the Python keywords. These are reserved words and you cannot use them as constant or variable or any other identifier names. All the Python keywords contain lowercase letters only.

Lines and Indentation

Python provides no braces to indicate blocks of code for class and function definitions or flow control. Blocks of code are denoted by line indentation, which is rigidly enforced.

The number of spaces in the indentation is variable, but all statements within the block must be indented the same amount. For example −

If True:

Print "True"

Else:

Print "False"

However, the following block generates an error −

If True:

Print "Answer"

Print "True"

Else:

Print "Answer"

Print "False"

Thus, in Python all the continuous lines indented with same number of spaces would form a block. The following example has various statement blocks −

Note− Do not try to understand the logic at this point of time. Just make sure you understood various blocks even if they are without braces.

#!/usr/bin/python

Import sys

Try:

# open file stream

File = open(file_name, "w")

ExceptIOError:

Print "There was an error writing to", file_name

Sys.exit()

Print "Enter '", file_finish,

Print "' When finished"

Whilefile_text != file_finish:

File_text = raw_input("Enter text: ")

Iffile_text == file_finish:

# close the file

File.close

Break

File.write(file_text)

File.write("\n")

File.close()

File_name = raw_input("Enter filename: ")

Iflen(file_name) == 0:

Print "Next time please enter something"

Sys.exit()

Try:

File = open(file_name, "r")

ExceptIOError:

Print "There was an error reading file"

Sys.exit()

File_text = file.read()

File.close()

Printfile_text

Multi-Line Statements

Statements in Python typically end with a new line. Python does, however, allow the use of the line continuation character (\) to denote that the line should continue. For example −

Total = item_one + \

Item_two + \

Item_three

Statements contained within the [], {}, or () brackets do not need to use the line continuation character. For example −

Days = ['Monday', 'Tuesday', 'Wednesday',

'Thursday', 'Friday']

Quotation in Python

Python accepts single ('), double (") and triple (''' or """) quotes to denote string literals, as long as the same type of quote starts and ends the string.

The triple quotes are used to span the string across multiple lines. For example, all the following are legal −

Word = 'word'

Sentence = "This is a sentence."

Paragraph = """This is a paragraph. It is

Made up of multiple lines and sentences."""

Comments in Python

A hash sign (#) that is not inside a string literal begins a comment. All characters after the # and up to the end of the physical line are part of the comment and the Python interpreter ignores them.

#!/usr/bin/python

# First comment

Print "Hello, Python!" # second comment

This produces the following result −

Hello, Python!

You can type a comment on the same line after a statement or expression −

Name = "Madisetti" # This is again comment

You can comment multiple lines as follows −

# This is a comment.

# This is a comment, too.

# This is a comment, too.

# I said that already.

Following triple-quoted string is also ignored by Python interpreter and can be used as a multiline comments:

'''

This is a multiline

Comment.

'''

Using Blank Lines

A line containing only whitespace, possibly with a comment, is known as a blank line and Python totally ignores it.

In an interactive interpreter session, you must enter an empty physical line to terminate a multiline statement.

Waiting for the User

The following line of the program displays the prompt, the statement saying “Press the enter key to exit”, and waits for the user to take action −

#!/usr/bin/python

Raw_input("\n\nPress the enter key to exit.")

Here, "\n\n" is used to create two new lines before displaying the actual line. Once the user presses the key, the program ends. This is a nice trick to keep a console window open until the user is done with an application.

Multiple Statements on a Single Line

The semicolon ( ; ) allows multiple statements on the single line given that neither statement starts a new code block. Here is a sample snip using the semicolon −

Import sys; x = 'foo'; sys.stdout.write(x + '\n')

Multiple Statement Groups as Suites

A group of individual statements, which make a single code block are called suites in Python. Compound or complex statements, such as if, while, def, and class require a header line and a suite.

Header lines begin the statement (with the keyword) and terminate with a colon ( : ) and are followed by one or more lines which make up the suite. For example −

If expression :

Suite

Elif expression :

Suite

Else :

Suite

Command Line Arguments

Many programs can be run to provide you with some basic information about how they should be run. Python enables you to do this with -h −

$ python -h

Usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser (also PYTHONDEBUG=x)

-E     : ignore environment variables (such as PYTHONPATH)

-h     : print this help message and exit

[ etc. ]

You can also program your script in such a way that it should accept various options. Command Line Arguments is an advanced topic and should be studied a bit later once you have gone through rest of the Python concepts.

2.4 Interactive shell, editing, saving, and running a script

Run Command

You can use run command in the input prompt to run a Python script. The run command is actually line magic command and should actually be written as %run. However, the %automagic mode is always on by default, so you can omit this.

In [1]: run hello.py

Hello IPython

Edit Command

IPython also provides edit magic command. It invokes default editor of the operating system. You can open it through Windows Notepad editor and the script can be edited. Once you close it after saving its input, the output of modified script will be displayed.

In [2]: edit hello.py

Editing... Done. Executing edited code...

Hello IPython

Welcome to interactive computing

Note that hello.py initially contained only one statement and after editing one more statement was added. If no file name is given to edit command, a temporary file is created. Observe the following code that shows the same.

In [7]: edit

IPython will make a temporary file named:

C:\Users\acer\AppData\Local\Temp\ipython_edit_4aa4vx8f\ipython_edit_t7i6s_er.py

Editing... Done. Executing edited code...

Magic of IPython

Out[7]: 'print ("magic of IPython")'

The Terms 'Interactive' and 'Shell'

The term "interactive" traces back to the Latin expression "inter agere". The verb "agere" means that amongst different things "to do something" and "to act", whereas "inter" denotes the abstraction and temporal position to things and events, i.e. "between" or "among" objects, persons, and events. Thus "inter agere" means that "to act between" or "to act among" these.

With this in mind, we will say that the interactive shell is between the user and also the software system (e.g. Linux, Unix, Windows or others). Rather than associate degree software system associate degree interpreter are often used for a artificial language like Python still. The Python interpreter are often used from associate degree interactive shell.

The interactive shell is additionally interactive within the means that it stands between the commands or actions and their execution. In different words, the shell waits for commands from the user, that it executes and returns the results of the execution. Afterwards, the shell waits for consequent input.

A shell in biology may be a carbonate "wall" that protects snails or mussels from its setting or its enemies. Similarly, a shell in software systems lies between the kernel of the operative system and also the user. It is a "protection" in each directions. The user does not ought to use the sophisticated basic functions of the OS however is capable of mistreatment the interactive shell that is comparatively straightforward and simple to grasp. The kernel is protected against unintentional and incorrect usages of system functions.

Python offers a snug instruction interface with the Python Shell, that is additionally referred to as the "Python Interactive Shell". It's just like the term "Interactive Shell" may be a tautology, as a result of "shell" is interactive on its own, a minimum of the sort of shells we've represented within the previous paragraphs.

Using the Python Interactive Shell

With the Python interactive interpreter it is easy to check Python commands. The Python interpreter can be invoked by typing the command "python" without any parameter followed by the "return" key at the shell prompt:

Python

Python comes back with the following information:

$ python

Python 2.7.11 (default, Mar 27 2019, 22:11:17)

[GCC 7.3.0] :: Anaconda, Inc. On linux

Type "help", "copyright", "credits" or "license" for more information.

A closer look at the output above reveals that we have the wrong Python version. We wanted to use Python 3.x, but what we got is the installed standard of the operating system, i.e. version 2.7.11+.

The easiest way to check if a Python 3.x version is installed: Open a Terminal. Type in python but no return. Instead, type the "Tab" key. You will see possible extensions and other installed versions, if there are some:

Bernd@venus:~$ $ python

Python             python3            python3.7-config   python-config

Python2            python3.6          python3.7m         pythontex

Python2.7          python3.6-config   python3.7m-config  pythontex3

Python2.7-config   python3.6m         python3-config     python-whiteboard

Python2-config     python3.6m-config  python3m          

Python2-pbr        python3.7          python3m-config  

Bernd@venus:~$ python

If no other Python version shows up, python3.x has to be installed. Afterwards, we can start the newly installed version by typing python3:

$ python3

Python 3.6.7 (default, Oct 22 2018, 11:32:17)

[GCC 8.2.0] on linux

Type "help", "copyright", "credits" or "license" for more information.

Once the Python interpreter is started, you can issue any command at the command prompt ">>>". Let's see, what happens, if we type in the word "hello":

Hello

---------------------------------------------------------------------------

NameErrorTraceback (most recent call last)

<ipython-input-1-f572d396fae9> in <module>

----> 1 hello

NameError: name 'hello' is not defined

Of course, "hello" is not a proper Python command, so the interactive shell returns ("raises") an error.

The first real command we will use is the print command. We will create the mandatory "Hello World" statement:

Print("Hello World")

Hello World

It couldn't have been easier, could it? Oh yes, it can be written in a even simpler way. In the Interactive Python Interpreter - but not in a program - the print is not necessary. We can just type in a string or a number and it will be "echoed"

"Hello World"

Output::

'Hello World'

3

Output::

3

How to Quit the Python Shell

So, we have just started, and we are already talking about quitting the shell. We do this, because we know, how annoying it can be, if you don't know how to properly quit a program.

It's easy to end the interactive session: You can either use exit() or Ctrl-D (i.e. EOF) to exit. The brackets behind the exit function are crucial. (Warning: Exit without brackets works in Python2.x but doesn't work anymore in Python3.x)

The Shell as a Simple Calculator

In the following example we use the interpreter as a simple calculator by typing an arithmetic expression:

4.567 * 8.323 * 17

Output::

646.189397

Python follows the usual order of operations in expressions. The standard order of operations is expressed in the following enumeration:

• Exponents and roots
• Multiplication and division
• Addition and subtraction

In other words, we don't need parentheses in the expression "3 + (2 * 4)":

3 + 2 * 4

Output::

11

The most recent output value is automatically stored by the interpreter in a special variable with the name "_". So we can print the output from the recent example again by typing an underscore after the prompt:

_

Output::

11

The underscore can be used in other expressions like any other variable:

_ * 3

Output::

33

The underscore variable is only available in the Python shell. It's NOT available in Python scripts or programs.

Using Variables

It's simple to use variables in the Python shell. If you are an absolute beginner and if you don't know anything about variables. Values can be saved in variables. Variable names don't require any special tagging, like they do in Perl, where you have to use dollar signs, percentage signs and at signs to tag variables:

Maximal = 124

Width = 94

Print(maximal - width)

30

Multiline Statements

We haven't introduced multiline statements so far. So beginners can skip the rest of this chapter and can continue with the following chapters.

We will show how the interactive prompt deals with multiline statements like for loops.

l = ["A", 42, 78, "Just a String"]

For character in l:

Print(character)

A

42

78

Just a String

After having input "for character in l: " the interpretor expects the input of the next line to be indented. In other words: the interpretor expects an indented block, which is the body of the loop. This indented block will be iterated. The interpretor shows this "expectation" by displaying three dots "..." instead of the standard Python interactive prompt ">>>". Another special feature of the interactive shell: when we are done with the indented lines, i.e. the block, we have to enter an empty line to indicate that the block is finished. Attention: the additional empty line is only necessary in the interactive shell! In a Python program, it is enough to return to the indentation level of the "for" line, the one with the colon ":" at the end.

Strings

Strings are created by putting a sequence of characters in quotes. Strings can be surrounded by single quotes, double quotes or triple quotes, which are made up of three single or three double quotes. Strings are immutable. In other words, once defined, they cannot be changed. We will cover this topic in detail in another chapter.

"Hello" + " " + "World"

Output::

'Hello World'

A string in triple quotes can span several lines without using the escape character:

City = """

... Toronto is the largest city in Canada

... And the provincial capital of Ontario.

... It is located in Southern Ontario on the

... Northwestern shore of Lake Ontario.

... """

Print(city)

Toronto is the largest city in Canada

And the provincial capital of Ontario.

It is located in Southern Ontario on the

Northwestern shore of Lake Ontario.

Multiplication on strings is defined, which is essentially a multiple concatenation:

".-." * 4

Output::

'.-..-..-..-.'

2.5 Concept of data types

Variables can hold values, and every value has a data-type. Python is a dynamically typed language; hence we do not need to define the type of the variable while declaring it. The interpreter implicitly binds the value with its type.

1. a = 5  

The variable a holds integer value five and we did not define its type. Python interpreter will automatically interpret variables a as an integer type.

Python enables us to check the type of the variable used in the program. Python provides us the type() function, which returns the type of the variable passed.

Consider the following example to define the values of different data types and checking its type.

1. a=10  
2. b="Hi Python"  
3. c = 10.5  
4. Print(type(a))  
5. Print(type(b))  
6. Print(type(c))  

Output:

<type 'int'>

<type 'str'>

<type 'float'>

Standard data types

A variable can hold different types of values. For example, a person's name must be stored as a string whereas its id must be stored as an integer.

Python provides various standard data types that define the storage method on each of them. The data types defined in Python are given below.

1. Numbers
2. Sequence Type
3. Boolean
4. Set
5. Dictionary

In this section of the tutorial, we will give a brief introduction of the above data-types. We will discuss each one of them in detail later in this tutorial.

Numbers

Number stores numeric values. The integer, float, and complex values belong to a Python Numbers data-type. Python provides the type() function to know the data-type of the variable. Similarly, the isinstance() function is used to check an object belongs to a particular class.

Python creates Number objects when a number is assigned to a variable. For example;

1. a = 5  
2. Print("The type of a", type(a))  
3.  
4. b = 40.5  
5. Print("The type of b", type(b))  
6.  
7. c = 1+3j  
8. Print("The type of c", type(c))  
9. Print(" c is a complex number", isinstance(1+3j,complex))  

Output:

The type of a <class 'int'>

The type of b <class 'float'>

The type of c <class 'complex'>

c is complex number: True

Python supports three types of numeric data.

1. Int - Integer value can be any length such as integers 10, 2, 29, -20, -150 etc. Python has no restriction on the length of an integer. Its value belongs to int
2. Float - Float is used to store floating-point numbers like 1.9, 9.902, 15.2, etc. It is accurate upto 15 decimal points.
3. Complex - A complex number contains an ordered pair, i.e., x + iy where x and y denote the real and imaginary parts, respectively. The complex numbers like 2.14j, 2.0 + 2.3j, etc.

Sequence Type

String

The string can be defined as the sequence of characters represented in the quotation marks. In Python, we can use single, double, or triple quotes to define a string.

String handling in Python is a straightforward task since Python provides built-in functions and operators to perform operations in the string.

In the case of string handling, the operator + is used to concatenate two strings as the operation "hello"+" python" returns "hello python".

The operator * is known as a repetition operator as the operation "Python" *2 returns 'Python Python'.

The following example illustrates the string in Python.

Example - 1

1. Str = "string using double quotes"  
2. Print(str)  
3. s = '''''A multiline 
4. String'''  
5. Print(s)  

Output:

String using double quotes

A multiline

String

Consider the following example of string handling.

Example - 2

1. Str1 = 'hello javatpoint' #string str1    
2. Str2 = ' how are you' #string str2    
3. Print (str1[0:2]) #printing first two character using slice operator    
4. Print (str1[4]) #printing 4th character of the string    
5. Print (str1*2) #printing the string twice    
6. Print (str1 + str2) #printing the concatenation of str1 and str2    

Output:

He

o

Hellojavatpointhellojavatpoint

Hellojavatpoint how are you

List

Python Lists are similar to arrays in C. However, the list can contain data of different types. The items stored in the list are separated with a comma (,) and enclosed within square brackets [].

We can use slice [:] operators to access the data of the list. The concatenation operator (+) and repetition operator (*) works with the list in the same way as they were working with the strings.

Consider the following example.

1. List1  = [1, "hi", "Python", 2]    
2. #Checking type of given list  
3. Print(type(list1))  
4.  
5. #Printing the list1  
6. Print (list1)  
7.  
8. # List slicing  
9. Print (list1[3:])  
10.  
11. # List slicing  
12. Print (list1[0:2])   
13.  
14. # List Concatenation using + operator  
15. Print (list1 + list1)  
16.  
17. # List repetation using * operator  
18. Print (list1 * 3)  

Output:

[1, 'hi', 'Python', 2]

[2]

[1, 'hi']

[1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2]

[1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2, 1, 'hi', 'Python', 2]

Tuple

A tuple is similar to the list in many ways. Like lists, tuples also contain the collection of the items of different data types. The items of the tuple are separated with a comma (,) and enclosed in parentheses ().

A tuple is a read-only data structure as we can't modify the size and value of the items of a tuple.

Let's see a simple example of the tuple.

1. Tup  = ("hi", "Python", 2)    
2. # Checking type of tup  
3. Print (type(tup))    
4.  
5. #Printing the tuple  
6. Print (tup)  
7.  
8. # Tuple slicing  
9. Print (tup[1:])    
10. Print (tup[0:1])    
11.  
12. # Tuple concatenation using + operator  
13. Print (tup + tup)    
14.  
15. # Tuple repatation using * operator  
16. Print (tup * 3)     
17.  
18. # Adding value to tup. It will throw an error.  
19. t[2] = "hi"  

Output:

<class 'tuple'>

('hi', 'Python', 2)

('Python', 2)

('hi',)

('hi', 'Python', 2, 'hi', 'Python', 2)

('hi', 'Python', 2, 'hi', 'Python', 2, 'hi', 'Python', 2)

Traceback (most recent call last):

File "main.py", line 14, in <module>

t[2] = "hi";

TypeError: 'tuple' object does not support item assignment

Dictionary

Dictionary is an unordered set of a key-value pair of items. It is like an associative array or a hash table where each key stores a specific value. Key can hold any primitive data type, whereas value is an arbitrary Python object.

The items in the dictionary are separated with the comma (,) and enclosed in the curly braces {}.

Consider the following example.

1. d = {1:'Jimmy', 2:'Alex', 3:'john', 4:'mike'}     
2.  
3. # Printing dictionary  
4. Print (d)  
5.  
6. # Accesing value using keys  
7. Print("1st name is "+d[1])   
8. Print("2nd name is "+ d[4])    
9.  
10. Print (d.keys())    
11. Print (d.values())    

Output:

1st name is Jimmy

2nd name is mike

{1: 'Jimmy', 2: 'Alex', 3: 'john', 4: 'mike'}

Dict_keys([1, 2, 3, 4])

Dict_values(['Jimmy', 'Alex', 'john', 'mike'])

Boolean

Boolean type provides two built-in values, True and False. These values are used to determine the given statement true or false. It denotes by the class bool. True can be represented by any non-zero value or 'T' whereas false can be represented by the 0 or 'F'. Consider the following example.

1. # Python program to check the boolean type  
2. Print(type(True))  
3. Print(type(False))  
4. Print(false)  

Output:

<class 'bool'>

<class 'bool'>

NameError: name 'false' is not defined

Set

Python Set is the unordered collection of the data type. It is iterable, mutable(can modify after creation), and has unique elements. In set, the order of the elements is undefined; it may return the changed sequence of the element. The set is created by using a built-in function set(), or a sequence of elements is passed in the curly braces and separated by the comma. It can contain various types of values. Consider the following example.

1. # Creating Empty set  
2. Set1 = set()  
3.  
4. Set2 = {'James', 2, 3,'Python'}  
5.  
6. #Printing Set value  
7. Print(set2)  
8.  
9. # Adding element to the set  
10.  
11. Set2.add(10)  
12. Print(set2)  
13.  
14. #Removing element from the set  
15. Set2.remove(2)  
16. Print(set2)  

Output:

{3, 'Python', 'James', 2}

{'Python', 'James', 3, 2, 10}

{'Python', 'James', 3, 10}

2.6 Random number, Real numbers

There is a need to generate random numbers when studying a model or behavior of a program for different range of values. Python can generate such random numbers by using the random module. In the below examples we will first see how to generate a single random number and then extend it to generate a list of random numbers.

Generating a Single Random Number

The random() method in random module generates a float number between 0 and 1.

Example

Import random

n =random.random()

Print(n)

Output

Running the above code gives us the following result −

0.2112200

Generating Number in a Range

The randint() method generates a integer between a given range of numbers.

Example

Import random

n =random.randint(0,22)

Print(n)

Output

Running the above code gives us the following result −

2

Generating a List of numbers Using For Loop

We can use the above randint() method along with a for loop to generate a list of numbers. We first create an empty list and then append the random numbers generated to the empty list one by one.

Example

Import random

Randomlist=[]

Foriin range(0,5):

n =random.randint(1,30)

Randomlist.append(n)

Print(randomlist)

Output

Running the above code gives us the following result −

[10, 5, 21, 1, 17]

Using random.sample()

We can also use the sample() method available in random module to directly generate a list of random numbers.Here we specify a range and give how many random numbers we need to generate.

Example

Import random

#Generate 5 random numbers between 10 and 30

Randomlist=random.sample(range(10,30),5)

Print(randomlist)

Output

Running the above code gives us the following result −

[16, 19, 13, 18, 15]

Python – Numbers

Number data types store numeric values. They are immutable data types, means that changing the value of a number data type results in a newly allocated object.

Number objects are created when you assign a value to them. For example −

Var1 = 1

Var2 = 10

You can also delete the reference to a number object by using the del statement. The syntax of the del statement is −

Del var1[,var2[,var3[....,varN]]]]

You can delete a single object or multiple objects by using the del statement. For example −

Delvar

Delvar_a, var_b

Python supports four different numerical types −

• Int (signed integers)− They are often called just integers or ints, are positive or negative whole numbers with no decimal point.
• Long (long integers )− Also called longs, they are integers of unlimited size, written like integers and followed by an uppercase or lowercase L.
• Float (floating point real values)− Also called floats, they represent real numbers and are written with a decimal point dividing the integer and fractional parts. Floats may also be in scientific notation, with E or e indicating the power of 10 (2.5e2 = 2.5 x 102 = 250).
• Complex (complex numbers)− are of the form a + bJ, where a and b are floats and J (or j) represents the square root of -1 (which is an imaginary number). The real part of the number is a, and the imaginary part is b. Complex numbers are not used much in Python programming.

Examples

Here are some examples of numbers

• Python allows you to use a lowercase L with long, but it is recommended that you use only an uppercase L to avoid confusion with the number 1. Python displays long integers with an uppercase L.
• A complex number consists of an ordered pair of real floating point numbers denoted by a + bj, where a is the real part and b is the imaginary part of the complex number.

Number Type Conversion

Python converts numbers internally in an expression containing mixed types to a common type for evaluation. But sometimes, you need to coerce a number explicitly from one type to another to satisfy the requirements of an operator or function parameter.

• Type int(x) to convert x to a plain integer.
• Type long(x) to convert x to a long integer.
• Type float(x) to convert x to a floating-point number.
• Type complex(x) to convert x to a complex number with real part x and imaginary part zero.
• Type complex(x, y) to convert x and y to a complex number with real part x and imaginary part y. x and y are numeric expressions

Mathematical Functions

Python includes following functions that perform mathematical calculations.

Random Number Functions

Random numbers are used for games, simulations, testing, security, and privacy applications. Python includes following functions that are commonly used.

Trigonometric Functions

Python includes following functions that perform trigonometric calculations.

Mathematical Constants

The module also defines two mathematical constants −

2.7 Immutable variables

Every variable in python holds an instance of an object. There are two types of objects in python i.e. Mutable and Immutable objects. Whenever an object is instantiated, it is assigned a unique object id. The type of the object is defined at the runtime and it can’t be changed afterwards. However, it’s state can be changed if it is a mutable object.

To summarise the difference, mutable objects can change their state or contents and immutable objects can’t change their state or content.

• Immutable Objects : These are of in-built types like int, float, bool, string, unicode, tuple. In simple words, an immutable object can’t be changed after it is created. 

Error :

Traceback (most recent call last):

File "e0eaddff843a8695575daec34506f126.py", line 3, in

Tuple1[0]=4

TypeError: 'tuple' object does not support item assignment

Error :

Traceback (most recent call last):

File "/home/ff856d3c5411909530c4d328eeca165b.py", line 3, in

Message[0] = 'p'

TypeError: 'str' object does not support item assignment

• Mutable Objects:These are of type list,dict,set. Custom classes are generally mutable. 

Output

['red', 'blue', 'green']

['pink', 'blue', 'orange']

Conclusion

1. Mutable and immutable objects are handled differently in python. Immutable objects are quicker to access and are expensive to change because it involves the creation of a copy.
   Whereas mutable objects are easy to change.
2. Use of mutable objects is recommended when there is a need to change the size or content of the object.
3. Exception : However, there is an exception in immutability as well. We know that tuple in python is immutable. But the tuple consists of a sequence of names with unchangeable bindings to objects.
   Consider a tuple

Tup = ([3, 4, 5], 'myname')

The tuple consists of a string and a list. Strings are immutable so we can’t change its value. But the contents of the list can change. The tuple itself isn’t mutable but contain items that are mutable.

2.8 Python console Input / Output

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 since the memory is volatile, it is impossible to recover the programmatically generated data again and again.

The file handling plays an important role when the data needs to be stored permanently into the file. A file is a named location on disk to store related information. We can access the stored information (non-volatile) after the program termination.

The file-handling implementation is slightly lengthy or complicated in the other programming language, but it is easier and shorter in Python.

In Python, files are treated in two modes as text or binary. The file may be in the text or binary format, and each line of a file is ended with the special character.

Hence, a file operation can be done in the following order.

• Open a file
• Read or write - Performing operation
• Close the file

Opening a file

Python provides an open() function that 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.

Syntax:

1. File object = open(<file-name>, <access-mode>, <buffering>)     

The files can be accessed using various modes like read, write, or append. The following are the details about the access mode to open a file.

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.    
4. If fileptr:    
5.    Print("file is opened successfully")    

Output:

<class '_io.TextIOWrapper'>

File is opened successfully

In the above code, we have passed filename as a first argument and opened file in read mode as we mentioned r as the second argument. The fileptr holds the file object and if the file is opened successfully, it will execute the print statement

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 using the file system which is the currently 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.

Syntax

1. Fileobject.close()   

Consider the following example.

1. # opens the file file.txt in read mode    
2. Fileptr = open("file.txt","r")    
3.    
4. If fileptr:    
5.    Print("file is opened successfully")    
6.    
7. #closes the opened file    
8. Fileptr.close()  

After closing the file, we cannot perform any operation in the file. The file needs to be properly closed. If any exception occurs while performing some operations in the file then the program terminates without closing the file.

We should use the following method to overcome such type of problem.

1. Try:  
2.   Fileptr = open("file.txt")  
3.   # perform file operations  
4. Finally:  
5.   Fileptr.close()  

The with statement

The with statement was introduced in python 2.5. The with statement is useful in the case of manipulating the files. It 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 the statement is given below.

1. With open(<file name>, <access mode>) as <file-pointer>:    
2.    #statement suite     

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 files because, if the break, return, or exception occurs in the nested block of code then it automatically closes the file, we don't need to write the close() function. It doesn't let the file to corrupt.

Consider the following example.

Example

1. With open("file.txt",'r') as f:    
2.    Content = f.read();    
3.    Print(content)    

Writing the file

To write some text to a file, we need to open the file using the open method with one of the following access modes.

w: It will overwrite the file if any file exists. The file pointer is at the beginning of the file.

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.

Consider the following example.

Example

1. # open the file.txt in append mode. Create a new file if no such file exists.  
2. Fileptr = open("file2.txt", "w")  
3.  
4. # appending the content to the file  
5. Fileptr.write('''''Python is the modern day language. It makes things so simple. 
6. It is the fastest-growing programing language''')  
7.  
8. # closing the opened the file  
9. Fileptr.close()  

Output:

File2.txt

Python is the modern-day language. It makes things so simple. It is the fastest growing programming language.

Snapshot of the file2.txt

We have opened the file in w mode. The file1.txt file doesn't exist, it created a new file and we have written the content in the file using the write() function.

Example 2

1. #open the file.txt in write mode.    
2. Fileptr = open("file2.txt","a")  
3.    
4. #overwriting the content of the file    
5. Fileptr.write(" Python has an easy syntax and user-friendly interaction.")    
6.      
7. #closing the opened file     
8. Fileptr.close()  

Output:

Python is the modern day language. It makes things so simple.

It is the fastest growing programing language Python has an easy syntax and user-friendly interaction.

Snapshot of the file2.txt

We can see that the content of the file is modified. We have opened the file in a mode and it appended the content in the existing file2.txt.

To read a file using the Python script, the Python provides the read() method. The read() method reads a string from the file. It can read the data in the text as well as a binary format.

The syntax of the read() method is given below.

Syntax:

1. Fileobj.read(<count>)    

Here, the count is the number of bytes to be read from the file starting from the beginning of the file. If the count is not specified, then it may read the content of the file until the end.

Consider the following example.

Example

1. #open the file.txt in read mode. causes error if no such file exists.    
2. Fileptr = open("file2.txt","r")  
3. #stores all the data of the file into the variable content    
4. Content = fileptr.read(10)   
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'>

Python is

In the above code, we have read the content of file2.txt by using the read() function. We have passed count value as ten which means it will read the first ten characters from the file.

If we use the following line, then it will print all content of the file.

1. Content = fileptr.read()  
2. Print(content)   

Output:

Python is the modern-day language. It makes things so simple.

It is the fastest-growing programing language Python has easy an syntax and user-friendly interaction.

Read file through for loop

We can read the file using for loop. Consider the following example.

1. #open the file.txt in read mode. causes an error if no such file exists.    
2. Fileptr = open("file2.txt","r");     
3. #running a for loop     
4. For i in fileptr:    
5.    Print(i) # i contains each line of the file     

Output:

Python is the modern day language.

It makes things so simple.

Python has easy syntax and user-friendly interaction.

Read Lines of the file

Python facilitates to read the file line by line by using a function readline() method. 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 "file2.txt" containing three lines. Consider the following example.

Example 1: Reading lines using readline() function

1. #open the file.txt in read mode. causes error if no such file exists.    
2. Fileptr = open("file2.txt","r");     
3. #stores all the data of the file into the variable content    
4. Content = fileptr.readline()     
5. Content1 = fileptr.readline()  
6. #prints the content of the file    
7. Print(content)     
8. Print(content1)  
9. #closes the opened file    
10. Fileptr.close()    

Output:

Python is the modern day language.

It makes things so simple.

We called the readline() function two times that's why it read two lines from the file.

Python provides also the readlines() method which is used for the reading lines. It returns the list of the lines till the end of file(EOF) is reached.

Example 2: Reading Lines Using readlines() function

1. #open the file.txt in read mode. causes error if no such file exists.    
2. Fileptr = open("file2.txt","r");     
3.    
4. #stores all the data of the file into the variable content    
5. Content = fileptr.readlines()     
6.  
7. #prints the content of the file    
8. Print(content)     
9.    
10. #closes the opened file    
11. Fileptr.close()    

Output:

['Python is the modern day language.\n', 'It makes things so simple.\n', 'Python has easy syntax and user-friendly interaction.']

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.

Consider the following example.

Example 1

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:

<_io.TextIOWrapper name='file2.txt' mode='x' encoding='cp1252'>

File created successfully

File Pointer positions

Python provides the tell() method which is used to print the byte number at which the file pointer currently exists. Consider the following example.

1. # open the file file2.txt in read mode    
2. Fileptr = open("file2.txt","r")    
3.  
4. #initially the filepointer is at 0     
5. Print("The filepointer is at byte :",fileptr.tell())    
6.    
7. #reading the content of the file    
8. Content = fileptr.read();    
9.    
10. #after the read operation file pointer modifies. tell() returns the location of the fileptr.     
11.    
12. Print("After reading, the filepointer is at:",fileptr.tell())    

Output:

The filepointer is at byte : 0

After reading, the filepointer is at: 117

Modifying file pointer position

In 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.

Syntax:

1. <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.

Consider the following example.

Example

1. # open the file file2.txt in read mode    
2. Fileptr = open("file2.txt","r")    
3.    
4. #initially the filepointer is at 0     
5. Print("The filepointer is at byte :",fileptr.tell())    
6.    
7. #changing the file pointer location to 10.    
8. Fileptr.seek(10);    
9.    
10. #tell() returns the location of the fileptr.     
11. Print("After reading, the filepointer is at:",fileptr.tell())    

Output:

The filepointer is at byte : 0

After reading, the filepointer is at: 10

Python OS module

Renaming the file

The Python os module enables interaction with the operating system. The os module provides the functions that are involved in file processing operations like renaming, deleting, etc. It provides us the rename() method to rename the specified file to a new name. The syntax to use the rename() method is given below.

Syntax:

1. Rename(current-name, new-name)    

The first argument is the current file name and the second argument is the modified name. We can change the file name bypassing these two arguments.

Example 1:

1. Import os    
2.    
3. #rename file2.txt to file3.txt    
4. Os.rename("file2.txt","file3.txt")  

Output:

The above code renamed current file2.txt to file3.txt

Removing the file

The os module provides the remove() method which is used to remove the specified file. The syntax to use the remove() method is given below.

1. Remove(file-name)   

Example 1

1. Import os;    
2. #deleting the file named file3.txt     
3. Os.remove("file3.txt")    

Creating the new directory

The mkdir() method is used to create the directories in the current working directory. The syntax to create the new directory is given below.

Syntax:

1. Mkdir(directory name)  

Example 1

1. Import os    
2.    
3. #creating a new directory with the name new    
4. Os.mkdir("new")    

The getcwd() method

This method returns the current working directory.

The syntax to use the getcwd() method is given below.

Syntax

1. Os.getcwd()  

Example

1. Import os  
2. Os.getcwd()  

Output:

'C:\\Users\\DEVANSH SHARMA'

Changing the current working directory

The chdir() method is used to change the current working directory to a specified directory.

The syntax to use the chdir() method is given below.

Syntax

1. Chdir("new-directory")    

Example

1. Import os   
2. # Changing current directory with the new directiory  
3. Os.chdir("C:\\Users\\DEVANSH SHARMA\\Documents")  
4. #It will display the current working directory  
5. Os.getcwd()  

Output:

'C:\\Users\\DEVANSH SHARMA\\Documents'

Deleting directory

The rmdir() method is used to delete the specified directory.

The syntax to use the rmdir() method is given below.

Syntax

1. Os.rmdir(directory name)    

Example 1

1. Import os  
2. #removing the new directory     
3. Os.rmdir("directory_name")    

It will remove the specified directory.

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.

Example

File.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))    

File.py

1. Import subprocess    
2.    
3. With open("output.txt", "wb") as f:    
4.    Subprocess.check_call(["python", "file.py"], stdout=f)    

The file related methods

The file object provides the following methods to manipulate the files on various operating systems.

2.9 Arithmetic operators, Comparison operators, Logical Operators and expressions

Python Operators

The operator can be defined as a symbol which is responsible for a particular operation between two operands. Operators are the pillars of a program on which the logic is built in a specific programming language. Python provides a variety of operators, which are described as follows.

• Arithmetic operators
• Comparison operators
• Assignment Operators
• Logical Operators
• Bitwise Operators
• Membership Operators
• Identity Operators

Arithmetic Operators

Arithmetic operators are used to perform arithmetic operations between two operands. It includes + (addition), - (subtraction), *(multiplication), /(divide), %(reminder), //(floor division), and exponent (**) operators.

Consider the following table for a detailed explanation of arithmetic operators.

Comparison operator

Comparison operators are used to comparing the value of the two operands and returns Boolean true or false accordingly. The comparison operators are described in the following table.

Assignment Operators

The assignment operators are used to assign the value of the right expression to the left operand. The assignment operators are described in the following table.

Bitwise Operators

The bitwise operators perform bit by bit operation on the values of the two operands. Consider the following example.

For example,

1. If a = 7   
2.   b = 6     
3. Then, binary (a) = 0111    
4.    Binary (b) = 0011    
5.    
6. Hence, a & b = 0011    
7.      a | b = 0111    
8.             a ^ b = 0100    
9.       ~ a = 1000  

Logical Operators

The logical operators are used primarily in the expression evaluation to make a decision. Python supports the following logical operators.

Membership Operators

Python membership operators are used to check the membership of value inside a Python data structure. If the value is present in the data structure, then the resulting value is true otherwise it returns false.

Identity Operators

The identity operators are used to decide whether an element certain class or type.

Operator Precedence

The precedence of the operators is essential to find out since it enables us to know which operator should be evaluated first. The precedence table of the operators in Python is given below.

Python - Regular Expressions

A regular expression is a special sequence of characters that helps you match or find other strings or sets of strings, using a specialized syntax held in a pattern. Regular expressions are widely used in UNIX world.

The Python module re provides full support for Perl-like regular expressions in Python. The re module raises the exception re.error if an error occurs while compiling or using a regular expression.

We would cover two important functions, which would be used to handle regular expressions. But a small thing first: There are various characters, which would have special meaning when they are used in regular expression. To avoid any confusion while dealing with regular expressions, we would use Raw Strings as r'expression'.

The match Function

This function attempts to match RE pattern to string with optional flags.

Here is the syntax for this function −

Re.match(pattern, string, flags=0)

Here is the description of the parameters −

The re.match function returns a match object on success, None on failure. We usegroup(num) or groups() function of match object to get matched expression.

Example

#!/usr/bin/python

Import re

Line="Cats are smarter than dogs"

MatchObj=re.match( r'(.*) are (.*?) .*', line,re.M|re.I)

IfmatchObj:

Print"matchObj.group() : ",matchObj.group()

Print"matchObj.group(1) : ",matchObj.group(1)

Print"matchObj.group(2) : ",matchObj.group(2)

Else:

Print"No match!!"

When the above code is executed, it produces following result −

MatchObj.group() :  Cats are smarter than dogs

MatchObj.group(1) :  Cats

MatchObj.group(2) :  smarter

The search Function

This function searches for first occurrence of RE pattern within string with optional flags.

Here is the syntax for this function −

Re.search(pattern, string, flags=0)

Here is the description of the parameters −

The re.search function returns a match object on success, none on failure. We use group(num) or groups() function of match object to get matched expression.

Example

#!/usr/bin/python

Import re

Line="Cats are smarter than dogs";

SearchObj=re.search( r'(.*) are (.*?) .*', line,re.M|re.I)

IfsearchObj:

Print"searchObj.group() : ",searchObj.group()

Print"searchObj.group(1) : ",searchObj.group(1)

Print"searchObj.group(2) : ",searchObj.group(2)

Else:

Print"Nothing found!!"

When the above code is executed, it produces following result −

SearchObj.group() :  Cats are smarter than dogs

SearchObj.group(1) :  Cats

SearchObj.group(2) :  smarter

Matching Versus Searching

Python offers two different primitive operations based on regular expressions: match checks for a match only at the beginning of the string, while search checks for a match anywhere in the string (this is what Perl does by default).

Example

#!/usr/bin/python

Import re

Line="Cats are smarter than dogs";

MatchObj=re.match(r'dogs', line,re.M|re.I)

IfmatchObj:

Print"match -->matchObj.group() : ",matchObj.group()

Else:

Print"No match!!"

SearchObj=re.search(r'dogs', line,re.M|re.I)

IfsearchObj:

Print"search -->searchObj.group() : ",searchObj.group()

Else:

Print"Nothing found!!"

When the above code is executed, it produces the following result −

No match!!

Search -->searchObj.group() :  dogs

Search and Replace

One of the most important re methods that use regular expressions is sub.

Syntax

Re.sub(pattern, repl, string, max=0)

This method replaces all occurrences of the RE pattern in string with repl, substituting all occurrences unless max provided. This method returns modified string.

Example

#!/usr/bin/python

Import re

Phone="2004-959-559 # This is Phone Number"

# Delete Python-style comments

Num=re.sub(r'#.*$',"", phone)

Print"Phone Num : ",num

# Remove anything other than digits

Num=re.sub(r'\D',"", phone)

Print"Phone Num : ",num

When the above code is executed, it produces the following result −

Phone Num :  2004-959-559

Phone Num :  2004959559

Regular Expression Modifiers: Option Flags

Regular expression literals may include an optional modifier to control various aspects of matching. The modifiers are specified as an optional flag. You can provide multiple modifiers using exclusive OR (|), as shown previously and may be represented by one of these −

Regular Expression Patterns

Except for control characters, (+ ? . * ^ $ ( ) [ ] { } | \), all characters match themselves. You can escape a control character by preceding it with a backslash.

Following table lists the regular expression syntax that is available in Python −

Regular Expression Examples

Literal characters

Character classes

Special Character Classes

Repetition Cases

Nongreedy repetition

This matches the smallest number of repetitions −

Grouping with Parentheses

Backreferences

This matches a previously matched group again −

Alternatives

Anchors

This needs to specify match position.

Special Syntax with Parentheses

2.10 Is and In operators

Membership operators are operators used to validate the membership of a value. It test for membership in a sequence, such as strings, lists, or tuples.

1. In operator : The ‘in’ operator is used to check if a value exists in a sequence or not. Evaluates to true if it finds a variable in the specified sequence and false otherwise. 

Output:

Not overlapping

Same example without using in operator:

Output:

Not overlapping

2.     ‘not in’ operator- Evaluates to true if it does not finds a variable in the specified sequence and false otherwise. 

Identity operators

In Python are used to determine whether a value is of a certain class or type. They are usually used to determine the type of data a certain variable contains.
There are different identity operators such as

1. ‘is’ operator – Evaluates to true if the variables on either side of the operator point to the same object and false otherwise. 

Output:

True

2.     ‘is not’ operator – Evaluates to false if the variables on either side of the operator point to the same object and true otherwise. 

Output:

True

2.11 Conditions, Control statements: if-else, Nested If-Else, Loops (for, while)

Python Loops

The flow of the programs written in any programming language is sequential by default. Sometimes we may need to alter the flow of the program. The execution of a specific code may need to be repeated several numbers of times.

For this purpose, The programming languages provide various types of loops which are capable of repeating some specific code several numbers of times. Consider the following diagram to understand the working of a loop statement.

Why we use loops in python?

The looping simplifies the complex problems into the easy ones. It enables us to alter the flow of the program so that instead of writing the same code again and again, we can repeat the same code for a finite number of times. For example, if we need to print the first 10 natural numbers then, instead of using the print statement 10 times, we can print inside a loop which runs up to 10 iterations.

Advantages of loops

There are the following advantages of loops in Python.

1. It provides code re-usability.
2. Using loops, we do not need to write the same code again and again.
3. Using loops, we can traverse over the elements of data structures (array or linked lists).

There are the following loop statements in Python.

Python for loop

The forloop in Python is used to iterate the statements or a part of the program several times. It is frequently used to traverse the data structures like list, tuple, or dictionary.

The syntax of for loop in python is given below.

1. For iterating_var in sequence:    
2.    Statement(s)    

The for loop flowchart

For loop Using Sequence

Example-1: Iterating string using for loop

1. Str = "Python"  
2. For i in str:  
3.    Print(i)  

Output:

P

y

t

h

o

n

Example- 2: Program to print the table of the given number .

1. List = [1,2,3,4,5,6,7,8,9,10]  
2. n = 5  
3. For i in list:  
4.    c = n*i  
5.    Print(c)  

Output:

5

10

15

20

25

30

35

40

45

50s

Example-4: Program to print the sum of the given list.

1. List = [10,30,23,43,65,12]  
2. Sum = 0  
3. For i in list:  
4.    Sum = sum+i  
5. Print("The sum is:",sum)  

Output:

The sum is: 183

For loop Using range() function

The range() function

The range() function is used to generate the sequence of the numbers. If we pass the range(10), it will generate the numbers from 0 to 9. The syntax of the range() function is given below.

Syntax:

1. Range(start,stop,step size)  

• The start represents the beginning of the iteration.
• The stop represents that the loop will iterate till stop-1. The range(1,5) will generate numbers 1 to 4 iterations. It is optional.
• The step size is used to skip the specific numbers from the iteration. It is optional to use. By default, the step size is 1. It is optional.

Consider the following examples:

Example-1: Program to print numbers in sequence.

1. For i in range(10):  
2.    Print(i,end = ' ')  

Output:

0 1 2 3 4 5 6 7 8 9

Example - 2: Program to print table of given number.

1. n = int(input("Enter the number "))  
2. For i in range(1,11):  
3.    c = n*i  
4.    Print(n,"*",i,"=",c)  

Output:

Enter the number 10

10 * 1 = 10

10 * 2 = 20

10 * 3 = 30

10 * 4 = 40

10 * 5 = 50

10 * 6 = 60

10 * 7 = 70

10 * 8 = 80

10 * 9 = 90

10 * 10 = 100

Example-3: Program to print even number using step size in range().

1. n = int(input("Enter the number "))  
2. For i in range(2,n,2):  
3.    Print(i)  

Output:

Enter the number 20

2

4

6

8

10

12

14

16

18

We can also use the range() function with sequence of numbers. The len() function is combined with range() function which iterate through a sequence using indexing. Consider the following example.

1. List = ['Peter','Joseph','Ricky','Devansh']  
2. For i in range(len(list)):  
3.    Print("Hello",list[i])  

Output:

Hello Peter

Hello Joseph

Hello Ricky

Hello Devansh

Nested for loop in python

Python allows us to nest any number of for loops inside a for loop. The inner loop is executed n number of times for every iteration of the outer loop. The syntax is given below.

Syntax

1. For iterating_var1 in sequence:  #outer loop  
2.    For iterating_var2 in sequence:  #inner loop  
3.        #block of statements     
4. #Other statements    

Example- 1: Nested for loop

1. # User input for number of rows  
2. Rows = int(input("Enter the rows:"))  
3. # Outer loop will print number of rows  
4. For i in range(0,rows+1):  
5. # Inner loop will print number of Astrisk  
6.    For j in range(i):  
7.        Print("*",end = '')  
8.    Print()  

Output:

Enter the rows:5

*

**

***

****

*****

Example-2: Program to number pyramid.

1. Rows = int(input("Enter the rows"))  
2. For i in range(0,rows+1):  
3.    For j in range(i):  
4.        Print(i,end = '')  
5.    Print()  

Output:

1

22

333

4444

55555

Using else statement with for loop

Unlike other languages like C, C++, or Java, Python allows us to use the else statement with the for loop which can be executed only when all the iterations are exhausted. Here, we must notice that if the loop contains any of the break statement then the else statement will not be executed.

Example 1

1. For i in range(0,5):    
2.    Print(i)    
3. Else:  
4.    Print("for loop completely exhausted, since there is no break.")  

Output:

0

1

2

3

4

For loop completely exhausted, since there is no break.

The for loop completely exhausted, since there is no break.

Example 2

1. For i in range(0,5):    
2.    Print(i)    
3.    Break;    
4. Else:print("for loop is exhausted");    
5. Print("The loop is broken due to break statement...came out of the loop")    

In the above example, the loop is broken due to the break statement; therefore, the else statement will not be executed. The statement present immediate next to else block will be executed.

Output:

0

The loop is broken due to the break statement...came out of the loop.

Python While loop

The Python while loop allows a part of the code to be executed until the given condition returns false. It is also known as a pre-tested loop.

It can be viewed as a repeating if statement. When we don't know the number of iterations then the while loop is most effective to use.

The syntax is given below.

1. While expression:    
2.    Statements    

Here, the statements can be a single statement or a group of statements. The expression should be any valid Python expression resulting in true or false. The true is any non-zero value and false is 0.

While loop Flowchart

Loop Control Statements

We can change the normal sequence of while loop's execution using the loop control statement. When the while loop's execution is completed, all automatic objects defined in that scope are demolished. Python offers the following control statement to use within the while loop.

1. Continue Statement - When the continue statement is encountered, the control transfer to the beginning of the loop. Let's understand the following example.

Example:

1. # prints all letters except 'a' and 't'   
2. i = 0  
3. Str1 = 'javatpoint'  
4.  
5. While i < len(str1):   
6.    If str1[i] == 'a' or str1[i] == 't':   
7.        i += 1  
8.        Continue  
9.    Print('Current Letter :', a[i])   
10.    i += 1  

Output:

Current Letter : j

Current Letter : v

Current Letter : p

Current Letter : o

Current Letter :i

Current Letter : n

2. Break Statement - When the break statement is encountered, it brings control out of the loop.

Example:

1. # The control transfer is transfered  
2. # when break statement soon it sees t  
3. i = 0  
4. Str1 = 'javatpoint'  
5.  
6. While i < len(str1):   
7.    If str1[i] == 't':   
8.        i += 1  
9.        Break  
10.    Print('Current Letter :', str1[i])   
11.    i += 1  

Output:

Current Letter : j

Current Letter : a

Current Letter : v

Current Letter : a

3. Pass Statement - The pass statement is used to declare the empty loop. It is also used to define empty class, function, and control statement. Let's understand the following example.

Example -

1. # An empty loop   
2. Str1 = 'javatpoint'  
3. i = 0  
4.  
5. While i < len(str1):   
6.    i += 1  
7.    Pass  
8. Print('Value of i :', i)  

Output:

Value of i : 10

Example-1: Program to print 1 to 10 using while loop

1. i=1  
2. #The while loop will iterate until condition becomes false.  
3. While(i<=10):    
4.    Print(i)   
5.    i=i+1   

Output:

1

2

3

4

5

6

7

8

9

10

Example -2: Program to print table of given numbers.

1. i=1    
2. Number=0    
3. b=9    
4. Number = int(input("Enter the number:"))    
5. While i<=10:    
6.    Print("%d X %d = %d \n"%(number,i,number*i))    
7.    i = i+1    

Output:

Enter the number:10

10 X 1 = 10

10 X 2 = 20

10 X 3 = 30

10 X 4 = 40

10 X 5 = 50

10 X 6 = 60

10 X 7 = 70

10 X 8 = 80

10 X 9 = 90

10 X 10 = 100

Infinite while loop

If the condition is given in the while loop never becomes false, then the while loop will never terminate, and it turns into the infinite while loop.

Any non-zero value in the while loop indicates an always-true condition, whereas zero indicates the always-false condition. This type of approach is useful if we want our program to run continuously in the loop without any disturbance.

Example 1

1. While (1):    
2.    Print("Hi! we are inside the infinite while loop")  

Output:

Hi! we are inside the infinite while loop

Hi! we are inside the infinite while loop

Example 2

1. Var = 1    
2. While(var != 2):    
3.    i = int(input("Enter the number:"))    
4.    Print("Entered value is %d"%(i))    

Output:

Enter the number:10

Entered value is 10

Enter the number:10

Entered value is 10

Enter the number:10

Entered value is 10

Infinite time

Using else with while loop

Python allows us to use the else statement with the while loop also. The else block is executed when the condition given in the while statement becomes false. Like for loop, if the while loop is broken using break statement, then the else block will not be executed, and the statement present after else block will be executed. The else statement is optional to use with the while loop. Consider the following example.

Example 1

1. i=1   
2. While(i<=5):    
3.    Print(i)    
4.    i=i+1    
5. Else:  
6.    Print("The while loop exhausted")    

Example 2

1. i=1    
2. While(i<=5):    
3.    Print(i)    
4.    i=i+1    
5.    If(i==3):    
6.        Break   
7. Else:  
8.    Print("The while loop exhausted")  

Output:

1

2

In the above code, when the break statement encountered, then while loop stopped its execution and skipped the else statement.

Example-3 Program to print Fibonacci numbers to given limit

1. Terms = int(input("Enter the terms "))  
2. # first two intial terms  
3. a = 0  
4. b = 1  
5. Count = 0  
6.  
7. # check if the number of terms is Zero or negative  
8. If (terms <= 0):  
9.   Print("Please enter a valid integer")  
10. Elif (terms == 1):  
11.   Print("Fibonacci sequence upto",limit,":")  
12.   Print(a)  
13. Else:  
14.   Print("Fibonacci sequence:")  
15.   While (count < terms) :  
16.       Print(a, end = ' ')  
17.       c = a + b  
18.       # updateing values  
19.       a = b  
20.       b = c  
21.     
22.    Count += 1  

Output:

Enter the terms 10

Fibonacci sequence:

0 1 1 2 3 5 8 13 21 34

Python break statement

The break is a keyword in python which is used to bring the program control out of the loop. The break statement breaks the loops one by one, i.e., in the case of nested loops, it breaks the inner loop first and then proceeds to outer loops. In other words, we can say that break is used to abort the current execution of the program and the control goes to the next line after the loop.

The break is commonly used in the cases where we need to break the loop for a given condition.

The syntax of the break is given below.

1. #loop statements  
2. Break;   

Example 1

1. List =[1,2,3,4]  
2. Count = 1;  
3. For i in list:  
4.    If i == 4:  
5.        Print("item matched")  
6.        Count = count + 1;  
7.        Break  
8. Print("found at",count,"location");  

Output:

Item matched

Found at 2 location

Example 2

1. Str = "python"  
2. For i in str:  
3.    If i == 'o':  
4.        Break  
5.    Print(i);  

Output:

p

y

t

h

Example 3: break statement with while loop

1. i = 0;  
2. While 1:  
3.    Print(i," ",end=""),  
4.    i=i+1;  
5.    If i == 10:  
6.        Break;  
7. Print("came out of while loop");  

Output:

0  1  2  3  4  5  6  7  8  9  came out of while loop

Example 3

1. n=2  
2. While 1:  
3.    i=1;  
4.    While i<=10:  
5.        Print("%d X %d = %d\n"%(n,i,n*i));  
6.        i = i+1;  
7.    Choice = int(input("Do you want to continue printing the table, press 0 for no?"))  
8.    If choice == 0:  
9.        Break;      
10.    n=n+1  

Output:

2 X 1 = 2

2 X 2 = 4

2 X 3 = 6

2 X 4 = 8

2 X 5 = 10

2 X 6 = 12

2 X 7 = 14

2 X 8 = 16

2 X 9 = 18

2 X 10 = 20

Do you want to continue printing the table, press 0 for no?1

3 X 1 = 3

3 X 2 = 6

3 X 3 = 9

3 X 4 = 12

3 X 5 = 15

3 X 6 = 18

3 X 7 = 21

3 X 8 = 24

3 X 9 = 27

3 X 10 = 30

Do you want to continue printing the table, press 0 for no?0

Python continue Statement

The continue statement in Python is used to bring the program control to the beginning of the loop. The continue statement skips the remaining lines of code inside the loop and start with the next iteration. It is mainly used for a particular condition inside the loop so that we can skip some specific code for a particular condition.The continue statement in Python is used to bring the program control to the beginning of the loop. The continue statement skips the remaining lines of code inside the loop and start with the next iteration. It is mainly used for a particular condition inside the loop so that we can skip some specific code for a particular condition.

Syntax

1. #loop statements    
2. Continue  
3. #the code to be skipped     

Flow Diagram

Consider the following examples.

Example 1

1. i = 0                     
2. While(i < 10):                
3.   i = i+1  
4.   If(i == 5):  
5.      Continue  
6.   Print(i)  

Output:

1

2

3

4

6

7

8

9

10

Observe the output of above code, the value 5 is skipped because we have provided the if condition using with continue statement in while loop. When it matched with the given condition then control transferred to the beginning of the while loop and it skipped the value 5 from the code.

Let's have a look at another example:

Example 2

1. Str = "JavaTpoint"  
2. For i in str:  
3.    If(i == 'T'):  
4.        Continue  
5.    Print(i)  

Output:

J

a

v

a

p

o

i

n

t

Pass Statement

The pass statement is a null operation since nothing happens when it is executed. It is used in the cases where a statement is syntactically needed but we don't want to use any executable statement at its place.

For example, it can be used while overriding a parent class method in the subclass but don't want to give its specific implementation in the subclass.

Pass is also used where the code will be written somewhere but not yet written in the program file. Consider the following example.

Example

1. List = [1,2,3,4,5]    
2. Flag = 0    
3. For i in list:    
4.    Print("Current element:",i,end=" ");    
5.    If i==3:    
6.        Pass    
7.        Print("\nWe are inside pass block\n");    
8.        Flag = 1    
9.    If flag==1:    
10.        Print("\nCame out of pass\n");    
11.        Flag=0   

Output:

Current element: 1 Current element: 2 Current element: 3

We are inside pass block

Came out of pass

Current element: 4 Current element: 5

Reference Books:

1 Computers Today by Sanders.

2 Fundamentals of Computers TTTI Publication.

3 Learning Python by Mark Lutz, 5th edition

4 Python cookbook, by David Beazley , 3rd Edition

5 Python Essential Reference, by David Beazley , 4th edition

6 Python in a Nutshell, by Alex Mortelli, 2nd Edition.

7 Python programming: An Introduction to computer science, by John Zelle, 2nd Edition.