Python Creating a Class

To create a class in Python code, use the class keyword followed by the class name and a colon.

Classes often include an __init__() method, also called a constructor. __init__(), which has two
underscores as prefixes and suffixes, is a special method to initialize (or set initial values for) class
attributes. These are known as instance attributes, as they are specific to each instance of the class.

class MyClass:

def __init__(self, attribute1, attribute2):

self.attribute1 = attribute1

self.attribute2 = attribute2

class: The keyword to start a class definition in Python.

MyClass: The name of the class, typically with every word in capitals, including the first word.

__init__: The constructor (or init) method to set default values for the new instance.

self: A parameter to reference the new instance.

attribute1, attribute2: Attributes of the class, often referred to as instance variables.

The attribute name is used to assign unique properties to each instance. Each class can define multiple
instance attributes, allowing for flexible object creation.

Python Creating an Instance of a Class

To create a new Python object from a class, call the class like a function, passing any required arguments
to the constructor. This instantiation process allows you to create multiple objects from the same class,
each with its own unique set of data, defined by their instance attributes.

my_object = MyClass("value1", "value2")

MyClass: The name of the class you want to use as a template for the new object.

my_object: The variable name for the new instance of the class.

Creating Class Methods

Class methods define a class's behavior and allow instances of a class to perform specific actions. You
can define class methods using the def keyword inside the class body and use them to operate on
instance data or perform tasks.

class MyClass:

def __init__(self, attribute1, attribute2):

self.attribute1 = attribute1

self.attribute2 = attribute2

def my_method(self):

return f"Attributes are: {self.attribute1} and {self.attribute2}"

# Creating an instance and calling a class method

my_object = MyClass("value1", "value2")

print(my_object.display_attributes())

# Outputs: 'Attributes are: value1 and value2'

Calling Class Methods

In Python, methods can operate on instance data or perform specific tasks. You can call
methods from a class to perform actions or retrieve data. To call a method, you use the syntax
my_object.my_method(), which accesses the method from the class instance.

class Greeting:

def __init__(self, name):

self.name = name

def say_hello(self):

return f"Hello, {self.name}!"

# Creating an instance

greet = Greeting("Alice")

# Calling an instance method

message = greet.say_hello()

print(message) # Outputs: 'Hello, Alice!'

Generator

Greater than operator

Greater than or equal to operator

If statement

in operator

Indices

Python Class: Syntax and Examples [Python Tutorial]

In Python, classes bundle data and functionality within templates you can use to create objects from.
How to Use Python Classes

Classes are a fundamental component of object-oriented programming (OOP). With classes, you can
turn complex systems into objects using data structures like dictionaries, lists, and tuples.

Python’s class syntax is easy to learn for beginners and similar to that of other programming languages
(e.g., Java). Here’s a brief intro:

Python Creating a Class

To create a class in Python code, use the class keyword followed by the class name and a colon.

Classes often include an __init__() method, also called a constructor. __init__(), which has two
underscores as prefixes and suffixes, is a special method to initialize (or set initial values for) class
attributes. These are known as instance attributes, as they are specific to each instance of the class.

Copy Code

class MyClass:

def __init__(self, attribute1, attribute2):

self.attribute1 = attribute1

self.attribute2 = attribute2

class: The keyword to start a class definition in Python.

MyClass: The name of the class, typically with every word in capitals, including the first word.

__init__: The constructor (or init) method to set default values for the new instance.

self: A parameter to reference the new instance.

attribute1, attribute2: Attributes of the class, often referred to as instance variables.

The attribute name is used to assign unique properties to each instance. Each class can define multiple
instance attributes, allowing for flexible object creation.

Python Creating an Instance of a Class

To create a new Python object from a class, call the class like a function, passing any required arguments
to the constructor. This instantiation process allows you to create multiple objects from the same class,
each with its own unique set of data, defined by their instance attributes.

Copy Code

my_object = MyClass("value1", "value2")

MyClass: The name of the class you want to use as a template for the new object.

my_object: The variable name for the new instance of the class.

Creating Class Methods

Class methods define a class's behavior and allow instances of a class to perform specific actions. You
can define class methods using the def keyword inside the class body and use them to operate on
instance data or perform tasks.

Copy Code

class MyClass:

def __init__(self, attribute1, attribute2):

 self.attribute1 = attribute1

self.attribute2 = attribute2

def my_method(self):

return f"Attributes are: {self.attribute1} and {self.attribute2}"

# Creating an instance and calling a class method

my_object = MyClass("value1", "value2")

print(my_object.display_attributes())

