Wednesday 15 May 2019

Python for Beginners

All Python codes have been successfully executed on Python 3.5 (32 bits) and Anaconda Navigator (anaconda3)

Source Code Github Link: https://github.com/sachin365123/examworld.co.in

Content:

Lecture :1 : If else, for loop, function, factorial etc.
Lecture :2 : String manipulation
Lecture :3 : Class and object using python
Lecture :4 : Dirty hands with Pandas
Lecture :5: Working on Numpy
Lecture :6 : How Image Processing works in Python
Lecture: 7: OpenCV Programs
Web References and further reading

click here for entire notes

Lecture_1_Practical_1
you working as software developer. one of your customer is planning to make 50% discount on the products that he is selling so he asked you to design a program that gives the price of the any product after 50% discount

discount_rate=50/100
original=int(input('what is the original price for the produt '))
sales_price=original*discount_rate bits

print('the price after 50% discount is $',int(sales_price),sep='')

define function for three different numbers:

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))

LECTURE_1_PRACTICAL_2_PASS+OR+FAIL
your teacher asked from you to write a program that allows her to enter student 4 exam result and then the program calculates the average and displays whether student passed the semester or no. in order to pass the semester, the average score must be 50 or more.

number_of_exams=4
#ask from the user each exam score
exam1=int(input('enter the first exam result: '))
exam2=int(input('enter the second exam result: '))
exam3=int(input('enter the third exam result: '))
exam4=int(input('enter the fourth exam result: '))

#get the total of all exams
total=exam1+exam2+exam3+exam4
average_score=total/number_of_exams

if average_score>=50:
    print('the student passed the semester')
else:
    print('the student failed the semester')

Lecture_1_practical_3_pass+percentage
write a program that gives the percentage of student who passed in a class and the percentage of students who failed in a class

#get number of students who passed
passed=int(input('enter number of students that passed the exam: '))
#get numer of students who failed
failed=int(input('enter number of students that failed in the exam: '))
#total number of students in the class
total=passed+failed
print('total of students: ',total)

#get percentages
pass_percentage=passed/total
fail_percentage=failed/total

print(format(pass_percentage,'.0%'),'of students passed in the class')
print(format(fail_percentage,'.0%'), 'of students failed in the class')

Lecture_1_practical_4__score+into+grade
design a program that converts student score into grades (a,b,c,d, and failed)

#ask for student score
score=int(input('enter your score: '))

if score>=90:
    print('your grade is a')
elif score>=80:
    print('your grade is b')
elif score>=70:
    print('your grade is c')
elif score>=60:
    print('your grade is d')
else:
    print('you failed')
    print('you need to study harder')

click here for entire notes
Lecture_1_practical_5_player score
Design a program with Python using list. The program will ask from the user to enter the players score and after it will show the highest score

score_list=[]
print('How many scores you want to add?')
num_score=int(input())

hi_score=0
for i in range(num_score):
    print('Enter the',i+1,'score')
    n=int(input())
    if n>hi_score:
        hi_score=n
    score_list.append(n)


print('The scores that you entered:')
print(score_list)
print()
print('The Highest score is',hi_score)

Lecture_1_practical_6_factorial
your math teacher know that you have good programming skills. she asked from you to design a program for her that will find factorial for any number. she will use your program in her classes so make it elegant. ( example: factorial of 3 is 3*2*1=6, factorial of 4 is 4*3*2*1 = 24, factorial of 5 is 5*4*3*2*1= 120)

#this is recursion function
def factorial_func(n):
    #this is the base case
    #program will stop calling it self
    #when it reaches base case
    if n==0:
        return 1
    #this is recursive case
    #program will keep calling it self
    #but each time it will be smaller
    #than before until it reaches
    #the base case
    else:
        return n*factorial_func(n-1)
def main():

    n=int(input('enter a number to get factorial '))
    #display the factorial of the number
    print('the factorial for', n,'is',factorial_func(n))


main()

Lecture_1_practical_7_sentinel
you working in a shipment company. your manager asked from you to design a program that allows them to enter items weight in order to be saved in the shipment file. your program should have a sentinel value, if the user finished adding all the items, then he will enter the sentinel value to stop the program

print('please enter the item weight')
print('or enter 0 to stop the program')
item_weight=int(input())

#as long as the condition is true
#than the loop will keep iterating
while item_weight!=0:
   print('please enter the item weight')
    print('or enter 0 to stop')
    item_weight=int(input())

print('all the items will be saved to the file')
print('thank you')

Lecture_1_practical_8__fibonacci
fibonacci

def fib(n):
    if n==0:
        return 1
    if n==1:
        return 1
    else:
        return (fib(n-1)+fib(n-2))

def main():
    print('the first 8 numbers in fibonacci is')
    for i in range(8):
        print(fib(i))

main()



Lecture_1_practical_9_gcd
your math teacher liked your first program. this time she asked from you to design a program that will find greatest common divisor of two given integers. she will give extra grades if you complete this project.

def gcd(x,y):
    if x%y==0:
        return(y)
    else:
        return (gcd(y,x%y))


num1=int(input('enter an integer '))
num2=int(input('enter another integer '))

print('gcd for them is ',gcd(num1,num2))

click here for entire notes
Lecture_1_practice_10__real

design a program that allows your teacher to enter the result of three exam and it shows the average score.

number_of_exams=3
exam1=int(input('enter the first exam result: '))
exam2=int(input('enter the second exam result: '))
exam3=int(input('enter the third exam result: '))

average_score=(exam1+exam2+exam3)/number_of_exams

