Simulating Social Networks

At this point, any file can import opinion and leverage the Person class that you wrote. Let’s implement an example of that!

The Goal

The goal of Part 2 of the lab is to gain experience working with instances of classes. In the file simulate.py you will build a simulation which does the following steps:

• Asks the user for what type of social network to simulate
• Creates a network of that type
• Simulates the network updating over n total steps

To help you accomplish this goal, we’ve built some additional tools in the module opinion_helper and imported them into your starter code for simulate.py. The two steps below help you learn how to use them!

Step 1: Ang, Boone, and Charlie

The first tool we’ve imported for you is print_relationships(population) which, given a population (list of Person objects), prints the relationships between the members as an adjacency matrix. The first row below says that Ang has befriended both Boone and Charlie.

          Ang      Boone    Charlie  
Ang       0        1        1        
Boone     0        0        1        
Charlie   1        0        0        

• In simulate.py, add code to the main method to create three Person objects to represent Ang (opinion: 0), Boone (opinion: 1), and Charlie (opinion: 0). Assign their friendships to match the connections in the table above using the class methods you wrote in Part 1.

• Check your work by making a list called population which contains all three people and pass population to the print_relationships function.

Step 2: Visualizing Social Networks

The second tool we’ve built for you is the class SocialMap. SocialMap is designed so that we can draw the connections among friends and see how people’s opinions change over time (all using the picture module!). The constructor for SocialMap takes a single parameter - the “population” of the social network as Person objects. Once constructed, your social network will automatically be displayed.

Using the Live View

To see the visualization used in this portion of the lab, you’ll need to use the Ports tab to open a live view window over port 6080, like you did in Lab 4. If you need a reminder, please refer to the lab 4 warmup for detailed instructions on how to do this. As in previous labs, the password is csci.

network = SocialMap(population)

Now let’s put the Readme above into practice with the social network containing Ang, Boone, and Charlie! Just like described above, the steps are:

• In your main method, initialize an instance of SocialMap with the Ang, Boone, and Charlie population.
• Run 25 steps of the simulation, using your instance of SocialMap to call the animate_update method on a random Person (i.e. one of Ang, Boone, or Charlie) each time.
• Call print_results to see how the simulation has changed people’s opinions.

Note that the simulation always tries to make sure people (nodes in the graph) don’t visually overlap. For more complex simulations, it may take a moment for the graph to setup - feel free to refresh your browser window if it’s taking too long!

Make sure you understand how “befriending” each other turns a list of people into a network, and how to display a SocialMap, before you continue. In the next section, we will follow a similar process as above to generate and simulate social networks with new shapes.

Note: you’ve demonstrated that you can access your own, bespoke class from another file and use it, as well as being able to use it together with the opinion_helper.py functions. Great work.

You Can Pick Your Friends

Having implemented our visualizations, we will now make our program simulate a few pre-formed networks at the user’s request. This will be similar to menus we’ve created in previous labs, where the user chooses an option by number. However, in this case we will not use the input function. We’ll use the command line, which is a much more general method in software engineering to obtain user choice. This looks the following way:

python3 simulate.py 1

In this example, the user is running our program, and requesting network number 1 among the list of options. More details on how to get user input from the command line are below.

First, more details on what the program will do. You will need to support creating four different social network options via the command line:

1. The Ang, Boone, and Charlie example from above.
2. One of the example networks below.
3. A second, different example network below.
4. A network of your own development! It does not have to be complex.

Every Person object that you create should have a random opinion (with the exception of Ang, Boone, and Charlie). This is the built-in behavior for the example networks.

The table below lists functions you may find helpful for creating interesting example networks. These functions create populations (i.e. interesting combinations of Person objects) - you’ll still need to call SocialMap on them to visaulize them. These functions are defined in opinion_helper.py - you do not have to write them yourself. They do the work of generating Person objects and befriending each other.

To test out how they work, you can use print_relationships, as below, before visualizing them with SocialMap:

population = circle(15)
print_relationships(population)

The table below describes what each of the functions does - you should not need to consult opinion_helper.py yourself to be able to use them. Each of them returns a population.

The default value of n in the below networks is 10, but you’re welcome to specify any small-ish n you’d like.

Note that unlike the other functions, pop_star augments existing populations. Make sure you’ve already created population lists to use before choosing to call it!

Remember that your fourth network option should be your own idea. You can use functions from opinion_helper.py to help generate your network, but your own code should add at least one person and their connections, or some friendship connections should manually be added.

Getting User Choice via Command Line Arguments

How can we support user input from the command line? Well, if you add:

import sys

at the beginning of your program, you’ll get access to the variable sys.argv, which is a list of the arguments passed to Python. The first of these is always the name of the program itself. But if you were to run:

python3 simulate.py 1 a

and that program included the statement print(sys.argv), we’d get as output:

['simulate.py', '1', 'a']

Note that all values in sys.argv are strings by default. Given this, and possibly judicious use of the int() function, you should be able to get all the input you need from command line arguments.

We want the user to give us exactly two command line arguments. Firstly, the name of the program (what they normally give us - you don’t need to do anything fancy to handle this) and a single numeric argument which represents which social network the user would like to display.

Now that we have an overview of how command line arguments work, let’s talk about how we’ll use them to handle user choice in this lab:

• In the main method of simulate.py, you should check that the arguement given in the second position (index 1) is of type int, for example using choice = int(sys.argv[1]) within a try statement.
• If the wrong type of argument was entered, catch that case (using except) and print a message explaining the problem, then exit the program completely using sys.exit(1) so the computer knows something went wrong.

If the user provides valid command line input, then we have a valid index of sys.argv that represents the user’s chosen network! Let’s process it appropriately:

• Check if the user entered 1 as a command line argument. If they did, generate the network from the example, with Ang, Boone, and Charlie.

• For each of the other three options, generate the network you’ve chosen for that option. This should be reminiscent of the menus you created in previous labs. The main difference is that the choice is read before the program even starts.

• Finally, create an instance of SocialMap with your population and loop over the animate_update function just as you did in Step 2. Make sure to pick a random Person from the population to update each time!

To gain full credit for Part 2 of this lab, you should have:

• A program that visualizes a social network based on a command line argument of the user’s choice. You should error check the user’s provided choice.
• There should be four population options available to the user, two of which you built yourself and two of which come from helper functions.
• The simulation should run for a minimum of 25 steps, but feel free to vary n as needed to see the full simulation for each network!