Приведите базовый класс к производному классу python (или более pythonic способ расширения классов)

вот как "волшебным образом" заменить класс в модуле на пользовательский подкласс, не касаясь модуля. Это всего лишь несколько дополнительных строк из обычной процедуры подкласса, и поэтому дает вам (почти) всю силу и гибкость подкласса в качестве бонуса. Например, это позволяет добавлять новые атрибуты, если вы хотите.

import networkx as nx

class NewGraph(nx.Graph):
    def __getattribute__(self, attr):
        "This is just to show off, not needed"
        print "getattribute %s" % (attr,)
        return nx.Graph.__getattribute__(self, attr)

    def __setattr__(self, attr, value):
        "More showing off."
        print "    setattr %s = %r" % (attr, value)
        return nx.Graph.__setattr__(self, attr, value)

    def plot(self):
        "A convenience method"
        import matplotlib.pyplot as plt
        nx.draw(self)
        plt.show()

до сих пор это точно так же, как обычный подкласс. Теперь нам нужно подключить этот подкласс к networkx модуль, так что все инстанцирование nx.Graph результаты NewGraph объект вместо этого. Вот что обычно происходит, когда вы создаете экземпляр nx.Graph объект nx.Graph()

1. nx.Graph.__new__(nx.Graph) is called
2. If the returned object is a subclass of nx.Graph, 
   __init__ is called on the object
3. The object is returned as the instance

мы заменим nx.Graph.__new__ и вернуть его NewGraph вместо. В нем, мы называем __new__ метод object вместо __new__ метод NewGraph, потому что последний является еще одним способом вызова метода, который мы заменяем, и поэтому приведет к бесконечной рекурсии.

def __new__(cls):
    if cls == nx.Graph:
        return object.__new__(NewGraph)
    return object.__new__(cls)

# We substitute the __new__ method of the nx.Graph class
# with our own.     
nx.Graph.__new__ = staticmethod(__new__)

# Test if it works
graph = nx.generators.random_graphs.fast_gnp_random_graph(7, 0.6)
graph.plot()

в большинстве случаях это все, что вам нужно знать, но есть один подводный камень. Наше преодоление __new__ метод влияет только на nx.Graph, а не его подклассов. Например, если вы вызываете nx.gn_graph, который возвращает экземпляр nx.DiGraph, это не наши фантазии расширений. Вам нужно подкласс каждого из подклассов nx.Graph что вы хотите работать и добавлять необходимые методы и атрибуты. Используя mix-ins может облегчить последовательное расширение подклассов при выполнении сухой принципе.

хотя этот пример может показаться достаточно простым, этот метод подключения к модулю трудно обобщить таким образом, чтобы охватить все небольшие проблемы, которые могут возникнуть. Я считаю, что проще просто адаптировать его к текущей проблеме. Например, если класс, к которому вы подключаетесь, определяет свой собственный пользовательский __new__ метод, вам нужно сохранить его перед заменой и вызвать этот метод вместо object.__new__.

если функция создает объекты Graph, вы не можете превратить их в объекты NewGraph.

другой вариант для NewGraph-это график, а не график. Вы делегируете методы Graph объекту Graph, и вы можете обернуть любой объект Graph в новый объект NewGraph:

class NewGraph:
    def __init__(self, graph):
        self.graph = graph

    def some_graph_method(self, *args, **kwargs):
        return self.graph.some_graph_method(*args, **kwargs)
    #.. do this for the other Graph methods you need

    def my_newgraph_method(self):
        ....

для вашего простого случая вы также можете написать свой подкласс __init__ как это и назначить указатели из структур данных графика для ваших данных подкласса.

from networkx import Graph

class MyGraph(Graph):
    def __init__(self, graph=None, **attr):
        if graph is not None:
            self.graph = graph.graph   # graph attributes
            self.node = graph.node   # node attributes
            self.adj = graph.adj     # adjacency dict
        else:
            self.graph = {}   # empty graph attr dict
            self.node = {}    # empty node attr dict 
            self.adj = {}     # empty adjacency dict

        self.edge = self.adj # alias 
        self.graph.update(attr) # update any command line attributes


if __name__=='__main__':
    import networkx as nx
    R=nx.gnp_random_graph(10,0.4)
    G=MyGraph(R)

вы также можете использовать copy () или deepcopy () в заданиях, но если вы это делаете, вы также можете использовать

G=MyGraph()
G.add_nodes_from(R)
G.add_edges_from(R.edges())

для загрузки данных графика.

вы можете просто создать новый NewGraph полученные от Graph объект и есть __init__ функция включает что-то вроде self.__dict__.update(vars(incoming_graph)) в качестве первой строки, прежде чем определить свои собственные свойства. Таким образом, вы в основном копируете все свойства из Graph у вас есть на новый объект, производный от Graph, но с особым соусом.

class NewGraph(Graph):
  def __init__(self, incoming_graph):
    self.__dict__.update(vars(incoming_graph))

    # rest of my __init__ code, including properties and such

использование:

graph = function_that_returns_graph()
new_graph = NewGraph(graph)
cool_result = function_that_takes_new_graph(new_graph)

вы пробовали [Python] привести базовый класс к производному классу

я протестировал его и, похоже, он работает. Также я думаю, что этот метод немного лучше, чем ниже одного, так как ниже один не выполняет init функции производная функции.

c.__class__ = CirclePlus