Here is an example:

def __str__(self):
    return f'({self.self.country},{self.self.code},{self.self.product}, {self.cost},{self.quantity })'

This way, when you assign values to a class, you can print its string representation

print(new_shoe)

More info here https://www.pythontutorial.net/python-oop/python-str/

The purpose of having a __str__ method is to create a string representation of the object. __str__ should return a string. If the implementation of __str__ instead printed the string representation and returned nothing, when the object was used in a string context a TypeError will be raised. Take for example:

def __str__(self):
        print '%f/%f'%(self.num,self.den)

If we went to display a fraction object like so:

f = Fraction(1,2)
print f

we get an exception:

Traceback (most recent call last):
  File "/Users/.../Desktop/...", line 13, in <module>
    print f
TypeError: __str__ returned non-string (type NoneType)
>>> 

This is because __str__ is used to get the string representation of the object, not print it (by convention that is, you could print as long as you return a string). That's what the print statment/function is used for in conjunction with a __str__ method.

On the other hand a method like show:

def show(self):
        print(self.num,"/",self.den) #or even print(self) (for the last part of answer)

Is essentially equivalent to print(f) in the above case (except it includes spaces next to the operands). show is used to output the string representation, while __str__ to get the representation.

However, additional logic may be added to show which isn't appropriate/necessary when constructing a string representation, and hence make sense to have both methods.

You can however use a method like show where a print statement is inappropriate i.e:

if f.show(): pass
if print(f): pass #raise exception

You should define __str__() method inside the class, also use f strings so:

class Product(models.Model):
    user = models.ForeignKey(User, on_delete=models.SET_NULL, null=True)
    name = models.CharField(max_length=200, null=True, blank=True)
    # image =
    category = models.CharField(max_length=200, null=True, blank=True)
    description = models.TextField(null=True, blank=True)
    rating = models.DecimalField(
        max_digits=7, decimal_places=2, null=True, blank=True)
    numReviews = models.IntegerField(null=True, blank=True, default=0)
    price = models.DecimalField(
        max_digits=7, decimal_places=2,  null=True, blank=True)
    countInStock = models.IntegerField(null=True, blank=True, default=0)
    createdAt = models.DateTimeField(auto_now_add=True)
    _id = models.AutoField(primary_key=True, editable=False)


    def __str__(self):
        return f"{self.name}"

For this we can use enumerate to easily get the index number of a given element in a list, and with its second argument we can shift it to start from 1, we can use this to get

>>> question = 'Biggest city in England?'
>>> alternatives = ['Manchester', 'Liverpool', 'London']
>>> for i,v in enumerate(alternatives,1):
        print(f'{i} - {v}')

    
1 - Manchester
2 - Liverpool
3 - London
>>>     

Now lets change the previous loop into an appropriate list comprehension

>>> [f'{i} - {v}' for i,v in enumerate(alternatives,1)]
['1 - Manchester', '2 - Liverpool', '3 - London']
>>>

Now we use str.join to, well, join them together and remove the [] to make it into a generator expression while we are at it

>>> temp=', '.join(f'{i} - {v}' for i,v in enumerate(alternatives,1))
>>> temp
'1 - Manchester, 2 - Liverpool, 3 - London'
>>> 

now we got the 80% of it, lets go for the final touch

>>> f"{question} {temp}"
'Biggest city in England? 1 - Manchester, 2 - Liverpool, 3 - London'
>>> 

And we're done.

Also f-string can take almost any python expression, so we can make this into a one liner

>>> f"{question} { ', '.join(f'{i} - {v}' for i,v in enumerate(alternatives,1)) }"
'Biggest city in England? 1 - Manchester, 2 - Liverpool, 3 - London'
>>>      

You created a Blog model. Once you migrate this, Django will create a table with "name" and "tagline" columns in your database.

If you want to interact with the database with the model, for example create an instance of the model and save it or retrieve the model from db,

def __str__(self):
    return self.name 

will come handy. Open the python interactive shell in your project's root folder via:

python manage.py shell

Then

from projectName.models import Blog 
Blog.objects.all() # will get you all the objects in "Blog" table

Also, when you look at the models in your admin panel, you will see your objects listed, with the name property.

The problem is, the return will look like this if you did not add that function:

<QuerySet [<Blog:>,<Blog:>,<Blog:>....]

So you will not know what those objects are. A better way to recognize those objects is retrieving them by one of its properties which you set it as name. This way you will get the result as follow:

 <QuerySet [<Blog:itsName>,<Blog:itsName>,<Blog:itsName>....]

If you want to test this out, run python manage.py shell and run:

from projectName.models import Blog

# The below will create and save an instance.
# It is a single step. Copy-paste multiple times.
Blog.objects.create(name="first",tagline="anything")
Blog.objects.all() # check out the result

Python has two different ways to convert an object to a string: str() and repr(). Printing an object uses str(); printing a list containing an object uses str() for the list itself, but the implementation of list.__str__() calls repr() for the individual items.

So you should also overwrite __repr__(). A simple

__repr__ = __str__

at the end of the class body will do the trick.