Object Oriented Programming in Python

-
In this article, you will learn the Python program and Python program and the basic concepts and examples.

Table of Contents

  • Introduction to OOP in Python
  • Class
  • Object
  • Methods
  • Inheritance
  • Encapsulation
  • Polymorphism
  • Key Points to Remember

Introduction to OOP in Python:

Python is a multi-paradigm program. That is, it supports a variety of programs.
The most popular way to solve the problem by making software programs. This is called a product-oriented program (OOP).
The object has two characteristics:
• characteristics
• Conditions
Let's take an example:
Parrot is a thing,
• Name, age, color characteristics
• Singing, dance is a tradition
Python's program objective is to focus on creating a recyclable number. This idea is also called dry (Do not repeat itself).
In Python, the idea of the program's program is fundamental principles:

Inheritance
A process of using details from a new class without modifying an existing class.
Encapsulation
Hiding the private details of a class from other objects.
Polymorphism
A concept of using common operation in different ways for different data input.

Class:

The class is a type of thing.
We can think of a parrot and a label. This includes all the details about the name, color, size, etc. According to this explanation, we can study the nursery schools. Here, theft is something.
Examples of the Parrot class may be:

Class Parrot:
Pass

Here, we use the keyword in the classroom to describe a clean class design. From class, I will build institutions. Examples are specific items made from a particular class.

Object:

An object (eg) is possible in the classroom. When classified, the only explanation of the item is defined. Therefore, it does not give memory or storage.
Examples of laboratory labels can be Parrot:
Here, the parrot obj classroom.
Please have a description of the brand. Now, we want to show you how to do stuff and classrooms.

class Parrot:

   # class attribute

    species = "bird"

 # instance attribute

    def __init__(self, name, age):

        self.name = name

        self.age = age

 # instantiate the Parrot class

blu = Parrot("Blu", 10)

woo = Parrot("Woo", 15)

 # access the class attributes

print("Blu is a {}".format(blu.__class__.species))

print("Woo is also a {}".format(woo.__class__.species))

 # access the instance attributes

print("{} is {} years old".format( blu.name, blu.age))

print("{} is {} years old".format( woo.name, woo.age))

When we implement the program, productivity will be:

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

Next, we create a classified classroom. Here, Blu and Woo are a reference (value) for a new product.
Then, we find the class features using the __CLASS __. Class sizes are the same in all parts of the classroom. Also, obtain the example attributes used in blu.age blu.name. However, for example, the character is different from any type of class.

Method:

The system of procedures is defined in the classroom. It is used to describe the behavior of the product.

class Parrot:
   # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
   # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)
 def dance(self):
        return "{} is now dancing".format(self.name)
 # instantiate the object
blu = Parrot("Blu", 10)
 # call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

When we implement the program, productivity will be:

Blu sings 'Happy'
Blu is now dancing

In the first program, two methods are defined, which are songs (), and dance (). This system is called for example, because it is in Blu-ray.

Inheritance:

