Question

IN PYTHON

Assignment Overview

This assignment will give you experience on the use of classes.

Understand the Application

The assignment is to first create a class calledTripleString.TripleStringwill consist of threeinstance attribute strings as its basic data. It will also contain a few instance methods to support that data.

Once defined, we will use it to instantiate TripleString objects that can be used in our main program.

TripleString will contain three member strings as its main data: string1, string2, and string3. We will also add a few class/ static members such as const int MAX_LEN and MIN_LEN. These represents the maximum and minimum length that our class will allow any of its strings to be set to. We can use these static members in the TripleString method whose job it is to test for valid strings (see below).

The Program Spec

Class TripleString Spec Instance Members:

• (string) string1

• (string) string2

• (string) string3

  All legal strings should be between 1 and 50 characters, inclusive.
  As stated in the modules, we never want to see a literal in our methods. So, the class should have static members to hold values for the limits described above, as well as default values for any field that is construct-ed using illegal arguments from the client. These are defined and initialized in the static section.

  Class Static Intended Constants:

• MIN_LEN = 1

• MAX_LEN = 50

• DEFAULT_STRING = "(undefined) "

  Instance Methods
  Default Constructor
  TripleString() -- a default constructor that initializes all members to DEFAULT_STRING. Combination Default/Paramteter-Taking Constructor

  def __init__(self, string1 = DEFAULT_STRING, string2 = DEFAULT_STRING, string3 = DEFAULT_STRING): a constructor that initializes all members according to the passed parameters. It must be sure each string satisfies the class requirement for a member string. It does this, as in the modules, by calling the mutators and taking possible action if a return value is false. If any passed parameter does not pass the test,
  a default string should be stored in that member.

  Mutators/Accessor

  set()s andget()s for these members.Mutators in our course are named using the convention as follows: set_string1(...), set_string3(...), etc. Likewise, with accessors: get_string2(). We need an accessor and mutator for each individual string member, so three pairs of methods in this category. Mutators make use of the helper method valid_string(). When a mutator detects an invalid string, no action should be taken. In that case, mutator returns False and the existing string stored in that member prior to the call remains in that member, not a new default string.

string to_string()– a method that returns a string which contains all the information (three strings) of the TripleString object. This string can be in any format as long as it is understandable and clearly formatted.

Helper Methods

def valid_string(self, the_str): – a helper function that the mutators can use to determine whether a string is legal. This method returns True if the string's length is between MIN_LEN and MAX_LEN (inclusive). It returns False, otherwise. This would normally be defined as a class member method, but since we are just starting to learn about static and class methods, we'll allow it to be an instance method this week.

Where it All Goes

There are now a variety of program elements, so let's review the order in which things appear in your .py file:

1. class definition(s)

2. global-scope function definition(s) [You may not need them for this assignment.]

3. main program

In other words, triple_string.py will look like this:

# ---------------- SOURCE ---------------------------------------- class TripleString:

""" encapsulates a 3-string object """

# intended class constants ------------------------------------ MAX_LEN = 50
...

# constructor method ------------------------------------ def __init__(self,

string1 = DEFAULT_STRING, string2 = DEFAULT_STRING, string3 = DEFAULT_STRING):

...

# mutator ("set") methods ------------------------------- ...

# accessor ("get") methods ------------------------------- ...

# helper methods for entire class ----------------- ...

# ------------- CLIENT --------------------------------------------------

# Create 4 TripleString objects triple_string_num_1 = TripleString() ...

The main program

1. Instantiate four or more TripleString objects, some of them using the default values, some using

   arguments.

2. Immediately display all objects.

3. Mutate one or more members of every object.

4. Display all objects a second time.

5. Do two explicit mutator tests. For each, call a mutator in an if/else statement which prints one message

   if the call is successful and a different message if the call fails.

6. Make two accessor calls to demonstrate that they work.

More:

• Be sure that all output is descriptive. Use labels to differentiate your output sections and full sentences

  in your mutator/accessor tests.

• No user input should be done in this program.

  I am not supplying a sample output this week – the above description is adequate.

