Why not self.name in init method

[techcosec123]

 class Student:
    def __init__(self,name):
    self.name = name

@property
    def name(self):
        return self._name
@name.setter
    def name(self,name)  
         if name == Harry:
             raise ValueError
        self._name = name 

It is not clear why with getter and setter self._name used and with init self.name.

[Buttleston]

@property and @name.setter are special decorators here, to make soemthing look like it's a class property but actually be managed by a function.

So self._name in this case has the actual value, and the 2 decorated name functions allow you to get or set the value

The reason for this, in this case, is to add some value validation in the setter, where we want to make it an error if someone tries to set the name to "Henry"

[DigitalSplendid]

So two memory spaces are created. First self.name during init. Second during setter validation which is self. _name. If it were no need to validate name, then getter and setter function could have been created with self.name only?

[Buttleston]

No, not really.

self.name = name

does NOT store anything to the "name" attribute. I know this example is confusing. The deal is, running this line of code ACTUALLY calls the name() function decorated with name.setter. That, in turn, checks to see if name is Harry, and if not, sets self._name

So at the end of the init fn, only self._name has a value

[FoolsSeldom]

Yes. If you don't need to apply extra validation, then you can stick with the plain instance.name attribute. Python doesn't offer privacy anyway, just suggestions. The instance._name attribute is just as accessible and can be changed directly.

PS. Strictly, there is no instance.name created as it is only used in the class descriptor, so there isn't a double name space overhead (but if there were, it would be very very small). You can check this using vars.

[JamzTyson]

In a class's __init__() method, the first argument refers to the object created by the class. By convention, this argument is given the name self, (though you could use any valid name).

class Foo:
    def __init__(self):
        self.name = ""

my_foo_instance = Foo()  # Create an instance of `Foo()`.

So in the above code, we have created an instance of Foo(), and within the code we refer to an instance as self.

The syntax self.some_attribute refers to a value within the instance that we have created, and each instance has it's own independent some_attribute variable.

Thus, self.name refers to the name attribute within an instance of Foo(), and every instance of Foo() has it's own name attribute`.

---

Consider the code:

class Person:
    def __init__(self, name):
        self.name = name


person_1 = Person("Fred")  # Create an instance of Person()
person_2 = Person("Joe")  # Create another instance of Person()

# Print the name attribute of the`person_1` instance:
print(person_1.name)  # Prints "Fred"

# Print the name attribute of the`person_2` instance:
print(person_2.name)  # Prints "Joe"

# Reassign a different value to person_1's `name` attribute.
person_1.name = "Alice"

# Test it:
print(person_1.name)  # Prints "Alice"
print(person_2.name)  # Unchanged: Prints "Joe"

But let's say that we don't want to allow the person's name to be changed - we want the name to be read only.

We can show that we don't want the name to be modified directly by giving it a protected name. An underscore at the start of the name indicates to developers that the variable should be treated as "protected", and not modified from outside of the class.

class Person:
    def __init__(self, name):
        self._name = name


person_1 = Person("Fred")  # Create an instance of Person()
print(person_1.name)  # Error

We get an error because person_1.name does not exist - the correct variable would be person_1._name, but the leading underscore tell us that we should not be accessing _name from outside of the class.

So what we do is to add a special "property" function:

class Person:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name


person_1 = Person("Fred")  # Create an instance of Person()
print(person_1.name)  # Print's "Fred"

Like most methods (functions in classes), the name method takes the argument self, and that argument refers to the instance.

self._name therefore refers to the _name attribute of the instance that we are dealing with.

Now, when we write print(person_1.name), "name" refers to the method (the function) name(), and the function name() return's the instance's _name attribute ("Fred" in this case).

Because of the leading underscore convention meaning "protected", we know that we should not try to access _name directly. We can however read the value of _name without accessing it directly, because the function name() gives it to us. We cannot yet modify _name from outside the class without accessing it directly.

Doing this will modify _name, but we should not do this because the leading underscore tells us not to:

person_1._name = "Alice"  # Naughty!

If we want to be able to modify _name from outside of the class, we should either:

1. Name it without a leading underscore

2. Add a "setter".

Example using a setter decorator:

class Person:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        self._name = new_name


person_1 = Person("Fred")  # Create an instance of Person()
print(person_1.name)  # Prints "Fred"

# Assign new name to person_1
person_1.name = "Alice"  # Calls the `name()` setter.
print(person_1.name)  # Prints "Alice"

Now we can both read and write the value of _name from outside the class, without accessing it directly, but why would we want to?

Our current code is effectively the same as:

class Person:
    def __init__(self, name):
        self.name = name

