从Python中的另一个程序访问类/方法

我有一个程序（

blackjack.py

），它在代码中访问另一个程序的（

cards.py

和

games.py

）。大部分内容来自一本书，所以我很难理解它是如何工作的

这是

卡的代码。py

：

class Card(object):
    """ A playing card. """
    RANKS = ["A", "2", "3", "4", "5", "6", "7",
             "8", "9", "10", "J", "Q", "K"]
    SUITS = ["c", "d", "h", "s"]
    def __init__(self, rank, suit, face_up = True):
        self.rank = rank
        self.suit = suit
        self.is_face_up = face_up

    def __str__(self):
        if self.is_face_up:
            rep = self.rank + self.suit
        else:
            rep = "XX"
        return rep

    def flip(self):
        self.is_face_up = not self.is_face_up


class Hand(object):
    """ A Hand of playing cards. """
    def __init__(self):
        self.cards = []

    def __str__(self):
        if self.cards:
            rep = ""
            for card in self.cards:
                rep += str(card) + "\t"
        else:
            rep = "<empty>"
        return rep

    def clear(self):
        self.cards = []

    def add(self, card):
        self.cards.append(card)

    def give(self, card, other_hand):
        self.cards.remove(card)
        other_hand.add(card)


class Deck(Hand):
    """ A deck of playing cards. """
    def populate(self):
        for suit in Card.SUITS:
            for rank in Card.RANKS:
                self.add(Card(rank, suit))

    def shuffle(self):
        import random
        random.shuffle(self.cards)

    def deal(self, hands, per_hand = 1):
        for round in range(per_hand):
            for hand in hands:
                if self.cards:
                    top_card = self.cards[0]
                    self.give(top_card, hand)
                else:
                    print "Can't continue deal. Out of cards!"

if __name__ == "__main__":
    print "This is a module with classes for playing cards."
    raw_input("\n\nPress the enter key to exit.")

类卡（对象）：
“一张扑克牌。”
排名=[“A”、“2”、“3”、“4”、“5”、“6”、“7”，
“8”、“9”、“10”、“J”、“Q”、“K”]
西装=[“c”、“d”、“h”、“s”]
定义初始值（自我、等级、西装、面朝上=真）：
self.rank=等级
西服
self.is\u face\u up=面朝上
定义（自我）：
如果self.u面朝上：
代表=自我排名+自我套装
其他：
rep=“XX”
退货代表
def翻转（自我）：
self.is\u face\u up=不self.is\u face\u up
班手（对象）：
“一手扑克牌。”
定义初始化（自）：
self.cards=[]
定义（自我）：
如果是自助卡：
rep=“”
对于self.cards中的卡：
rep+=str（卡片）+“\t”
其他：
rep=“”
退货代表
def清除（自）：
self.cards=[]
def添加（自身、卡）：
self.cards.append（卡片）
def赠送（自己、卡片、另一只手）：
self.cards.remove（卡）
另一手添加（卡片）
舱面（手动）：
“一副扑克牌。”
def填充（自我）：
对于卡片中的套装。套装：
对于Card.RANKS中的等级：
自我添加（卡片（等级、套装））
def随机播放（自）：
随机输入
随机。洗牌（自我。牌）
def交易（自、手、每手=1）：
对于范围内的圆形（每只手）：
手牵手：
如果是自助卡：
顶级卡片=自我卡片[0]
自我给予（顶牌，手牌）
其他：
打印“无法继续交易。卡已用完！”
如果名称=“\uuuuu main\uuuuuuuu”：
print“这是一个包含扑克牌类的模块。”
原始输入（“\n\n按enter键退出”）

我正在为

blackjack.py

编写一个错误检查，我需要收集到目前为止使用过的卡的数量。我想我可以通过访问

cards[]

中的值的数量来做到这一点。问题是，我不知道该怎么做