Answer 1

Python Code:

class TripleString:
   """ Encapsulates three string objects """
  
   # Class constants
   MIN_LEN = 1
   MAX_LEN = 50
   DEFAULT_STRING = "(undefined)"
  
   def __init__(self, string1 = DEFAULT_STRING, string2 = DEFAULT_STRING, string3 = DEFAULT_STRING):
       """ Constructor """
       # Calling mutator methods
       if not self.set_string1(string1):
           self.string1 = DEFAULT_STRING; # Storing default string
      
       # Assigning string 2
       if not self.set_string2(string2):
           self.string2 = DEFAULT_STRING; # Storing default string
          
       # Assigning string 3  
       if not self.set_string3(string3):
           self.string3 = DEFAULT_STRING; # Storing default string
          
   # Mutator methods
   def set_string1(self, val):
       """ Assigns if valid value is passed """
       if self.valid_string(val):
           self.string1 = val
           return True
       else:
           return False
          
   def set_string2(self, val):
       """ Assigns if valid value is passed """
       if self.valid_string(val):
           self.string2 = val
           return True
       else:
           return False
      
   def set_string3(self, val):
       """ Assigns if valid value is passed """
       if self.valid_string(val):
           self.string3 = val
           return True
       else:
           return False
          
   # Accessor methods
   def get_string1(self):
       """ Returns the string """
       return self.string1
      
   def get_string2(self):
       """ Returns the string """
       return self.string2
  
   def get_string3(self):
       """ Returns the string """
       return self.string3
      
   def valid_string(self, val):
       """ Validates the string """
       if len(val) >= self.MIN_LEN and len(val) <= self.MAX_LEN:
           return True
       else:
           return False
          
   def to_string(self):
       """ Method that prints the three strings """
       return "\nString1: " + self.get_string1() + " \t String2: " + self.get_string2() + " \t String3: " + self.get_string3();
      
      
# Testing class
def main():
   """ Main function """
   # Creating instances
   ts1 = TripleString("Hello", "Hai", "Bye")
   ts2 = TripleString("Welcome", "World")
   ts3 = TripleString("Nice", "Python", "Programming")
   ts4 = TripleString("Good")
  
   print("\n\n After Assigning: \n");
  
   # Printing values
   print(ts1.to_string())
   print(ts2.to_string())
   print(ts3.to_string())
   print(ts4.to_string())
  
   # Mutating values of objects
   ts1.set_string2("Morning")
   ts2.set_string3("Subject")
   ts3.set_string1("Good")
   ts4.set_string2("Nice")
   ts4.set_string3("Weather")
  
   print("\n\n After Updating: \n");
  
   # Printing values
   print(ts1.to_string())
   print(ts2.to_string())
   print(ts3.to_string())
   print(ts4.to_string())
  
  
   # Testing mutator methods
   if ts1.set_string2("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"):
       print("\n Updated \n")
   else:
       print("\nError!!! Invalid value\n");
      
   if ts4.set_string2("sssaaaaa"):
       print("\n Updated \n")
   else:
       print("\nError!!! Invalid value\n");
      
   # Checking Accessor methods
   print("\n\n String 2 in Object 1: " + ts2.get_string1())
   print("\n String 3 in Object 3: " + ts3.get_string3() + " \n")
  
  
# Calling main function
main()

_____________________________________________________________________________________

Sample Run:

C:\Users\SaiBabu\AppData\Local\Programs\Python\Python35>python d:\Python TripleString.py After Assigning: string1: Hello String2: Hai String3: Bye String1: Welcome String2: World String3: (undefined) String1: Nice String2: Python String3: Programming String1: Good String2: (undefined) String3: (undefined) After Updating: stringl: Hello String2: Morning String3: Bye string1: Welcome String2: World String3: Subject Stringl: Good String2: Python String3: Programming Stringl: Good String2: Nice String3: Weather Error!!! Invalid value Updated String 2 in object 1: Welcome String 3 in object 3: Programming C:\Users\Saibabu\AppData\Local\Programs\Python\Python35>