assignment 3 chatbot python quizlet

Introductory Python

Assignment 3: chatbots, assignment 3: chatbots ¶.

This is a demo assignment that is available as part of the Introductory Python open materials.

This assignment covers Functions & Algorithms, and builds up to the application of Chatbots.

This assignment is out of 8 points, worth 8% of your grade.

Make sure your completed assignment passes all the asserts. This assignment also has hidden tests - which means that passing all the asserts you see does not guarantee that you have the correct answer! Make sure to double check and re-run your code to make sure it does what you expect.

Quick Tips ¶

Make sure you execute your code to define the functions you write, and then add a new cell to apply your function to different inputs, and check that you get the outputs you expect.

If you’re not sure where to start, look at the code in the test cases (in the asserts) for examples for what kind of inputs and outputs the function you are writing should take, and what kind of behaviour it should have.

Keep in mind that each question is mostly independent from every other - so if you get stuck on something, you can always move on to the next one, and come back to any that you have trouble with later.

Code Imports ¶

You must run the following cell before proceeding with the assignment.

Zen Chatbot ¶

In this assignment, we will be working our way up to building a chatbot.

To start with, we can have a quick chat with a zen chatbot, to see what these kinds of chatbots look like.

Also, if you get stuck on anything, come back here, and talk to the Zen chatbot, to relax :)

Note: in this, and other, chatbot lines, running this code will start an open-ended while loop, that will interupt your code flow, until you explicity quit out of the conversation. If you want to be able to run all your code (from kernel restart & run all ), then comment these lines back out when you are finished exploring them.

Part 1: Functions ¶

This part covers the basics of writing and using functions.

Function Examples ¶

The following are a couple examples of functions provided to you, so you can see their structure.

You don’t need to do anything with these functions.

Q1 - Find Max Value (0.5 points) ¶

Write a function called find_max , that takes in a single parameter called random_list , which should be a list.

This function will find the maximum (max) value of the input list, and return it.

This function will assume the list is composed of only positive numbers.

To find the max, within the function, use a variable called list_max , that you initialize to value 0.

Then use a for loop, to loop through random_list .

Inside the list, use a conditional to check if the current value is larger than list_max , and if so, re-assign list_max to store this new value.

After the loop, return list_max , which should now store the maximum value from within the input list.

Q2 - Square Everything (0.5 points) ¶

Write a function called square_all that takes an input called collection that you assume to be a list or tuple of numbers.

This function should return a new list , which contains the square of each value in collection .

To do so, inside the function, you will define a new list, use a loop to loop through the input list, use an operator to square the current value, and use the append method to add this to your output list. After the loop, return the output list.

Part 2: Refactoring Code to Use Functions ¶

‘Refactoring’ is the process of updating existing computer code, to keep the same outputs, but to have better internal organization and/or properties.

We’ve written a lot of code in previous assignments. However, since we did not yet have functions at our disposal, a lot of that code is not very easy to re-use.

In this section we will refactor some code - rewriting (and extending) some code from previous assignments as functions, to make it easier to re-use.

Q3 - Calculator (0.5 points) ¶

Let’s start with the calculator code that we worked on in A1.

Instead of using a conditional, like we did before, we will make a series of functions to do all the mathematical operations that we want to do.

Define four functions, called summation , subtraction , multiplication , and division .

Each of them will take two inputs num1 and num2 (that could be int or float ), and use them as follows:

summation will add num1 to num2 and return the result

subtraction will subtract num2 from num1 and return the result

multiplication will multiply num1 by num2 and return the result

division will divide num1 by num2 and return the result

Q4 - Extending our Calculator (0.5 points) ¶

Let’s now add some more functions to our calculator:

Write a function called squared that takes one parameter, called num , and returns the square of it.

Write a function called square_root that takes one parameter, called num , and returns the square root of it.

Example: Chaining Functions Together ¶

The goal of using functions is partly to be able to re-use code segments.

It’s also a way to able to flexibly apply and combine different functions together, to build up to more complex and interesting programs.

The cell below shows a couple examples of using our calculator functions that we have now defined, in combination with each other.

Q5 - Using Our Calculator (0.5 points) ¶

Let’s now use our new calculator functions to do some calculations!

Add the square of 3 to the square root of 9

Save the result to a variable called calc_a

