如何从父实例调用子类中的方法？

Question

How do I create an instance of Stats and call a method on in GameStats ? Like below:

class Stats():

    """Object to instansiate a league and season pair 
    Args:
        league(str): league_id
        season(str): season_id
    """
    fb = Football()
    dir = Directory()
    def __init__(self, league='EN_PR', season='2019/2020'):
        self.pool = multiprocessing.cpu_count()
        self.league = league
        self.season = season

    def load_season_fixture(self):
        """Loads the fixtures for a league-season,
        calls api_scraper.py methods
        """
        self.fb.load_leagues()
        self.fb.leagues[self.league].load_seasons()
        return self.fb.leagues[self.league].seasons[self.season].load_played_fixtures()

    def load_season_players(self):
        """Loads the players for a league-season,
        calls api_scraper.py methods
        """
        player_id = []
        self.fb.load_leagues()
        self.fb.leagues[self.league].load_seasons()
        teams = self.fb.leagues[self.league].seasons[self.season].load_teams()
        for team in tqdm(teams.values()):
            players = self.fb.leagues[self.league].seasons['2019/2020'].teams[team['shortName']].load_players()
        for player in players.keys():
            player_id.append(player)
        return player_id

    def load_season_teams(self):
        """Loads the teams for a league-season,
        calls api_scraper.py methods
        """
        player_id = []
        self.fb.load_leagues()
        self.fb.leagues[self.league].load_seasons()
        return self.fb.leagues[self.league].seasons[self.season].load_teams()

class GameStats(Stats):
    def __init__(self, *args, **kwargs):
        super().__init__()
        self.fixture_id = [fix['id'] for fix in self.load_season_fixture().values()]

    def fixture_stats_singel(self, fixture):
        """Gets stats for a fixture"""
        ds = load_match_data(f'https://footballapi.pulselive.com/football/stats/match/{fixture}')
        return ds

    def fixture_stats(self):
        """Gets stats for all fixtures in a league-season using multithreading
        saves output in a json file.

        """
        stats = {}
        with Pool(self.pool) as p:
            fixture_stats = list(tqdm(p.imap(self.fixture_stats_singel, self.fixture_id, chunksize=1), total=len(self.fixture_id)))
        i = 0
        for fixture in fixture_stats:
            game_id = fixture['entity']['id'] #Get's the gameIDs for each game
            index = game_id #Set's gameIDs as index for dictionairy
            stats[index] = {'info': fixture['entity']}

        print(f'Saved as {filename}.json in {path}')

class PlayerStats(Stats):
    def __init__(self, *args, **kwargs):
        super().__init__()
        self.player_id = self.load_season_players()

    def player_stats_singel(self, player):
        #NEED TO HAVE SEASON ID
        season_id = self.fb.leagues[self.league].seasons[self.season]['id']
        ds = load_match_data(
            f'https://footballapi.pulselive.com/football/stats/player/{player}?compSeasons={season_id}')
        return ds

    def player_stats(self):
        stats = {}
        with Pool(self.pool) as p:
            player_stats = list(tqdm(p.imap(self.player_stats_singel, self.player_id, chunksize=1), total=len(self.player_id)))
        all_players = player_stats
        i = 0
        for player in all_players:
            game_id = int(player['entity']['id']) #Get's the gameIDs for each game
            index = game_id #Set's gameIDs as index for dictionairy
            stats[index] = {'info': player['entity']}

        print(f'Saved as {filename}.json in {path}')

class TeamStandings(Stats):
    def __init__(self, *args, **kwargs):
        super().__init__()
        self.team_id = [fix['id'] for fix in self.load_season_teams().values()]

    def team_standings_singel(self, team_id):
        #NEED TO HAVE SEASON ID
        season_id = self.fb.leagues[self.league].seasons[self.season]['id']
        ds = load_match_data(
            f'https://footballapi.pulselive.com/football/compseasons/{season_id}/standings/team/{team_id}')
        return ds

    def team_standings(self):
        stats = {}
        with Pool(self.pool) as p:
            team_standings = list(tqdm(p.imap(self.team_standings_singel, self.team_id, chunksize=1), total=len(self.team_id)))
        i = 0
        team_standing = team_standings
        for team in team_standing:
            team_id = int(team['team']['club']['id']) #Get's the gameIDs for each game
            index = team_id #Set's gameIDs as index for dictionairy
            if 'compSeason' in team:
                stats[index] = {'season': team['compSeason']}

        print(f'Saved as {filename}.json in {path}')