print('the average score: ',format(average_score, '.1f'))

----------------------------------------------
Lecture_2_Practical_1_String Manipulation
In computer science, sequences of characters are referred to as strings. Strings can be any length and can include any character such as letters, numbers, symbols, and whitespace (spaces, tabs, new lines).

Escaping Characters
Backslashes (\) are used to escape characters in a Python string.

For instance, to print a string with quotation marks, the given code snippet can be used.

txt = "She said \"Never let go\"."
print(txt) # She said "Never let go".
The in Syntax
The in syntax is used to determine if a letter or a substring exists in a string. It returns True if a match is found, otherwise False is returned.

game = "Popular Nintendo Game: Mario Kart"

print("l" in game) # Prints: True
print("x" in game) # Prints: False

Lecture_2_Practical_2_Indexing and Slicing Strings

Python strings can be indexed using the same notation as lists, since strings are lists of characters. A single character can be accessed with bracket notation ([index]), or a substring can be accessed using slicing ([start:end]).

Indexing with negative numbers counts from the end of the string.

str = 'yellow'
str[1]     # => 'e'
str[-1]    # => 'w'
str[4:6]   # => 'ow'
str[:4]    # => 'yell'
str[-3:]   # => 'low'
Iterate String
To iterate through a string in Python, “for…in” notation is used.

str = "hello"
for c in str:
print(c)

# h
# e
# l
# l
# o
Built-in Function len()
In Python, the built-in len() function can be used to determine the length of an object. It can be used to compute the length of strings, lists, sets, and other countable objects.

length = len("Hello")
print(length)
# Output: 5

colors = ['red', 'yellow', 'green']
print(len(colors))
# Output: 3
String Concatenation
To combine the content of two strings into a single string, Python provides the + operator. This process of joining strings is called concatenation.

x = 'One fish, '
y = 'two fish.'

z = x + y

print(z)
# Output: One fish, two fish.
Immutable strings
Strings are immutable in Python. This means that once a string has been defined, it can’t be changed.

There are no mutating methods for strings. This is unlike data types like lists, which can be modified once they are created.

IndexError
When indexing into a string in Python, if you try to access an index that doesn’t exist, an IndexError is generated. For example, the following code would create an IndexError:

fruit = "Berry"
indx = fruit[6]
Python String .format()
The Python string method .format() replaces empty brace ({}) placeholders in the string with its arguments.

If keywords are specified within the placeholders, they are replaced with the corresponding named arguments to the method.

msg1 = 'Fred scored {} out of {} points.'
msg1.format(3, 10)
# => 'Fred scored 3 out of 10 points.'

msg2 = 'Fred {verb} a {adjective} {noun}.'
msg2.format(adjective='fluffy', verb='tickled', noun='hamster')
# => 'Fred tickled a fluffy hamster.'

String Method .lower()
The string method .lower() returns a string with all uppercase characters converted into lowercase.

greeting = "Welcome To Chili's"

print(greeting.lower())
# Prints: welcome to chili's

String Method .strip()
The string method .strip() can be used to remove characters from the beginning and end of a string.

A string argument can be passed to the method, specifying the set of characters to be stripped. With no arguments to the method, whitespace is removed.

text1 = '   apples and oranges   '
text1.strip()       # => 'apples and oranges'

text2 = '...+...lemons and limes...-...'

# Here we strip just the "." characters
text2.strip('.')    # => '+...lemons and limes...-'

# Here we strip both "." and "+" characters
text2.strip('.+')   # => 'lemons and limes...-'

# Here we strip ".", "+", and "-" characters
text2.strip('.+-') # => 'lemons and limes'

click here for entire notes
Lecture_2_Practical_3_String Method .title()

The string method .title() returns the string in title case. With title case, the first character of each word is capitalized while the rest of the characters are lowercase.

my_var = "dark knight"
print(my_var.title())

# Prints: Dark Knight
String Method .split()
The string method .split() splits a string into a list of items:

If no argument is passed, the default behavior is to split on whitespace.
If an argument is passed to the method, that value is used as the delimiter on which to split the string.
text = "Silicon Valley"

print(text.split())
# Prints: ['Silicon', 'Valley']

print(text.split('i'))
# Prints: ['S', 'l', 'con Valley']

Python string method .find()
The Python string method .find() returns the index of the first occurrence of the string passed as the argument. It returns -1 if no occurrence is found.

mountain_name = "Mount Kilimanjaro"
print(mountain_name.find("o")) # Prints 1 in the console.

String replace
The .replace() method is used to replace the occurence of the first argument with the second argument within the string.

The first argument is the old substring to be replaced, and the second argument is the new substring that will replace every occurence of the first one within the string.

fruit = "Strawberry"
print(fruit.replace('r', 'R'))

# StRawbeRRy
String Method .upper()
The string method .upper() returns the string with all lowercase characters converted to uppercase.

dinosaur = "T-Rex"

print(dinosaur.upper())
# Prints: T-REX

String Method .join()
The string method .join() concatenates a list of strings together to create a new string joined with the desired delimiter.

The .join() method is run on the delimiter and the array of strings to be concatenated together is passed in as an argument.

x = "-".join(["Codecademy", "is", "awesome"])

print(x)
# Prints: Codecademy-is-awesome

Lecture_2_Practical_4_String Method *Operator

The * operator can be used to repeat the string for a given number of times.
# Python String Operations
str1 = 'Hello'
str2 ='World!'

# using +
print('str1 + str2 = ', str1 + str2)

# using *
print('str1 * 3 =', str1 * 3)