Subtract the division of 12 by 3 from the the multiplication of 2 and 4

Save the result to a variable called calc_b

Multiply the square root of 16 to the sum of 7 and 9

Save the result to a variable called calc_c

Divide the square of 7 by the square root of 49

Save the result to a variable called calc_d

Calling Functions from Functions ¶

In the example above, we were able to refactor our code into re-useable functions.

We were then able to use these functions and chain them together to flexibly and extensibly do computation.

Next we’ll dive into another aspect of writing good modular code: dividing complex tasks into independent functions and then using them together.

In practice, this will look like writing lots of and small and specific functions to do simple tasks.

We can then use these functions from within other functions build up to being able to do more complex tasks.

Q6 - Functions for Even & Positive Numbers (0.5 points) ¶

Recall Q13 from A2, when we wanted to check a series of conditions across items in a list.

We can consider that checking each of these conditions is really a separate task.

When writing modular code, these separate tasks should therefore be organized as separate functions.

For this question, write two functions, one called is_even , and the other called is_positive .

Each function should take in a single parameter, a number called value :

is_even will check if value is even, and return True if so, and False otherwise.

is_positive will check if value is positive, and return True if so, and False otherwise.

Note: for our purposes here, ‘positive’ numbers are all numbers greater than 0 (so 0 is not considered positive).

Q7 - Functions Using Functions (0.5 points) ¶

In this section, your are going to recreate a function called make_new_list which takes a list called data_list as its input.

This function will use is_positive and is_even to mimic the task from A2-Q13.

That is, this function will check each value in data_list to see if they are even or odd and whether they are positive or negative.

If they are both positive and even, encode this as the number 1

If they are both negative and odd, encode this as the the number -1

Otherwise, encode this as the number 0

Store the result for each value into a list called output and return it.

Part 3: Algorithms ¶

This part covers working with algorithms.

Q8 - Algorithms (0.5 points) ¶

For each of the tasks below, indicate whether you think it is something that a human or a computer would be better at doing.

Answer each question by setting each requested variable to the string either ‘human’ or ‘computer’.

Set the variable to reflect the answer of which of them you think would be better at the task.

a) Recognize whether a sentence is sarcastic and/or ironic.

Answer in a variable called algo_q_a

b) Reply to a question with information about a topic, replying with the exact wording from a wikipedia article.

Answer in a variable called algo_q_b

c) Keep answering messages for an arbitrarily long period of time, without demonstrating fatigue.

Answer in a variable called algo_q_c

d) Interpret the tone of what was said, to infer if someone is angry.

Answer in a variable called algo_q_d

For each, try to think through if and how you could write an algorithm to do this task - and if you could not, what about it is hard to formalize.

We can use these questions to start to think through what might be easy and hard to program our chatbot to do.

Part 4: Chatbots ¶

This part is an application of all the tools we have covered so far, to the problem of creating a chatbot.

A chatbot is a piece of software that tries to have a conversation with a human.

While today’s chatbots are powerful learners, traditional chatbots are much simpler.

Traditional chatbots follow a “rule-based” approach that is defined for them (by you, the programmer), usually without any learning.

These rules can be very simple or sometimes quite complex - but everything is pre-defined.

These types of chatbots can handle simple conversations but do tend to fail at more complex ones.

Chatbot functions ¶

In order to make our chatbot, we will create a series of functions that our eventual chatbot will use together to try and chat with a user.

At the end, we will test that these functions do indeed allow us to have simple conversations with our chatbot.

Below are some more example chatbots to talk to. Remember to comment these lines back out if you want to be able to Restart and Run All .

Example Chatbot - Eliza ¶

The following demo is from the Natural Language ToolKit (nltk), a Python package available through Anaconda.

Uncomment the line below, and run the code to be able to have a chat with Eliza.

More information on Eliza: https://en.wikipedia.org/wiki/ELIZA

Example Chatbot - Iesha ¶

The following is another demo chatbot from nltk, this one called Iesha.

As you try the chatbot demos with Eliza and Iesha, see if you can notice any patterns that might help you figure out how they work.

That is, can you guess at what kind of programming structures these programs might use?

Chatbots: Words & Rules ¶

So, how do these kinds of chatbots work? Most broadly, they combine two simple but powerful approaches:

