Python classes - Basics of Python classes, objects, instance methods and variables (3.11.0 docs) and examples

The text below is selected, press Ctrl+C to copy to your clipboard. (⌘+C on Mac) No line numbers will be copied.

Python classes - Basics of Python classes, objects, instance methods and variables (3.11.0 docs) and examples
By Guest on 31st October 2022 06:24:12 PM | Syntax: PYTHON | Views: 237

New paste | Download Paste

Download | Toggle Line Numbers

Show/Hide line no. | Copy Paste

Copy text to clipboard

Answers to questions:
What are class variables and instance variables in Python?
What is the difference between class and instance variable?
What is an instance variable Python?
What is class and instance in Python?
What is instance method and class method in Python?
What is the difference between instance and class in Python?
What are instance and class methods?
What is instance methods in Python?
Tutorial links are listed below.
9.3.1. Class Definition Syntax
------------------------------
The simplest form of class definition looks like this:
class ClassName:
<statement-1>
.
.
.
<statement-N>
Class definitions, like function definitions ("def" statements) must
be executed before they have any effect. (You could conceivably place
a class definition in a branch of an "if" statement, or inside a
function.)
In practice, the statements inside a class definition will usually be
function definitions, but other statements are allowed, and sometimes
useful --- we'll come back to this later. The function definitions
inside a class normally have a peculiar form of argument list,
dictated by the calling conventions for methods --- again, this is
explained later.
When a class definition is entered, a new namespace is created, and
used as the local scope --- thus, all assignments to local variables
go into this new namespace. In particular, function definitions bind
the name of the new function here.
When a class definition is left normally (via the end), a *class
object* is created. This is basically a wrapper around the contents
of the namespace created by the class definition; we'll learn more
about class objects in the next section. The original local scope
(the one in effect just before the class definition was entered) is
reinstated, and the class object is bound here to the class name given
in the class definition header ("ClassName" in the example).
9.3.2. Class Objects
--------------------
Class objects support two kinds of operations: attribute references
and instantiation.
*Attribute references* use the standard syntax used for all attribute
references in Python: "obj.name". Valid attribute names are all the
names that were in the class's namespace when the class object was
created. So, if the class definition looked like this:
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
then "MyClass.i" and "MyClass.f" are valid attribute references,
returning an integer and a function object, respectively. Class
attributes can also be assigned to, so you can change the value of
"MyClass.i" by assignment. "__doc__" is also a valid attribute,
returning the docstring belonging to the class: ""A simple example
class"".
Class *instantiation* uses function notation. Just pretend that the
class object is a parameterless function that returns a new instance
of the class. For example (assuming the above class):
x = MyClass()
creates a new *instance* of the class and assigns this object to the
local variable "x".
The instantiation operation ("calling" a class object) creates an
empty object. Many classes like to create objects with instances
customized to a specific initial state. Therefore a class may define a
special method named "__init__()", like this:
def __init__(self):
self.data = []
When a class defines an "__init__()" method, class instantiation
automatically invokes "__init__()" for the newly created class
instance. So in this example, a new, initialized instance can be
obtained by:
x = MyClass()
Of course, the "__init__()" method may have arguments for greater
flexibility. In that case, arguments given to the class instantiation
operator are passed on to "__init__()". For example,
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
9.3.3. Instance Objects
-----------------------
Now what can we do with instance objects? The only operations
understood by instance objects are attribute references. There are
two kinds of valid attribute names: data attributes and methods.
*data attributes* correspond to "instance variables" in Smalltalk, and
to "data members" in C++. Data attributes need not be declared; like
local variables, they spring into existence when they are first
assigned to. For example, if "x" is the instance of "MyClass" created
above, the following piece of code will print the value "16", without
leaving a trace:
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print(x.counter)
del x.counter
The other kind of instance attribute reference is a *method*. A method
is a function that "belongs to" an object. (In Python, the term
method is not unique to class instances: other object types can have
methods as well. For example, list objects have methods called
append, insert, remove, sort, and so on. However, in the following
discussion, we'll use the term method exclusively to mean methods of
class instance objects, unless explicitly stated otherwise.)
Valid method names of an instance object depend on its class. By
definition, all attributes of a class that are function objects
define corresponding methods of its instances. So in our example,
"x.f" is a valid method reference, since "MyClass.f" is a function,
but "x.i" is not, since "MyClass.i" is not. But "x.f" is not the same
thing as "MyClass.f" --- it is a *method object*, not a function
object.
9.3.4. Method Objects
---------------------
Usually, a method is called right after it is bound:
x.f()
In the "MyClass" example, this will return the string "'hello world'".
However, it is not necessary to call a method right away: "x.f" is a
method object, and can be stored away and called at a later time. For
example:
xf = x.f
while True:
print(xf())
will continue to print "hello world" until the end of time.
What exactly happens when a method is called? You may have noticed
that "x.f()" was called without an argument above, even though the
function definition for "f()" specified an argument. What happened to
the argument? Surely Python raises an exception when a function that
requires an argument is called without any --- even if the argument
isn't actually used...
Actually, you may have guessed the answer: the special thing about
methods is that the instance object is passed as the first argument of
the function. In our example, the call "x.f()" is exactly equivalent
to "MyClass.f(x)". In general, calling a method with a list of *n*
arguments is equivalent to calling the corresponding function with an
argument list that is created by inserting the method's instance
object before the first argument.
If you still don't understand how methods work, a look at the
implementation can perhaps clarify matters. When a non-data attribute
of an instance is referenced, the instance's class is searched. If
the name denotes a valid class attribute that is a function object, a
method object is created by packing (pointers to) the instance object
and the function object just found together in an abstract object:
this is the method object. When the method object is called with an
argument list, a new argument list is constructed from the instance
object and the argument list, and the function object is called with
this new argument list.
9.3.5. Class and Instance Variables
-----------------------------------
Generally speaking, instance variables are for data unique to each
instance and class variables are for attributes and methods shared by
all instances of the class:
class Dog:
kind = 'canine' # class variable shared by all instances
def __init__(self, name):
self.name = name # instance variable unique to each instance
>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind # shared by all dogs
'canine'
>>> e.kind # shared by all dogs
'canine'
>>> d.name # unique to d
'Fido'
>>> e.name # unique to e
'Buddy'
As discussed in A Word About Names and Objects, shared data can have
possibly surprising effects with involving *mutable* objects such as
lists and dictionaries. For example, the *tricks* list in the
following code should not be used as a class variable because just a
single list would be shared by all *Dog* instances:
class Dog:
tricks = [] # mistaken use of a class variable
def __init__(self, name):
self.name = name
def add_trick(self, trick):
self.tricks.append(trick)
>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks # unexpectedly shared by all dogs
['roll over', 'play dead']
Correct design of the class should use an instance variable instead:
class Dog:
def __init__(self, name):
self.name = name
self.tricks = [] # creates a new empty list for each dog
def add_trick(self, trick):
self.tricks.append(trick)
>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']
Practice with Python class syntax and instance variables.
Video references with examples and tutorials:
Understand Classes & Objects in 8 Minutes
https://www.youtube.com/watch?v=BM9tPve8T1o
Python Object Oriented Programming (OOP) - For Beginners
https://www.youtube.com/watch?v=JeznW_7DlB0
Python As Fast as Possible - Learn Python in ~75 Minutes
https://www.youtube.com/watch?v=VchuKL44s6E