Support is a way to create a new classroom using a classroom that explains nothing. The new class produced by class (or children's classes). Also, there is a classroom (or a parent class).

# parent class
class Bird:
   def __init__(self):
        print("Bird is ready")
   def whoisThis(self):
        print("Bird")
   def swim(self):
        print("Swim faster")
 # child class
class Penguin(Bird):
  def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")
 def whoisThis(self):
        print("Penguin")
  def run(self):
        print("Run faster")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

When we implement this program, production will be:

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

The program was created in two classrooms such as the Teacher (parent class) and penguin (classroom children). the classroom is between the parents' class. We can see the swimming pool (). Again, the classroom has changed the behavior of parents in the classroom. Here we can see this method. Next, we increase classroom parents, so the new way of true ().
We also use super () before __ __init (). This is because we want to produce the __init () types in the classroom for the parents' classroom.

Encapsulation:

Using the Python programming program, we can control the availability of methods and variables. This prevents data transfers from the camps. In Python, we indicate the specific use of the line as a block, such as "_" or "double" or "__".

class Computer:
   def __init__(self):
        self.__maxprice = 900
  def sell(self):
        print("Selling Price: {}".format(self.__maxprice))
  def setMaxPrice(self, price):
        self.__maxprice = price
 c = Computer()
c.sell()
 # change the price
c.__maxprice = 1000
c.sell()
 # using setter function
c.setMaxPrice(1000)
c.sell()

When we implement this program, production will be:

Selling Price: 900
Selling Price: 900
Selling Price: 1000

The highest level of our program is defined in the computer class. We use the __ __init () method for the computer. We try to evaluate the value. However, we can not change because Python works on __maxprice like the private sector. To change the value, the setMaxPrice service is used, ie, where () it takes the value of the item.

Polymorphism:

Polymorphism is the power (in OOP) using a common interface in several types (data type).
Tell them that we have color schemes, there are different types of rails (rails, square, circle). However, we can use the same methods and different color types. This idea is called polymorphism.

 class Parrot:
 def fly(self):
        print("Parrot can fly")
   def swim(self):
        print("Parrot can't swim")
 class Penguin:
 def fly(self):
        print("Penguin can't fly")
   def swim(self):
        print("Penguin can swim")
 # common interface
def flying_test(bird):
    bird.fly()
 #instantiate objects
blu = Parrot()
peggy = Penguin()
 # passing the object
flying_test(blu)
flying_test(Peggy)

When we implement the old program, productivity will be:

Parrot can fly
Penguin can't fly

 In the first two classes, we multiply the exercise and penguin. Each of them must be the way ().

To getting expect level training for Python training in your Location – Python training in Chennai | Python training institute in Chennai | Python Course institute in Chennai | Python training in Bangalore | Python training institute in Bangalore | Python training in Electronic City | Python training in Jaya Nagar | Python training in Pune | Python training institute in Pune | Python training in OMR | Python training in Velachery | Python training in Tambaram | Python training in Annanagar | Python training in Marathahalli | Python training in Btm | Python Online Training | Online Certification Course | Python Course in Chennai | Python interview questions and answers | Python tutorials | Python training in Indira Nagar | Python Course in Btm | Python Course in Marathahalli | Python training institute in Marathahalli | Python course institute in Btm | Python course in Electronic City | Python online training in Chennai | Python online training in Bangalore

 

Comments

Post a Comment

Popular posts from this blog

Python – Functions

-
Functions is a structured and reusable organization that is used to perform only practical action. The  Python  Function will regularly make your application and a higher level of reuse. As you have already learned, Python offers many local functions such as print (), etc., but you can also create your own work. These staff are called user-defined. Defining a Function You can describe jobs to pay for necessary work. Here are some simple rules to describe Python’s activities. The types of activity begin with the main language followed by the name of the job and the cards (). All borders or panels should be placed inside. You can also do the holes in these articles. The first evidence of action can be voluntary training – documented work document or document. The pulse code for each function starts with a clot (:) and goes backwards. The return statement [presentation] deletes the action, submitting it voluntarily to the applicant. Evidence of return w...
Read more

What is Django in python?

-
Django is a high level of  Python  that promotes rapid development and clean and elegant design. Django facilitates the creation of web applications faster and less. Django is an open free application system in Python. The design is far beyond the scope of facilitating development. They contain and allow you to create applications or locations from existing sources rather than scratch. Django in Python: This is how websites - even simplified by one person - they still have features such as waiting support, management and management, contact forms, comment boxes, uploading files and more. In other words, if you create scratches, you will need to improve these parts alone. When you use this structure, these sections are built, which you do not fit properly to fit your site. The official website describes Django as a " python web-based web site that promotes rapid development and pure design, developed by experienced developers, has a lot of improvements, so that you c...
Read more

Python Global Keyword

-
In this article, you will learn a lot about important international roles, the world, and the use of an important global keyword. Table of Contents Python global Keyword Rules of global Keyword Use of global Keyword (With Example) Global Variables Across Python Modules Global in Nested Functions in Python Before reading this article, be sure to have some of the Global Python foundations inside and outside. Python global Keyword: In Python, the important international word allows the change of variables outside of the scope of today. It is used to make global variables and variables to create a change in the environmental situation. Rules of global Keyword: Basic rules for the keyword in Python are: • If we make changes to work, which is at a level. • If a variable is left out of the operation, which is an international standard. You should not use the important international word. • We use words that are keywords for reading and writing across the gl...
Read more