Rule Based Artificial Intelligence (GOFAI)

Bag-Of-Word Language Models

Rule based AI , sometimes called ‘Good Old Fashion Artificial Intelligence’, or ‘GOFAI’, is an approach to making artificial agents that tries to write down a set of rules to follow to perform some task. In practice, this often looks like using a lot of conditionals: if X happens, do Y . If we can write down enough logical procedures (call them algorithms) to follow to complete some task, then we can create an artificially intelligent agent (for that task).

Bag-Of-Word language models are an approach to language that takes the simple approach of saying ‘lets try and figure out what someone is saying simply by checking and counting which words they use’. If someone says the word ‘dog’ three times in conversation, they are probably talking about dogs. This ignores many many things about language, and how it works, but is a good ‘first guess’ for what is being said.

From our perspective, this means two things:

We can broadly try to figure out the topic simply by checking which words are used

We can choose a response based on a rule that defines what to do if and when we identify particular topics

In code then, this looks like:

taking input as strings of continuous text, and splitting this up into lists that contain all the words we see

use conditionals (if/elif/else) that choose an output based on what words appear in those lists

As we work through and create all the function in the next section to create our chatbot, try to think through how these functions relate to this approach.

Q9 - Is It a Question (0.5 points) ¶

One thing we might want to know, given an input to a chatbot, is if the input is a question.

We are going to use a very simple heuristic to check this: we will consider any input that has a question mark (‘?’) in it to be a question.

To do so, write a function called is_question .

This function should have the following inputs, outputs and internal procedures:

input_string - string

output - boolean

Procedure(s):

if there is a ‘?’ in input_string , set output to True

otherwise, set output to False.

return output

Example: string.punctuation ¶

When working with strings, it can be useful to check what kind of things particular characters are.

To do things like this, Python offers some collections of items, that we can check against.

For example, we can ask if a particular character is a punctuation mark, by asking if it is in the collection of punctuation characters.

Q10 - Removing punctuation (0.5 points) ¶

Once we know if an input is a question, we are going to get rid of all punctuation.

To do so, write a function called remove_punctuation .

out_string - string

define a new variable out_string as an empty string

loop through each character in input_string

if this character is not in string.punctuation

then append the current character to out_string

return out_string

Q11 - Preparing Text (0.5 points) ¶

Now we want a more general function to prepare the text inputs for processing.

Inside this function, we will use some string methods as well as our new remove_punctuation function.

Write a function called prepare_text .

out_list - list of string

make the string all lower case (use a string method called lower )

note that you will have to assign the output to a variable. You can use a variable name like temp_string

remove all punctuation from the string (use your new function remove_punctuation )

this can also assign out to temp_string

split the string into words (look for and use a string method called split )

note that split will return a list of strings. Assign this as out_list

return out_list

Q12 - Echo a Response (0.5 points) ¶

We will define a function that will return a string that has been repeated a specified number of times, with a given separator.

We will also want to deal with the case where the input to this function may be None .

Write a function called respond_echo .

input_string - string, or None

number_of_echoes - integer

spacer - string

echo_output - string, or None

if input_string is not None :

set a variable echo_output to be input_string , repeated the number of times specified by number_of_echoes , joined by the spacer .

Hint: to do so, recall what “*” does to strings

otherwise (if input_string is None)

set echo_output to None

return echo_output

Note that a simple version of this version will end up appending the spacer to the end of the list as well. For our purposes here, implement that simple version.

So, for example, respond_echo('bark', 2, '-') should return: ‘bark-bark-‘

Example: random.choice ¶

We want our chatbot to have some variation in it’s responses - not only anwering the same thing.

So, we want to be able to choose an output from a list of options.

We can use the random.choice function to so.

An example of using random.choice is offered below.

Q13 - Selector (0.5 points) ¶

Next we will write a function that will help us select an output for the chatbot, based on the input it got.

The overall goal of this function is to take a list of words that we got as input, a list of words to check for if they appear in the input, and a list of possible outputs to return if something from the list to check is in the input list.

Define a function, called selector .

input_list - list of string

check_list - list of string

return_list - list of string

output - string, or None

Initialize output to None

Loop through each element in input_list

Use a conditional to check if the current element is in check_list

If it is, assign output as the returned value of calling the random.choice function on return_list

Also, break out of the loop

