Key features

Python has many reasons for being popular and in demand. A few of the reasons are mentioned
below.
 Emphasis on code readability, shorter codes, ease of writing.
 Programmers can express logical concepts in fewer lines of code in comparison
to languages such as C++ or Java.
 Python supports multiple programming paradigms, like object-oriented,
imperative and functional programming or procedural.
 It provides extensive support libraries (Django for web development, Pandas
for data analytics etc)
 Dynamically typed language (Data type is based on value assigned)

Variables

Variables in Python are not “statically typed”. We do not need to declare variables before using
them or declare their type. A variable is created the moment we first assign a value to it.
#!/usr/bin/python

# An integer assignment

age = 45

# A floating point

salary = 1456.8

# A string

name = "John"

print(age)

print(salary)

print(name)

Operators

Operators are the main building block of any programming language. Operators allow the
programmer to perform different kinds of operations on operands. These operators can be
categorized based upon their different functionality:
 Arithmetic operators: Arithmetic operators are used to perform mathematical
operations like addition, subtraction, multiplication and division.
# Examples of Arithmetic Operator
a =9
b =4

# Addition of numbers
add = a + b
# Subtraction of numbers
sub = a - b
# Multiplication of number
mul = a * b
 # Division(float) of number
div1 = a / b
# Division(floor) of number
div2 = a // b
# Modulo of both number
mod = a % b

# print results
print(add)
print(sub)
print(mul)
print(div1)
print(div2)
print(mod)

Relational Operators: Relational operators compares the values. It either returns

True or False according to the condition.
# Examples of Relational Operators
a = 13
b = 33

# a > b is False
print(a > b)

# a < b is True
print(a < b)

# a == b is False
print(a == b)

# a != b is True
print(a != b)

# a >= b is False
print(a >= b)

# a <= b is True
print(a <= b)

Logical Operators: Logical operators perform Logical AND, Logical OR and Logical
NOT operations.
# Examples of Logical Operator
a = True
b = False

# Print a and b is False

print(a and b)

# Print a or b is True
print(a or b)

# Print not a is False

print(not a)
Bitwise operators: Bitwise operator acts on bits and performs bit by bit operation.
# Examples of Bitwise operators
a = 10
b =4

# Print bitwise AND operation

print(a & b)

# Print bitwise OR operation

print(a | b)

# Print bitwise NOT operation

print(~a)

# print bitwise XOR operation

print(a ^ b)

# print bitwise right shift operation

print(a >> 2)

# print bitwise left shift operation

print(a << 2)

 Assignment operators: Assignment operators are used to assign values to the

variables.
 Special operators: Special operators are of two types-
 Identity operator that contains is and is not.
 Membership operator that contains in and not in.
# Examples of Identity and
# Membership operator

a1 = 'GeeksforGeeks'
b1 = 'GeeksforGeeks'

# Identity operator
print(a1 is not b1)
print(a1 is b1)

# Membership operator
print("G" in a1)
print("N" not in b1)

Basics of Input/Output

Taking input from user –

Python provides us with two inbuilt functions to read the input from the keyboard.
 raw_input(): This function works in older version (like Python 2.x). This function
takes exactly what is typed from the keyboard, convert it to string and then return it to
the variable in which we want to store. For example:
# Python program showing

# a use of raw_input()
 g = raw_input("Enter your name : ")

print g

 input(): This function first takes the input from the user and then evaluates the
expression, which means Python automatically identifies whether the user entered a
string or a number or list. For example:
# Python program showing

# a use of input()

val = input("Enter your value: ")

print(val)

Printing output to console –

The simplest way to produce output is using the print() function where you can pass zero or
more expressions separated by commas. This function converts the expressions you pass into a
string before writing to the screen.
# Python 3.x program showing

# how to print data on

# a screen

# One object is passed

print("GeeksForGeeks")

x =5

# Two objects are passed

print("x =", x)

# code for disabling the softspace feature

print('G', 'F', 'G', sep ='')

# using end argument

print("Python", end = '@')

print("GeeksforGeeks")

Built-in Data Types

Python has the following data types built-in by default, in these categories:

Text Type: str

Numeric Types: int, float, complex

Sequence list, tuple, range

Types:

Mapping Type: dict

Set Types: set, frozenset

Boolean Type: bool

Binary Types: bytes, bytearray, memoryview

Getting the Data Type

can get the data type of any object by using the type() function:
Setting the Data Type

In Python, the data type is set when you assign a value to a variable:

Example Data Type

x = "Hello World" str

x = 20 int

x = 20.5 float

x = 1j complex

x = ["apple", "banana", "cherry"] list

 x = ("apple", "banana", "cherry") tuple

x = range(6) range

x = {"name" : "John", "age" : 36} dict

x = {"apple", "banana", "cherry"} set

x = frozenset({"apple", "banana", frozenset

"cherry"})

x = True bool

x = b"Hello" bytes

x = bytearray(5) bytearray

x = memoryview(bytes(5)) memoryview

Setting the Specific Data Type

If you want to specify the data type, you can use the following constructor
functions:

Example Data Type

x = str("Hello World") str

x = int(20) int

x = float(20.5) float

x = complex(1j) complex

x = list(("apple", "banana", list

"cherry"))

x = tuple(("apple", "banana", tuple

"cherry"))

x = range(6) range

x = dict(name="John", age=36) dict

x = set(("apple", "banana", "cherry")) set

x = frozenset(("apple", "banana", frozenset

"cherry"))

x = bool(5) bool
 x = bytes(5) bytes

x = bytearray(5) bytearray

x = memoryview(bytes(5)) memoryview

Python Numbers

There are three numeric types in Python:

 int
 float
 complex

Variables of numeric types are created when you assign a value to them:

Example
x = 1 # int
y = 2.8 # float
z = 1j # complex

To verify the type of any object in Python, use the type() function:

Example
print(type(x))
print(type(y))
print(type(z))

Int

Int, or integer, is a whole number, positive or negative, without decimals, of

unlimited length.

Example
Integers:

x = 1
y = 35656222554887711
z = -3255522
print(type(x))
print(type(y))
print(type(z))

Float

Float, or "floating point number" is a number, positive or negative, containing

one or more decimals.

Example
Floats:

x = 1.10
y = 1.0
z = -35.59

print(type(x))
print(type(y))
print(type(z))

Float can also be scientific numbers with an "e" to indicate the power of 10.

Example
Floats:

x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))

Complex

Complex numbers are written with a "j" as the imaginary part:

Example
Complex:

x = 3+5j
y = 5j
z = -5j
print(type(x))
print(type(y))
print(type(z))

Type Conversion

You can convert from one type to another with the int(), float(),
and complex() methods:

Example
Convert from one type to another:

x = 1 # int
y = 2.8 # float
z = 1j # complex

#convert from int to float:

a = float(x)

#convert from float to int:

b = int(y)

#convert from int to complex:

c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

Random Number

Python does not have a random() function to make a random number, but
Python has a built-in module called random that can be used to make random
numbers:

Example
Import the random module, and display a random number between 1 and 9:

import random

print(random.randrange(1, 10))
Python Casting
Specify a Variable Type

Casting in python is therefore done using constructor functions:

 int() - constructs an integer number from an integer literal, a float

