Programming using Python Filename: cards.py In this program, you will create functions that use lists to create, shuffle, and deal cards to a number up to 4 “hands”. The standard deck of playing cards contains 52 cards. Each card has one of four suits along with a value. Suits are normally spades, hearts, diamonds and clubs. The values are 2 through 10, Jack, Queen, King and Ace (we will ignore the “Joker”). Each card will be represented using two characters in a string. The first character is the value of the card, with 2 through 9 represented directly. The other cars with letters: “T”, “J”, “Q”, “K”, and “A” represent the values 10, Jack, Queen, King, and Ace respectively. The second character in the string represents the suit of the card. These are: “s” for spades, “h” for hearts, “d” for diamonds, and “c” for clubs. Here’s an example: In addition to any other functions you decide to write, you MUST provide the following functions that we can run with our test suite. The names, return type and parameter types must match (of course, you can name the parameters anything you wish). Note: You are NOT providing a test suite. Make sure your function names & argument types match the descriptions below. create_deck(): Creates a deck of 52 cards using the abbreviations outlined in the requirements. Input parameters: None. Return value: a list of cards, not shuffled. If we specified this with Python annotations, the signature would be: create_deck() -> list: shuffle(cards): Shuffles the 52 cards in a new list, such that the list of cards is ordered randomly, while leaving the original list of 52 cards unchanged. Shuffle returns the “shuffled deck” to the caller. Input parameters: a list of cards, not shuffled. Return value: a list of cards, shuffled. The original list is not modified (aka “mutated”) If we specified this with Python annotations, the signature would be: shuffle(cards : list) -> list: deal(number_of_hands, number_of_cards, cards): Takes the number of hands (players) (up to 4), number of cards per hand/player (up to 13), and the deck of cards to deal from. Your function should return a list containing all of the hands that were dealt. Each hand will be a represented as a list of cards. Therefore, this function will return a list of lists. As a side-effect, the cards dealt should be removed from deck passed as an input parameter to this function. Input parameters: number of hands -> int, number of cards -> int, cards -> list. *** Note: It's perfectly fine to rename the "hands" parameter to "players" if you wish to, especially if that makes it more clear to you *** Return value: a list of hands/players, where each hand is itself a list of cards dealt for a player. If we specified this with Python annotations, the signature would be: deal(number_of_hands : int, number_of_cards : int, cards : list) -> list: For this function, assume PRECONDITION: number of cards has been pre-validated, values allowed: 0..13; number of hands has been pre-validated, values allowed: 1..4 Also keep in mind that deal() returns a nested list, not a single list! Example tests we might run with your functions: (in photo attached named "exampleofcards")

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

Programming using Python

  • Filename: cards.py

In this program, you will create functions that use lists to create, shuffle, and deal cards to a number up to 4 “hands”.

The standard deck of playing cards contains 52 cards. Each card has one of four suits along with a value. Suits are normally spades, hearts, diamonds and clubs. The values are 2 through 10, Jack, Queen, King and Ace (we will ignore the “Joker”).

Each card will be represented using two characters in a string. The first character is the value of the card, with 2 through 9 represented directly. The other cars with letters: “T”, “J”, “Q”, “K”, and “A” represent the values 10, Jack, Queen, King, and Ace respectively.

The second character in the string represents the suit of the card. These are: “s” for spades, “h” for hearts, “d” for diamonds, and “c” for clubs.

Here’s an example:

In addition to any other functions you decide to write, you MUST provide the following functions that we can run with our test suite. The names, return type and parameter types must match (of course, you can name the parameters anything you wish).
Note: You are NOT providing a test suite.

Make sure your function names & argument types match the descriptions below.

  • create_deck(): Creates a deck of 52 cards using the abbreviations outlined in the requirements.
    Input parameters: None. Return value: a list of cards, not shuffled.
    If we specified this with Python annotations, the signature would be: create_deck() -> list:
  • shuffle(cards): Shuffles the 52 cards in a new list, such that the list of cards is ordered randomly, while leaving the original list of 52 cards unchanged. Shuffle returns the “shuffled deck” to the caller.
    Input parameters: a list of cards, not shuffled. Return value: a list of cards, shuffled. The original list is not modified (aka “mutated”)
    If we specified this with Python annotations, the signature would be: shuffle(cards : list) -> list:
  • deal(number_of_hands, number_of_cards, cards): Takes the number of hands (players) (up to 4), number of cards per hand/player (up to 13), and the deck of cards to deal from. Your function should return a list containing all of the hands that were dealt. Each hand will be a represented as a list of cards. Therefore, this function will return a list of lists. As a side-effect, the cards dealt should be removed from deck passed as an input parameter to this function.
    Input parameters: number of hands -> int, number of cards -> int, cards -> list.
    *** Note: It's perfectly fine to rename the "hands" parameter to "players" if you wish to, especially if that makes it more clear to you ***
    Return value: a list of hands/players, where each hand is itself a list of cards dealt for a player.
    If we specified this with Python annotations, the signature would be:
    deal(number_of_hands : int, number_of_cards : int, cards : list) -> list:
    For this function, assume PRECONDITION:
    number of cards has been pre-validated, values allowed: 0..13;
    number of hands has been pre-validated, values allowed: 1..4