At the end of the function, return output

Note that if we don’t find any words from input_list that are in check_list , output will be returned as None .

Q14 - String Concatenator Function (0.5 points) ¶

Create a function that will concatenate two strings, combining them with a specified separator.

To do so, write a function called string_concatenator .

string1 - string

string2 - string

separator - string

concatenate string1 to string2 with separator in between them.

return the result

Q15 - List to String (0.5 points) ¶

Since we are often dealing with a list of strings, it would be useful to have a function to turn a list of strings back into one single concatenated string.

This function will return a string that is each element of input_list concatenated together with each separated by the string seperator .

For example, the following function call:

shoud return:

To do this, write a function called list_to_string .

output - string

assign a variable called output to be the first (index 0) element from input_list

loop through the rest of input_list , looping from the 2nd element (index 1) through to the end of the list

Within the loop, use string_concatenator to combine output with the current element, separated by separator

Assign the output of this to be the new value of output

return output , which should now be a list of the elements of input_list , joined together into a a single string

Q16 - End Chat (0.5 points) ¶

The last thing we need is a way to end the chat with our chatbot.

We will use the same convention that nltk uses - namely, that we will end the conversation if the word quit appears.

To be able to do so, write a function called end_chat

input_list - list

This function should return True if the string ‘quit’ is in input_list , and return False otherwise.

Pulling it all Together ¶

If everything has gone well with writing everything above, then we are ready to pull all these functions together to create our chatbot.

The next few cells define a bunch of code, all provided for you. This code adds a couple more functions we can use and then defines some lists of inputs and outputs that our chatbot will know about. After that, there is a big function that pulls everything together and creates the procedure to use all of this code together as a chatbot.

You don’t have to write anything in the cells below (or in the rest of the assignment).

Do have a quick read through the code though, to see how our chatbot works, and to see how all the functions you just wrote are used to create the chatbot.

If you need, revisit the information at the beginning of this section about the logic our chatbot uses.

You don’t have to understand everything about what happens here, but try to have a first-pass look through it.

We will build up to understanding and writing this kind of code that brings a lot of things together as we continue through the course.

If the code seems intimidating, just scroll down to the bottom, and test out talking to our chatbot.

Talking to our Chatbot ¶

To talk to our chatbot, uncomment and run the cell below.

If anything seems to go weird, note that you can always interrupt the code from running with chat with kernel - interrupt from the menu.

If this happens, it probably means there is some issue with one of the functions you wrote for the chatbot.

Extending Our Chatbot ¶

You might notice that our chatbot, right now, is pretty limited in how many things it can respond to.

To respond to more topics, we could re-use these same functions, adding more input & output options for our chatbot to respond to, using the basic approaches and functionality we have defined here.

If you are interested in this topic, extending this chatbot (or ones like it) will be one of your project options.

After you’ve explored chatting to the chatbot, you are done!

Have a look back over your answers, and also make sure to Restart & Run All from the kernel menu to double check that everything is working properly.

When you are ready to submit your assignment, upload it to TritonED under Assignment-3.

Assignment 4: Artificial Agents

• Services Custom Web Development Custom Mobile Development Application Maintenance Application Modernization Quality Assurance Custom API Development DevOps Services SaaS Development Data Processing Cross-Platform App IT Security Services Cloud Application Development Chatbot Development MVP Development
• Industries Logistics & Transportations Banking & Finance eCommerce & Retail E-learning & Education Travel & Hospitality Legal Healthcare Food & Beverage Agriculture Real Estate Sports Event Management Oil & Gas Insurance Construction Aviation Supply Chain Management Telecom Manufacturing Payment Processing Lending
• On-demand Developers Python Django Full-Stack React JS PHP Symfony Vue JS Angular JS iOS Swift Android Kotlin DevOps Flask Laravel Yii Zend
• Digital Marketing
• Case Studies
• On-demand Developers
• Custom Web Development
• Custom Mobile Development
• Application Maintenance
• Application Modernization
• Quality Assurance
• Custom API Development
• DevOps Services
• SaaS Development
• Data Processing
• Cross-Platform App
• IT Security Services
• Cloud Application Development
• Chatbot Development
• MVP Development
• Logistics & Transportations
• Banking & Finance
• eCommerce & Retail
• E-learning & Education
• Travel & Hospitality
• Food & Beverage
• Agriculture
• Real Estate
• Event Management
• Oil & Gas
• Construction
• Supply Chain Management
• Manufacturing
• Payment Processing