Learn More:

Tags For This Paste:

Raw Paste:

Answers to questions:
What are class variables and instance variables in Python?
What is the difference between class and instance variable?
What is an instance variable Python?
What is class and instance in Python?
What is instance method and class method in Python?
What is the difference between instance and class in Python?
What are instance and class methods?
What is instance methods in Python?
Tutorial links are listed below.

9.3.1. Class Definition Syntax
------------------------------

The simplest form of class definition looks like this:

class ClassName:
       <statement-1>
       .
       .
       .
       <statement-N>

Class definitions, like function definitions ("def" statements) must
be executed before they have any effect.  (You could conceivably place
a class definition in a branch of an "if" statement, or inside a
function.)

In practice, the statements inside a class definition will usually be
function definitions, but other statements are allowed, and sometimes
useful --- we'll come back to this later.  The function definitions
inside a class normally have a peculiar form of argument list,
dictated by the calling conventions for methods --- again, this is
explained later.

When a class definition is entered, a new namespace is created, and
used as the local scope --- thus, all assignments to local variables
go into this new namespace.  In particular, function definitions bind
the name of the new function here.

When a class definition is left normally (via the end), a *class
object* is created.  This is basically a wrapper around the contents
of the namespace created by the class definition; we'll learn more
about class objects in the next section.  The original local scope
(the one in effect just before the class definition was entered) is
reinstated, and the class object is bound here to the class name given
in the class definition header ("ClassName" in the example).

