Python PhD

slicing can be used to reverse a sequence in Python. Syntax for slice is:

[start:stop:step]

“step” defines increment of the index while moving from start to stop. -1 as step will make the slice object start from the end.

list_demo = [1,2,3,4,5,6,7,8,9,10]
list_demo[::-1]

Output:

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Keeping start and stop empty makes it take all the values of the list starting from the end.

Solve these questions to get acquainted with basic syntax of Python programming language.

Write a program which will find all such numbers which are divisible by 7 but are not a multiple of 5,
between 2000 and 3200 (both included).
The numbers obtained should be printed in a comma-separated sequence on a single line.

num_list = []
for x in range(2000, 3201):
    if x%7 == 0 and x%5 != 0:
        num_list.append(x)

print(num_list, sep=",")

Write a program which can compute the factorial of a given numbers.
The results should be printed in a comma-separated sequence on a single line.

def fact_recursion(x):
    x = int(x)
    if x == 1:
        return 1
    else:
        return x*fact_recursion(x-1)


def fact_loop(x):
    x = int(x)
    product = 1
    for num in range(1, x+1):
        product = product*num
    return product

print("Enter number to get its factorial:\n")
num = input()
print(fact_loop(num))
print(fact_recursion(num))

With a given integral number n, write a program to generate a
dictionary that contains (i, i*i) such that is an integral
number between 1 and n (both included). and then the program should print the dictionary.

def gen_dict(n):
    num_dict = {}
    n = int(n)
    for i in range(1, n+1):
        num_dict[i] = i*i
    return num_dict


print("Please enter n")
number = input()
print(gen_dict(number))

Write a program which accepts a sequence of comma-separated numbers
from the console and generate a list and a tuple which contains every number.

input_values = input()
num_list = input_values.split(sep=",")


num_tuple = tuple(num_list)


print(num_tuple, type(num_tuple))
print(num_list, type(num_list))

Define a class which has at least two methods:
getString: to get a string from console input
printString: to print the string in upper case.
Also please include simple test function to test the class methods.

class NewClass:

    def __init__(self):
        self.string_from_console = ""
        print("Object Initialized")

    def get_string(self):
        self.string_from_console = str(input())
        return self.string_from_console

    def print_string(self):
        print(self.string_from_console.upper())


obj = NewClass()
obj.get_string()
obj.print_string()

Write a program that calculates and prints the value according to the given formula:
Q = Square root of [(2 * C * D)/H]
Following are the fixed values of C and H:
C is 50. H is 30.
D is the variable whose values should be input to your program in a comma-separated sequence.

import math
C = 50
H = 30
Q = []
D_list = input().split(',')

for D in D_list:
    D = int(D)
    Q.append(int(math.sqrt((2 * C * D)/H)))

print(Q, sep=",")

Write a program which takes 2 digits, X,Y as input and generates a 2-dimensional array.
The element value in the i-th row and j-th column of the array should be i*j.
Note: i=0,1.., X-1; j=0,1,¡­Y-1.

r, c = input().split(",")
row = range(0, int(r))
col = range(0, int(c))
matrix = [[0 for co in col] for ro in row]
for i in row:
    for j in col:
        matrix[i][j] = i*j

print(matrix)


import numpy as np


matrix_np = np.zeros([3, 5], dtype=int)
for i in row:
    for j in col:
        matrix_np[i][j] = int(i*j)

print(matrix_np)

Write a program that accepts a comma-separated sequence of words as input
and prints the words in a comma-separated sequence after sorting them alphabetically.

word_list = input().split(",")
word_list.sort()
print(",".join(word_list))


def take_second_character(string):
    return string[1]


word_list_1 = input().split(",")
word_list_1.sort(key=take_second_character)
print(",".join(word_list_1))

Map function is used to combine two or more iterables in a single iterable ( Map functions returns a Tuple). 

To illustrate its use, let take an example:

# define two lists
name = ['Lee','Shin','Chan']
roll = ['1','2','3']
name_n_roll = zip(name,roll)
print (name_n_roll)

Output:

[('Lee', '1'), ('Shin', '2'), ('Chan', '3')]

To unzip the zipped iterable we just have to use ” * ” while using zip. For Example:

name, roll = zip(*name_n_roll)

print(n,r)

Output:

((‘Lee’, ‘Shin’, ‘Chan’), (‘1’, ‘2’, ‘3’))

Supervised Learning: As we know we have to train our machine before expecting anything sensible from them in ML. Supervised machine learning algorithm is like a teacher teaching a student a certain subject. Teacher first tells the student what is right and what is wrong. They even check their test papers. Students have the answers to their question. After being trained to a certain degree, teacher expects them to be right. 

This is how supervised machine learning algorithms work. Algorithm learns from data set and correct and wrong results.

Unsupervised Learning : Under unsupervised learning there is no teacher and no student. It’s like self study. Algorithm has to learn from the data set , how and on what basis it read the data set and make sense of it. For example, we can put a bucket full of fruits in machine and expect it to make sense of all the different fruits in it on the basis of shape, size, color and structure.

Reinforcement Learning : Under reinforcement learning algorithms, machines learn from their progress. Under this type algorithms determine what the ideal behavior within a context can be. In Reinforcement Learning an agent decides the best action based on the current state of the results. Below graphics explains a lot about the reinforcement learning algorithms working.

Note : This post is under progress and will be updated with time.

filter function expects two arguments, function_object and an iterable. function_object returns a boolean value. function_object is called for each element of the iterable and filter returns only those element for which the function_object returns true.

Like map function, filter function also returns a list of that element. Unlike mapfunction filter function can only have one iterable as input.

Basic syntax:

filter(function_object, iterable)

For Example:

Even number using filter function

a = [1, 2, 3, 4, 5, 6]
filter(lambda x : x % 2 == 0, a) 

Output:

[2, 4, 6]

Map functions expects a function object and any number of iterables like list, dictionary, etc. It executes the function_object for each element in the sequence and returns a list of the elements modified by the function object

As the name suggests it maps the each object in iterable to function object, returning iterable.

Basic Syntax:

map(function_object, iterable1, iterable2,...)

For Example:

def multiply2(x):
  return x * 2
    
map(multiply2, [1, 2, 3, 4]) 

In the above example, map executes multiply2 function for each element in the list i.e. 1, 2, 3, 4 and returns [2, 4, 6, 8]

Output:

[2, 4, 6, 8]

Lambda operator or lambda function is used for creating small, one-time and anonymous function objects in Python.

They are called anonymous functions as there is no formal definition given in the code as we give for formal functions. That is there is no def keyword used while defining Lambda functions.

Basic Syntax:

lambda arguments : expression

lambda operator can have any number of arguments, but it can have only one expression. It cannot contain any statements and it returns a function object which can be assigned to any variable.

For Example:

Normal function definition of a function that adds two number:

def add(x, y): 
    return x + y
  
print(add(2, 3))   

Output:

5

Function name is add, it expects two arguments x and y and returns their sum.

Using Lambda Function to do tha same:

add = lambda x,y : x+y  #returns function object to add
print(add(2,3))

Output:

5

Summary: 

Lambda function basic syntax

lambda arguments : expression