Bank Account Code with Multiple Accounts

We will again use the BankAccount class from the previous problem. You should be able to use the same definition for both problems.

Of course, a bank with only one account will go out of business, so we want our BankAccount class to work correctly with many accounts. Naturally, each bank account should have its own balance, with deposits and withdrawals going to the appropriate account. Similarly, the penalty fees for each account should be kept separate.

class BankAccount:
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        …
    def deposit(self, amount):
        """Deposits the amount into the account."""
        …
    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
        …
    def get_balance(self):
        """Returns the current balance in the account."""
        …
    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        …

Here's one possible test with multiple accounts. It should print the values 10, 5, 5, and 0.

account1 = BankAccount(10)
account1.withdraw(15)
account2 = BankAccount(15)
account2.deposit(10)
account1.deposit(20)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()

Copy-and-paste the following much longer test. What four numbers are printed at the end? Enter the four numbers, separated only by spaces.

account1 = BankAccount(20)
account1.deposit(10)
account2 = BankAccount(10)
account2.deposit(10)
account2.withdraw(50)
account1.withdraw(15)
account1.withdraw(10)
account2.deposit(30)
account2.withdraw(15)
account1.deposit(5)
account1.withdraw(10)
account2.withdraw(10)
account2.deposit(25)
account2.withdraw(15)
account1.deposit(10)
account1.withdraw(50)
account2.deposit(25)
account2.deposit(25)
account1.deposit(30)
account2.deposit(10)
account1.withdraw(15)
account2.withdraw(10)
account1.withdraw(10)
account2.deposit(15)
account2.deposit(10)
account2.withdraw(15)
account1.deposit(15)
account1.withdraw(20)
account2.withdraw(10)
account2.deposit(5)
account2.withdraw(10)
account1.deposit(10)
account1.deposit(20)
account2.withdraw(10)
account2.deposit(5)
account1.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account2.deposit(10)
account2.deposit(15)
account2.deposit(20)
account1.withdraw(15)
account2.deposit(10)
account1.deposit(25)
account1.deposit(15)
account1.deposit(10)
account1.withdraw(10)
account1.deposit(10)
account2.deposit(20)
account2.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account1.deposit(10)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()

CODE :

# http://www.codeskulptor.org/#user25_e4TY2qlXm9gkKEk.py
class BankAccount: 
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        self.money = initial_balance 
        self.penalty = 0
    
    def deposit(self, amount):
        """Deposits the amount into the account."""
        self.money += amount
        return self.money

    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
       
        if self.money - amount < 0:
            self.money -= amount+5
            self.penalty += 5
            
        else:
            self.money -= amount
        return self.money


    def get_balance(self):
        """Returns the current balance in the account."""
        return self.money

    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        return self.penalty

account1 = BankAccount(10)
account1.withdraw(15)
account2 = BankAccount(15)
account2.deposit(10)
account1.deposit(20)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()
print"..............."
account1 = BankAccount(20)
account1.deposit(10)
account2 = BankAccount(10)
account2.deposit(10)
account2.withdraw(50)
account1.withdraw(15)
account1.withdraw(10)
account2.deposit(30)
account2.withdraw(15)
account1.deposit(5)
account1.withdraw(10)
account2.withdraw(10)
account2.deposit(25)
account2.withdraw(15)
account1.deposit(10)
account1.withdraw(50)
account2.deposit(25)
account2.deposit(25)
account1.deposit(30)
account2.deposit(10)
account1.withdraw(15)
account2.withdraw(10)
account1.withdraw(10)
account2.deposit(15)
account2.deposit(10)
account2.withdraw(15)
account1.deposit(15)
account1.withdraw(20)
account2.withdraw(10)
account2.deposit(5)
account2.withdraw(10)
account1.deposit(10)
account1.deposit(20)
account2.withdraw(10)
account2.deposit(5)
account1.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account2.deposit(10)
account2.deposit(15)
account2.deposit(20)
account1.withdraw(15)
account2.deposit(10)
account1.deposit(25)
account1.deposit(15)
account1.deposit(10)
account1.withdraw(10)
account1.deposit(10)
account2.deposit(20)
account2.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account1.deposit(10)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()
print"..............."