Iterating Through a string

We can iterate through a string using a for loop. Here is an example to count the number of 'l's in a string.

# Iterating through a string
count = 0
for letter in 'Hello World':
    if(letter == 'l'):
        count += 1
print(count,'letters found')

Web Reference or further reading:

https://realpython.com/python-strings/
https://www.codecademy.com/learn/learn-python-3/modules/learn-python3-strings/cheatsheet

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

Lecture_3_practical_1_student class display
create a student class and initialize it with name and roll number. make methods to :
1. display - it should display all information of the student.
2. setage - it should assign age to student
3. setmarks - it should assign marks to the student.

class student():
def __init__(self,name,roll):
    self.name = name
    self.roll= roll

def display(self):
    print(self.name)
    print(self.roll)

def setage(self,age):
    self.age=age

def setmarks(self,marks):
    self.marks = marks

p=student('nikhil', '101')
p.display()

lecture_3_practice_2_point_square root
write the definition of a point class. objects from this class should have a

a method show to display the coordinates of the point
a method move to change these coordinates.
a method dist that computes the distance between 2 points.

import math

class point(object):
    """class to handle point in a 2 dimensions space"""

    def __init__(self, x, y):
        """
        :param x: the value on the x-axis
        :type x: float
        :param y: the value on the y-axis
        :type y: float
        """
        self.x = x
        self.y = y

    def show(self):
        """
        :return: the coordinate of this point
        :rtype: a tuple of 2 elements (float, float)
        """
        return self.x, self.y

    def move(self, x, y):
        """
        :param x: the value to move on the x-axis
        :type x: float
        :param y: the value to move on the y-axis
        :type y: float
        """
        self.x += x
        self.y += y

    def dist(self, pt):
        """
        :param pt: the point to compute the distance with
        :type pt: :class:`point` object
        :return: the distance between this point ant pt
        :rtype: int
        """
        dx = pt.x - self.x
        dy = pt.y - self.y
        return math.sqrt(dx ** 2 + dy ** 2)

>>> p1=point(2,3)
>>> p2=point(3,3)
>>> p1.show()
(2, 3)
>>> p2.show()
(3, 3)
>>> p1.dist(p2)
1.0
>>> p1.move(10, -10)
>>> p1.show()
(12, -7)
>>> p1.dist(p2)
13.45362404707371

lecture_3_practice_3_deposit and withdraw
suppose we want to model a bank account with support for deposit and withdraw operations.

class bankaccount:
    def __init__(self):
        self.balance = 0

    def withdraw(self, amount):
        self.balance -= amount
        return self.balance

    def deposit(self, amount):
        self.balance += amount
        return self.balance

a = bankaccount()
>>> b = bankaccount()
>>> a.deposit(100)
100
>>> a.deposit(100)
200
>>> a.deposit(100)
300
>>> b.withdraw(10)
-10
>>> a.withdraw(10)
290
Lecture_3_practice_4_rectangle_area
write a python class named rectangle constructed by a length and width and a method which will compute the area of a rectangle.
  class rectangle():
    def __init__(self, l, w):
        self.length = l
        self.width = w

    def rectangle_area(self):
        return self.length*self.width

newrectangle = rectangle(12, 10)
print(newrectangle.rectangle_area())

lecture_3_practice_5_time and minutes
create a time class and initialize it with hours and minutes.
1. make a method addtime which should take two time object and add them.
e.g.- (2 hour and 50 min)+(1 hr and 20 min) is (4 hr and 10 min)
2. make a method displaytime which should print the time.
3. make a method displayminute which should display the total minutes in the time.
e.g.- (1 hr 2 min) should display 62 minute.

class time():

def __init__(self, hours, mins):
    self.hours = hours
    self.mins = mins

def addtime(t1, t2):
    t3 = time(0,0)
    if t1.mins+t2.mins > 60:
      t3.hours = (t1.mins+t2.mins)/60
    t3.hours = t3.hours+t1.hours+t2.hours
    t3.mins = (t1.mins+t2.mins)-(((t1.mins+t2.mins)/60)*60)
    return t3

def displaytime(self):
    print("time is",self.hours,"hours and",self.mins,"minutes.")

def displayminute(self):
    print((self.hours*60)+self.mins)

a = time(2,50)
b = time(1,20)
c = time.addtime(a,b)
c.displaytime()
c.displayminute()

lecture_3_practice_6_rectangle class and inherited child
·         rectangle class and inherited child parallelepipede class

write a rectangle class in python language, allowing you to build a rectangle with length and width attributes.
create a perimeter() method to calculate the perimeter of the rectangle and a area() method to calculate the area of the rectangle.
create a method display() that display the length, width, perimeter and area of an object created using an instantiation on rectangle class.
create a parallelepipede child class inheriting from the rectangle class and with a height attribute and another volume() method to calculate the volume of the parallelepiped.

explain inheritance in python with an example.
answer : inheritance allows one class to gain all the members(say attributes and methods) of another class. inheritance provides code reusability, makes it easier to create and maintain an application. the class from which we are inheriting is called super-class and the class that is inherited is called a derived / child class.
they are different types of inheritance supported by python:
1.    single inheritance – where a derived class acquires the members of a single superclass.
2.    multi-level inheritance – a derived class d1 in inherited from base class base1, and d2 are inherited from base2.
3.    hierarchical inheritance – from one base class you can inherit any number of child classes
4.    multiple inheritance – a derived class is inherited from more than one base class

