Cf Appendices: argparse, Truthiness

As with all the solutions presented, this assumes you have stubbed the program with `new.py` and that you are using the `argparse` module. I suggest putting this logic into a separate function which here is called `get_args` and which I like to define first so that I can see right away when I'm reading the program what the program expects as input. On line 12, I set the `description` for the program that will be displayed with the help documentation. On line 15, I indicate that the program expects just one *positional* argument, no more, no less. Since it is a "word" that I expect, I called the argument `word` which is also how I will access the value on line 25. I use the `metavar` on line 15 to let the user know that this should be a string.

The `get_args` function will `return` the result of parsing the command line arguments which I put into the variable `args` on line 24. I can now access the `word` by call `args.word`. Note the lack of parentheses -- it's not `args.word()` -- as this is not a function call. Think of it like a slot where the value lives.

On line 26, we need to figure out whether the `article` should be `a` or `an`. We'll use a very simple rule that any word that has a first character that is a vowel should get `an` and otherwise we choose `a`. This obviously misses actual pronunciations like in American English we don't pronounce the "h" in "herb" and so actually say "an herb" whereas the British *do* pronounce the "h" and so would say "an herb". (Even more bizarre to me is that the British leave off the article entirely for the word "hospital" as in, "The Queen is in hospital!") Nor will we consider words where the initial `y` acts like a vowel.

We can access the first character of the `word` with `word[0]` which looks the same as how we access the first element of a list. Strings are really list of characters, so this isn't so far-fetched, but we do have to remember that Python, like so many programming languages, starts numbering at `0`, so we often talked about the first element of a list as the "zeroth" element.

To decided if the given word starts with a vowel, we ask if `word[0].lower() in 'aeiou'`. So, to unpack that, `word[0]` returns a one-character-long `str` type which has the method `.lower()` which we call using the parentheses. Without the parens, this would just be the *idea* of the function that returns a lowercased version of the string. Understand that the `word` remains unchanged. The function does not lowercase `word[0]`, it only *returns a lowercase version* of that character.

The `X in Y` form is a way to ask if element `X` is in the collection `Y`:

So we get the first character of `word` and ask if the lowercased version is in the list of characters `aeiou`.

The `if` *expression* is different from an `if` *statement*. An expression returns a value, and a statement does not. The `if` expression must have an `else`, but the `if` statement does not have this requirement. The first value is returned if the predicate (the bit after the `if`) evaluates to `True` in a Boolean context (more on that later), otherwise the last value is returned:

The longer way to write this would have been:

Or more succinctly:

consonant_words = [

'bear', 'cow', 'deer', 'frog', 'giraffe', 'horse', 'jackyl', 'kestrel',

'lion', 'marmot', 'nutria', 'porpoise', 'quark', 'rooster', 'sturgeon',

'turtle', 'vermin', 'walrus', 'xray', 'yoosy', 'zebra'

]

vowel_words = ['appaloosa', 'elephant', 'ingot', 'octopus', 'unicorn']

for word in consonant_words:

out = getoutput('{} {}'.format(prg, word))

assert out.strip() == 'a ' + word

for word in consonant_words:

out = getoutput('{} {}'.format(prg, word.title()))

assert out.strip() == 'a ' + word.title()

for word in vowel_words:

out = getoutput('{} {}'.format(prg, word))

assert out.strip() == 'an ' + word

for word in vowel_words:

out = getoutput('{} {}'.format(prg, word.title()))

assert out.strip() == 'an ' + word.title()

argparse

truthiness

markov

'--chapters',

help='Chapters listing',

metavar='FILE',

type=argparse.FileType('r'),

default=None)

parser.add_argument('-a',

'--appendix',

help='Appendix listing',

metavar='FILE',

type=argparse.FileType('r'),

chapters = args.chapters

appendix = args.appendix

cur_dir = os.path.dirname(sys.argv[0])

if not chapters:

chapters = os.path.join(cur_dir, 'chapters.txt')

if not os.path.isfile(chapters):

die('--chapters "{}" is not a file'.format(chapters))

if not appendix:

appendix = os.path.join(cur_dir, 'appendices.txt')

if appendix and not os.path.isfile(appendix):

die('--appendix "{}" is not a file'.format(appendix))

fh.write('\\setcounter{tocdepth}{2}\\tableofcontents\n\\newpage\n\n')

for i, dir_name in enumerate(map(str.rstrip, open(chapters)), 1):

print('Chapter {}: {}'.format(i, dir_name))

solution_py = os.path.join(in_dir, dir_name, 'solution.py')

if os.path.isfile(solution_py):

print('\tSOLUTION PY')

numbered = getoutput('cat -n {}'.format(solution_py))

solution_md = os.path.join(in_dir, dir_name, 'discussion.md')

if os.path.isfile(solution_md):

print('\tDISCUSSION MD')

fh.write('## Discussion\n\n')

fh.write(open(solution_md).read())

fh.write('\n\\newpage\n\n')

if appendix:

for i, dir_name in enumerate(map(str.rstrip, open(appendix)), 1):

print('Appendix {}: {}'.format(i, dir_name))

readme = os.path.join(in_dir, 'appendix', dir_name, 'README.md')

if os.path.isfile(readme):

print('\tREADME')

header = 'Appendix {}: '.format(i)

text = open(readme).read()

text = re.sub(r'^#\s+', '# ' + header, text)

fh.write(text + '\n\\newpage\n\n')