#What I'm doing right now
d = TeamStandings()
d.team_standings()
e = PlayerStats()
e.player_stats()
f = GameStats()
f.fixture_stats()

#What I want to do
d.Stats()
d.team_standings()
d.player_stats()
d.fixture_stats()

Answer 1

With the more context from the comments:

So... you don't want to have a child object, you just want to have more methods in the original class? But without putting those methods in the original class?

@h4ze that sounds right! I want the fragmentation

If you specify class name explicitly, you can pass anything as self .

d = Stats()
GameStats.fixture_stats(d)

It's called duck typing - we don't care about actual type of the object, we care about what it does: "if it swims like a duck and quacks like a duck, it's a duck".

This allows you to pass any object anywhere... But this also means the object needs to "swim" and "quacks" like the originally expected object, right?

We know that all GameStats object are Stats objects (because inheritance), but not the other way around. - This means your methods in GameStats can only use things that Stats has.

---

But just because you can do something doesn't mean you should . You can't use your child class's potential - you're basically just using the class as storage of methods for different class!

---

Better idea would be to do it the other way around - use multi-inheritance. Each parent class would have what is needed to perform its actions (and of course you would set all those parts in your child init) and those actions - thus minimizing the need of overwriting methods in child.

Think of it like interfaces in other languages, but with already implemented methods (normally you have to implement the interface - causing more things in the class).

---

Or just do normal functions , document (in docstrings) that they should take the given object, and use that. You can store those functions in different modules, thus giving them different namespaces - providing the "fragmentation" you want.

Answer 2

This is a bad design. So my answer is just you should not do that .

It is dangerous, because methods from a subclass expect a subclass object that could have additional attributes. And calling those methods on a base class object could break. In your example, only true GameStats object will have an initialized fixture_id

Ok, if you write that carefully, it will work, but it would require comments in red flashing font to prevent future maintainers not to break it, because you are willingly misusing a class hierachy.

There are acceptable designs if you want to build a base class object, and later use methods from a subclass:

• make sure that all subclasses can be initialized from a base class object and then do:

   d = Stats() # additional Stats operation on d... (GameStats(d)).fixture_stats()

• use a __getattr__ that will load methods from additional mixins (manual equivalent of above design)

   class Base: def set_mixin(self, mixin): self.mixin = mixin def __getattr__(self, attr): return functools.partial(getattr(self.mixin, attr), self) class M1: """Mixin for class Base: only contains methods that apply on Base objects""" def __init__(self, *args, **kwargs): raise TypeError("Cannot create M1 objects") def foo(self, x): print(x, 'on', self) b = Base() b.set_mixin(M1) b.foo('x')

  would print

  x on <__main__.Base object at 0x...>

  But IMHO this is a questionable design and should only be used for special use cases.

Answer 3

'Simple is better than complex' and 'Practicality beats purity' -- PEP 20

 #What I want to do d.Stats() d.team_standings() d.player_stats() d.fixture_stats()

Your examples are all in the context of a single season. As such, I would simply make it one class SeasonStats with all the methods you want to use. This also makes it clear that these methods are restricted to that single season.

class SeasonStats:
    ...
    def __init__(self, league='EN_PR', season='2019/2020'):
        ...

        ### Included from '__init__'s of previous subclasses ###
        self.fixture_ids = [fix['id'] for fix in self.load_season_fixture().values()]
        self.team_ids = [team['id'] for team in self.load_season_teams().values()]
        self.player_ids = self.load_season_players()

    def load_season_fixture(self):
        ...
    def load_season_players(self):
        ...
    def load_season_teams(self):
        ...
    def fixture_stats_singel(self, fixture):
        ...
    def fixture_stats(self):
        ...
    def player_stats_singel(self, player):
        ...
    def player_stats(self):
        ...
    def team_standings_singel(self, team_id):
        ...
    def team_standings(self):
        ...

Note that I've subtly changed the variable names included from the previous subclasses __init__ s

And then indeed just using it as:

season_19_20 = SeasonStats(season='2019/2020')
season_19_20.team_standings()
season_19_20.player_stats()
season_19_20.fixture_stats()

Some variable naming advice

d , e , f

I would advise against using a , b , c , etc... Memory is cheap and screens are large enough: don't be afraid to use meaningful names such as season .

Lists are plural

When talking about a list of IDs, you naturally use the plural 'IDs' already. By naming your variable as such, you can easily distinguish between lists of things and single things. This also makes it very natural to use in eg for -loops:

team_ids = [team['id'] for team in ...]
for team_id in team_ids:
    do_something_with(team_id)