How to Build a Chatbot with Python in 4 Easy Steps

Artificial intelligence has brought numerous advancements to modern businesses. One such advancement is the development of chatbots — programs that solve various tasks via automated messaging. 

Perhaps the most popular application of chatbots is virtual customer service in commercial enterprises. Chatbot technology first appeared more than 40 years ago but only recently gained extreme popularity due to multiple commercial benefits and excellent communication capabilities. Customers praise the comfort of using virtual assistants that have become more intelligent and human-like without annoying communication weaknesses often associated with humans.

So, does your business need a robust AI chatbot? What benefits can it bring? Continue reading to find these answers and get a step-by-step tutorial on how to build a chatbot in Python.

5 Types of Chatbots

A chatbot is an Artificial Intelligence (AI) based software that simulates human conversation. It analyzes the user request and outputs relevant information. Modern chatbots are called digital assistants and can solve many tasks. They are mainly used for customer support but can also be used for optimizing inner processes.

Types of Chatbots

Here are a few main chatbot types that vary in technology and functionalities:

1. Menu/button-based

This is the most basic type. It utilizes a decision tree hierarchy presented to a user as a list of buttons. Using the menu, customers can select the option they need and get the proper instructions to solve their problem or get the required information. This type of chatbots is widely used to answer FAQs, which make up about 80% of all support requests.

2. Rule-based

Rule-Based Chatbot

Rule-based chatbots are also called linguistic. It uses a collection of different conditions to assess the incoming words, detect specific word combinations, and form a response based on if/then logic. If the input matches the defined conditions, a chatbot outputs a relevant answer.

3. Keyword recognition-based

It uses Natural Language Processing (NLP) algorithms to form answers based on the detected keywords. Often it is combined with the menu/button-based option to give customers a choice if the keyword recognition mechanism outputs poor results.

4. ML-based

These chatbots utilize various Machine Learning (ML), Deep Learning (DL), and Artificial Intelligence (AI) algorithms to remember past conversations and self-improve with time. They are also called contextual chatbots.

5. Voice bots

Apple’s Siri, Amazon’s Alexa, Google Assistant are the best examples of voice recognition-based bots. They make you feel like you are having a conversation with a human. You don’t need to type anything to get the required information or enable the required features. For now, these are the most complicated in implementation.

10 Chatbot Benefits For Business

Chatbots are one of the top points in the digital strategies of companies worldwide. Before 2019, virtual interactions with customers were optional. However, in 2020 brands were pushed to connect with and serve their customers online due to the pandemic. As a result, the global chatbot market value will steadily increase over the next several years. A  Statista  report projects chatbot market revenues to hit $83.4 million in 2021 and $454.8 million by 2027.

Global Chatbot Market Revenue from 2018 to 2027

According to Fortune Business Insights research, the global chatbot market size will reach $1,953.3M by 2027 at a CAGR of 22.5% in 2020-2027. Such tremendous growth is not without reason. Chatbots bring numerous benefits for both businesses and customers.

The end goal for commercial implementation of any technology is bringing money and saving money. And this is how chatbots help with it.

• Better lead generation and maintenance : a chatbot can qualify leads by asking relevant questions and nurture the qualified leads according to their customers’ journey.
• 24/7 automated customer support : no wait time and no request queues during business hours.
• Reduced customer service cost : there is no need to hire and train human support agents. According to different surveys, the companies can save up to 35% on customer service costs.
• Higher customer engagement : a recent HubSpot study shows that 71% of people like getting assistance from messaging apps. People prefer texting to calling and tend to use a service more actively when getting timely, comfortable aid.
• Less time for information-based requests : chatbots filter customer requests before the team gets them, reducing the human resources and time needed for their processing.
• More straightforward support scalability : while a human can handle 2 to 3 conversations simultaneously, chatbots can manage thousands of conversations. Regardless of the workloads, chatbots are easily scalable without increasing the business costs.
• Better team productivity : as with any automation tool, chatbots reduce the workloads and help manage more tasks within the same time. You can automate your customer service and sales processes with a chatbot. While it performs standard duties like informing customers about order status, delivery time, and other common queries, the team can concentrate on higher-end processes.
• Higher customer satisfaction : chatbots can become a powerful channel for proactive communication with clients, providing them with relevant, personalized information on time. Moreover, it is much cheaper to provide multilingual customer support by a chatbot than by humans.
• Less human errors : another advantage of automation is eliminating the human-factor issues like mistakes in sharing product details, service pricing, etc. Properly programmed chatbots automatically provide the requested information correctly.
• Hybrid customer experience : companies practice switching conversations between a bot and live chat seamlessly. As a primary channel, a bot communicates with a customer until their questions require a more comprehensive discussion with a live person. It helps to optimize costs without sacrificing customer satisfaction.

