Download our latest MNC Answers Application at Play Store. Download Now

Python Qualis Hands-on Solution | TCS Fresco Play

Python Qualis Hands-on Solution  |  TCS Fresco Play

Disclaimer: The primary purpose of providing this solution is to assist and support anyone who are unable to complete these courses due to a technical issue or a lack of expertise. This website's information or data are solely for the purpose of knowledge and education.

Make an effort to understand these solutions and apply them to your Hands-On difficulties. (It is not advisable that copy and paste these solutions).

Course Path: Data Science/DATA SCIENCE BASICS/Python Qualis

Suggestion: Just Copy whole code from below and replace with existing code on hackerrank.

Please follow the below steps before Run Tests to run your code successfully otherwise you will face some server issues even Hands-On code is correct.

Step 1: Run->Install
Step 2: Run->Run
Step 3: Run Tests


Doctest 1


import math

import os

import random

import re

import sys

import inspect

# Complete the following isPalindrome function:

def isPalindrome(x):

    # Write the doctests:







    Traceback (most recent call last):

    ValueError: x must be a positive integer


    Traceback (most recent call last):

    TypeError: x must be an integer


    # Write the functionality:

    y = list(str(x))[::-1]

    y = "".join([i for  i in y])


        if type(x) == type(1):


                if x>0:

                    if str(x) == y:

                        return True


                         return False


                    raise ValueError('x must be a positive integer')

            except ValueError as  e:



            raise TypeError('x must be an integer')

    except TypeError as r:



if __name__ == '__main__':

Doctest 2

import inspect

import doctest

import re

import math

# Define the class 'Circle' and its methods with proper doctests:

class Circle:


    def __init__( self, radius):

        # Define doctests for __init__ method:


        >>> c1 = Circle(2.5)

        >>> c1.radius



        self.radius = radius


    def area(self):

        # Define doctests for area method:


        >>> c1 =Circle(2.5)

        >>> c1.area()



        return round(math.pi*( self.radius**2),2)

        # Define area functionality:


    def circumference(self):

        # Define doctests for circumference method:


        >>> c1=Circle(2.5)

        >>> c1.circumference()



        return  round(math.pi* (self.radius*2),2)

        # Define circumference functionality:


if __name__ == '__main__':

2.Welcome to Python Qualis - Nose Testing Framework

from import Circle

from import assert_raises, eq_, eq_