Also keep in mind that deal() returns a nested list, not a single list!

Example tests we might run with your functions:

(in photo attached named "exampleofcards") 

**Original deck:**
```
['2s', '3s', '4s', '5s', '6s', '7s', '8s', '9s', 'Ts', 'Js', 'Qs', 'Ks', 'As', 
 '2h', '3h', '4h', '5h', '6h', '7h', '8h', '9h', 'Th', 'Jh', 'Qh', 'Kh', 'Ah', 
 '2d', '3d', '4d', '5d', '6d', '7d', '8d', '9d', 'Td', 'Jd', 'Qd', 'Kd', 'Ad', 
 '2c', '3c', '4c', '5c', '6c', '7c', '8c', '9c', 'Tc', 'Jc', 'Qc', 'Kc', 'Ac']
```

**The shuffled deck:**
```
['4d', '3s', '4s', '5s', '6s', '7s', '8s', '9s', 'Ts', 'Js', 'Qs', 'Ks', 'As', 
 '2h', '3h', '4h', '5h', '6h', '7h', '8h', '9h', 'Th', 'Jh', 'Qh', 'Kh', 'Ah', 
 '2d', '3d', '2s', '5d', '6d', '7d', '8d', '9d', 'Td', 'Jd', 'Qd', 'Kd', 'Ad', 
 '2c', '3c', '4c', '5c', '6c', '7c', '8c', '9c', 'Tc', 'Jc', 'Qc', 'Kc', 'Ac']
```

**Dealt one round of 4 players:**
```
[['4d', '6s'], ['3s', '7s'], ['4s', '8s'], ['5s', '9s']]
```

**Cards left in deck:**
```
['Ts', 'Js', 'Qs', 'Ks', 'As', '2h', '3h', '4h', '5h', '6
Transcribed Image Text:**Original deck:** ``` ['2s', '3s', '4s', '5s', '6s', '7s', '8s', '9s', 'Ts', 'Js', 'Qs', 'Ks', 'As', '2h', '3h', '4h', '5h', '6h', '7h', '8h', '9h', 'Th', 'Jh', 'Qh', 'Kh', 'Ah', '2d', '3d', '4d', '5d', '6d', '7d', '8d', '9d', 'Td', 'Jd', 'Qd', 'Kd', 'Ad', '2c', '3c', '4c', '5c', '6c', '7c', '8c', '9c', 'Tc', 'Jc', 'Qc', 'Kc', 'Ac'] ``` **The shuffled deck:** ``` ['4d', '3s', '4s', '5s', '6s', '7s', '8s', '9s', 'Ts', 'Js', 'Qs', 'Ks', 'As', '2h', '3h', '4h', '5h', '6h', '7h', '8h', '9h', 'Th', 'Jh', 'Qh', 'Kh', 'Ah', '2d', '3d', '2s', '5d', '6d', '7d', '8d', '9d', 'Td', 'Jd', 'Qd', 'Kd', 'Ad', '2c', '3c', '4c', '5c', '6c', '7c', '8c', '9c', 'Tc', 'Jc', 'Qc', 'Kc', 'Ac'] ``` **Dealt one round of 4 players:** ``` [['4d', '6s'], ['3s', '7s'], ['4s', '8s'], ['5s', '9s']] ``` **Cards left in deck:** ``` ['Ts', 'Js', 'Qs', 'Ks', 'As', '2h', '3h', '4h', '5h', '6
**Playing Card Abbreviations**

In this guide, we will explore the common abbreviations used for various playing cards. Understanding these abbreviations can be helpful in many card games and related scenarios.

| Card              | Abbreviation |
|-------------------|--------------|
| Jack of spades    | Js           |
| Two of clubs      | 2c           |
| Ten of diamonds   | Td           |
| Ace of hearts     | Ah           |
| Nine of spades    | 9s           |

Each abbreviation consists of the rank of the card followed by the initial of the suit. For example, the "Jack of spades" is abbreviated as "Js", where 'J' stands for Jack and 's' stands for spades. Similarly, this pattern is followed for other cards like "Two of clubs" as "2c" and so forth.
Transcribed Image Text:**Playing Card Abbreviations** In this guide, we will explore the common abbreviations used for various playing cards. Understanding these abbreviations can be helpful in many card games and related scenarios. | Card | Abbreviation | |-------------------|--------------| | Jack of spades | Js | | Two of clubs | 2c | | Ten of diamonds | Td | | Ace of hearts | Ah | | Nine of spades | 9s | Each abbreviation consists of the rank of the card followed by the initial of the suit. For example, the "Jack of spades" is abbreviated as "Js", where 'J' stands for Jack and 's' stands for spades. Similarly, this pattern is followed for other cards like "Two of clubs" as "2c" and so forth.
Expert Solution
trending now

Trending now

This is a popular solution!

steps

Step by step

Solved in 2 steps with 4 images

Blurred answer
Similar questions
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education