CODEWITHSUNDEEP
pythonclassmember
bdhar
bdhar

Reputation: 22983

Type of an instance variable

Suppose that I have a class like this

class Employee:
    pass

I create two objects for Employee as below

john = Employee()
rob = Employee()

..and create instance variables

john.age = 12
rob.age = '15'

The compiler accepts both and prints the age (john's age in int and rob's age in string). How is this logical? The same data attribute having different type in each object.

Thanks.

Upvotes: 0

Views: 375

Answers (5)

eyquem
eyquem

Reputation: 27575

The term "variable" is confusioning in Python.

Upvotes: 0

Brandon Rhodes
Brandon Rhodes

Reputation: 89454

Because by saying rob.age you are not creating a class-wide data attribute that has a specific type; you are merely creating an instance-local, instance-specific attribute that refers to a concrete entity, the string '15'. To create a class-wide attribute you would have to say Employee.age = … or set age inside the class Employee: block. By setting the attribute to a descriptor, I suppose you could check its type every time it is set and restrict it to an integer or string or whatever; but in general, either a class attribute or an instance attribute is just a name for an object, and all Python cares is that .age names an object.

And note that Python could not really guess what you mean anyway. If you say that john.age is 12, you seem to want Python to guess that all other .age attributes should also be numbers. But why shouldn't Python go even further, and guess that they are integers — or better yet, that they are positive even integers? I really do not think it would be reasonable in any case for Python to extrapolate from a single assignment to some kind of guess as to how you will treat that attribute in all other instances of the class.

Upvotes: 2

Eli Bendersky
Eli Bendersky

Reputation: 273536

Be sure to understand this fundamental principle: in Python, variables don't have types. Values have types. This is the essence of Python's being a dynamically-typed language similarly to Lisp and Javascript, but unlike C, C++ and Java.

>>> foo = 5       # foo now holds a value of type int
>>> foo = 'hello' # foo now holds a value of type string

Here's an excerpt from Wikipedia's entry on typing in Python:

Python uses duck typing and has typed objects but untyped variable names. Type constraints are not checked at compile time; rather, operations on an object may fail, signifying that the given object is not of a suitable type. Despite being dynamically typed, Python is strongly typed, forbidding operations that are not well-defined (for example, adding a number to a string) rather than silently attempting to make sense of them.

Do read more on this subject (especially what Duck Typing is) if you want to learn Python.

P.S. This issue is totally orthogonal to attributes of objects. Attributes are just other "variables" in Python, which also can hold values. These values can be of different types.

Upvotes: 7

Ignacio Vazquez-Abrams
Ignacio Vazquez-Abrams

Reputation: 798744

Python's compiler does not care what type of value you bind to an attribute/name, nor does it have to; Python's dynamic nature means that the important type checks (which are usually actually attribute checks) are done at runtime.

Upvotes: 1

Mark Nenadov
Mark Nenadov

Reputation: 6927

It's fundamentally what you get when you have a dynamically typed language.

Type is determined at runtime not at declaration.

It has advantages and disadvantages, but I believe the advantages outweigh its disadvantages in most development contexts.

(It's what Ruby, Python, PHP, etc. do)

Upvotes: 1

Related Questions