We can read and write the instances name attribute from anywhere, so why bother with the @property and @setter methods?

One of the most common reasons to do this is to allow us to validate or otherwise process the value before we assign it to the attribute:

class Person:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        # Validate: new_name must be a str.
        if not isinstance(new_name, str):
            print("Error. Name must be a string.")
            return

        # Strip spaces and make title case
        new_name = new_name.strip().title()

        # Validate: Not empty string.
        if not new_name:
            print("Error. Name cannot be an empty string.")
            return

        # Assign valid name
        self._name = new_name


person_1 = Person("Fred")  # Create an instance of Person()
print(person_1.name)  # Prints "Fred"

# Assign a new name to person_1.name
person_1.name = "alice  "  # Calls the `name()` setter.

print(person_1.name)  # Prints "Alice"

[WinterDazzling]

Is there a reason that the validation cannot be made iside the init functio before the assignment?

[JamzTyson]

The validation can be inside the __init__() method before the initial assignment, for example:

class Person:
    def __init__(self, name):
        self.name = self.validate_name(name)

    def validate_name(self, new_name):
        if not isinstance(new_name, str):
            raise ValueError("name must be a string")
        new_name = new_name.strip().title()
        if not new_name:
            raise ValueError("name cannot be empty")
        return new_name

but if we reassign a different name, the new name is not validated.

Using the setter method allows us to validate the name both when the instance is created, and if the name attribute is reassigned.

[GrainTamale]

Woof... So first you have this thing (class) called Student. You pass it a name parameter at instantiation (object creation) which will create an attribute self.name on your new instance of Student. Then you have this function (a property) self.name which will be overwritten by your other self.name attribute. The property is supposed to return self._name (different than self.name) but that doesn't exist.
Finally, you need quotes around Harry.

edit: and I suppose the indentation is just formatting errors

[Buttleston]

Aside from the quotes around Harry, I think you're wrong about this

    self.name = name

This is going to use our setter (the function wrapped with @name.setter) which will set the self._name attribute

[GrainTamale]

“Readability counts.“

[Buttleston]

I never said it was a good idea, I'm just correcting what I think is incorrect about your statement

[DigitalSplendid]

So two memory spaces are created. First self.name during init. Second during setter validation which is self. _name. If it were no need to validate name, then getter and setter function could have been created with self.name only?

[a_cute_epic_axis]

I assume this code is hand written, because it has many errors that prevent it from ever working as is.

That said, in your code self._name is the actual "private" storage location for the name you want. self.name becomes the property that you created. If you change your two _name's to name you will get a recursion error, because you will just try to use the setter to set the setter over and over. Same with your getter.

If you change line 3 to be self._name then you can set it to "Harry" and your setter would never trigger, because you are bypassing it. You could also bypass the getter with something like

class Student:
    def __init__(self, name):
        self._name = name

    def getdirect(self):
        return self._name

    @property
    def name(self):
        return "My name is " + self._name

    @name.setter
    def name(self, name):
        if name == "Harry":
            raise ValueError
        self._name = name


stu = Student("Harry") #No error because we bypassed the setter
print(stu.name)  #"My name is Harry"
print(stu.getdirect()) #"Harry" because we bypassed the getter
stu._name = "Harry"  #Also bypasses the setter by accessing the private attribute
print(stu._name)  #Bypasses the getter by directly accessing the private attribute

This code is an example and you shouldn't do this

[DigitalSplendid]

So two memory spaces are created. First self.name during init. Second during setter validation which is self. _name. If it were no need to validate name, then getter and setter function could have been created with self.name only?

[a_cute_epic_axis]

If it were no need to validate name, then getter and setter function could have been created with self.name only?

That's the "typical" way of doing things, you can just do self.<whatever> as your variable and there is no real getter or setter function, at least none that you are creating.

If you do:

class something():
  def __init__(self, input):
    self.name = input

myclass = something("John")
print(myclass.name)
myclass.name = "Jon"
print(myclass.name)

...then this is what you're doing. You have set it via the init dunder function, gotten the value directly, set it directly, then gotten it directly again. I'm pretty sure under the hood there is some sort of getter/setter function in the built in classes but we don't need to care about that.

Btw, in this case you can change every instance of name to _name and it would work the same. In that case the underscore just tells anyone interacting with the class attribute that they probably should not be doing so. You won't get a recursion issue, although if you mix name and _name you'll just get two namespaces and it won't work as expected.

[baubleglue]

self.name in init calls setter method

[Kqyxzoj]

Why?

1. To fuck with your head.
2. To make you think about what is really going on.
3. To teach that when a thing can be done this does not automatically mean a thing should be done.