# Outputs: 'Attributes are: value1 and value2'

Calling Class Methods

In Python, methods can operate on instance data or perform specific tasks. You can call methods from a
class to perform actions or retrieve data. To call a method, you use the syntax my_object.my_method(),
which accesses the method from the class instance.

Copy Code

class Greeting:

def __init__(self, name):

self.name = name

def say_hello(self):
 return f"Hello, {self.name}!"

# Creating an instance

greet = Greeting("Alice")

# Calling an instance method

message = greet.say_hello()

print(message) # Outputs: 'Hello, Alice!'

When to Use Classes in Python

Classes in Python programming help you group behavior and data. They provide a structured way to
define and organize the properties and behaviors that different objects should have.

Encapsulation of Data and Methods

You can use classes to group related data and methods. This makes your code easier to manage and
helps prevent accidental changes. For example, encapsulation helps you hide the implementation details
of algorithms and limit access to class attributes.

class Book:

def __init__(self, title, author, is_available=True):

self.title = title

self.author = author

self.is_available = is_available

def display_info(self):
 return f"{self.title} by {self.author}"

def check_availability(self):

return self.is_available

book = Book("1984", "George Orwell", is_available=False)

print(book.check_availability()) # Outputs: False

Modeling the Real World

You can use classes to resemble the natural world in your application. This approach is beneficial for
applications that simulate real-world systems, such as inventory management or customer tracking.
Creating a class for each entity ensures that your application accurately represents and manages these
entities.

class Car:

def __init__(self, make, model, year):

self.make = make

self.model = model

self.year = year

def car_details(self):

return f"{self.year} {self.make} {self.model}"

Inheritance for Code Reuse

You can also create new classes to extend existing classes, reusing code and reducing unnecessary
repetition. Inheritance helps you build a hierarchy of classes that share some functionality while
allowing for specialized behavior in subclasses. Using inheritance, the derived class (e.g., ElectricCar)
inherits attributes and methods from a parent class (e.g., Car).

class ElectricCar(Car):

def __init__(self, make, model, year, battery_size):

super().__init__(make, model, year)

self.battery_size = battery_size

def battery_info(self):

return f"Battery size: {self.battery_size} kWh"

Python Class Examples

Customer Database Application

A customer database application might use classes to handle customer records. Each customer can have
a name, email address, and purchase history (stored as a dict). Class methods like add_purchase() can
update a customer’s purchase history by working with instance attributes.

class Customer:

def __init__(self, customer_id, name, email):

self.customer_id = customer_id

self.name = name

self.email = email

self.purchase_history = []
 def update_email(self, new_email):

self.email = new_email

def add_purchase(self, item, amount):

self.purchase_history.append({'item': item, 'amount': amount})

def get_purchase_history(self):

return self.purchase_history

customer1 = Customer(1, "Alice", "[email protected]")

customer1.update_email("[email protected]")

customer1.add_purchase("Laptop", 1200)

print(customer1.get_purchase_history()) # Outputs: [{'item': 'Laptop', 'amount': 1200}]

Here, customer_id, name, and email are examples of instance attributes used to store individual
customer details.

Inventory Management System

An inventory management system might use classes to represent items in stock. Each item can be an
instance of an InventoryItem class, with methods to work on item data.

class InventoryItem:

def __init__(self, item_id, name, quantity):

 self.item_id = item_id

self.name = name

self.quantity = quantity

def update_quantity(self, new_quantity):

self.quantity = new_quantity

def item_details(self):

return f"ID: {self.item_id}, Name: {self.name}, Quantity: {self.quantity}"

item1 = InventoryItem(101, "Laptop", 50)

item1.update_quantity(45)

print(item1.item_details()) # Outputs: 'ID: 101, Name: Laptop, Quantity: 45'

E-commerce Platform

An e-commerce platform might use classes to handle orders. Each order can be an instance of an Order
class. Python class methods can add items, calculate the total price, and retrieve order details.

class Order:

def __init__(self, order_id, customer):

self.order_id = order_id

self.customer = customer

self.items = []

def add_item(self, item_name, price, quantity):

 self.items.append({'item_name': item_name, 'price': price, 'quantity': quantity})

def total_price(self):

return sum(item['price'] * item['quantity'] for item in self.items)

def order_details(self):

return {'order_id': self.order_id, 'customer': self.customer, 'items': self.items, 'total':

self.total_price()}

order1 = Order(1, "Alice")

order1.add_item("Laptop", 1200, 1)

order1.add_item("Mouse", 25, 2)

print(order1.order_details()) # Outputs order details with total price