# and add it to back of the deck

deck.append(next_card)

def initial_deal():

deal_player()

dealer_hand.append(deal_card(dealer_card_frame))

dealer_score_label.set(score_hand(dealer_hand))

deal_player()

def new_game():

global dealer_card_frame

global player_card_frame

global dealer_hand

global player_hand

# embedded frame to hold the card images

dealer_card_frame.destroy()

dealer_card_frame = tkinter.Frame(card_frame, background='green')

dealer_card_frame.grid(row=0, column=1, sticky='ew', rowspan=2)

# embedded frame to hold the card images

player_card_frame.destroy()

player_card_frame = tkinter.Frame(card_frame, background='green')

player_card_frame.grid(row=2, column=1, sticky='ew', rowspan=2)

result_text.set("")

# Create the list to store the dealer's and player's hands

dealer_hand = []

player_hand = []

initial_deal()

def shuffle():

random.shuffle(deck)

def play():

initial_deal()

deal_player()

mainWindow.mainloop()

new_game_button = tkinter.Button(button_frame, text="New Game", command=new_game)

new_game_button.grid(row=0, column=2)

shuffle_button = tkinter.Button(button_frame, text="Shuffle", command=shuffle)

shuffle_button.grid(row=0, column=3)

deck = list(cards) * 2

shuffle()

if __name__ == "__main__":

play()

import blackjack

print(__name__)

blackjack.play()

class Wing(object):

def __init__(self, ratio):

self.ratio = ratio

def fly(self):

if self.ratio > 1:

print("Weee, this is fun")

elif self.ratio == 1:

print("This is hard word, but I'm flying")

else:

print("I think I'll just walk")

class Duck(object):

def __int__(self):

self._wing = Wing(1.8)

def walk(self):

print("Waddle, waddle, waddle")

def swim(self):

print("Come on it, th water's lovely")

def quack(self):

print("Quack quack")

def fly(self):

self._wing.fly()

class Penguin(object):

def walk(self):

print("Waddle, waddle, I waddle too")

def swim(self):

print("Come on in, it's a bit chilly this far South")

def quack(self):

print("Are you 'avin' a larf? I'm penguin!")

if __name__ == '__main__':

donald = Duck()

# percy = Penguin()

# test_duck(percy)

import random

class Enemy:

def __init__(self, name="Enemy", hit_points=0, lives=1):

self._name = name

self._hit_points = hit_points

self._lives = lives

self._alive = True

def take_damage(self, damage):

remaining_points = self._hit_points - damage

if remaining_points >= 0:

self._hit_points = remaining_points

print(f"I took {damage} points damage and have {self._hit_points} left.")

else:

self._lives -= 1

if self._lives > 0:

print(f"{self._name} lost a life and have {self._lives} lives left.")

else:

print(f"{self._name} is dead")

self._alive = False

def __str__(self):

return f"Name: {self._name}, Lives: {self._lives}, Hit points: {self._hit_points}"

class Troll(Enemy):

def __init__(self, name):

# super(Troll, self).__init__(name=name, lives=1, hit_points=23)

super().__init__(name=name, lives=1, hit_points=23)

def grunt(self):

print(f"Me {self._name}. {self._name} stomp you")

class Vampyre(Enemy):

def __init__(self, name):

super().__init__(name=name, lives=3, hit_points=12)

def dodges(self):

if random.randint(1, 3) == 3:

print(f"***** {self._name} dodges *****")

return True

else:

return False

def take_damage(self, damage):

if not self.dodges():

super().take_damage(damage=damage)

class VampyreKing(Vampyre):

def __init__(self, name):

super().__init__(name=name)

self._hit_points = 140

def take_damage(self, damage):

