We Keep Coding

I need an explanation through my code, where do we need to define init method and declare "self". How to call a function in each cases give in my code

I need to understand these things in python here are some codes. I want a nice description of it.
When I used the first code, "self" was necessary, When I used the second code "self" gave me an error. How?
class Sample():
def example(self, x, y):
z = x+ y
return print(z)
x = Sample()
x.example(1,2)
class Sample():
def example(x, y):
z = x+ y
return print(z)
Sample.example(1,2)
and this code gives me an error, I don't know where I am wrong
class Sample():
def __init__(self, x, y):
self.x = x
self.y =y
def example(self):
z = self.x + self.y
return print(z)
x = Sample()
x.example(1,2)
Error
Traceback (most recent call last):
File "c:\Users\Lenovo\Documents\PP\Advance python\example.py", line 13, in <module>
x = Sample()
TypeError: __init__() missing 2 required positional arguments: 'x' and 'y'
Another code with error
def example(self):
z = self.x + self.y
return print(z)
example(1,2)
Error
Traceback (most recent call last):
File "c:\Users\Lenovo\Documents\PP\Advance python\example.py", line 8, in <module>
example(1,2)
TypeError: example() takes 1 positional argument but 2 were given
I would really appreciate the help.

The __init__ method is a constructor so it essentially initializes the attributes of the object. So you should pass the arguments when you are creating the object. When you use self that means those attribute/methods relates to the same class.
class Sample:
def __init__(self, x, y):
self.x = x
self.y = y
def example(self):
z = self.x + self.y
return print(z)
x_object = Sample(1, 2)
x_object.example()
So rather than passing the arguments to x.example you should pass them to Sample()

Python Classes using __init and __repr__ methods

Iam trying to create a class that should accept two arguments, x and y, and be represented by a string 'Point(x, y)' with appropriate values for x and y
class Point(object):
def __init__(self, x, y):
self.x = 0
self.y = 0
def __repr__(self):
return "Point(%s,%s)"%(self.x, self.y)
Error:
Point(0,0) is not of type 'string'
Failed validating 'type' in schema['items']:
{'type': 'string'}
On instance[0]:
Point(0,0)

"self.x" is the value of the instance of your class. So, if you set "self.x = 0", it means whenever you create an object for that class, the "x" value of that object will always be 0 instead of what you pass in the parameter.
"x" is the value of what you pass in the parameter.
self.x = x
self.y = y

Code:
class MyClass():
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Point(%s,%s)"%(self.x, self.y)
thiss = MyClass(0, 0)
print(thiss.__repr__())
thiss = MyClass(20, 20)
print(thiss.__repr__())
Output:
daudn$ python3 point.py
Point(20,20)
daudn$ python3 point.py
Point(0,0)
When declaring your init function, you initialized self.x and self.y to always be 0. If you look at the code I've posted, whatever number you pass to the class will become the values or Point.

Why don't I get an error message for failing to initializing an inherited classes instance attribute in an instance of it's derived class?

When I initialize an instance of class B, shouldn't it raise an error for not attempting to supply a value for the x attribute in class A's init method? What if I want an error to be raised if x is not supplied a value?
Example:
class A:
def __init__(self, x):
self.x = x
class B(A):
def __init__(self, y):
self.y = y
z = B(4) #Shouldn't I be getting an error for not attempting to
#initialize x from the base class?

No.
What you are doing is initializing y, since in your init of B class, you are not calling your parents constructror
super.__init__()
If you wanted to use both x,y from B and having to initialize x from B, you should use this:
class A:
def __init__(self, x):
self.x = x
class B(A):
def __init__(self, x, y):
super().__init__(x)
self.y = y

Force user to call Object :__call__

Is it possible to only allow a user invoke any/all object methods when the object itself is called?
Looking for different examples on how to do this
Some example code
class Test:
def __init__(self, x=1):
self.x = x
def __call__(self, x=1):
self.x = x
return self
def get(self, y):
return (self.x * y)
t_obj = Test()
t_obj(2).get(1) # Acceptable case
t_obj.get(1) # Raises exception
t_obj().get(2) # Acceptable case

Right way to do it
It seems to me that what you want is for t_obj to actually be the class and not an instance of Test. It then gives the exact behavior you showed in your example.
class Test:
def __init__(self, x=1):
self.x = x
def get(self, y):
return (self.x * y)
t_obj = Test # not an object, actually a class
t_obj(2).get(1) # 2
t_obj.get(1) # Raises exception
t_obj().get(2) # 2
In particular, the exception states that method get() must be called with Test instance, i.e. you had to call t_obj to instantiate an object before being able to call get(), which is exactly what you want.
Fun way to do it
Although, suppose you really need your objects to be callable, here is a hacky way to get this working. It replaces the get method of your object when called, replacing a placeholder which only purpose is to raise.
class Test:
def __init__(self, x=1):
self.x = x
def __call__(self, x):
self.x = x
self.get = lambda y: self.x * y
return self
def get(self, y):
raise AttributeError('call object first')
t_obj = Test()
t_obj.get(1) # Raises exception
t_obj(2)
t_obj.get(1) # 2

How do I define a Python method that I only want to use in the __init__ method, i.e., that is not accessible from outside the class definition?

Say I have a class definition which takes some arguments and creates additional data with it, all within the __init__ method:
class Foo():
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
self.bar = generate_bar(x, y, z)
def generate_bar(self, x, y, z):
return x+y+z
I only want to run the generate_bar() method once, when an instance of the class is created, so it wouldn't make sense for that method to be callable on the instance. Is there a sleeker way to ensure that a method is only available to __init__, or do I just have to assume anyone who looks at my code will understand that there's never a situation in which it would be appropriate to call generate_bar() on an instance of the class?

If you are not using any instance state, just make it a separate function:
def _generate_bar(x, y, z):
return x + y + z
class Foo():
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
self.bar = _generate_bar(x, y, z)
The leading underscore, by convention, signals it is an internal function not to be used by external consumers of your module.
You could nest the function inside the __init__ but this doesn't really help with readability:
class Foo():
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def generate_bar():
return x + y + z
self.bar = generate_bar()
Here generate_bar() doesn't even need arguments, it could access x, y and z from the enclosing scope.

For "hidden" functions, it is customary to use a single underscore to signify your intent:
def _generate_bar(self, x, y, z): ...
These are still accessible, but are not visible via tab completion.
See this SO explanation:
class foo:
def __init__(self):
self.response = self._bar()
def _bar(self):
return "bar"
f = foo()
>>> f.response
bar
You can verify yourself that the function _bar is not visible to the object via tab completion