class TestingCircleCreation:


    def test_creating_circle_with_numeric_radius(self):

      c = Circle(2.5)

      eq_(2.5, c.radius)

    # Hint: Use assert_raises and with.

    def test_creating_circle_with_negative_radius(self):

      with assert_raises(ValueErroras e:

        c = Circle(-2.5)

      eq_(str(e.exception), 'radius must be between 0 and 1000 inclusive')

    def test_creating_circle_with_greaterthan_radius(self):

      with assert_raises(ValueErroras e:

        c = Circle(1000.1)

      eq_(str(e.exception), 'radius must be between 0 and 1000 inclusive')

    def test_creating_circle_with_nonnumeric_radius(self):

        with assert_raises(TypeErroras e:

          c = Circle('hello')

        eq_(str(e.exception), 'radius must be a number')

#Define a nose test class 'TestCircleArea'

class TestCircleArea:

    def test_circlearea_with_random_numeric_radius(self):

        c = Circle(2.5)

        eq_(c.area(), 19.63)

    def test_circlearea_with_min_radius(self):

        c = Circle(0)

        eq_(c.area(), 0)

    def test_circlearea_with_max_radius(self):

        c3 =Circle(1000)

        eq_(c3.area(), 3141592.65)

# Define a nose test class 'TestCircleCircumference'

class TestCircleCircumference:

    def test_circlecircum_with_random_numeric_radius(self):

        c = Circle(2.5)

        eq_(c.circumference(), 15.71)

    def test_circlecircum_with_min_radius(self):

        c = Circle(0)

        eq_(0, c.circumference())

    def test_circlecircum_with_max_radius(self):

        c = Circle(1000)

        eq_(c.circumference(), 6283.19)

3.Welcome to Python Qualis - Pytest Testing Framework

import sys

import os


from proj.inventory import MobileInventory, InsufficientException

import pytest

# Import pytest using the expression import pytest.

# Use assert statement for assert, and to check. Ex: assert 1 == 1

# Define a pytest test class **'TestingInventoryCreation'**

class TestingInventoryCreation:

    def test_creating_empty_inventory(self):

        x = MobileInventory()

        assert  x.balance_inventory == {}

    def test_creating_specified_inventory(self):

        x = MobileInventory({'iPhone Model X':100'Xiaomi Model Y'1000'Nokia Model Z':25})

        assert {'iPhone Model X':100'Xiaomi Model Y'1000'Nokia Model Z':25} == x.balance_inventory

    def test_creating_inventory_with_list(self):

        with pytest.raises(TypeError) :

          assert "Input inventory must be a dictionary" == MobileInventory(['iPhone Model X''Xiaomi Model Y''Nokia Model Z'])

    def test_creating_inventory_with_numeric_keys(self):

        with pytest.raises(ValueError):

          assert "Mobile model name must be a string" == MobileInventory({1'iPhone Model X'2'Xiaomi Model Y'3'Nokia Model Z'})

    def test_creating_inventory_with_nonnumeric_values(self):

        with pytest.raises(ValueError) :

          assert  "No. of mobiles must be a positive integer" == MobileInventory({ 'iPhone Model X':'100''Xiaomi Model Y''1000''Nokia Model Z':'25'})

    def test_creating_inventory_with_negative_value(self):

        with pytest.raises(ValueError):

          assert "No. of mobiles must be a positive integer" == MobileInventory({'iPhone Model X':-45'Xiaomi Model Y'200'Nokia Model Z':25})

class TestInventoryAddStock:

    inventory = None


    def setup_class(cls):

        cls.inventory = MobileInventory({'iPhone Model X':100'Xiaomi Model Y'1000'Nokia Model Z':25})

    def test_add_new_stock_as_dict(self):

        self.inventory.add_stock({'iPhone Model X'50'Xiaomi Model Y'2000'Nokia Model A'10})

        assert {'iPhone Model X':150'Xiaomi Model Y'3000'Nokia Model Z':25,'Nokia Model A':10} == self.inventory.balance_inventory

    def test_add_new_stock_as_list(self):

        with pytest.raises(TypeError):

          assert "Input stock must be a dictionary" == MobileInventory.add_stock(self, ['iPhone Model X''Xiaomi Model Y''Nokia Model Z'])

    def test_add_new_stock_with_numeric_keys(self):

        with pytest.raises(ValueError):

          assert "Mobile model name must be a string" == MobileInventory.add_stock(self, {1'iPhone Model A'2'Xiaomi Model B',3'Nokia Model C'})

    def test_add_new_stock_with_nonnumeric_values(self):

        with pytest.raises(ValueError):

          assert "No. of mobiles must be a positive integer" == MobileInventory.add_stock(self, {'iPhone Model A''50''Xiaomi Model B''2000''Nokia Model C''25'})

    def test_add_new_stock_with_float_values(self):

        with pytest.raises(ValueError):

          assert "No. of mobiles must be a positive integer" == MobileInventory.add_stock(self, {'iPhone Model A'50.5'Xiaomi Model B'2000.3'Nokia Model C'25})

class TestInventorySellStock:


    inventory = None


    def setup_class(cls):

        cls.inventory = MobileInventory({ 'iPhone Model A'50'Xiaomi Model B'2000'Nokia Model C'10'Sony Model D'1})

    def test_sell_stock_as_dict(self):

        self.inventory.sell_stock({'iPhone Model A'2'Xiaomi Model B'20'Sony Model D'1})

        assert {'iPhone Model A':48'Xiaomi Model B'1980'Nokia Model C':10'Sony Model D':0} == self.inventory.balance_inventory

    def test_sell_stock_as_list(self):

        with pytest.raises(TypeError):

          assert "Requested stock must be a dictionary" == MobileInventory.sell_stock(self, ['iPhone Model A''Xiaomi Model B''Nokia Model C'])

    def test_sell_stock_with_numeric_keys(self):

        with pytest.raises(ValueError):

          assert "Mobile model name must be a string" == MobileInventory.sell_stock(self, {1'iPhone Model A'2'Xiaomi Model B'3'Nokia Model C'})


    def test_sell_stock_with_nonnumeric_values(self):

        with pytest.raises(ValueError):

          assert "No. of mobiles must be a positive integer" == MobileInventory.sell_stock(self, {'iPhone Model A''2''Xiaomi Model B':'3''Nokia Model C''4'})

    def test_sell_stock_with_float_values(self):

        with pytest.raises(ValueError):

          assert "No. of mobiles must be a positive integer" == MobileInventory.sell_stock(self, {'iPhone Model A'2.5'Xiaomi Model B'3.1'Nokia Model C'4})

    def test_sell_stock_of_nonexisting_model(self):

        with pytest.raises(InsufficientException):

          assert "No Stock. New Model Request" == MobileInventory.sell_stock(self.inventory, {'iPhone Model B'2'Xiaomi Model B'5})

    def test_sell_stock_of_insufficient_stock(self):

        with pytest.raises(InsufficientException):

          assert "Insufficient Stock" == MobileInventory.sell_stock(self.inventory, {'iPhone Model A'2'Xiaomi Model B'5'Nokia Model C'15})


Unittest 1

import inspect

import re

import unittest

import math

# Define class 'Circle' and its methods with proper doctests:

class Circle:


    def __init__(self, radius):

        # Define initialization method:

        if not isinstance(radius, (intfloat)):

                raise TypeError("radius must be a number")

        if not 1000 >=radius >=0:

            raise ValueError("radius must be between 0 and 1000 inclusive"