9.3.2. Class Objects
--------------------

Class objects support two kinds of operations: attribute references
and instantiation.

*Attribute references* use the standard syntax used for all attribute
references in Python: "obj.name".  Valid attribute names are all the
names that were in the class's namespace when the class object was
created.  So, if the class definition looked like this:

class MyClass:
       """A simple example class"""
       i = 12345

def f(self):
           return 'hello world'

then "MyClass.i" and "MyClass.f" are valid attribute references,
returning an integer and a function object, respectively. Class
attributes can also be assigned to, so you can change the value of
"MyClass.i" by assignment. "__doc__" is also a valid attribute,
returning the docstring belonging to the class: ""A simple example
class"".

Class *instantiation* uses function notation.  Just pretend that the
class object is a parameterless function that returns a new instance
of the class. For example (assuming the above class):

x = MyClass()

creates a new *instance* of the class and assigns this object to the
local variable "x".

The instantiation operation ("calling" a class object) creates an
empty object. Many classes like to create objects with instances
customized to a specific initial state. Therefore a class may define a
special method named "__init__()", like this:

def __init__(self):
       self.data = []

When a class defines an "__init__()" method, class instantiation
automatically invokes "__init__()" for the newly created class
instance.  So in this example, a new, initialized instance can be
obtained by:

x = MyClass()

Of course, the "__init__()" method may have arguments for greater
flexibility.  In that case, arguments given to the class instantiation
operator are passed on to "__init__()".  For example,

>>> class Complex:
   ...     def __init__(self, realpart, imagpart):
   ...         self.r = realpart
   ...         self.i = imagpart
   ...
   >>> x = Complex(3.0, -4.5)
   >>> x.r, x.i
   (3.0, -4.5)

9.3.3. Instance Objects
-----------------------

Now what can we do with instance objects?  The only operations
understood by instance objects are attribute references.  There are
two kinds of valid attribute names: data attributes and methods.

*data attributes* correspond to "instance variables" in Smalltalk, and
to "data members" in C++.  Data attributes need not be declared; like
local variables, they spring into existence when they are first
assigned to.  For example, if "x" is the instance of "MyClass" created
above, the following piece of code will print the value "16", without
leaving a trace:

x.counter = 1
   while x.counter < 10:
       x.counter = x.counter * 2
   print(x.counter)
   del x.counter

The other kind of instance attribute reference is a *method*. A method
is a function that "belongs to" an object.  (In Python, the term
method is not unique to class instances: other object types can have
methods as well.  For example, list objects have methods called
append, insert, remove, sort, and so on. However, in the following
discussion, we'll use the term method exclusively to mean methods of
class instance objects, unless explicitly stated otherwise.)

Valid method names of an instance object depend on its class.  By
definition, all attributes of a class that are function  objects
define corresponding methods of its instances.  So in our example,
"x.f" is a valid method reference, since "MyClass.f" is a function,
but "x.i" is not, since "MyClass.i" is not.  But "x.f" is not the same
thing as "MyClass.f" --- it is a *method object*, not a function
object.

9.3.4. Method Objects
---------------------

Usually, a method is called right after it is bound:

x.f()

In the "MyClass" example, this will return the string "'hello world'".
However, it is not necessary to call a method right away: "x.f" is a
method object, and can be stored away and called at a later time.  For
example:

xf = x.f
   while True:
       print(xf())