literal (by removing all decimals), or a string literal (providing the
string represents a whole number)
 float() - constructs a float number from an integer literal, a float
literal or a string literal (providing the string represents a float or an
integer)
 str() - constructs a string from a wide variety of data types, including
strings, integer literals and float literals

Example
Integers:

x = int(1) # x will be 1
y = int(2.8) # y will be 2
z = int("3") # z will be 3

Example
Floats:

x = float(1) # x will be 1.0

y = float(2.8) # y will be 2.8
z = float("3") # z will be 3.0
w = float("4.2") # w will be 4.2

Example
Strings:

x = str("s1") # x will be 's1'

y = str(2) # y will be '2'
z = str(3.0) # z will be '3.0'

Python Strings
Strings
Strings in python are surrounded by either single quotation marks, or double
quotation marks.
'hello' is the same as "hello".

You can display a string literal with the print() function:

Example
print("Hello")
print('Hello')

Assign String to a Variable

Assigning a string to a variable is done with the variable name followed by an
equal sign and the string:

Example
a = "Hello"
print(a)

Multiline Strings
You can assign a multiline string to a variable by using three quotes:

Example
You can use three double quotes:

a = """Lorem ipsum dolor sit amet,

consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)

Or three single quotes:

Example
a = '''Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.'''
print(a)

Strings are Arrays

Like many other popular programming languages, strings in Python are
arrays of bytes representing unicode characters.
However, Python does not have a character data type, a single character is
simply a string with a length of 1.

Square brackets can be used to access elements of the string.

Example
Get the character at position 1 (remember that the first character has the
position 0):

a = "Hello, World!"
print(a[1])

Looping Through a String

Since strings are arrays, we can loop through the characters in a string, with
a for loop.

Example
Loop through the letters in the word "banana":

for x in "banana":
print(x)

String Length
To get the length of a string, use the len() function. Example
The len() function returns the length of a string:

a = "Hello, World!"
print(len(a))

Check String
To check if a certain phrase or character is present in a string, we
can use the keyword in.

Example
Check if "free" is present in the following text:

txt = "The best things in life are free!"

print("free" in txt)

Use it in an if statement:
Example
Print only if "free" is present:

txt = "The best things in life are free!"

if "free" in txt:
print("Yes, 'free' is present.")

Check if NOT
To check if a certain phrase or character is NOT present in a string,
we can use the keyword not in.

Example
Check if "expensive" is NOT present in the following text:

txt = "The best things in life are free!"

print("expensive" not in txt)

Use it in an if statement:

Example
print only if "expensive" is NOT present:

txt = "The best things in life are free!"

if "expensive" not in txt:
print("Yes, 'expensive' is NOT present.")

Python - Slicing Strings

Slicing
You can return a range of characters by using the slice syntax.

Specify the start index and the end index, separated by a colon, to return a
part of the string.

Example
Get the characters from position 2 to position 5 (not included):

b = "Hello, World!"
print(b[2:5])
Python - Modify Strings
Python has a set of built-in methods that you can use on strings.

Upper Case
Example
The upper() method returns the string in upper case:

a = "Hello, World!"
print(a.upper())

Lower Case
Example
The lower() method returns the string in lower case:

a = "Hello, World!"
print(a.lower())

Remove Whitespace
Whitespace is the space before and/or after the actual text, and very often
you want to remove this space.

Example
The strip() method removes any whitespace from the beginning or the end:

a = " Hello, World! "

print(a.strip()) # returns "Hello, World!"

Replace String
Example
The replace() method replaces a string with another string:

a = "Hello, World!"
print(a.replace("H", "J"))

Split String
The split() method returns a list where the text between the specified
separator becomes the list items.

Example
The split() method splits the string into substrings if it finds instances of the
separator:

a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']

Python - String Concatenation

String Concatenation
To concatenate, or combine, two strings you can use the + operator.

Example
Merge variable a with variable b into variable c:

a = "Hello"
b = "World"
c = a + b
print(c)

Example
To add a space between them, add a " ":

a = "Hello"
b = "World"
c = a + " " + b
print(c)

Python - Format - Strings

String Format
As we learned in the Python Variables chapter, we cannot combine strings
and numbers like this:

Example
age = 36
txt = "My name is John, I am " + age
print(txt)
But we can combine strings and numbers by using the format() method!

The format() method takes the passed arguments, formats them, and places
them in the string where the placeholders {} are:

Example
Use the format() method to insert numbers into strings:

age = 36
txt = "My name is John, and I am {}"
print(txt.format(age))

The format() method takes unlimited number of arguments, and are

placed into the respective placeholders:

Example
quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

You can use index numbers {0} to be sure the arguments are placed in the
correct placeholders:

Example
quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

Python - Escape Characters

Escape Character
To insert characters that are illegal in a string, use an escape character.

An escape character is a backslash \ followed by the character you want to

insert.

An example of an illegal character is a double quote inside a string that is

surrounded by double quotes:
Example
You will get an error if you use double quotes inside a string that is
surrounded by double quotes:

txt = "We are the so-called "Vikings" from the north."

To fix this problem, use the escape character \":

Example
The escape character allows you to use double quotes when you normally
would not be allowed:

txt = "We are the so-called \"Vikings\" from the north."

Escape Characters
Other escape characters used in Python:

Code Result

\' Single Quote

\\ Backslash

\n New Line

\r Carriage Return

\t Tab

\b Backspace
 \f Form Feed

\ooo Octal value

\xhh Hex value

Python - String Methods

String Methods
Python has a set of built-in methods that you can use on strings.

Note: All string methods returns new values. They do not change the original
string.

Method Description

capitalize() Converts the first character to upper case

casefold() Converts string into lower case

center() Returns a centered string

count() Returns the number of times a specified value occurs in a

string

encode() Returns an encoded version of the string

endswith() Returns true if the string ends with the specified value

expandtabs() Sets the tab size of the string

find() Searches the string for a specified value and returns the
position of where it was found

format() Formats specified values in a string

format_map() Formats specified values in a string

index() Searches the string for a specified value and returns the
position of where it was found

isalnum() Returns True if all characters in the string are alphanumeric

isalpha() Returns True if all characters in the string are in the alphabet

isdecimal() Returns True if all characters in the string are decimals

isdigit() Returns True if all characters in the string are digits

isidentifier() Returns True if the string is an identifier

islower() Returns True if all characters in the string are lower case

isnumeric() Returns True if all characters in the string are numeric

isprintable() Returns True if all characters in the string are printable

isspace() Returns True if all characters in the string are whitespaces

istitle() Returns True if the string follows the rules of a title

isupper() Returns True if all characters in the string are upper case

join() Joins the elements of an iterable to the end of the string

ljust() Returns a left justified version of the string

lower() Converts a string into lower case

lstrip() Returns a left trim version of the string

maketrans() Returns a translation table to be used in translations

partition() Returns a tuple where the string is parted into three parts
replace() Returns a string where a specified value is replaced with a
specified value

rfind() Searches the string for a specified value and returns the last
position of where it was found

rindex() Searches the string for a specified value and returns the last
position of where it was found

rjust() Returns a right justified version of the string

rpartition() Returns a tuple where the string is parted into three parts

rsplit() Splits the string at the specified separator, and returns a list

rstrip() Returns a right trim version of the string

split() Splits the string at the specified separator, and returns a list

splitlines() Splits the string at line breaks and returns a list

startswith() Returns true if the string starts with the specified value

strip() Returns a trimmed version of the string

 swapcase() Swaps cases, lower case becomes upper case and vice versa

title() Converts the first character of each word to upper case

translate() Returns a translated string

upper() Converts a string into upper case

zfill() Fills the string with a specified number of 0 values at the

beginning

Python Booleans
Booleans represent one of two values: True or False.

Boolean Values
In programming you often need to know if an expression is True or False.

You can evaluate any expression in Python, and get one of two
answers, True or False.

When you compare two values, the expression is evaluated and Python
returns the Boolean answer:

Example
print(10 > 9)
print(10 == 9)
print(10 < 9)

When you run a condition in an if statement, Python returns True or False:

Example
Print a message based on whether the condition is True or False:
a = 200
b = 33

if b > a:
print("b is greater than a")
else:
print("b is not greater than a")

Evaluate Values and Variables

The bool() function allows you to evaluate any value, and give
you True or False in return,

Example
Evaluate a string and a number:

print(bool("Hello"))
print(bool(15))

Example
Evaluate two variables:

x = "Hello"
y = 15

print(bool(x))
print(bool(y))

Most Values are True

Almost any value is evaluated to True if it has some sort of content.

Any string is True, except empty strings.

Any number is True, except 0.

Any list, tuple, set, and dictionary are True, except empty ones.

Example
The following will return True:

bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])
Some Values are False
In fact, there are not many values that evaluate to False, except empty
values, such as (), [], {}, "", the number 0, and the value None. And of course
the value False evaluates to False.

Example
The following will return False:

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

One more value, or object in this case, evaluates to False, and that is if you
have an object that is made from a class with a __len__ function that
returns 0 or False:

Example
class myclass():
def __len__(self):
return 0

myobj = myclass()
print(bool(myobj))

Functions can Return a Boolean

You can create functions that returns a Boolean Value:

Example
Print the answer of a function:

def myFunction() :
return True

print(myFunction())

You can execute code based on the Boolean answer of a function:

Example
Print "YES!" if the function returns True, otherwise print "NO!":

def myFunction() :
return True

if myFunction():
print("YES!")
else:
print("NO!")

Python also has many built-in functions that return a boolean value, like
the isinstance() function, which can be used to determine if an object is of
a certain data type:

Example
Check if an object is an integer or not:

x = 200
print(isinstance(x, int))

Python Operators
Python Operators
Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Example
print(10 + 5)

Python divides the operators in the following groups:

 Arithmetic operators
 Assignment operators
 Comparison operators
 Logical operators
 Identity operators
 Membership operators
 Bitwise operators

Python Arithmetic Operators

Arithmetic operators are used with numeric values to perform common
mathematical operations:
 Operator Name Example

+ Addition x+y

- Subtraction x-y

* Multiplication x*y

/ Division x/y

% Modulus x%y

** Exponentiation x ** y

// Floor division x // y

Python Assignment Operators

Assignment operators are used to assign values to variables:

Operator Example Same As

= x=5 x=5
+= x += 3 x=x+3

-= x -= 3 x=x-3

*= x *= 3 x=x*3

/= x /= 3 x=x/3

%= x %= 3 x=x%3

//= x //= 3 x = x // 3

**= x **= 3 x = x ** 3

&= x &= 3 x=x&3

|= x |= 3 x=x|3

^= x ^= 3 x=x^3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

Python Comparison Operators
Comparison operators are used to compare two values:

Operator Name Example

== Equal x == y

!= Not equal x != y

> Greater than x>y

< Less than x<y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

Python Logical Operators

Logical operators are used to combine conditional statements:

Operator Description Example

and Returns True if both statements are true x<5

and x <
 10

or Returns True if one of the statements is true x < 5 or

x<4

not Reverse the result, returns False if the result not(x <
is true 5 and x
< 10)

Python Identity Operators

Identity operators are used to compare the objects, not if they are equal, but
if they are actually the same object, with the same memory location:

Operator Description Example

is Returns True if both variables are x is y

the same object

is not Returns True if both variables are x is not y

not the same object

Python Membership Operators

Membership operators are used to test if a sequence is presented in an
object:

Operator Description Example

 in Returns True if a sequence with the x in y
specified value is present in the object

not in Returns True if a sequence with the x not in y

specified value is not present in the
object

Python Bitwise Operators

Bitwise operators are used to compare (binary) numbers:

Operator Name Description

& AND Sets each bit to 1 if both bits are 1

| OR Sets each bit to 1 if one of two bits is 1

^ XOR Sets each bit to 1 if only one of two bits is 1

~ NOT Inverts all the bits

<< Zero fill Shift left by pushing zeros in from the right and let the
left shift leftmost bits fall off

>> Signed Shift right by pushing copies of the leftmost bit in from
right the left, and let the rightmost bits fall off
shift
Python Lists
mylist = ["apple", "banana", "cherry"]

List
Lists are used to store multiple items in a single variable.

Lists are one of 4 built-in data types in Python used to store collections of
data, the other 3 are Tuple, Set, and Dictionary, all with different qualities
and usage.

Lists are created using square brackets:

Example
Create a List:

thislist = ["apple", "banana", "cherry"]

print(thislist)

List Items
List items are ordered, changeable, and allow duplicate values.

List items are indexed, the first item has index [0], the second item has
index [1] etc.

Ordered
When we say that lists are ordered, it means that the items have a defined
order, and that order will not change.

If you add new items to a list, the new items will be placed at the end of the
list.

Note: There are some list methods that will change the order, but in
general: the order of the items will not change.

Changeable
The list is changeable, meaning that we can change, add, and remove items
in a list after it has been created.

Allow Duplicates
Since lists are indexed, lists can have items with the same value:

Example
Lists allow duplicate values:

thislist = ["apple", "banana", "cherry", "apple", "cherry"]

print(thislist)

List Length
To determine how many items a list has, use the len() function:

Example
Print the number of items in the list:

thislist = ["apple", "banana", "cherry"]

print(len(thislist))

List Items - Data Types

List items can be of any data type:

Example
String, int and boolean data types:

list1 = ["apple", "banana", "cherry"]

list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]

A list can contain different data types:

Example
A list with strings, integers and boolean values:

list1 = ["abc", 34, True, 40, "male"]

type()
From Python's perspective, lists are defined as objects with the data type
'list':

<class 'list'>

Example
What is the data type of a list?

mylist = ["apple", "banana", "cherry"]

print(type(mylist))

The list() Constructor

It is also possible to use the list() constructor when creating a new list.

Example
Using the list() constructor to make a List:

thislist = list(("apple", "banana", "cherry")) # note the double round-

brackets
print(thislist)

Python Collections (Arrays)

There are four collection data types in the Python programming language:

 List is a collection which is ordered and changeable. Allows duplicate

members.
 Tuple is a collection which is ordered and unchangeable. Allows
duplicate members.
 Set is a collection which is unordered and unindexed. No duplicate
members.
 Dictionary is a collection which is ordered* and changeable. No
duplicate members.

When choosing a collection type, it is useful to understand the properties of

that type. Choosing the right type for a particular data set could mean
retention of meaning, and, it could mean an increase in efficiency or security.
Python - Access List Items
Access Items
List items are indexed and you can access them by referring to the index
number:

Example
Print the second item of the list:

thislist = ["apple", "banana", "cherry"]

print(thislist[1])

Negative Indexing
Negative indexing means start from the end

-1 refers to the last item, -2 refers to the second last item etc.

Example
Print the last item of the list:

thislist = ["apple", "banana", "cherry"]

print(thislist[-1])

Range of Indexes
You can specify a range of indexes by specifying where to start and where to
end the range.

When specifying a range, the return value will be a new list with the specified
items.

Example
Return the third, fourth, and fifth item:

thislist =
["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

By leaving out the start value, the range will start at the first item:
Example
This example returns the items from the beginning to, but NOT including,
"kiwi":

thislist =
["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])

By leaving out the end value, the range will go on to the end of the list:

Example
This example returns the items from "cherry" to the end:

thislist =
["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:])

Range of Negative Indexes

Specify negative indexes if you want to start the search from the end of the
list:

Example
This example returns the items from "orange" (-4) to, but NOT including
"mango" (-1):

thislist =
["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1])

Check if Item Exists

To determine if a specified item is present in a list use the in keyword:

Example
Check if "apple" is present in the list:

thislist = ["apple", "banana", "cherry"]

if "apple" in thislist:
print("Yes, 'apple' is in the fruits list")
Python - Change List Items
Change Item Value
To change the value of a specific item, refer to the index number:

Example
Change the second item:

thislist = ["apple", "banana", "cherry"]

thislist[1] = "blackcurrant"
print(thislist)

Change a Range of Item Values

To change the value of items within a specific range, define a list with the
new values, and refer to the range of index numbers where you want to
insert the new values:

Example
Change the values "banana" and "cherry" with the values "blackcurrant" and
"watermelon":

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]

thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)

If you insert more items than you replace, the new items will be inserted
where you specified, and the remaining items will move accordingly:

Example
Change the second value by replacing it with two new values:

thislist = ["apple", "banana", "cherry"]

thislist[1:2] = ["blackcurrant", "watermelon"]
print(thislist)

Note: The length of the list will change when the number of items inserted
does not match the number of items replaced.

If you insert less items than you replace, the new items will be inserted
where you specified, and the remaining items will move accordingly:

Example
Change the second and third value by replacing it with one value:

thislist = ["apple", "banana", "cherry"]

thislist[1:3] = ["watermelon"]
print(thislist)

Insert Items
To insert a new list item, without replacing any of the existing values, we can
use the insert() method.

The insert() method inserts an item at the specified index:

Example
Insert "watermelon" as the third item:

thislist = ["apple", "banana", "cherry"]

thislist.insert(2, "watermelon")
print(thislist)

Note: As a result of the example above, the list will now contain 4 items.

Python - Add List Items

Append Items
To add an item to the end of the list, use the append() method:

Example
Using the append() method to append an item:

thislist = ["apple", "banana", "cherry"]

thislist.append("orange")
print(thislist)

Insert Items
To insert a list item at a specified index, use the insert() method.

The insert() method inserts an item at the specified index:

Example
Insert an item as the second position:
thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)

Note: As a result of the examples above, the lists will now contain 4 items.

Extend List
To append elements from another list to the current list, use
the extend() method.

Example
Add the elements of tropical to thislist:

thislist = ["apple", "banana", "cherry"]

tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)

The elements will be added to the end of the list.

Add Any Iterable

The extend() method does not have to append lists, you can add any iterable
object (tuples, sets, dictionaries etc.).

Example
Add elements of a tuple to a list:

thislist = ["apple", "banana", "cherry"]

thistuple = ("kiwi", "orange")
thislist.extend(thistuple)
print(thislist)

Python - Remove List Items

Remove Specified Item
The remove() method removes the specified item.

Example
Remove "banana":
thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

Remove Specified Index

The pop() method removes the specified index.

Example
Remove the second item:

thislist = ["apple", "banana", "cherry"]

thislist.pop(1)
print(thislist)

If you do not specify the index, the pop() method removes the last item.

Example
Remove the last item:

thislist = ["apple", "banana", "cherry"]

thislist.pop()
print(thislist)

The del keyword also removes the specified index:

Example
Remove the first item:

thislist = ["apple", "banana", "cherry"]

del thislist[0]
print(thislist)

The del keyword can also delete the list completely.

Example
Delete the entire list:

thislist = ["apple", "banana", "cherry"]

del thislist

Clear the List

The clear() method empties the list.
The list still remains, but it has no content.

Example
Clear the list content:

thislist = ["apple", "banana", "cherry"]

thislist.clear()
print(thislist)

Python - Loop Lists

Loop Through a List
You can loop through the list items by using a for loop:

Example
Print all items in the list, one by one:

thislist = ["apple", "banana", "cherry"]

for x in thislist:
print(x)

Learn more about for loops in our Python For Loops Chapter.

Loop Through the Index Numbers

You can also loop through the list items by referring to their index number.

Use the range() and len() functions to create a suitable iterable.

Example
Print all items by referring to their index number:

thislist = ["apple", "banana", "cherry"]

for i in range(len(thislist)):
print(thislist[i])

The iterable created in the example above is [0, 1, 2].

Using a While Loop

You can loop through the list items by using a while loop.
Use the len() function to determine the length of the list, then start at 0 and
loop your way through the list items by refering to their indexes.

Remember to increase the index by 1 after each iteration.

Example
Print all items, using a while loop to go through all the index numbers

thislist = ["apple", "banana", "cherry"]

i = 0
while i < len(thislist):
print(thislist[i])
i = i + 1

Looping Using List Comprehension

List Comprehension offers the shortest syntax for looping through lists:

Example
A short hand for loop that will print all items in a list:

thislist = ["apple", "banana", "cherry"]

[print(x) for x in thislist]

Python - List Comprehension

List Comprehension
List comprehension offers a shorter syntax when you want to create a new
list based on the values of an existing list.

Example:

Based on a list of fruits, you want a new list, containing only the fruits with
the letter "a" in the name.

Without list comprehension you will have to write a for statement with a
conditional test inside:

Example
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

for x in fruits:
 if "a" in x:
newlist.append(x)

print(newlist)

With list comprehension you can do all that with only one line of code:

Example
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if "a" in x]

print(newlist)

The Syntax
newlist = [expression for item in iterable if condition == True]

Condition
The condition is like a filter that only accepts the items that valuate to True.

Example
Only accept items that are not "apple":

newlist = [x for x in fruits if x != "apple"]

The condition if x != "apple" will return True for all elements other than
"apple", making the new list contain all fruits except "apple".

The condition is optional and can be omitted:

Example
With no if statement:

newlist = [x for x in fruits]

Iterable
The iterable can be any iterable object, like a list, tuple, set etc.

Example
You can use the range() function to create an iterable:
newlist = [x for x in range(10)]

Same example, but with a condition:

Example
Accept only numbers lower than 5:

newlist = [x for x in range(10) if x < 5]

Expression
The expression is the current item in the iteration, but it is also the outcome,
which you can manipulate before it ends up like a list item in the new list:

Example
Set the values in the new list to upper case:

newlist = [x.upper() for x in fruits]

You can set the outcome to whatever you like:

Example
Set all values in the new list to 'hello':

newlist = ['hello' for x in fruits]

The expression can also contain conditions, not like a filter, but as a way to
manipulate the outcome:

Example
Return "orange" instead of "banana":

newlist = [x if x != "banana" else "orange" for x in fruits]

The expression in the example above says:

"Return the item if it is not banana, if it is banana return orange".

Python - Sort Lists

Sort List Alphanumerically
List objects have a sort() method that will sort the list alphanumerically,
ascending, by default:
Example
Sort the list alphabetically:

thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]

thislist.sort()
print(thislist)

Example
Sort the list numerically:

thislist = [100, 50, 65, 82, 23]

thislist.sort()
print(thislist)

Sort Descending
To sort descending, use the keyword argument reverse = True:

Example
Sort the list descending:

thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]

thislist.sort(reverse = True)
print(thislist)

Example
Sort the list descending:

thislist = [100, 50, 65, 82, 23]

thislist.sort(reverse = True)
print(thislist)

Customize Sort Function

You can also customize your own function by using the keyword
argument key = function.

The function will return a number that will be used to sort the list (the lowest
number first):

Example
Sort the list based on how close the number is to 50:
def myfunc(n):
return abs(n - 50)

thislist = [100, 50, 65, 82, 23]

thislist.sort(key = myfunc)
print(thislist)

Case Insensitive Sort

By default the sort() method is case sensitive, resulting in all capital letters
being sorted before lower case letters:

Example
Case sensitive sorting can give an unexpected result:

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.sort()
print(thislist)

Luckily we can use built-in functions as key functions when sorting a list.

So if you want a case-insensitive sort function, use str.lower as a key

function:

Example
Perform a case-insensitive sort of the list:

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.sort(key = str.lower)
print(thislist)

Reverse Order
What if you want to reverse the order of a list, regardless of the alphabet?

The reverse() method reverses the current sorting order of the elements.

Example
Reverse the order of the list items:

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.reverse()
print(thislist)
Python - Copy Lists
Copy a List
You cannot copy a list simply by typing list2 = list1, because: list2 will only
be a reference to list1, and changes made in list1 will automatically also be
made in list2.

There are ways to make a copy, one way is to use the built-in List
method copy().

Example
Make a copy of a list with the copy() method:

thislist = ["apple", "banana", "cherry"]

mylist = thislist.copy()
print(mylist)

Another way to make a copy is to use the built-in method list().

Example
Make a copy of a list with the list() method:

thislist = ["apple", "banana", "cherry"]

mylist = list(thislist)
print(mylist)

Python - Join Lists

Join Two Lists
There are several ways to join, or concatenate, two or more lists in Python.

One of the easiest ways are by using the + operator.

Example
Join two list:
list1 = ["a", "b", "c"]
list2 = [1, 2, 3]

list3 = list1 + list2

print(list3)

Another way to join two lists is by appending all the items from list2 into
list1, one by one:

Example
Append list2 into list1:

list1 = ["a", "b" , "c"]

list2 = [1, 2, 3]

for x in list2:
list1.append(x)

print(list1)

Or you can use the extend() method, which purpose is to add elements from
one list to another list:

Example
Use the extend() method to add list2 at the end of list1:

list1 = ["a", "b" , "c"]

list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

Python - List Methods

List Methods
Python has a set of built-in methods that you can use on lists.

Method Description

append() Adds an element at the end of the list

 clear() Removes all the elements from the list

copy() Returns a copy of the list

count() Returns the number of elements with the specified value

extend() Add the elements of a list (or any iterable), to the end of the
current list

index() Returns the index of the first element with the specified value

insert() Adds an element at the specified position

pop() Removes the element at the specified position

remove() Removes the item with the specified value

reverse() Reverses the order of the list

sort() Sorts the list

Python Tuples
mytuple = ("apple", "banana", "cherry")

Tuple
Tuples are used to store multiple items in a single variable.

Tuple is one of 4 built-in data types in Python used to store collections of

data, the other 3 are List, Set, and Dictionary, all with different qualities and
usage.

A tuple is a collection which is ordered and unchangeable.

Tuples are written with round brackets.

Example
Create a Tuple:

thistuple = ("apple", "banana", "cherry")

print(thistuple)

Tuple Items
Tuple items are ordered, unchangeable, and allow duplicate values.

Tuple items are indexed, the first item has index [0], the second item has
index [1] etc.

Ordered
When we say that tuples are ordered, it means that the items have a defined
order, and that order will not change.

Unchangeable
Tuples are unchangeable, meaning that we cannot change, add or remove
items after the tuple has been created.

Allow Duplicates
Since tuples are indexed, they can have items with the same value:

Example
Tuples allow duplicate values:

thistuple = ("apple", "banana", "cherry", "apple", "cherry")

print(thistuple)
Tuple Length
To determine how many items a tuple has, use the len() function:

Example
Print the number of items in the tuple:

thistuple = ("apple", "banana", "cherry")

print(len(thistuple))

Create Tuple With One Item

To create a tuple with only one item, you have to add a comma after the
item, otherwise Python will not recognize it as a tuple.

Example
One item tuple, remember the comma:

thistuple = ("apple",)
print(type(thistuple))

#NOT a tuple
thistuple = ("apple")
print(type(thistuple))

Tuple Items - Data Types

Tuple items can be of any data type:

Example
String, int and boolean data types:

tuple1 = ("apple", "banana", "cherry")

tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)

A tuple can contain different data types:

Example
A tuple with strings, integers and boolean values:
tuple1 = ("abc", 34, True, 40, "male")

type()
From Python's perspective, tuples are defined as objects with the data type
'tuple':

<class 'tuple'>

Example
What is the data type of a tuple?

mytuple = ("apple", "banana", "cherry")

print(type(mytuple))

The tuple() Constructor

It is also possible to use the tuple() constructor to make a tuple.

Example
Using the tuple() method to make a tuple:

thistuple = tuple(("apple", "banana", "cherry")) # note the double

round-brackets
print(thistuple)

Python - Access Tuple Items

Access Tuple Items
You can access tuple items by referring to the index number, inside square
brackets:

Example
Print the second item in the tuple:

thistuple = ("apple", "banana", "cherry")

print(thistuple[1])

Negative Indexing
Negative indexing means start from the end.
-1 refers to the last item, -2 refers to the second last item etc.

Example
Print the last item of the tuple:

thistuple = ("apple", "banana", "cherry")

print(thistuple[-1])

Range of Indexes
You can specify a range of indexes by specifying where to start and where to
end the range.

When specifying a range, the return value will be a new tuple with the
specified items.

Example
Return the third, fourth, and fifth item:

thistuple =
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

Python - Update Tuples

print(thistuple[2:5])

Change Tuple Values

Once a tuple is created, you cannot change its values. Tuples
are unchangeable, or immutable as it also is called.

But there is a workaround. You can convert the tuple into a list, change the
list, and convert the list back into a tuple.

Example
Convert the tuple into a list to be able to change it:

x = ("apple", "banana", "cherry")

y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)

Add Items
Once a tuple is created, you cannot add items to it.

Example
You cannot add items to a tuple:

thistuple = ("apple", "banana", "cherry")

thistuple.append("orange") # This will raise an error
print(thistuple)

Just like the workaround for changing a tuple, you can convert it into
a list, add your item(s), and convert it back into a tuple.

Example
Convert the tuple into a list, add "orange", and convert it back into a tuple:

thistuple = ("apple", "banana", "cherry")

y = list(thistuple)
y.append("orange")
thistuple = tuple(y)

Remove Items
Tuples are unchangeable, so you cannot remove items from it, but
you can use the same workaround as we used for changing and
adding tuple items:

Example
Convert the tuple into a list, remove "apple", and convert it back into a
tuple:

thistuple = ("apple", "banana", "cherry")

y = list(thistuple)
y.remove("apple")
thistuple = tuple(y)

Or you can delete the tuple completely:

Example
The del keyword can delete the tuple completely:

thistuple = ("apple", "banana", "cherry")

del thistuple
print(thistuple) #this will raise an error because the tuple no longer
exists

Python TUPLE - Pack, Unpack, Compare, Slicing, Delete, Key:

What is Tuple Matching in Python?

Tuple Matching in Python is a method of grouping the tuples by matching the second
element in the tuples. It is achieved by using a dictionary by checking the second element in
each tuple in python programming. However, we can make new tuples by taking portions of
existing tuples.

Tuple Syntax

Tup = ('Jan','feb','march')

To write an empty tuple, you need to write as two parentheses containing

nothing-
tup1 = ();
For writing tuple for a single value, you need to include a comma, even though
there is a single value. Also at the end you need to write semicolon as shown
below.
Tup1 = (50,);
Tuple indices begin at 0, and they can be concatenated, sliced and so on.
Tuple Assignment

we have assigned tuple 1 with the persons information like name, surname,
birth year, etc. and another tuple 2 with the values in it like number (1,2,3,….,7).

For Example,

(name, surname, birth year, favorite movie and year, profession, birthplace) =
Robert

Here is the code,

tup1 = ('Robert', 'Carlos','1965','Terminator 1995', 'Actor','Florida');

tup2 = (1,2,3,4,5,6,7);
print(tup1[0])
print(tup2[1:4])

Packing and Unpacking

In packing, we place value into a new tuple while in unpacking we extract those
values back into variables.

x = ("Guru99", 20, "Education") # tuple packing

(company, emp, profile) = x # tuple unpacking
print(company)
print(emp)
print(profile)

Comparing tuples
A comparison operator in Python can work with tuples.

The comparison starts with a first element of each tuple. If they do not compare
to =,< or > then it proceed to the second element and so on.

It starts with comparing the first element from each of the tuples

Let's study this with an example-

#case 1

a=(5,6)
b=(1,4)
if (a>b):print("a is bigger")
else: print("b is bigger")

#case 2
a=(5,6)
b=(5,4)
if (a>b):print("a is bigger")
else: print ("b is bigger")

#case 3
a=(5,6)
b=(6,4)
if (a>b):print("a is bigger")
else: print("b is bigger")

Case1: Comparison starts with a first element of each tuple. In this case 5>1, so
the output a is bigger

Case 2: Comparison starts with a first element of each tuple. In this case 5>5
which is inconclusive. So it proceeds to the next element. 6>4, so the output a is
bigger

Case 3: Comparison starts with a first element of each tuple. In this case 5>6
which is false. So it goes into the else block and prints "b is bigger."

Using tuples as keys in dictionaries

Since tuples are hashable, and list is not, we must use tuple as the key if we
need to create a composite key to use in a dictionary.

Example: We would come across a composite key if we need to create a

telephone directory that maps, first-name, last-name, pairs of telephone
numbers, etc. Assuming that we have declared the variables as last and first
number, we could write a dictionary assignment statement as shown below:

directory[last,first] = number

Inside the brackets, the expression is a tuple. We could use tuple assignment in
a for loop to navigate this dictionary.
for last, first in directory:
print first, last, directory[last, first]

This loop navigates the keys in the directory, which are tuples. It assigns the
elements of each tuple to last and first and then prints the name and
corresponding telephone number.

Tuples and dictionary

Dictionary can return the list of tuples by calling items, where each tuple is a key
value pair.
a = {'x':100, 'y':200}
b = list(a.items())
print(b)

Deleting Tuples
Tuples are immutable and cannot be deleted. You cannot delete or remove
items from a tuple. But deleting tuple entirely is possible by using the keyword

del

Slicing of Tuple
To fetch specific sets of sub-elements from tuple or list, we use this unique
function called slicing. Slicing is not only applicable to tuple but also for array
and list.

x = ("a", "b","c", "d", "e")

print(x[2:4])

The output of this code will be ('c', 'd').

Here is the Python 2 Code for all above example

tup1 = ('Robert', 'Carlos','1965','Terminator 1995', 'Actor','Florida');

tup2 = (1,2,3,4,5,6,7);
print tup1[0]
print tup2[1:4]

#Packing and Unpacking

x = ("Guru99", 20, "Education") # tuple packing
(company, emp, profile) = x # tuple unpacking
print company
print emp
print profile

#Comparing tuples
#case 1
a=(5,6)
b=(1,4)
if (a>b):print "a is bigger"
else: print "b is bigger"
#case 2
a=(5,6)
b=(5,4)
if (a>b):print "a is bigger"
else: print "b is bigger"

#case 3
a=(5,6)
b=(6,4)
if (a>b):print "a is bigger"
else: print "b is bigger"

#Tuples and dictionary

a = {'x':100, 'y':200}
b = a.items()
print b
#Slicing of Tuple
x = ("a", "b","c", "d", "e")
print x[2:4]

Built-in functions with Tuple

To perform different task, tuple allows you to use many built-in functions like
all(), any(), enumerate(), max(), min(), sorted(), len(), tuple(), etc.

Advantages of tuple over list

 Iterating through tuple is faster than with list, since tuples are immutable.
 Tuples that consist of immutable elements can be used as key for
dictionary, which is not possible with list
 If you have data that is immutable, implementing it as tuple will
guarantee that it remains write-protected

To work with PDF:

1. Run Pip install pyPDF2
Extract table from PDF:
1. pip install camelot-py[cv]. Using Camelot is one method
2. pip install tabula-py. Using Tabula is another method
3. pip install excalibur-py. When extracting PDF tables from Web interface

Personal Voice Assistant in Python:

# importing speech recognition package from google api
import speech_recognition as sr
import playsound # to play saved mp3 file
from gtts import gTTS # google text to speech
import os # to save/open files
import wolframalpha # to calculate strings into formula
from selenium import webdriver # to control browser operations
num = 1
def assistant_speaks(output):
global num
# num to rename every audio file
# with different name to remove ambiguity
num += 1
print("PerSon : ", output)
toSpeak = gTTS(text = output, lang ='en', slow = False)
# saving the audio file given by google text to speech
file = str(num)+".mp3
toSpeak.save(file)
# playsound package is used to play the same file.
playsound.playsound(file, True)
os.remove(file)
def get_audio():
rObject = sr.Recognizer()
audio = ''
with sr.Microphone() as source:
print("Speak...")
# recording the audio using speech recognition
audio = rObject.listen(source, phrase_time_limit = 5)
print("Stop.") # limit 5 secs
try:
text = rObject.recognize_google(audio, language ='en-US')
print("You : ", text)
return text
except:
assistant_speaks("Could not understand your audio, PLease try
again !")
return 0
# Driver Code
if __name__ == "__main__":
assistant_speaks("What's your name, Human?")
name ='Human'
name = get_audio()
assistant_speaks("Hello, " + name + '.')
while(1):
assistant_speaks("What can i do for you?")
text = get_audio().lower()
if text == 0:
continue
 if "exit" in str(text) or "bye" in str(text) or "sleep" in str(text):
assistant_speaks("Ok bye, "+ name+'.')
break
# calling process text to process the query
process_text(text)
WolframAPI for calculations part Code
def process_text(input):
try:
if 'search' in input or 'play' in input:
# a basic web crawler using selenium
search_web(input)
return
elif "who are you" in input or "define yourself" in input:
speak = '''Hello, I am Person. Your personal Assistant.
I am here to make your life easier. You can command me to
perform
various tasks such as calculating sums or opening
applications etcetra'''
assistant_speaks(speak)
return
elif "who made you" in input or "created you" in input:
speak = "I have been created by Sheetansh Kumar."
assistant_speaks(speak)
return
elif "geeksforgeeks" in input:# just
speak = """Geeks for Geeks is the Best Online Coding
Platform for learning."""
 assistant_speaks(speak)
return
elif "calculate" in input.lower():
# write your wolframalpha app_id here
app_id = "WOLFRAMALPHA_APP_ID"
client = wolframalpha.Client(app_id)
indx = input.lower().split().index('calculate')
query = input.split()[indx + 1:]
res = client.query(' '.join(query))
answer = next(res.results).text
assistant_speaks("The answer is " + answer)
return
elif 'open' in input:
# another function to open
# different application availaible
open_application(input.lower())
return
else:
assistant_speaks("I can search the web for you, Do you
want to continue?")
ans = get_audio()
if 'yes' in str(ans) or 'yeah' in str(ans):
search_web(input)
else:
return
except :
 assistant_speaks("I don't understand, I can search the web for
you, Do you want to continue?")
ans = get_audio()
if 'yes' in str(ans) or 'yeah' in str(ans):
search_web(input)
def search_web(input):
driver = webdriver.Firefox()
driver.implicitly_wait(1)
driver.maximize_window()
if 'youtube' in input.lower():
assistant_speaks("Opening in youtube")
indx = input.lower().split().index('youtube')
query = input.split()[indx + 1:]
driver.get("http://www.youtube.com/results?search_query =" +
'+'.join(query))
return
elif 'wikipedia' in input.lower():
assistant_speaks("Opening Wikipedia")
indx = input.lower().split().index('wikipedia')
query = input.split()[indx + 1:]
driver.get("https://en.wikipedia.org/wiki/" + '_'.join(query))
return
else:
if 'google' in input:
indx = input.lower().split().index('google')
query = input.split()[indx + 1:]
 driver.get("https://www.google.com/search?q =" +
'+'.join(query))
elif 'search' in input:
indx = input.lower().split().index('google')
query = input.split()[indx + 1:]
driver.get("https://www.google.com/search?q =" +
'+'.join(query))
else:
driver.get("https://www.google.com/search?q =" +
'+'.join(input.split()))
return
# function used to open application
# present inside the system.
def open_application(input):
if "chrome" in input:
assistant_speaks("Google Chrome")
os.startfile('C:\Program Files (x86)\Google\Chrome\Application\
chrome.exe')
return
elif "firefox" in input or "mozilla" in input:
assistant_speaks("Opening Mozilla Firefox")
os.startfile('C:\Program Files\Mozilla Firefox\\firefox.exe')
return
elif "word" in input:
assistant_speaks("Opening Microsoft Word")
os.startfile('C:\ProgramData\Microsoft\Windows\Start Menu\
Programs\Microsoft Office 2013\\Word 2013.lnk')
return
 elif "excel" in input:
assistant_speaks("Opening Microsoft Excel")
os.startfile('C:\ProgramData\Microsoft\Windows\Start Menu\
Programs\Microsoft Office 2013\\Excel 2013.lnk')
return
else:
assistant_speaks("Application not available")
return
Matrix

Machine Learning

Types of Machine Learning (ML)

Machine Learning Algorithms helps computer system learn without being explicitly
programmed. These algorithms are categorized into supervised or unsupervised.
Let us now see a few algorithms −

Supervised machine learning algorithms

This is the most commonly used machine learning algorithm. It is called supervised
because the process of algorithm learning from the training dataset can be thought
of as a teacher supervising the learning process. In this kind of ML algorithm, the
possible outcomes are already known and training data is also labeled with correct
answers. It can be understood as follows −
Suppose we have input variables x and an output variable y and we applied an
algorithm to learn the mapping function from the input to output such as −
Y = f(x)
Now, the main goal is to approximate the mapping function so well that when we
have new input data (x), we can predict the output variable (Y) for that data.
Mainly supervised leaning problems can be divided into the following two kinds of
problems −
 Classification − A problem is called classification problem when we have the
categorized output such as “black”, “teaching”, “non-teaching”, etc.
 Regression − A problem is called regression problem when we have the real
value output such as “distance”, “kilogram”, etc.
Decision tree, random forest, knn, logistic regression are the examples of
supervised machine learning algorithms.

Unsupervised machine learning algorithms

As the name suggests, these kinds of machine learning algorithms do not have any
supervisor to provide any sort of guidance. That is why unsupervised machine
learning algorithms are closely aligned with what some call true artificial intelligence.
It can be understood as follows −
Suppose we have input variable x, then there will be no corresponding output
variables as there is in supervised learning algorithms.
In simple words, we can say that in unsupervised learning there will be no correct
answer and no teacher for the guidance. Algorithms help to discover interesting
patterns in data.
Unsupervised learning problems can be divided into the following two kinds of
problem −
 Clustering − In clustering problems, we need to discover the inherent
groupings in the data. For example, grouping customers by their purchasing
behavior.
 Association − A problem is called association problem because such kinds
of problem require discovering the rules that describe large portions of our
data. For example, finding the customers who buy both x and y.
K-means for clustering, Apriori algorithm for association are the examples of
unsupervised machine learning algorithms.

Most Common Machine Learning Algorithms

In this section, we will learn about the most common machine learning algorithms.
The algorithms are described below −

Linear Regression

It is one of the most well-known algorithms in statistics and machine learning.

Basic concept − Mainly linear regression is a linear model that assumes a linear
relationship between the input variables say x and the single output variable say y.
In other words, we can say that y can be calculated from a linear combination of the
input variables x. The relationship between variables can be established by fitting a
best line.

Types of Linear Regression

Linear regression is of the following two types −

 Simple linear regression − A linear regression algorithm is called simple
linear regression if it is having only one independent variable.
  Multiple linear regression − A linear regression algorithm is called multiple
linear regression if it is having more than one independent variable.
Linear regression is mainly used to estimate the real values based on continuous
variable(s). For example, the total sale of a shop in a day, based on real values, can
be estimated by linear regression.

Logistic Regression

It is a classification algorithm and also known as logit regression.

Mainly logistic regression is a classification algorithm that is used to estimate the
discrete values like 0 or 1, true or false, yes or no based on a given set of
independent variable. Basically, it predicts the probability hence its output lies in
between 0 and 1.

Decision Tree

Decision tree is a supervised learning algorithm that is mostly used for classification
problems.
Basically it is a classifier expressed as recursive partition based on the independent
variables. Decision tree has nodes which form the rooted tree. Rooted tree is a
directed tree with a node called “root”. Root does not have any incoming edges and
all the other nodes have one incoming edge. These nodes are called leaves or
decision nodes. For example, consider the following decision tree to see whether a
person is fit or not.

Support Vector Machine (SVM)

It is used for both classification and regression problems. But mainly it is used for
classification problems. The main concept of SVM is to plot each data item as a
point in n-dimensional space with the value of each feature being the value of a
particular coordinate. Here n would be the features we would have. Following is a
simple graphical representation to understand the concept of SVM −

In the above diagram, we have two features hence we first need to plot these two
variables in two dimensional space where each point has two co-ordinates, called
support vectors. The line splits the data into two different classified groups. This line
would be the classifier.
Naïve Bayes

It is also a classification technique. The logic behind this classification technique is

to use Bayes theorem for building classifiers. The assumption is that the predictors
are independent. In simple words, it assumes that the presence of a particular
feature in a class is unrelated to the presence of any other feature. Below is the
equation for Bayes theorem −
$$P\left ( \frac{A}{B} \right ) = \frac{P\left ( \frac{B}{A} \right )P\left ( A \right )}{P\left
( B \right )}$$
The Naïve Bayes model is easy to build and particularly useful for large data sets.

K-Nearest Neighbors (KNN)

It is used for both classification and regression of the problems. It is widely used to
solve classification problems. The main concept of this algorithm is that it used to
store all the available cases and classifies new cases by majority votes of its k
neighbors. The case being then assigned to the class which is the most common
amongst its K-nearest neighbors, measured by a distance function. The distance
function can be Euclidean, Minkowski and Hamming distance. Consider the
following to use KNN −
 Computationally KNN are expensive than other algorithms used for
classification problems.
 The normalization of variables needed otherwise higher range variables can
bias it.
 In KNN, we need to work on pre-processing stage like noise removal.

K-Means Clustering

As the name suggests, it is used to solve the clustering problems. It is basically a

type of unsupervised learning. The main logic of K-Means clustering algorithm is to
classify the data set through a number of clusters. Follow these steps to form
clusters by K-means −
 K-means picks k number of points for each cluster known as centroids.
 Now each data point forms a cluster with the closest centroids, i.e., k clusters.
 Now, it will find the centroids of each cluster based on the existing cluster
members.
 We need to repeat these steps until convergence occurs.

Random Forest

It is a supervised classification algorithm. The advantage of random forest algorithm

is that it can be used for both classification and regression kind of problems.
Basically it is the collection of decision trees (i.e., forest) or you can say ensemble
of the decision trees. The basic concept of random forest is that each tree gives a
classification and the forest chooses the best classifications from them. Followings
are the advantages of Random Forest algorithm −
 Random forest classifier can be used for both classification and regression
tasks.
 They can handle the missing values.
 It won’t over fit the model even if we have more number of trees in the forest.
AI in Python

Pre-processing the Data

In our daily life, we deal with lots of data but this data is in raw form. To provide the
data as the input of machine learning algorithms, we need to convert it into a
meaningful data. That is where data pre-processing comes into picture. In other
simple words, we can say that before providing the data to the machine learning
algorithms we need to pre-process the data.

Data pre-processing steps

Follow these steps to pre-process the data in Python −

Step 1 − Importing the useful packages − If we are using Python then this would be the
first step for converting the data into a certain format, i.e., pre-processing. It can be done as
follows −

Import numpy as np
Import sklearn.preprocessing
 NumPy − Basically NumPy is a general purpose array-processing package
designed to efficiently manipulate large multi-dimensional arrays of arbitrary
records without sacrificing too much speed for small multi-dimensional
arrays.
 Sklearn.preprocessing − This package provides many common utility
functions and transformer classes to change raw feature vectors into a
representation that is more suitable for machine learning algorithms.
Step 2 − Defining sample data − After importing the packages, we need to define some
sample data so that we can apply pre-processing techniques on that data. We will now
define the following sample data –

input_data = np.array([2.1, -1.9, 5.5],

[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8])

Step3 − Applying preprocessing technique − In this step, we need to apply any

of the preprocessing techniques.
The following section describes the data preprocessing techniques.
Techniques for Data Preprocessing
The techniques for data preprocessing are described below −

Binarization

This is the preprocessing technique which is used when we need to convert our
numerical values into Boolean values. We can use an inbuilt method to binarize the
input data say by using 0.5 as the threshold value in the following way –
data_binarized = preprocessing.Binarizer(threshold =
0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)
output: all the values above 0.5(threshold value) would be converted to 1 and all the values
below 0.5 would be converted to 0.
Binarized data
[[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]]

Mean Removal

It is another very common preprocessing technique that is used in machine learning.

Basically it is used to eliminate the mean from feature vector so that every feature is
centered on zero. We can also remove the bias from the features in the feature vector. For
applying mean removal preprocessing technique on the sample data, we can write the
Python code shown below. The code will display the Mean and Standard deviation of the
input data –
print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))

output:
Mean = [ 1.75 -1.275 2.2]
Std deviation = [ 2.71431391 4.20022321 4.69414529]

The code below will remove the Mean and Standard deviation of the input data –

data_scaled = preprocessing.scale(input_data)
print("Mean =", data_scaled.mean(axis=0))
print("Std deviation =", data_scaled.std(axis = 0))
output :
Mean = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Std deviation = [ 1. 1. 1.]

Scaling
It is another data preprocessing technique that is used to scale the feature vectors. Scaling of feature
vectors is needed because the values of every feature can vary between many random values. In
other words we can say that scaling is important because we do not want any feature to be
synthetically large or small. With the help of the following Python code, we can do the scaling of our
input data, i.e., feature vector −
# Min max scaling

data_scaler_minmax =
preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)
output:

[ [ 0.48648649 0.58252427 0.99122807]

[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0. 99029126 0. ]]

Normalization

It is another data preprocessing technique that is used to modify the feature vectors. Such kind of
modification is necessary to measure the feature vectors on a common scale. Followings are two
types of normalization which can be used in machine learning −
L1 Normalization
It is also referred to as Least Absolute Deviations. This kind of normalization modifies the values
so that the sum of the absolute values is always up to 1 in each row. It can be implemented on the
input data with the help of the following Python code –
# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm =
'l1')
print("\nL1 normalized data:\n", data_normalized_l1)
output:
L1 normalized data:
[[ 0.22105263 -0.2 0.57894737]
[ -0.2027027 0.32432432 0.47297297]
[ 0.03571429 -0.56428571 0.4 ]
[ 0.42142857 0.16428571 -0.41428571]]

L2 Normalization
It is also referred to as least squares. This kind of normalization modifies the values so that the sum
of the squares is always up to 1 in each row. It can be implemented on the input data with the help of
the following Python code −
# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm =
'l2')
print("\nL2 normalized data:\n", data_normalized_l2)
Output:
L2 normalized data:
[[ 0.33946114 -0.30713151 0.88906489]
[ -0.33325106 0.53320169 0.7775858 ]
[ 0.05156558 -0.81473612 0.57753446]
[ 0.68706914 0.26784051 -0.6754239 ]]