class rectangle:
    # define constructor with attributes: length and width
    def __init__(self, length , width):
        self.length = length
        self.width = width

    # create perimeter method
    def perimeter(self):
        return 2*(self.length + self.width)

    # create area method
    def area(self):
        return self.length*self.width

    # create display method
    def display(self):
        print("the length of rectangle is: ", self.length)
        print("the width of rectangle is: ", self.width)
        print("the perimeter of rectangle is: ", self.perimeter())
        print("the area of rectangle is: ", self.area())
class parallelepipede(rectangle):
    def __init__(self, length, width , height):
        rectangle.__init__(self, length, width)
        self.height = height

    # define volume method
    def volume(self):
        return self.length*self.width*self.height

myrectangle = rectangle(7 , 5)
myrectangle.display()
print("----------------------------------")
myparallelepipede = parallelepipede(7 , 5 , 2)
print("the volume of myparallelepipede is: " , myparallelepipede.volume())

lecture_3_practice_7_real_car+dealer+inheritance
a car dealer hired you to create a program that allows him to upload a description for the cars he want to upload to his website. the description should include the make, the model, and the miles of the car. the dealer wants after writing all the descriptions, he wants to have an option whether to add the price.

class car:
    def __init__(self, p_make, p_model, p_miles):
        self.__make=p_make
        self.__model=p_model
        self.__miles=p_miles

    def get_make(self):
        return self.__make

    def get_model(self):
        return self.__model

    def get_miles(self):
        return self.__miles


class car_with_price(car):
    def __init__(self, p_make, p_model, p_miles, p_price):
        car.__init__(self, p_make, p_model, p_miles)
        self.__price=p_price

    def get_price(self):
        return self.__price

def main():
    intro()
    print()
    make=input('enter car make: ')
    model=input('enter car model: ')
    miles=input('enter the miles in the car: ')

    my_car=car(make, model, miles)
    print('here is the data you entered: ')
    show_data(my_car)
    print()
    print('do you want to add the price also before uploading to the website?')
    add_price=input('enter y for yes and n for no\n')

    if add_price.lower()=='y':
        price=int(input('what is the price: '))
        print()
        my_car=car_with_price(make, model, miles, str(format(price, ',d')))
        print('the price $',my_car.get_price(),' has been assigned to the car', sep='')


def show_data(my_car):
    print('make: ', my_car.get_make())
    print('model: ', my_car.get_model())
    print('miles: ', my_car.get_miles())


def intro():
    print('this program will help you')
    print('to write a description for the car')
    print('you want to upload to your website')

main()



lecture_3_practice_8_real_exmaemployee+name+class
Desing using OOP a program that creates an object my_employee_information. Then the program asks from the user to enter employee name, ID number, and his work shift. The entered information will be assigned to the object’s data attributes using it’s methods.

#creat class named employee
class Employee:
    #we intialized all data attributes
    #because in order for the methods
    #operate they must know
    #the data attribute type
    def __init__(self):
        self.__name=''
        self.__id=''
        self.__shift=''

    def set_name(self, p_name):
        self.__name=p_name

    def set_id(self, p_id):
        self.__id=p_id

    def set_shift(self, p_shift):
        self.__shift=p_shift


    def get_name(self):
        return self.__name

    def get_id(self):
        return self.__id

    def get_shift(self):
        return self.__shift


def main():
    #we will create an object
    my_employee_information=Employee()

    name=input('enter employee name: ')

    #input the id number by using try except
    #to prevent any error
    id_num=ask_id()

    #ask for the shift
    print('enter morning for morning shift')
    print('or enter night for night shif')
    shift=input()
    print()
    #assign the inputs to object data_attributes
    #using object's methods
    assign(my_employee_information, name, id_num, shift)


    print('here is the the data that you entered: ')
    print('name: ', my_employee_information.get_name())
    print('ID number: ',my_employee_information.get_id())
    print('shift: ',my_employee_information.get_shift())

def assign(my_employee_information, name, id_num, shift):
    my_employee_information.set_name(name)
    my_employee_information.set_id(str(id_num))
    my_employee_information.set_shift(shift.lower())

def ask_id():
    try:
        id_num=int(input('enter id number: '))
        return id_num
    except:
        print('only enter integers')
        ask_id()
main()




LECTURE_4_PRACTICE_1_LEARN PANDAS LIBRARY
Ø  Create a CSV file and import it using Pandas Library

import pandas as pd

df = pd.read_csv('iris.csv')

print(df.to_string())

Ø  Create your own Dataframe/dataset and print the values using Pandas Library

Data sets in Pandas are usually multi-dimensional tables, called DataFrames.

Series is like a column, a DataFrame is the whole table.

import pandas

mydataset = {
  'cars': ["BMW", "Volvo", "Ford"],
  'passings': [3, 7, 2]
}

myvar = pandas.DataFrame(mydataset)

print(myvar)

Ø  Create a code with the index argument, you can name your own labels.

import pandas as pd

a = [1, 7, 2]

myvar = pd.Series(a, index = ["x", "y", "z"])

print(myvar)

Output:-
x    1
y    7
z    2
dtype: int64

Ø  Create a code with your own Python Dictionary into a DataFrame::

import pandas as pd

data = {
  "Duration":{
    "0":60,
    "1":60,
    "2":60,
    "3":45,
    "4":45,
    "5":60
  },
  "Pulse":{
    "0":110,
    "1":117,
    "2":103,
    "3":109,
    "4":117,
    "5":102
  },
  "Maxpulse":{
    "0":130,
    "1":145,
    "2":135,
    "3":175,
    "4":148,
    "5":127
  },
  "Calories":{
    "0":409,
    "1":479,
    "2":340,
    "3":282,
    "4":406,
    "5":300
  }
}