will continue to print "hello world" until the end of time.

What exactly happens when a method is called?  You may have noticed
that "x.f()" was called without an argument above, even though the
function definition for "f()" specified an argument.  What happened to
the argument? Surely Python raises an exception when a function that
requires an argument is called without any --- even if the argument
isn't actually used...

Actually, you may have guessed the answer: the special thing about
methods is that the instance object is passed as the first argument of
the function.  In our example, the call "x.f()" is exactly equivalent
to "MyClass.f(x)".  In general, calling a method with a list of *n*
arguments is equivalent to calling the corresponding function with an
argument list that is created by inserting the method's instance
object before the first argument.

If you still don't understand how methods work, a look at the
implementation can perhaps clarify matters.  When a non-data attribute
of an instance is referenced, the instance's class is searched.  If
the name denotes a valid class attribute that is a function object, a
method object is created by packing (pointers to) the instance object
and the function object just found together in an abstract object:
this is the method object.  When the method object is called with an
argument list, a new argument list is constructed from the instance
object and the argument list, and the function object is called with
this new argument list.

9.3.5. Class and Instance Variables
-----------------------------------

Generally speaking, instance variables are for data unique to each
instance and class variables are for attributes and methods shared by
all instances of the class:

class Dog:

kind = 'canine'         # class variable shared by all instances

def __init__(self, name):
           self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.kind                  # shared by all dogs
   'canine'
   >>> e.kind                  # shared by all dogs
   'canine'
   >>> d.name                  # unique to d
   'Fido'
   >>> e.name                  # unique to e
   'Buddy'

As discussed in A Word About Names and Objects, shared data can have
possibly surprising effects with involving *mutable* objects such as
lists and dictionaries. For example, the *tricks* list in the
following code should not be used as a class variable because just a
single list would be shared by all *Dog* instances:

class Dog:

tricks = []             # mistaken use of a class variable

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

def add_trick(self, trick):
           self.tricks.append(trick)

>>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks                # unexpectedly shared by all dogs
   ['roll over', 'play dead']

Correct design of the class should use an instance variable instead:

class Dog:

def __init__(self, name):
           self.name = name
           self.tricks = []    # creates a new empty list for each dog

def add_trick(self, trick):
           self.tricks.append(trick)

>>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks
   ['roll over']
   >>> e.tricks
   ['play dead']

Practice with Python class syntax and instance variables.
Video references with examples and tutorials:

Understand Classes & Objects in 8 Minutes
https://www.youtube.com/watch?v=BM9tPve8T1o

Python Object Oriented Programming (OOP) - For Beginners
https://www.youtube.com/watch?v=JeznW_7DlB0

Python As Fast as Possible - Learn Python in ~75 Minutes
https://www.youtube.com/watch?v=VchuKL44s6E

Copyrights, Credits and Attribution:

Python software and documentation are licensed under the PSF License Agreement.
Starting with Python 3.8.6, examples, recipes, and other code in the documentation are dual licensed under the PSF License Agreement and the Zero-Clause BSD license.
Some software incorporated into Python is under different licenses. The licenses are listed with code falling under that license. See Licenses and Acknowledgements for Incorporated Software for an incomplete list of these licenses.

Python and it's documentation is:
Copyright © 2001-2022 Python Software Foundation. All rights reserved.
Copyright © 2000 BeOpen.com. All rights reserved.
Copyright © 1995-2000 Corporation for National Research Initiatives. All rights reserved.
Copyright © 1991-1995 Stichting Mathematisch Centrum. All rights reserved.

See History and License for complete license and permissions information:
https://docs.python.org/3/license.html#psf-license

Discord...
1 sec ago
New bot...
1 hour ago
Bot...
1 hour ago
Telegram bot...
1 hour ago
Tele bot ez teen...
1 hour ago
Teeeeeeeeeen...
2 hours ago
Teeeeeeeeeen...
2 hours ago
Teeeeeeeeeen...
2 hours ago
Teeeeeeeeeen...
2 hours ago
Teeeeeeeeeen...
2 hours ago

Useful Links

Webmaster Tools

Share This Page