OUTPUT :

10 5 5 0
...............
-55 45 45 20
...............

Bank Account

First, complete the following class definition:

class BankAccount:
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        …
    def deposit(self, amount):
        """Deposits the amount into the account."""
        …
    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
        …
    def get_balance(self):
        """Returns the current balance in the account."""
        …
    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        …

The deposit and withdraw methods each change the account balance. The withdraw method also deducts a fee of 5 dollars from the balance if the withdrawal (before any fees) results in a negative balance. Since we also have the method get_fees, you will need to have a variable to keep track of the fees paid.

Here's one possible test of the class. It should print the values 10 and 5, respectively, since the withdrawal incurs a fee of 5 dollars.

my_account = BankAccount(10)
my_account.withdraw(15)
my_account.deposit(20)
print my_account.get_balance(), my_account.get_fees()

Copy-and-paste the following much longer test. What two numbers are printed at the end? Enter the two numbers, separated only by spaces.

my_account = BankAccount(10)
my_account.withdraw(5)
my_account.deposit(10)
my_account.withdraw(5)
my_account.withdraw(15)
my_account.deposit(20)
my_account.withdraw(5) 
my_account.deposit(10)
my_account.deposit(20)
my_account.withdraw(15)
my_account.deposit(30)
my_account.withdraw(10)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(50) 
my_account.deposit(30)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.deposit(20)
my_account.withdraw(15)
my_account.deposit(10)
my_account.deposit(30)
my_account.withdraw(25) 
my_account.withdraw(5)
my_account.deposit(10)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(10) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.deposit(30)
my_account.withdraw(25) 
my_account.withdraw(10)
my_account.deposit(20)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
print my_account.get_balance(), my_account.get_fees()

CODE :

# http://www.codeskulptor.org/#user25_wvi8CqCpEVvhzVa.py

class BankAccount: 

    def __init__(self, initial_balance):

        """Creates an account with the given balance."""

        self.money = initial_balance 

        self.penalty = 0

    

    def deposit(self, amount):

        """Deposits the amount into the account."""

        self.money += amount

        return self.money

    def withdraw(self, amount):

        """

        Withdraws the amount from the account.  Each withdrawal resulting in a

        negative balance also deducts a penalty fee of 5 dollars from the balance.

        """

       

        if self.money - amount < 0:

            self.money -= amount+5

            self.penalty += 5

            

        else:

            self.money -= amount

        return self.money

    def get_balance(self):

        """Returns the current balance in the account."""

        return self.money

    def get_fees(self):

        """Returns the total fees ever deducted from the account."""

        return self.penalty

my_account = BankAccount(10)

my_account.withdraw(15)

my_account.deposit(20)

print my_account.get_balance(), my_account.get_fees()

print "....."

my_account = BankAccount(10)

my_account.withdraw(5)

my_account.deposit(10)

my_account.withdraw(5)

my_account.withdraw(15)

my_account.deposit(20)

my_account.withdraw(5) 

my_account.deposit(10)

my_account.deposit(20)

my_account.withdraw(15)

my_account.deposit(30)

my_account.withdraw(10)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(50) 

my_account.deposit(30)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.deposit(20)

my_account.withdraw(15)

my_account.deposit(10)

my_account.deposit(30)

my_account.withdraw(25) 

my_account.withdraw(5)

my_account.deposit(10)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(10) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.deposit(30)

my_account.withdraw(25) 

my_account.withdraw(10)

my_account.deposit(20)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

print my_account.get_balance(), my_account.get_fees()

print "....."

OUTPUT :

10 5
......
-60 75
......

Enter the first year when the fast wumpuses outnumber the slow wumpuses