df = pd.DataFrame(data)

print(df)

Ø  Create a code full information about DataFrame::

print(df.info())

Ø  Empty Cells: Empty cells can potentially give you a wrong result when you analyze data. Remove Rows: One way to deal with empty cells is to remove rows that contain empty cells::

import pandas as pd

df = pd.read_csv('iris.csv')

df.dropna(inplace = True)

print(df.to_string())

#Return a new Data Frame with no empty cells:

Note: By default, the dropna() method returns a new DataFrame, and will not change the original.
If you want to change the original DataFrame, use the inplace = True argument:
Example
Remove all rows with NULL values:
import pandas as pd

df = pd.read_csv('iris.csv')

df.dropna(inplace = True)

print(df.to_string())

Another Example
Replace NULL values with the number 130:
import pandas as pd

df = pd.read_csv('iris.csv')

df.fillna(130, inplace = True)

REPLACE USING MEAN, MEDIAN, OR MODE
A common way to replace empty cells, is to calculate the mean, median or mode value of the column.
Pandas uses the mean() median() and mode() methods to calculate the respective values for a specified column:
Example
Calculate the MEAN, and replace any empty values with it:
import pandas as pd

df = pd.read_csv('iris.csv')

x = df["Calories"].mean()

df["Calories"].fillna(x, inplace = True)

Example
Calculate the MEDIAN, and replace any empty values with it:
import pandas as pd

df = pd.read_csv('iris.csv')

x = df["Calories"].median()

df["Calories"].fillna(x, inplace = True)
Median = the value in the middle, after you have sorted all values ascending.
Example
Calculate the MODE, and replace any empty values with it:
import pandas as pd

df = pd.read_csv('iris.csv')

x = df["Calories"].mode()[0]

df["Calories"].fillna(x, inplace = True)
Mode = the value that appears most frequently.

Ø  Empty Cells: Empty cells can potentially give you a wrong result when you analyze data. Remove Rows: One way to deal with empty cells is to remove rows that contain empty cells::

Example
Convert to date:
import pandas as pd

df = pd.read_csv('iris.csv')

df['Date'] = pd.to_datetime(df['Date'])

print(df.to_string())

Ø  To replace wrong data for larger data sets you can create some rules, e.g. set some boundaries for legal values, and replace any values that are outside of the boundaries::
Example
Loop through all values in the " Sepal Length" column.
If the value is higher than 2, set it to 2.22:
for x in df.index:
  if df.loc[x, 'Sepal Length'] > 2:
    df.loc[x, 'Sepal Length'] = 2.22

DISCOVERING DUPLICATES
Duplicate rows are rows that have been registered more than one time.
print(df.duplicated())

Returns True for every row that is a duplicate, othwerwise False:

REMOVING DUPLICATES
To remove duplicates, use the drop_duplicates() method.
Example
Remove all duplicates:
df.drop_duplicates(inplace = True)

PLOTTING
Pandas uses the plot() method to create diagrams.
Pythons uses Pyplot, a submodule of the Matplotlib library to visualize the diagram on the screen.
Read more about Matplotlib in our Matplotlib Tutorial.
Example
Import pyplot from Matplotlib and visualize our DataFrame:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('data.csv')

df.plot()

plt.show()

Ø  Apply function to every row in a Pandas DataFrameYou can use the numpy function as the parameters to the dataframe as well.

import pandas as pd
import numpy as np

def main():

    # create a dictionary with
    # five fields each
    data = {
            'A':[1, 2, 3],
            'B':[4, 5, 6],
            'C':[7, 8, 9] }

    # Convert the dictionary into DataFrame
    df = pd.DataFrame(data)
    print("Original DataFrame:\n", df)

    # applying function to each row in the dataframe
    # and storing result in a new coloumn
    df['add'] = df.apply(np.sum, axis = 1)

    print('\nAfter Applying Function: ')
    # printing the new dataframe
    print(df)

if __name__ == '__main__':
    main()

LECTURE_4_PRACTICE_2_LEARN PANDAS FOR SQL

Write the definition of a Point class. Objects from this class should have a

a method show to display the coordinates of the point
a method move to change these coordinates.
a method dist that computes the distance between 2 points.

https://pandas.pydata.org/pandas-docs/stable/getting_started/comparison/comparison_with_sql.html

·         Most of the examples will utilize the tips dataset found within pandas tests. We’ll read the data into a DataFrame called tips and assume we have a database table of the same name and structure.

import sqlite3

url = (
   ...:     "https://raw.github.com/pandas-dev"
   ...:     "/pandas/master/pandas/tests/io/data/csv/tips.csv"
   ...: )

tips = pd.read_csv(url)

tips.head()

·         With pandas, column selection is done by passing a list of column names to your DataFrame:

tips[["total_bill", "tip", "smoker", "time"]].head(5)

·         With pandas, you can use the DataFrame.assign() method of a DataFrame to append a new column:

tips.assign(tip_rate=tips["tip"] / tips["total_bill"]).head(5)

·         Notice that in the pandas code we used size() and not count(). This is because count() applies the function to each column, returning the number of not null records within each.

tips.groupby("sex").size()
·         Update:
tips.loc[tips["tip"] < 2, "tip"] *= 2

·         Delete:
tips = tips.loc[tips["tip"] <= 9]

