Python Forum

Hello, i have the following code:

class ParentClass:
    def use_name(self):
        print('Using {} somehow'.format(self.name))


class ChildClass(ParentClass):
    def __init__(self, name):
        self.name = name

As you can see i'm using a property created in a subclass, in a method of the parent class which of course works fine only if i run the method from a subclass instance. And i don't intend to instantiate the parent class in any case.
So is it OK or it is still bad coding practice? Is there any improvement on this?
Is it a bad "decoupling" practice since writing code for the parent class i have to know properties of the child class?

If it were me, I would play it safe by having thenameproperty in the parent class.

class ParentClass:
	def __init__ (self) :
		self.name = None

	def use_name(self):
		if self.name != None :
			print('Using {} somehow'.format(self.name))

Parent and child are not really the correct terms for a class hierarchy relationship. Use base class, subclass, superclass.

What is your reason for doing such a thing? Maybe you have a good reason. Are you trying to force the subclass to make an instance variable similar to how the abc.abstractmethod forces subclasses to define a method? Unfortunately there is no such thing. In your example the undefined attribute will not be found until it is used.

class ParentClass:
    def use_name(self):
        print('Using {} somehow'.format(self.name))

class ChildClass(ParentClass):
    def __init__(self, name="undefined"):
        self.name = name

class BadChildClass(ParentClass):
    def __init__(self):
        """I don't have a name"""

ChildClass().use_name()
BadChildClass().use_name()

Output:
Using undefined somehow
Traceback (most recent call last):
  File "...", line 14, in <module>
    BadChildClass().use_name()
  File "...", line 3, in use_name 
    print('Using {} somehow'.format(self.name))
AttributeError: 'BadChildClass' object has no attribute 'name'

You can have an abstract property, and a property looks and works a lot like an instance variable. In this example ParentClass defines an abstract property name. You still get an error when using BadChildClass, but now the error is identified when the instance is created instead of waiting until you try to use an undefined attribute.

from abc import ABC, abstractmethod

class ParentClass(ABC):
    def use_name(self):
        print('Using {} somehow'.format(self.name))

    @property
    @abstractmethod
    def name(self):
        """Abstract peroperty to get name"""


class ChildClass(ParentClass):
    def __init__(self, name="undefined"):
        self._name = name

    @property
    def name(self):
        return self._name

class BadChildClass(ParentClass):
    def __init__(self):
        """I don't have a name"""

ChildClass().use_name()
BadChildClass().use_name()

Output:
Using undefined somehow
Traceback (most recent call last):
  File "...", line 26, in <module>   
    BadChildClass().use_name()
TypeError: Can't instantiate abstract class BadChildClass with abstract method name

@deanhystad i really thought of using the ABC module but first of all it's somehow like turning Python to Java . And on the other hand it doesn't solve a problem with giving a more "proper" error when the BadChildClass runs the method. But OK, this is better than before.
OK, my real scenario is that i want a superclass and subclasses for scraping web content. Each subclass has hardcoded the url to scrape. The superclass needs access to this because for every url there is some content that can be scraped in the same exact way so this logic has to be in the superclass. And the rest of the content that is scraped differently in each url will be parsed in the subclass.
So isn't this subclassing model that i use right?

I would add an __init__(self, url): to the base class and the subclasses should call super().__init__(my_unique_url). Put the things that are common in the base class, and the things that are different in the subclasses. The url is really the same (all subclasses will have a url), but it will have a different value for each instances.

Are the subclasses all singletons?

Oh it was so simple and i didn't think of it. I found the complex way Thanks!