Write a Python program called `abuse.py` that generates some `-n|--number` of insults (default `3`) by randomly combining some number of `-a|--adjectives` (default `2`) with a noun (see below). Be sure your program accepts a `-s|--seed` argument (default `None`) to pass to `random.seed`.

The are the adjectives you should use:

And these are the nouns:

If run with the `-h|--help` flag, the program should generate usage:

When run with no arguments, the program should generate insults using the defaults:

````

It's unlikely you'll get the same output above when you run yours because no seed was set. The following, however, should be exactly reproducible due to the `--seed`:

If run with a `--number` less than 1, exit with an error code and message, preferably with the usage:

Hints:

* You can use three single or double quotes (\"\"\") to create a multi-line string and then `split()` that to get a list of strings. This is easier than individually quoting a long list of shorter strings (e.g., the list of adjectives and nouns).

* Perform the check for `--number` inside the `get_args` function and use `parser.error` to throw the error while printing a message and the usage.

* If you set the default for `args.seed` to `None` while using a `type=int`, you should be able to directly pass the argument's value to `random.seed` to control testing.

* Use a `for` loop with the `range` function to create a loop that will execute `--number` of times to generate each insult.

* Look at the `sample` and `choice` functions in the `random` module for help in selecting some adjectives and a noun.

* To construct an insult string to print, you can use the `+` operator to concatenate strings, use the `str.join` method, or use format strings (and maybe other methods?).


More than half of my solution is just in defining the program's arguments to `argparse`. The effort is well worth the result, because `argparse` will ensure that each argument is a valid integer value because I set `type=int`. Notice there are no quotes around the `int` -- it's not the string `'int'` but a reference to the class in Python. You can use the `type` function in Python to find out how Python represents a value:

For `--adjectives` and `--number`, I can set reasonable defaults so that no input is *required* from the user but the values are easily overridden. This makes your program dynamic, interesting, and testable. How do you know if your values are being used correctly unless you change them and test that the proper change was made in your program. Maybe you started off hardcoding the number of insults and forgot to change the `range` to use a variable. Without changing the input value and testing that the number of insults changed accordingly, it might be a user who discovers your bug, and that's somewhat embarrassing.

Another reason I quite like `argparse` is that, if I find there is a problem with an argument, I can use `parser.error` to do four things:

1. Print the short usage of the program to the user

2. Print a specific message about the problem

3. Halt execution of the program

4. Return an error code to the operating system

For instance, I can't very easily tell `argparse` that the `--number` should be a positive integer, only that it must be of type `int`. I can, however, inspect the value myself and call `parser.error('message')` if there is a problem. I do all this inside `get_args` so that, by the time I call `args = get_args()` in my `main` function, I know that all the arguments have been validated. I could have also added a similar check for `--adjectives`, but the main point was to highlight that such a thing is possible. As you write your own programs, you'll have to decide how much validation of user input you feel is necessary.

Once I'm in `main` and have my arguments, I can control the randomness of the program by calling `random.seed(args.seed)` because:

1. The default value of the `seed` is `None`, and setting `random.seed` to `None` is the same as not setting it at all.

2. The `type` of `args.seed` is `int` which is the proper type for `random.seed`. I do not have to validate the argument further. Negative integers are valid values.

To generate some `--number` of insults, I use the `range` function. Because I don't need the number of the insult, I can use the underscore (`_`) as a throwaway value:

The underscore is a way to unpack a value and indicate that you do not intend to use it. That is, it's not possible to write this:

You have to put *something* after the `for` that looks like a variable. If you put a named variable like `n` and then don't use it in the loop, some tools like `pylint` will detect this as a possible error (and well it could be). The `_` shows that you won't use it, which is good information for your future self, some other user, or external tools to know.

You can use multiple `_`, e.g., here I can unpack a 3-tuple so as to get the middle value:

To create my list of adjectives, I used the `str.split` method on a long, multi-line string I created using three quotes:

To select some number of adjectives, I chose to use `random.sample` function since I needed more than one:

For just one randomly selected value, I use `random.choice`:

To concatenante them together, I need to put `', '` (a comma and a space) between each of the adjectives, and I can use `str.join` for that:

And feed all this to a format string:

And now you have a handy way to make enemies and influence people.

description='Heap abuse',

args = parser.parse_args()

if args.number < 1:

parser.error('--number "{}" cannot be less than 1'.format(args.number))

return args