📅  最后修改于: 2020-09-19 14:06:22             🧑  作者: Mango
Python是一种多范式编程语言。它支持不同的编程方法。
解决编程问题的一种流行方法是创建对象。这就是所谓的面向对象编程(OOP)。
一个对象具有两个特征:
让我们举个例子:
Parrot可以是一个对象,因为它具有以下属性:
Python的OOP概念专注于创建可重用的代码。此概念也称为DRY(不要重复自己)。
在Python,OOP的概念遵循一些基本原则:
类是对象的蓝图。
我们可以将类看作是带有标签的Parrot的素描。它包含有关名称,颜色,大小等的所有详细信息。基于这些描述,我们可以研究Parrot。在这里,Parrot是一个对象。
Parrot类的示例可以是:
class Parrot:
pass
在这里,我们使用class
关键字定义一个空类Parrot
。从类中,我们构造实例。实例是从特定类创建的特定对象。
对象(实例)是类的实例。定义类时,仅定义对象的描述。因此,没有分配内存或存储。
Parrot类对象的示例可以是:
obj = Parrot()
在这里, obj
是Parrot
类的对象。
假设我们有Parrot的详细信息。现在,我们将展示如何构建Parrot的类和对象。
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))
输出
Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old
在上面的程序中,我们创建了一个名为Parrot
的类。然后,我们定义属性。属性是对象的特征。
这些属性在类的__init__
方法中定义。创建对象后,首先运行的是初始化方法。
然后,我们创建Parrot
类的实例。在这里, blu
和woo
是我们新对象的引用(值)。
我们可以使用__class__.species
访问class属性。类的所有实例的类属性都相同。同样,我们使用blu.name
和blu.age
访问实例属性。但是,类的每个实例的实例属性都不同。
要了解有关类和对象的更多信息,请转到Python类和对象。
方法是在类主体中定义的函数。它们用于定义对象的行为。
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())
输出
Blu sings 'Happy'
Blu is now dancing
在上面的程序中,我们定义了两种方法,即sing()
和dance()
。这些被称为实例方法,因为它们是在实例对象(即blu
上调用的。
继承是创建新类以使用现有类的详细信息而不进行修改的一种方式。新形成的类是派生类(或子类)。同样,现有类是基类(或父类)。
# 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()
输出
Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster
在上面的程序中,我们创建了两个类,即Bird
(父类)和Penguin
(子类)。子类继承父类的功能。我们可以从swim()
方法中看到这一点。
子类再次修改了父类的行为。我们可以从whoisThis()
方法中看到这一点。此外,我们通过创建新的run()
方法来扩展父类的功能。
此外,我们在__init__()
方法内使用了super()
函数 。这使我们可以在子类中运行父类的__init__()
方法。
在Python使用OOP,我们可以限制对方法和变量的访问。这样可以防止数据直接修改(称为封装)。在Python,我们使用下划线作为前缀来表示私有属性,即单_
或双__
。
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()
输出
Selling Price: 900
Selling Price: 900
Selling Price: 1000
在上面的程序中,我们定义了一个Computer
类。
我们使用__init__()
方法存储Computer
的最高售价。我们试图修改价格。但是,我们无法更改它,因为Python将__maxprice
视为私有属性。
如图所示,要更改该值,我们必须使用一个setter 函数,即setMaxPrice()
,该函数将price作为参数。
多态性是一种功能(在OOP中),可以将公共接口用于多种形式(数据类型)。
假设我们需要给一个形状着色,有多个形状选项(矩形,正方形,圆形)。但是,我们可以使用相同的方法为任何形状着色。这个概念称为多态。
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)
输出
Parrot can fly
Penguin can't fly
在上面的程序中,我们定义了两个类Parrot
和Penguin
。它们每个都有一个通用的fly()
方法。但是,它们的功能不同。
为了使用多态,我们创建了一个通用接口,即flying_test()
函数 ,该函数接受任何对象并调用该对象的fly()
方法。因此,当我们在flying_test()
函数传递了blu
和peggy
对象时,它有效地运行了。