import argparse

import sys

import os

import random

import re

from collections import defaultdict

def get_args():

"""get arguments"""

parser = argparse.ArgumentParser(

description='Explain acronyms',

formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument('acronym', help='Acronym', type=str, metavar='STR')

parser.add_argument('-n',

'--num',

help='Maximum number of definitions',

type=int,

metavar='NUM',

default=5)

parser.add_argument('-w',

'--wordlist',

help='Dictionary/word file',

type=str,

metavar='STR',

default='/usr/share/dict/words')

parser.add_argument('-x',

'--exclude',

help='List of words to exclude',

type=str,

metavar='STR',

default='a,an,the')

parser.add_argument('-s',

'--seed',

help='Random seed',

type=int,

metavar='INT',

default=None)

return parser.parse_args()

def main():

"""main"""

args = get_args()

acronym = args.acronym

wordlist = args.wordlist

limit = args.num

goodword = r'^[a-z]{2,}$'

badwords = set(re.split(r'\s*,\s*', args.exclude.lower()))

random.seed(args.seed)

if not re.match(goodword, acronym.lower()):

print('"{}" must be >1 in length, only use letters'.format(acronym))

sys.exit(1)

if not os.path.isfile(wordlist):

print('"{}" is not a file.'.format(wordlist))

sys.exit(1)

seen = set()

words_by_letter = defaultdict(list)

for word in open(wordlist).read().lower().split():

clean = re.sub('[^a-z]', '', word)

if not clean: # nothing left?

continue

if re.match(goodword,

clean) and clean not in seen and clean not in badwords:

seen.add(clean)

words_by_letter[clean[0]].append(clean)

len_acronym = len(acronym)

definitions = []

for i in range(0, limit):

definition = []

for letter in acronym.lower():

possible = words_by_letter.get(letter, [])

if len(possible) > 0:

definition.append(

random.choice(possible).title() if possible else '?')

if len(definition) == len_acronym:

definitions.append(' '.join(definition))

if len(definitions) > 0:

print(acronym.upper() + ' =')

for definition in definitions:

print(' - ' + definition)

else:

print('Sorry I could not find any good definitions')

if __name__ == '__main__':

main()

.PHONY: doc test

doc:

pandoc README.md -o README.pdf --latex-engine=xelatex

test:

pytest -v test.py

Write a Python program called "blackjack.py" that plays an abbreviated game of Blackjack. You will need to `import random` to get random cards from a deck you will construct, and so your program will need to accept a `-s|--seed` that will set `random.seed()` with the value that is passed in so that the test suite will work. The other arguments you will accept are two flags (Boolean values) of `-p|--player_hits` and `-d|--dealer_hits`. As usual, you will also have a `-h|--help` option for usage statement.

To play the game, the user will run the program and will see a display of what cards the dealer has (noted "D") and what cards the player has (noted "P") along with a sum of the values of the cards. In Blackjack, number cards are worth their value, face cards are worth 10, and the Ace will be worth 1 for our game (though in the real game it can alternate between 1 and 11).

To create your deck of cards, you will need to use the Unicode symbols for the suites ( ♥ ♠ ♣ ♦ ) [which won't display in the PDF, so consult the Markdown file].

Combine these with the numbers 2-10 and the letters "A", "J", "Q," and "K" (hint: look at `itertools.product`). Because your game will use randomness, you will need to sort your deck and then use the `random.shuffle` method so that your cards will be in the correct order to pass the tests.

When you make the initial deal, keep in mind how cards are actually dealt -- first one card to each of the players, then one to the dealer, then the players, then the dealer, etc. You might be tempted to use `random.choice` or something like that to select your cards, but you need to keep in mind that you are modeling an actual deck and so selected cards should no longer be present in the deck. If the `-p|--player_htis` flag is present, deal an additional card to the player; likewise with the `-d|--dealer_hits` flag.

After displaying the hands, the code should:

1. Check if the player has more than 21; if so, print 'Player busts! You lose, loser!' and exit(0)

2. Check if the dealer has more than 21; if so, print 'Dealer busts.' and exit(0)

3. Check if the player has exactly 21; if so, print 'Player wins. You probably cheated.' and exit(0)

4. Check if the dealer has exactly 21; if so, print 'Dealer wins!' and exit(0)

5. If the either the dealer or the player has less than 18, you should indicate "X should hit."

NB: Look at the Markdown format to see the actual output as the suites won't display in the PDF version!

A passing test suite looks like this:

import argparse

import random

import re

import sys

from itertools import product

def get_args():

"""get command-line arguments"""

parser = argparse.ArgumentParser(

description='Argparse Python script',

formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument(

'-s',

'--seed',

help='Random seed',

metavar='int',

type=int,

default=None)

parser.add_argument(

'-d',

'--dealer_hits',

help='Dealer hits',

action='store_true')

parser.add_argument(

'-p',

'--player_hits',

help='Player hits',

action='store_true')

return parser.parse_args()

def warn(msg):

"""Print a message to STDERR"""

print(msg, file=sys.stderr)

def die(msg='Something bad happened'):

"""warn() and exit with error"""

warn(msg)

sys.exit(1)

def bail(msg):

"""print() and exit(0)"""

print(msg)

sys.exit(0)

def card_value(card):

"""card to numeric value"""

val = card[1:]

faces = {'A': 1, 'J': 10, 'Q': 10, 'K': 10}

if val.isdigit():

return int(val)

elif val in faces:

return faces[val]

else:

die('Unknown card value for "{}"'.format(card))

def main():

"""Make a jazz noise here"""

args = get_args()

random.seed(args.seed)

# seed = args.seed

# if seed is not None:

# random.seed(seed)

suites = list('♥♠♣♦')

values = list(range(2, 11)) + list('AJQK')

cards = sorted(map(lambda t: '{}{}'.format(*t), product(suites, values)))

random.shuffle(cards)

p1, d1, p2, d2 = cards.pop(), cards.pop(), cards.pop(), cards.pop()

player = [p1, p2]

dealer = [d1, d2]

if args.player_hits:

player.append(cards.pop())

if args.dealer_hits:

dealer.append(cards.pop())

player_hand = sum(map(card_value, player))

dealer_hand = sum(map(card_value, dealer))

print('D [{:2}]: {}'.format(dealer_hand, ' '.join(dealer)))

print('P [{:2}]: {}'.format(player_hand, ' '.join(player)))

if player_hand > 21:

bail('Player busts! You lose, loser!')

elif dealer_hand > 21:

bail('Dealer busts.')

elif player_hand == 21:

bail('Player wins. You probably cheated.')

elif dealer_hand == 21:

bail('Dealer wins!')

if dealer_hand < 18:

print('Dealer should hit.')

if player_hand < 18:

print('Player should hit.')

if __name__ == '__main__':

main()