We can use loops to simulate natural processes over time. Write a program that calculates the populations of two kinds of “wumpuses” over time. At the beginning of year 1, there are 1000 slow wumpuses and 1 fast wumpus. This one fast wumpus is a new mutation. Not surprisingly, being fast gives it an advantage, as it can better escape from predators. Each year, each wumpus has one offspring. (We'll ignore the more realistic niceties of sexual reproduction, like distinguishing males and females.). There are no further mutations, so slow wumpuses beget slow wumpuses, and fast wumpuses beget fast wumpuses. Also, each year 40% of all slow wumpuses die each year, while only 30% of the fast wumpuses do.

So, at the beginning of year one there are 1000 slow wumpuses. Another 1000 slow wumpuses are born. But, 40% of these 2000 slow wumpuses die, leaving a total of 1200 at the end of year one. Meanwhile, in the same year, we begin with 1 fast wumpus, 1 more is born, and 30% of these die, leaving 1.4. (We'll also allow fractional populations, for simplicity.)

Beginning of Year	Slow Wumpuses	Fast Wumpuses
1	1000	1
2	1200	1.4
3	1440	1.96
…	…	…

Enter the first year in which the fast wumpuses outnumber the slow wumpuses. Remember that the table above shows the populations at the start of the year.

CODE: 
# http://www.codeskulptor.org/#user25_kGSRR7OF76rhSba.py

slow_wumpuses, fast_wumpuses = 1000, 1

years=0

while slow_wumpuses > fast_wumpuses:

    slow_wumpuses *=.6*2

    fast_wumpuses *=.7*2

    years+=1

print "First year when the fast wumpuses outnumber the slow wumpuses : ", years

Output :

First year when the fast wumpuses outnumber the slow wumpuses :  45

Convert English description into code

Convert the following English description into code.

1. Initialize n to be 1000. Initialize numbers to be a list of numbers from 2 to n, but not including n.
2. With results starting as the empty list, repeat the following as long as numbers contains any numbers.
   • Add the first number in numbers to the end of results.
   • Remove every number in numbers that is evenly divisible by (has no remainder when divided by) the number that you had just added toresults.

How long is results?

To test your code, when n is instead 100, the length of results is 25.

CODE :

n = 1000

numbers = range(2, n)

results = []

 while numbers != []:

    results.append(numbers[0])

    numbers = [n for n in numbers if n % numbers[0] != 0]

 print len(results)

# http://www.codeskulptor.org/#user25_2ekzalIuBzMYYnj.py

Output :

168

Mini-project # 5: Memory - Card Game

Mini-project development process

As usual, we suggest that you start from the program template for this mini-project.

1. Model the deck of cards used in Memory as a list consisting of 16 numbers with each number lying in the range [0,8) and appearing twice. We suggest that you create this list by concatenating two list with range [0,8) together. Use the Docs to locate the list concatenation operator.
2. Write a draw handler that iterates through the Memory deck using a for loop and uses draw_text to draw the number associated with each card on the canvas. The result should be a horizontal sequence of evenly-spaced numbers drawn on the canvas.
3. Shuffle the deck using random.shuffle(). Remember to debug your canvas drawing code before shuffling to make debugging easier.
4. Next, modify the draw handler to either draw a blank green rectangle or the card's value. To implement this behavior, we suggest that you create a second list called exposed. In the exposed list, the ith entry should be True if the ith card is face up and its value is visible or False if the ith card is face down and it's value is hidden. We suggest that you initialize exposed to some known values while testing your drawing code with this modification.
5. Now, add functionality to determine which card you have clicked on with your mouse. Add an event handler for mouse clicks that takes the position of the mouse click and prints the index of the card that you have clicked on to the console. To make determining which card you have clicked on easy, we suggest sizing the canvas so that the sequence of cards entirely fills the canvas.
6. Modify the event handler for mouse clicks to flip cards based on the location of the mouse click. If the player clicked on the ith card, you can change the value of exposed[i] from False to True. If the card is already exposed, you should ignore the mouseclick. At this point, the basic infrastructure for Memory is done.
7. You now need to add game logic to the mouse click handler for selecting two cards and determining if they match. We suggest following the game logic in the example code discussed in the Memory video. State 0 corresponds to the start of the game. In state 0, if you click on a card, that card is exposed, and you switch to state 1. State 1 corresponds to a single exposed unpaired card. In state 1, if you click on an unexposed card, that card is exposed and you switch to state 2. State 2 corresponds to the end of a turn. In state 2, if you click on an unexposed card, that card is exposed and you switch to state 1.
8. Note that in state 2, you also have to determine if the previous two cards are paired or unpaired. If they are unpaired, you have to flip them back over so that they are hidden before moving to state 1. We suggest that you use two global variables to store the index of each of the two cards that were clicked in the previous turn.
9. Add a counter that keeps track of the number of turns and uses set_text to update this counter as a label in the control panel. (BTW, Joe's record is 12 turns.)  This counter should be incremented after either the first or second card is flipped during a turn.
10. Finally, implement the new_game() function (if you have not already) so that the "Reset" button reshuffles the cards, resets the turn counter and restarts the game. All cards should start the game hidden.
11. (Optional) You may replace the draw_text for each card by a draw_image that uses one of eight different images.

Once the run button is clicked in CodeSkulptor, the game should start. You should not have to hit the "Reset" button to start. Once the game is over, you should hit the "Reset" button to restart the game. 

While this project may seem daunting at first glance, our full implementation took well under 100 lines with comments and spaces. If you feel a little bit intimidated, focus on developing your project to step six. Our experience is that, at this point, you will begin to see your game come together and the going will get much easier.

CODE :

# http://www.codeskulptor.org/#user24_KgfZC5P5oSvoRU9.py

# mini-project #5 : Card game - Memory

import simplegui

import random

turns=0

# helper function to initialize globals

def new_game():

    global listOfCards,exposed,openedCard,clickCounter,turns

    listOfCards=[i for i in range(8)]+[i for i in range(8)]

    random.shuffle(listOfCards)

    exposed=[False for i in range(16)]

    openedCard=[]

    clickCounter=0

    turns=0

   

# define event handlers

def mouseclick(pos):

    global clickCounter,turns

    if clickCounter==0:

        openedCard.append(pos[0]//50)

        exposed[pos[0]//50]=True

        clickCounter+=1

        turns=1

        

    elif clickCounter==1:

        if not (pos[0]//50 in openedCard):

            openedCard.append(pos[0]//50)

            clickCounter+=1

        exposed[pos[0]//50]=True

       

    else:

        if not (pos[0]//50 in openedCard):

            if listOfCards[openedCard[-1]]!=listOfCards[openedCard[-2]]:

                exposed[openedCard[-1]]=False

                exposed[openedCard[-2]]=False

                openedCard.pop()

                openedCard.pop()

            clickCounter=1

            turns+=1

            exposed[pos[0]//50]=True

            openedCard.append(pos[0]//50)

                        

# cards are logically 50x100 pixels in size    

def draw(canvas):

        label.set_text("Turns = "+str(turns))

        for i in range(16):

            canvas.draw_line([50*(i%15+1),0], [50*(i%15+1),100], 2, "Green")

            if exposed[i]:

                canvas.draw_text(str(listOfCards[i]), [15+50*i,70], 40, "White")

         

# create frame and add a button and labels

frame = simplegui.create_frame("Memory", 800, 100)

frame.add_button("Restart", new_game) 

label=frame.add_label("Turns = 0")

# register event handlers

frame.set_mouseclick_handler(mouseclick)

frame.set_draw_handler(draw)

# get things rolling

new_game()

frame.start()

Output :

Game- Pong!

Mini-project #4 - "Pong"

In this project, we will build a version of Pong, one of the first arcade video games (1972). While Pong is not particularly exciting compared to today's video games, Pong is relatively simple to build and provides a nice opportunity to work on the skills that you will need to build a game like Asteroids. As usual, we have provided a program template that can be used to guide your development of Pong.

Mini-project development process

1. Add code to the program template that draws a ball moving across the Pong table. We recommend that you add the positional update for the ball to the draw handler as shown in the second part of the "Motion" video.
2. Add code to the function spawn_ball that spawns a ball in the middle of the table and assigns the ball a fixed velocity (for now). Ignore the parameter direction at this point.
3. Add a call to spawn_ball in the function new_game which starts a game of Pong. Note that the program templates includes an initial call to new_game in the main body of your program to get a game going immediately.
4. Modify your code such that the ball collides with and bounces off of the top and bottom walls. Experiment with different hard-coded initial velocities to test your code.
5. Add randomization to the velocity in spawn_ball(direction) The velocity of the ball should be upwards and towards the right ifdirection == RIGHT and upwards and towards the left if direction == LEFT. The exact values for the horizontal and vertical components of this velocity should be generated using random.randrange(). For the horizontal velocity, we suggest a speed of aroundrandom.randrange(120, 240) pixels per second. For the vertical velocity, we suggest a speed of around random.randrange(60, 180)pixels per second. (You will need to set the signs of velocities appropriately.)
6. Add code to the draw handler that tests whether the ball touches/collides with the left and right gutters. (Remember that the gutters are offset from the left and right edges of the canvas by the width of the paddle as described in the "Pong" video.) When the ball touches a gutter, use either spawn_ball(LEFT) or spawn_ball(RIGHT) to respawn the ball in the center of the table headed towards the opposite gutter.
7. Next, add code that draws the left and right paddles in their respective gutters. The vertical positions of these two paddles should depend on two global variables. (In the template, the variables were paddle1_pos and paddle2_pos.)
8. Add code that modifies the values of these vertical positions via an update in the draw handler.  The update should reference two global variables that contain the vertical velocities of the paddles. (In the template, the variables were paddle1_vel and paddle2_vel.)
9. Update the values of these two vertical velocities using key handlers. The "w" and "s" keys should control the vertical velocity of the left paddle while the "Up arrow" and "Down arrow" key should control the velocity of the right paddle. In our version of Pong, the left paddle moves up at a constant velocity if the "w" key is pressed and moves down at a constant velocity if the "s" is pressed and is motionless if neither is pressed. (The motion if both are pressed is up to you.) To achieve this effect, you will need to use both a keydown and a keyup handler to increase/decrease the vertical velocity in an appropriate manner.
10. Restrict your paddles to stay entirely on the canvas by adding a check before you update the paddles' vertical positions in the draw handler. In particular, test whether the current update for a paddle's position will move part of the paddle off of the screen. If it does, don't allow the update.
11. Modify your collision code for the left and right gutters in step 6 to check whether the ball is actually striking a paddle when it touches a gutter. If so, reflect the ball back into play. This collision model eliminates the possibility of the ball striking the edge of the paddle and greatly simplifies your collision/reflection code.
12. To moderately increase the difficulty of your game, increase the velocity of the ball by 10% each time it strikes a paddle.
13. Add scoring to the game as shown in the Pong video lecture. Each time the ball strikes the left or right gutter (but not a paddle), the opposite player receives a point and ball is respawned appropriately.
14. Finally, add code to new_game which resets the score before calling spawn_ball. Add a "Restart" button that calls new_game to reset the score and relaunch the ball.

CODE :

#http://www.codeskulptor.org/#user23_ldEIrucvzpFeobZ.py

#Mini-Project 4 : PONG

import simplegui

import random

# initialize globals - pos and vel encode vertical info for paddles

WIDTH = 600

HEIGHT = 400       

BALL_RADIUS = 20

PAD_WIDTH = 8

PAD_HEIGHT = 80

HALF_PAD_WIDTH = PAD_WIDTH / 2

HALF_PAD_HEIGHT = PAD_HEIGHT / 2

# helper function that spawns a ball by updating the 

# ball's position vector and velocity vector

# if right is True, the ball's velocity is upper right, else upper left

def ball_init(right):

    global ball_pos, ball_vel # these are vectors stored as lists

    

    ball_pos,ball_vel= [0, 0], [0, 0]

         

    if right == True:

        ball_pos = [WIDTH / 2, HEIGHT / 2]

        ball_vel = [random.randrange(2, 4), -random.randrange(1, 3)]

    if right == False:

        ball_pos = [WIDTH / 2, HEIGHT / 2]

        ball_vel = [-random.randrange(2, 4), -random.randrange(1, 3)]

# define event handlers

def new_game():

    global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel  # these are floats

    global score1, score2  # these are ints

    global score1_string, score2_string

    score1_string = "0"

    score2_string = "0"

    

    paddle1_pos = [PAD_WIDTH / 2, HEIGHT / 2]

    paddle2_pos = [WIDTH - PAD_WIDTH / 2, HEIGHT / 2]

    paddle1_vel, paddle2_vel, score1, score2 = 0, 0, 0, 0

    ball_init(True)

# limit keeps the paddle on the screen

def limit():

    global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel

   

    # check for paddle 1

    if paddle1_pos[1] < HALF_PAD_HEIGHT:

       paddle1_pos[1] = HALF_PAD_HEIGHT

       paddle1_vel = 0

    elif paddle1_pos[1] > HEIGHT - HALF_PAD_HEIGHT:

       paddle1_pos[1] = HEIGHT - HALF_PAD_HEIGHT

       paddle1_vel = 0

     

    # check for paddle 2    

    if paddle2_pos[1] < HALF_PAD_HEIGHT:

       paddle2_pos[1] = HALF_PAD_HEIGHT

       paddle2_vel = 0

    elif paddle2_pos[1] > HEIGHT - HALF_PAD_HEIGHT:

       paddle2_pos[1] = HEIGHT - HALF_PAD_HEIGHT

       paddle2_vel = 0

    

def draw(c):

    global score1, score2, paddle1_pos, paddle2_pos, ball_pos, ball_vel

    global score1_string, score2_string

    # update paddle's vertical position, keep paddle on the screen

    limit()

    paddle1_pos[1] += paddle1_vel 

    paddle2_pos[1] += paddle2_vel

    

    # draw mid line and gutters

    c.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 1, "White")

    c.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "White")

    c.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "White")

    

    # draw paddles

    # paddle 1

    pad1top =  [paddle1_pos[0], paddle1_pos[1] - HALF_PAD_HEIGHT]

    pad1bot =  [paddle1_pos[0], paddle1_pos[1] + HALF_PAD_HEIGHT]

    c.draw_line(pad1top, pad1bot, PAD_WIDTH, "White")

    # paddle 2

    pad2top =  [paddle2_pos[0], paddle2_pos[1] - HALF_PAD_HEIGHT]

    pad2bot =  [paddle2_pos[0], paddle2_pos[1] + HALF_PAD_HEIGHT]

    c.draw_line(pad2top, pad2bot, PAD_WIDTH, "White")

     

    # update ball

    ball_pos[0] += ball_vel[0]

    ball_pos[1] += ball_vel[1]

    

    

    # collide and reflect off of left hand side of canvas

    # y directions

    if ball_pos[1] <= BALL_RADIUS:

        ball_vel[1] = - ball_vel[1]

    if ball_pos[1] > (HEIGHT - 1 - BALL_RADIUS):

        ball_vel[1] = - ball_vel[1]

    # x directions

    # paddle1

    if ball_pos[0] <= PAD_WIDTH + BALL_RADIUS:

        if ( pad1top[1] <= ball_pos[1] <= pad1bot[1] ):

            ball_vel[0] = - ball_vel[0] * 1.1

        else:

            ball_init(1)

            score2 += 1

            score2_string = str(score2) 

            

    # paddle2

    if ball_pos[0] >= WIDTH - PAD_WIDTH - BALL_RADIUS:

        if ( pad2top[1] <= ball_pos[1] <= pad2bot[1] ):

            ball_vel[0] = - ball_vel[0] * 1.1

        else:

            ball_init(0)

            score1 += 1

            score1_string = str(score1) 

       

    # draw ball and scores

    c.draw_circle(ball_pos, BALL_RADIUS, 1, "White", "White")

    c.draw_text(score2_string, (450, 50), 36, "White")

    c.draw_text(score1_string, (150, 50), 36, "White")

        

def keydown(key):

    acc = 1

    global paddle1_vel, paddle2_vel

    if key==simplegui.KEY_MAP["s"]:

        paddle1_vel += acc

    if key==simplegui.KEY_MAP["down"]:

        paddle2_vel += acc

   

def keyup(key):

    acc = 1

    global paddle1_vel, paddle2_vel

    if key==simplegui.KEY_MAP["w"]:

        paddle1_vel -= acc

    if key==simplegui.KEY_MAP["up"]:

        paddle2_vel -= acc

def restart():

    new_game()

def exit():

    frame.stop()

# create frame

frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)

frame.set_draw_handler(draw)

frame.set_keydown_handler(keydown)

frame.set_keyup_handler(keyup)

frame.add_button("Restart", restart, 100)

frame.add_button("Exit ",exit,100)

# start frame

frame.start()

new_game()

Output :