LECTURE_5_PRACTICE_1_LEARN NUMPY
NumPy provides an N-dimensional array type, the ndarray, which describes a collection of “items” of the same type. The items can be indexed using for example N integers.
All ndarrays are homogeneous: every item takes up the same size block of memory, and all blocks are interpreted in exactly the same way. How each item in the array is to be interpreted is specified by a separate data-type object, one of which is associated with every array. In addition to basic types (integers, floats, etc.), the data type objects can also represent data structures.
An item extracted from an array, e.g., by indexing, is represented by a Python object whose type is one of the array scalar types built in NumPy. The array scalars allow easy manipulation of also more complicated arrangements of data.

The N-dimensional array (ndarray)
An ndarray is a (usually fixed-size) multidimensional container of items of the same type and size. The number of dimensions and items in an array is defined by its shape, which is a tuple of N non-negative integers that specify the sizes of each dimension. The type of items in the array is specified by a separate data-type object (dtype), one of which is associated with each ndarray.
As with other container objects in Python, the contents of an ndarray can be accessed and modified by indexing or slicing the array (using, for example, N integers), and via the methods and attributes of the ndarray.

import numpy as np
a = np.array([1,2,3])
print(a)
-------------------

# more than one dimensions
import numpy as np
a = np.array([[1, 2], [3, 4]])
print(a)
---------------------------------------
x = np.arange(27).reshape((3,3,3))
------------------------------
x.dtype()

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

import numpy as np

# Creating array object
arr = np.array( [[ 1, 2, 3],
                 [ 4, 2, 5]] )

# Printing type of arr object
print("Array is of type: ", type(arr))

# Printing array dimensions (axes)
print("No. of dimensions: ", arr.ndim)

# Printing shape of array
print("Shape of array: ", arr.shape)

# Printing size (total number of elements) of array
print("Size of array: ", arr.size)

# Printing type of elements in array
print("Array stores elements of type: ", arr.dtype)

import numpy as np

# Creating array from list with type float
a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')
print ("Array created using passed list:\n", a)

# Creating array from tuple
b = np.array((1 , 3, 2))
print ("\nArray created using passed tuple:\n", b)

# Creating a 3X4 array with all zeros
c = np.zeros((3, 4))
print ("\nAn array initialized with all zeros:\n", c)

# Create a constant value array of complex type
d = np.full((3, 3), 6, dtype = 'complex')
print ("\nAn array initialized with all 6s."
            "Array type is complex:\n", d)

# Create an array with random values
e = np.random.random((2, 2))
print ("\nA random array:\n", e)

# Create a sequence of integers
# from 0 to 30 with steps of 5
f = np.arange(0, 30, 5)
print ("\nA sequential array with steps of 5:\n", f)

# Create a sequence of 10 values in range 0 to 5
g = np.linspace(0, 5, 10)
print ("\nA sequential array with 10 values between"
                                        "0 and 5:\n", g)

# Reshaping 3X4 array to 2X2X3 array
arr = np.array([[1, 2, 3, 4],
                [5, 2, 4, 2],
                [1, 2, 0, 1]])

newarr = arr.reshape(2, 2, 3)

print ("\nOriginal array:\n", arr)
print ("Reshaped array:\n", newarr)

# Flatten array
arr = np.array([[1, 2, 3], [4, 5, 6]])
flarr = arr.flatten()

print ("\nOriginal array:\n", arr)
print ("Fattened array:\n", flarr)

· Slicing: Just like lists in python, NumPy arrays can be sliced. As arrays can be multidimensional, you need to specify a slice for each dimension of the array.
· Integer array indexing: In this method, lists are passed for indexing for each dimension. One to one mapping of corresponding elements is done to construct a new arbitrary array.
· Boolean array indexing: This method is used when we want to pick elements from array which satisfy some condition.

import numpy as np

# An exemplar array
arr = np.array([[-1, 2, 0, 4],
                [4, -0.5, 6, 0],
                [2.6, 0, 7, 8],
                [3, -7, 4, 2.0]])

# Slicing array
temp = arr[:2, ::2]
print ("Array with first 2 rows and alternate"
                    "columns(0 and 2):\n", temp)

# Integer array indexing example
temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]
print ("\nElements at indices (0, 3), (1, 2), (2, 1),"
                                    "(3, 0):\n", temp)

# boolean array indexing example
cond = arr > 0 # cond is a boolean array
temp = arr[cond]
print ("\nElements greater than 0:\n", temp)

Basic operations: Plethora of built-in arithmetic functions are provided in NumPy.
·         Operations on single array: We can use overloaded arithmetic operators to do element-wise operation on array to create a new array. In case of +=, -=, *= operators, the exsisting array is modified.

# Python program to demonstrate
# basic operations on single array
import numpy as np

a = np.array([1, 2, 5, 3])

# add 1 to every element
print ("Adding 1 to every element:", a+1)

# subtract 3 from each element
print ("Subtracting 3 from each element:", a-3)

# multiply each element by 10
print ("Multiplying each element by 10:", a*10)

# square each element
print ("Squaring each element:", a**2)

# modify existing array
a *= 2
print ("Doubled each element of original array:", a)

# transpose of array
a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])

print ("\nOriginal array:\n", a)
print ("Transpose of array:\n", a.T)

·         Binary operators: These operations apply on array elementwise and a new array is created. You can use all basic arithmetic operators like +, -, /, , etc. In case of +=, -=, = operators, the exsisting array is modified.

# Python program to demonstrate
# binary operators in Numpy
import numpy as np

a = np.array([[1, 2],
  [3, 4]])
b = np.array([[4, 3],
                      [2, 1]])

# add arrays
print ("Array sum:\n", a + b)

