11.2 Classes and instances

Classes in Python are blueprints for creating objects, encapsulating data and behavior. They define attributes and methods that instances of the class will have, allowing for organized and reusable code in object-oriented programming.

Instances are individual objects created from a class, each with its own set of attributes. By using classes and instances, programmers can model real-world entities and their interactions, making code more intuitive and easier to maintain.

Classes and Instances

Class definition with constructor

Top images from around the web for Class definition with constructor

• 

  Object-oriented programming - Wikipedia View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  Object-oriented programming - Wikipedia View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

1 of 3

Top images from around the web for Class definition with constructor

• 

  Object-oriented programming - Wikipedia View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  Object-oriented programming - Wikipedia View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

1 of 3

• Class serves as a blueprint or template for creating objects (an example of object-oriented programming)
  • Defined using

    class

    keyword followed by class name (PascalCase convention)
  • Example class names:

    Person

    ,

    Car

    ,

    BankAccount

• [__init__()](https://www.fiveableKeyTerm:__init__())

  is a special constructor method that initializes instance attributes
  • Called automatically when a new class instance is created
  • Takes

    [self](https://www.fiveableKeyTerm:self)

    as the first parameter, referring to the instance being created
  • Additional parameters can be defined to accept values for instance attributes
    • Example:

      def __init__(self, name, age)

      to initialize

      name

      and

      age

      attributes
• Instance attributes are variables specific to each instance of a class
  • Defined within

    __init__()

    using

    self.attribute_name

    syntax
  • Each instance has its own copy of instance attributes
    • Example:

      self.name = name

      and

      self.age = age

      inside

      __init__()

• Instance methods are functions defined within a class that operate on instances
  • Defined like regular functions, but with

    self

    as the first parameter
  • Can access and modify instance attributes using

    self

    keyword
    • Example:

      def introduce(self): print(f"My name is {self.name} and I am {self.age} years old.")

Creation of class instances

• Instances are created by calling the class name followed by parentheses
  • Arguments can be passed to

    __init__()

    to initialize instance attributes
    • Example:

      person1 = Person("Alice", 25)

      creates a

      Person

      instance with

      name

      "Alice" and

      age

      25
• Instance attributes can be accessed and modified using dot notation
  • Syntax:

    instance_name.attribute_name

    • Example:

      person1.name

      accesses the

      name

      attribute of

      person1

• Instance methods can be called on instances using dot notation
  • Syntax:

    instance_name.method_name(arguments)

    • Example:

      person1.introduce()

      calls the

      introduce

      method on

      person1

• Multiple instances of a class can be created, each with its own set of instance attributes
  • Example:

    person2 = Person("Bob", 30)

    creates another

    Person

    instance with different attribute values

Instance vs class attributes

• Instance attributes are specific to each instance of a class
  • Defined within

    __init__()

    using

    self.attribute_name

  • Each instance has its own copy of instance attributes
    • Example:

      self.name

      and

      self.age

      are instance attributes
  • Accessed and modified using dot notation on the instance:

    instance_name.attribute_name

    • Example:

      person1.name = "Alice"

      modifies the

      name

      attribute of

      person1

• Class attributes are shared by all instances of a class
  • Defined directly within the class, outside of any methods
  • All instances of the class have access to the same class attributes
    • Example:

      species = "Human"

      defined directly in the

      Person

      class
  • Accessed using dot notation on the class itself:

    ClassName.attribute_name

    • Example:

      Person.species

      accesses the

      species

      class attribute
  • Can also be accessed through instances:

    instance_name.attribute_name

    • Example:

      person1.species

      also accesses the

      species

      class attribute
• Uses of instance attributes:
  • Storing data specific to each instance (

    name

    ,

    age

    , etc.)
  • Representing the state or properties of an object
• Uses of class attributes:
  • Storing data shared among all instances of a class (

    species

    , default values, etc.)
  • Defining constants or default values for the class
• Modifying class attributes affects all instances, while modifying instance attributes only affects the specific instance
  • Example: Changing

    Person.species

    affects all

    Person

    instances, but changing

    person1.name

    only affects

    person1

Object-Oriented Programming Concepts

• Encapsulation: Bundling data and methods that operate on that data within a single unit (class)
• Inheritance: Allows a class to inherit attributes and methods from another class
• Polymorphism: Ability of different classes to be treated as instances of the same class through a common interface