super().take_damage(damage // 4)

class Tag(object):

def __init__(self, name, contents):

self.start_tag = '<{}>'.format(name)

self.end_tag = '</{}>'.format(name)

self.contents = contents

def __str__(self):

return f"{self.start_tag}{self.contents}{self.end_tag}"

def display(self, file=None):

print(self, file=file)

class DocType(Tag):

def __init__(self):

super().__init__('!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" http://www.w3.org/TR/html4/strict.dtd', '')

self.end_tag = '' # DOCTYPE doesn't have an end tag

class Head(Tag):

def __init__(self, title=None):

super().__init__('head', '')

if title:

self._title_tag = Tag('title', title)

self.content = str(self._title_tag)

class Body(Tag):

def __init__(self):

super().__init__('body', '')

self._body_contents = []

def add_tag(self, name, contents):

new_tag = Tag(name, contents)

self._body_contents.append(new_tag)

def display(self, file=None):

for tag in self._body_contents:

self.contents += str(tag)

super().display(file=file)

class HtmlDoc(object):

# def __init__(self, title=None):

# self._doc_type = DocType()

# self._head = Head(title)

# self._body = Body()

def __init__(self, doc_type, head, body):

self._doc_type = doc_type

self._head = head

self._body = body

def add_tag(self, name, contents):

self._body.add_tag(name, contents)

def display(self, file=None):

self._doc_type.display(file=file)

print('<html>', file=file)

self._head.display(file=file)

self._body.display(file=file)

print('</html>', file=file)

if __name__ == '__main__':

# my_page = HtmlDoc('Demo HTML Doc')

# my_page.add_tag('h1', 'Main heading')

# my_page.add_tag('h2', 'sub-heading')

# my_page.add_tag('p', 'This is a paragraph that will appear on the page')

#

# with open('test.html', 'w') as test_doc:

# my_page.display(file=test_doc)

new_body = Body()

new_body.add_tag('h1', 'Aggregation')

new_body.add_tag('p', "Unlike <strong>composition</strong>, aggregation uses existing instances"

" of objects to build up another object.")

new_body.add_tag('p', "The composed object doesn't actually own the objects that it's composed of"

" - if it's destroyed, those objects continue to exist.")

new_docType = DocType()

new_header = Head('Aggregation document')

my_page = HtmlDoc(new_docType, new_header, new_body)

with open('test3.html', 'w') as test_doc:

my_page.display(file=test_doc)

from player import Player

from enemy import Enemy, Troll, Vampyre, VampyreKing

tim = Player("Tim")

random_monster = Enemy("Basic enemy", 12, 1)

print(random_monster)

ugly_troll = Troll("Pug")

print(f"Ugly troll - {ugly_troll}")

another_troll = Troll("Ug")

print(f"Another troll - {another_troll}")

brother = Troll("Urg")

print(brother)

ugly_troll.grunt()

another_troll.grunt()

brother.grunt()

brother.take_damage(10)

print(brother)

print("---")

big_vamp = Vampyre("Nosferatu")

print(big_vamp)

king_vamp = VampyreKing("Dodo")

print(king_vamp)

while king_vamp._alive:

king_vamp.take_damage(16)

print(king_vamp)

class Player(object):

def __init__(self, name):

self.name = name

self._lives = 3

self._level = 1

self._score = 0

def _get_lives(self):

return self._lives

def _set_lives(self, lives):

if lives >= 0:

self._lives = lives

else:

print("Lives cannot be negative")

self._lives = 0

def _get_level(self):

return self._level

def _set_level(self, level):

if level > 0:

delta = level - self._level

self._score += delta * 1000

self._level = level

else:

print("Level can't be less than 1")

lives = property(_get_lives, _set_lives)

level = property(_get_level, _set_level)

@property

def score(self):

return self._score

@score.setter

def score(self, score):

self._score = score

def __str__(self):

return "Name: {0.name}, Lives: {0.lives}, Level: {0.level}, Score: {0.score}".format(self)

<body><h1>Main heading</h1><h2>sub-heading</h2><p>This is a paragraph that will appear on the page</p></body>