# multiply arrays (elementwise multiplication)
print ("Array multiplication:\n", a*b)

# matrix multiplication
print ("Matrix multiplication:\n", a.dot(b))

np.random.normal(0, 1, (3,3))

LECTURE_6_PRACTICE_1_LEARN IMAGE PROCESSING USING PYTHON
Note: If images are not visible below click here
HOW DO MACHINES STORE IMAGES?
Let’s start with the basics. It’s important to understand how we can read and store images on our machines before we look at anything else. Consider this the ‘pd.read_‘ function, but for images.
I’ll kick things off with a simple example. Look at the image below:

We have an image of the number 8. Look really closely at the image – you’ll notice that it is made up of small square boxes. These are called pixels.
There is a caveat, however. We see the images as they are – in their visual form. We can easily differentiate the edges and colors to identify what is in the picture. Machines, on the other hand, struggle to do this. They store images in the form of numbers. Have a look at the image below:

Machines store images in the form of a matrix of numbers. The size of this matrix depends on the number of pixels we have in any given image.
Let’s say the dimensions of an image are 180 x 200 or n x m. These dimensions are basically the number of pixels in the image (height x width).
These numbers, or the pixel values, denote the intensity or brightness of the pixel. Smaller numbers (closer to zero) represent black, and larger numbers (closer to 255) denote white. You’ll understand whatever we have learned so far by analyzing the below image.

1.      SimpleITK
ITK (Insight Segmentation and Registration Toolkit) is an "open source, cross-platform system that provides developers with an extensive suite of software tools for image analysis. SimpleITK is a simplified layer built on top of ITK, intended to facilitate its use in rapid prototyping, education, [and] interpreted languages." It's also an image analysis toolkit with a large number of components supporting general filtering operations, image segmentation, and registration. SimpleITK is written in C++, but it's available for a large number of programming languages including Python.

2.      SciPy
SciPy is another of Python's core scientific modules (like NumPy) and can be used for basic image manipulation and processing tasks. In particular, the submodule scipy.ndimage (in SciPy v1.1.0) provides functions operating on n-dimensional NumPy arrays. The package currently includes functions for linear and non-linear filtering, binary morphology, B-spline interpolation, and object measurements.

3.      scikit-image
scikit-image is an open source Python package that works with NumPy arrays. It implements algorithms and utilities for use in research, education, and industry applications. It is a fairly simple and straightforward library, even for those who are new to Python's ecosystem. The code is high-quality, peer-reviewed, and written by an active community of volunteers.

4.      OpenCV-Python
OpenCV (Open Source Computer Vision Library) is one of the most widely used libraries for computer vision applications. OpenCV-Python is the Python API for OpenCV. OpenCV-Python is not only fast, since the background consists of code written in C/C++, but it is also easy to code and deploy (due to the Python wrapper in the foreground). This makes it a great choice to perform computationally intensive computer vision programs.

Further Reading orweb reference:
https://www.analyticsvidhya.com/blog/2019/09/9-powerful-tricks-for-working-image-data-skimage-python/
Ø Using skimage library :
scikit-image is a Python package dedicated to image processing, and using natively NumPy arrays as image objects. This chapter describes how to use scikit-image on various image processing tasks, and insists on the link with other scientific Python modules such as NumPy and SciPy.

from skimage import data, io, filters

image = data.coins()
# ... or any other NumPy array!
edges = filters.sobel(image)
io.imshow(edges)
io.show()

import skimage
from skimage import data

>Read image from Computer:
import numpy as np
import cv2
img = cv2.imread('r.jpg')
imshow(img)

Show Image using SKIMAGE:
from skimage.io import imread, imshow
from skimage import data

image = data.astronaut()
imshow(image)
>>Convert Image into GreyScale:
The imread function has a parameter “as_gray” which is used to specify if the image must be converted into a grayscale image or not. We will start with reading an image in grayscale format, by setting the parameter to true:

from skimage.io import imread, imshow
import matplotlib.pyplot as plt
%matplotlib inline

image_gray = imread('r.jpg', as_gray=True)
imshow(image_gray)

OR
from skimage.color import rgb2gray
img = imread('r.jpg')
img_new = rgb2gray(img)
plt.subplot(121), imshow(img)
plt.title('RGB Format')
plt.subplot(122), imshow(img_new)
plt.title('Grayscale Format')
plt.show()

camera = data.camera()
camera.dtype

camera.shape

from skimage import filters
filtered_camera = filters.gaussian(camera, 1)
type(filtered_camera)
>>Resize the image
from skimage.transform import resize
img = imread('r.jpg')
#resize image
img_resized = resize(img, (300, 300))

#plot images
plt.subplot(121), imshow(img)
plt.title('Original Image')
plt.subplot(122), imshow(img_resized)
plt.title('Resized Image')
plt.show()

NOTE: IF IMAGES ARE NOT VISIBLE BELOW CLICK HERE

Rotate any Image:
To fix this orientation problem, we will need to rotate the image by a certain angle. We can use the rotate function of skimage and specify the angle by which we need the image to be rotated:
from skimage.transform import rotate
image = imread('r.jpg')

image_rotated = rotate(image, angle=45)
imshow(image_rotated)

Rotate any Image without losing the image property and cropping :

The orientation problem is all fixed. But if you look closely, the picture is cropped around the corners. This is because, during the rotation, the size of the image remains the same causing the area around the corner to get cropped.
We are not losing any important information in this scenario but that might not always be the case. This obstacle is taken care of by the resize parameter in the rotate function (by default the parameter value is False):