不过这都是理论上的。我还将包含'blackjack.py'代码，这样你们都可以看到我正在尝试做什么，并帮助我确定我的逻辑是否有缺陷

blackjack.py

---

非常感谢您的任何意见。

虽然我不完全清楚您的预期结构，但您有两个选择

首先，要在

blackjack.py

模块中使用

cards.py

中的任何函数或类，可以使用

import

语句导入它们。这样做有两种方式：

# blackjack.py
import cards

将允许您访问

卡

模块中的所有内容，您可以通过在每个函数/类前面添加

卡来调用它们。

。因此，如果您想初始化

Deck

类的实例

# blackjack.py
import cards
mydeck = cards.Deck()

另一种方法是导入的

，

，它使您无需添加前缀即可访问函数和类。例如：

# blackjack.py
from cards import Deck  # or, to import everything, "from cards import *"
mydeck = Deck()

这两种方法中的任何一种都将为您提供

cards.Deck

类的实例

选项0 您已经可以在

牌组

类中看出这一点，因为它是从

手

中的子类，所以每次

给

一张牌时，它都会从

牌组

的

卡

属性中取出。因此，发放的卡片数量仅为：

class Deck(Hand):
    # ...
    def number_cards_used(self):
         return 52 - len(self.cards)

或者，如果您无法编辑

cards.py

，您只需通过以下方式获取给定

牌组中剩余的牌数：

# blackjack.py
def get_number_cards_used_from_deck(deck):
    return 52 - len(deck.cards)

使用中：

# blackjack.py
import cards
mydeck = cards.Deck()
# ...
# Do other operations with deck
# ...
cards_used = get_number_cards_used_from_deck(mydeck)

选择1
如果您可以隔离所有同时进行的手牌，并且仅限于这些手牌，则可以实现一种方法
卡牌计数
：

class Hand(object):
   # ...
   # other code
   # ....

   def card_count(self):
       return len(self.cards)

然后，如果您有一个所有手的列表，例如，您可以执行以下操作：

sum(map(lambda h: h.card_count(), list_of_hands))

选择2
在你的
Deck
类中，由于它是
Hand
的子类，你可以简单地保留另一个已经发出的卡片的运行列表，这些卡片经常会被刷新。这看起来像：

class Deck(Hand):
    # ...
    # other code
    # ...

    def __init__(self):
        self.populate()
        self.used_cards = []

    def give(self, card, other_hand):
        self.used_cards.append(card)
        super(Deck, self).give(card, other_hand)

    def number_cards_used(self):
        return len(self.used_cards)

当然还有其他的方法。
有没有办法在不添加到
卡的情况下执行此操作。py
？我也想到了类似的事情。我想这就是我应该做的。我在问如何使用我在
cards.py
和
blackjack.py
中所拥有的来收集剩余/正在使用的卡片数量。我不知道如何访问
cards.py
文件，并且认为通过访问它，我可以以某种方式获得剩余的卡数。我可以吗？我不知道你说的“访问”
cards.py
是什么意思。您不必编辑
cards.py
就可以使用选项0——给定在变量
mydeck
中初始化的
Deck（）
，您可以随时执行
52-len（mydeck.cards）
以了解使用了多少张卡。这就是你的意思吗？嗯，这意味着，
myDeck.cards
现在根本没有卡。这是因为当您刚刚执行
myDeck=cards.Deck（）
时，
Deck
类从
self.cards=[]
开始。您必须执行
myDeck=cards.Deck（）
，然后调用方法
myDeck.populate（）
，以便实际使用所有卡片填充
myDeck.cards
。如果您这样做，然后尝试调用
get\u num\u cards（myDeck）
，您可能会发现它返回
0
，但不会返回。当您实例化一个类时，实例化时会调用
\uuuu init\uuuu
方法，但是您在
cards.py
中提供的
Deck
类没有
\uuu init\uuuu
方法。如果您查看我提供的选项2，您将看到我创建了一个
\uuuu init\uuuu