Unsure about which type of chatbot best fits your business goals? Consult KeyUA experts to make the right choice.

Step 1. Installation

Let’s start with installing a ChatterBot corpus. Each corpus is a prototype of different inputs and responses that a chatbot learns. Saved data is used for self-training. Run two installation commands in the terminal:

Then install Jupyter Notebook:

And import the Chatbot class of the chatterbot module.

Step 2. Creating Chatbot Instance

We will create a chatbot object to name the future chatbot:

Now we need to position the storage adapter. Storage adapters connect a specific storage unit. To set the storage adapter, we will assign it to the import path of the storage we’d like to use. In this case, it is SQL Storage Adapter that helps to connect chatbot to databases in SQL. 

Now let’s position the logical adapter with a chatbot object. Logical adapters coordinate the logic. In Chatterbot, it picks responses for any input connected to it. The library allows using many logical adapters. We will use two, ‘BestMatch’ and ‘TimeLogicAdapter’:

Step 3. Chatbot Training

Within Chatterbot, training becomes an easy step that comes down to providing a conversation into the chatbot database. Given a set of data, the chatbot produces entries to the knowledge graph to properly represent input and output. We will import ‘ListTrainer,’ create its object by passing the ‘Chatbot’ object, and then call the ‘train()’ method by passing a set of sentences.

Step 4. Testing

This is the last stage of building a chatbot with Python. Running a test will check Kavana's bot conversational skills. Call the ‘get_responses()’ method of the ‘Chatbot’ instance.

Next, create a while loop. After the statement is passed into the loop, the chatbot will output the proper response from the database. ‘Bye’ or ‘bye’ statements will end the loop and stop the conversation.

Here is the result:

As you see, the conversation is not wholly accurate. It is a simple chatbot example to give you a general idea of making a chatbot with Python. With further training, this chatbot can achieve better conversational skills and output more relevant answers. 

In real life, developing an intelligent, human-like chatbot requires a much more complex code with multiple technologies. However, Python provides all the capabilities to manage such projects. The success depends mainly on the talent and skills of the development team. Currently, a talent shortage is the main thing hampering the adoption of AI-based chatbots worldwide. The demand for this technology surpasses the available intellectual supply.

Today’s AI- and ML-based chatbots give plenty of capabilities to improve customers’ satisfaction, boost loyalty to a brand, and optimize the time and money needed to run a business successfully. Here you’ve seen one of the multiple ways to develop chatbots using Python to understand this technology's basic principles. Real chatbots can fulfill significantly more complex scenarios.

If your company aims to provide customers with such an experience, KeyUA experts are available to build your chatbot based on Python or any other language that fits the project requirements. Depending on your communication channels, we can integrate a chatbot into your website, mobile application, and social network accounts to provide a complete connection with your customers.

Let’s level-up your customer support experience and strengthen your brand’s loyalty using the most advanced chatbot technologies.

Entrust your business chatbot development to the top experienced software engineers.

Leave a comment

• Sales: [email protected]
• Jobs: [email protected]
• Web Development
• Mobile Development
• IT Security
• Banking & Finance
• E-Commerce & Retail
• Web App vs Website
• How to Build a GPS App
• How to Create a Dating App
• How to Make Your Own Video Chat App Like Zoom
• How to Develop a Classroom Scheduling Software
• In-House vs Outsourcing
• How to Start a Delivery Service
• How to Build a CRM System
• 70 Mobile App Ideas for Startups
• Top 10 Strongest SaaS Trends for 2020

This website uses Cookies for analytical purposes. Read more at Privacy Policy Page .