from skimage.transform import rotate
image = imread('r.jpg')

image_rotated = rotate(image, angle=45, resize=True)
imshow(image_rotated)

FLIP IMAGES HORIZONTALLY AND VERTICALLY

import cv2

NOTE: IF IMAGES ARE NOT VISIBLE BELOW CLICK HERE

Machine Learning Tutorial Python - 2: Linear Regression Single Variable:

https://www.youtube.com/watch?v=8jazNUpO3lQ

Program: 0: Introduction

Program: 1: Loading an image using OpenCV

Program: 2 Face Detection Using OpenCV

Program 3: General object recognition: Watch Detection

Program 4: Reading an image in OpenCV using Python

Program: 5 Python | Detect corner of an image using OpenCV

Program: 6 Match Shapes using OpenCV Python

Program: 7: Backprojection in OpenCV

List of Top 10 Best Free Sources to Learn Python Programming

10. A Byte of Python:
source: https://python.swaroopch.com/basics.html

Awesome website to learn basic tutorial step wise, Python codes are clearly written to run on compiler. Description of the relevant code is also given there.

9. The Python Guru:
source: https://thepythonguru

A to Z summary of all lessons are given here just click on the content list and find the code. Advanced and Beginning codes are clearly mentioned over here.

8. The Pyschools:
source: http://doc.pyschools.com/html/index.html

A school to learn basic fundamental of Python is described here. Although advance codes for the learners are not given here yet it is sufficient to learn Python.

7. Python in wikibooks:
source: https://en.wikibooks.org/wiki/Non-Programmer’s_Tutorial_for_Python_3

Despite of many rumors about authenticity of Wikibooks, this web page has been set an example to the learners, although readers required to use their own outputs with appropriate code.

6. Python: The New Boston:
source: https://www.youtube.com/user/thenewboston#g/c/EA1FEF17E1E5C0DA

In order to detail coding of Python 3.4 this youtube channel consists total of 56 videos for step by step learning classes. You will have to intensively search the code to get the output.

5. LearnPython.org:
source: http://www.learnpython.org/

Along with run code and .py file one can easily verify the code without installing the software on PC, later can verify on his PC. Just for learning purpose from anywhere this website will be beneficial for beginners.

4. The Python Tips:
source: https://pythontips.com/

Excellent blog with Project support for Engineering students as well as various advance coding can be find there.

3. Code Academy:
source: https://www.codecademy.com/learn/python

One of the Most valuable and famous resource for the Python programming this website has establish such an example for students and learners.

2. Google’s Python Class:
source: https://developers.google.com/edu/python/?hl=en

Google always been successful provider for various users and learners all over span on www, therefore trustworthy and experienced platform to learn this language.

The Python Tutorial

source: https://docs.python.org/3/tutorial/

Last but not least for all kind of learners, must visit site for implementations of various online projects.

Thanks and Best of Luck !!!

Pages

Wednesday 15 May 2019

Python for Beginners

you working as software developer. one of your customer is planning to make 50% discount on the products that he is selling so he asked you to design a program that gives the price of the any product after 50% discount

discount_rate=50/100

original=int(input('what is the original price for the produt '))

sales_price=original*discount_rate bits

print('the price after 50% discount is $',int(sales_price),sep='')

define function for three different numbers:

def sign(x):

if x > 0:

return 'positive'

elif x < 0:

return 'negative'

else:

return 'zero'

for x in [-1, 0, 1]:

print(sign(x))

LECTURE_1_PRACTICAL_2_PASS+OR+FAIL

your teacher asked from you to write a program that allows her to enter student 4 exam result and then the program calculates the average and displays whether student passed the semester or no. in order to pass the semester, the average score must be 50 or more.

number_of_exams=4

#ask from the user each exam score

exam1=int(input('enter the first exam result: '))

exam2=int(input('enter the second exam result: '))

exam3=int(input('enter the third exam result: '))

exam4=int(input('enter the fourth exam result: '))

#get the total of all exams

total=exam1+exam2+exam3+exam4

average_score=total/number_of_exams

if average_score>=50:

print('the student passed the semester')

else:

print('the student failed the semester')

Lecture_1_practical_3_pass+percentage

write a program that gives the percentage of student who passed in a class and the percentage of students who failed in a class

#get number of students who passed

passed=int(input('enter number of students that passed the exam: '))

#get numer of students who failed

failed=int(input('enter number of students that failed in the exam: '))

#total number of students in the class

total=passed+failed

print('total of students: ',total)

#get percentages

pass_percentage=passed/total

fail_percentage=failed/total

print(format(pass_percentage,'.0%'),'of students passed in the class')

print(format(fail_percentage,'.0%'), 'of students failed in the class')

Lecture_1_practical_4__score+into+grade

design a program that converts student score into grades (a,b,c,d, and failed)

#ask for student score

score=int(input('enter your score: '))

if score>=90:

print('your grade is a')

elif score>=80:

print('your grade is b')

elif score>=70:

print('your grade is c')

elif score>=60:

print('your grade is d')

else:

print('you failed')

print('you need to study harder')

click here for entire notes

Lecture_1_practical_5_player score

Design a program with Python using list. The program will ask from the user to enter the players score and after it will show the highest score

score_list=[]

print('How many scores you want to add?')

num_score=int(input())

hi_score=0

for i in range(num_score):

print('Enter the',i+1,'score')

n=int(input())

if n>hi_score:

hi_score=n

score_list.append(n)

print('The scores that you entered:')

print(score_list)

print()

print('The Highest score is',hi_score)

Lecture_1_practical_6_factorial