📜  面向对象的Python构建块

📅  最后修改于: 2021-01-04 04:41:32             🧑  作者: Mango


在本章中,我们将详细讨论面向对象的术语和编程概念。类只是实例的工厂。该工厂包含描述如何制作实例的蓝图。从类构造实例或对象。在大多数情况下,一个类可以有多个实例。每个实例都有一组属性,并且这些属性是在类中定义的,因此特定类的每个实例都应具有相同的属性。

类组合:行为和状态

一个类可以让您将对象的行为和状态捆绑在一起。观察下图以更好地理解-

捆绑

讨论类包时,以下几点值得注意:

  • 行为”一词与“函数”相同–它是一段代码(执行某项行为(或实现某种行为))

  • 状态一词与变量相同–它是在类中存储值的地方。

  • 当我们声明一个类的行为并一起声明状态时,这意味着一个类将函数和变量打包在一起。

类具有方法和属性

在Python,创建方法定义了类行为。 “方法”一词是给在类中定义的函数的OOP名称。总结-

  • 类函数-是方法的同义词

  • 类变量-是名称属性的同义词

  • -具有确切行为的实例的蓝图。

  • 对象-类的实例之一,执行在类中定义的功能。

  • 类型-表示实例所属的类

  • 属性-任何对象值:object.attribute

  • 方法-类中定义的“可调用属性”

观察以下代码,例如-

var = “Hello, John”
print( type (var)) # ‘str’> or 
print(var.upper()) # upper() method is called, HELLO, JOHN

创建和实例化

以下代码显示了如何创建我们的第一个类,然后创建其实例。

class MyClass(object):
   pass
# Create first instance of MyClass
this_obj = MyClass()
print(this_obj)
# Another instance of MyClass
that_obj = MyClass()
print (that_obj)

在这里,我们创建了一个名为MyClass的类,该类不执行任何任务。 MyClass类中的参数对象涉及类继承,将在后面的章节中进行讨论。上面的代码中的pass表示此块为空,即它是一个空的类定义。

让我们创建MyClass()类的实例this_obj并将其打印出来,如下所示:

<__main__.myclass object="" at="">
<__main__.myclass object="" at="">

在这里,我们创建了MyClass的实例十六进制代码是指存储对象的地址。另一个实例指向另一个地址。

现在让我们在类MyClass()中定义一个变量,并从该类的实例中获取该变量,如以下代码所示:

class MyClass(object):
   var = 9

# Create first instance of MyClass
this_obj = MyClass()
print(this_obj.var)

# Another instance of MyClass

that_obj = MyClass()
print (that_obj.var)

输出

执行上面给出的代码时,您可以观察到以下输出:

9
9

实例知道是从哪个类实例化的,因此从实例请求属性时,实例将查找属性和类。这称为属性查找。

实例方法

类中定义的函数称为方法。实例方法需要一个实例才能调用它,并且不需要装饰器。创建实例方法时,第一个参数始终是self。尽管我们可以用其他任何名称来称呼它(自我),但还是建议使用自我,因为这是命名约定。

class MyClass(object):
   var = 9
   def firstM(self):
      print("hello, World")
obj = MyClass()
print(obj.var)
obj.firstM()

输出

执行上面给出的代码时,您可以观察到以下输出:

9
hello, World

注意,在上面的程序中,我们定义了一个以self为参数的方法。但是我们无法调用该方法,因为我们尚未对其声明任何参数。

class MyClass(object):
   def firstM(self):
      print("hello, World")
      print(self)
obj = MyClass()
obj.firstM()
print(obj)

输出

执行上面给出的代码时,您可以观察到以下输出:

hello, World
<__main__.myclass object="" at="">
<__main__.myclass object="" at="">

封装形式

封装是OOP的基础之一。 OOP使我们能够隐藏对象内部工作的复杂性,这在以下方面对开发人员有利:

  • 简化了使用对象的过程,使其易于理解,而无需了解内部原理。

  • 任何更改都可以轻松管理。

面向对象的编程严重依赖封装。术语封装和抽象(也称为数据隐藏)通常用作同义词。它们几乎是同义词,因为抽象是通过封装实现的。

封装为我们提供了限制访问某些对象组件的机制,这意味着无法从对象定义的外部看到对象的内部表示。通常通过特殊方法-GettersSetters可以访问此数据

此数据存储在实例属性中,并且可以在类外部的任何地方进行操作。为了保护数据安全,只能使用实例方法访问该数据。不允许直接访问。

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())

zack.setAge("Fourty Five")
print(zack.getAge())

输出

执行上面给出的代码时,您可以观察到以下输出:

45
Fourty Five

使用异常处理构造,只有在数据正确且有效时才应存储该数据。正如我们在上面看到的,对setAge()方法的用户输入没有任何限制。它可以是字符串,数字或列表。因此,我们需要检查以上代码以确保存储的正确性。

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age
zack = MyClass()
zack.setAge(45)
print(zack.getAge())
zack.setAge("Fourty Five")
print(zack.getAge())

初始化构造函数

实例化一个类的对象后会隐式调用__ init __方法,这将初始化该对象。

x = MyClass()

上面显示的代码行将创建一个新实例,并将此对象分配给局部变量x。

实例化操作(即调用类对象)将创建一个空对象。许多类喜欢创建具有定制为特定初始状态的实例的对象。因此,一个类可以定义一个名为’__init __()’的特殊方法,如下所示:

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

Python在实例化期间调用__init__来定义在实例化类时应该出现的附加属性,该类可能正在为该对象设置一些初始值或运行实例化所需的例程。因此,在此示例中,可以通过以下方式获取新的初始化实例:

x = MyClass()

__init __()方法可以具有单个或多个参数,以提高灵活性。初始化代表初始化,因为它初始化实例的属性。它称为类的构造函数。

class myclass(object):
   def __init__(self,aaa, bbb):
      self.a = aaa
      self.b = bbb

x = myclass(4.5, 3)
print(x.a, x.b)

输出

4.5 3

类属性

在类中定义的属性称为“类属性”,在函数定义的属性称为“实例属性”。在定义时,这些属性不以自身为前缀,因为它们是类的属性,而不是特定实例的属性。

可以通过类本身(className.attributeName)以及类实例(inst.attributeName)来访问类属性。因此,实例可以访问实例属性以及类属性。

>>> class myclass():
   age = 21
>>> myclass.age
21
>>> x = myclass()
>>> x.age
21
>>>

即使不是破坏封装的好方法,也可以在实例中覆盖class属性。

在Python有一个属性查找路径。第一个是在类中定义的方法,然后是其上方的类。

>>> class myclass(object):
   classy = 'class value'
>>> dd = myclass()
>>> print (dd.classy) # This should return the string 'class value'
class value
>>>
>>> dd.classy = "Instance Value"
>>> print(dd.classy) # Return the string "Instance Value"
Instance Value
>>>
>>> # This will delete the value set for 'dd.classy' in the instance.
>>> del dd.classy
>>> >>> # Since the overriding attribute was deleted, this will print 'class
value'.

>>> print(dd.classy)
class value
>>>

我们将在实例dd中覆盖“ classy”类属性。覆盖后, Python解释器将读取覆盖的值。但是,一旦使用“ del”删除了新值,该替换值就不再存在于实例中,因此,查找将向上一个级别并从类中获取它。

使用类和实例数据

在本节中,让我们了解类数据与实例数据之间的关系。我们可以将数据存储在类或实例中。在设计类时,我们决定哪些数据属于实例,哪些数据应存储到整个类中。

实例可以访问类数据。如果我们创建多个实例,则这些实例可以访问其各自的属性值以及整体类数据。

因此,类数据是在所有实例之间共享的数据。遵守下面给出的代码以更好地理解-

class InstanceCounter(object):
   count = 0 # class attribute, will be accessible to all instances
   def __init__(self, val):
      self.val = val
      InstanceCounter.count +=1 # Increment the value of class attribute, accessible through class name
# In above line, class ('InstanceCounter') act as an object
   def set_val(self, newval):
      self.val = newval

   def get_val(self):
      return self.val

   def get_count(self):
      return InstanceCounter.count
a = InstanceCounter(9)
b = InstanceCounter(18)
c = InstanceCounter(27)

for obj in (a, b, c):
   print ('val of obj: %s' %(obj.get_val())) # Initialized value ( 9, 18, 27)
   print ('count: %s' %(obj.get_count())) # always 3

输出

val of obj: 9
count: 3
val of obj: 18
count: 3
val of obj: 27
count: 3

简而言之,类属性对于类的所有实例都是相同的,而实例属性对于每个实例都是特定的。对于两个不同的实例,我们将具有两个不同的实例属性。

class myClass:
   class_attribute = 99

   def class_method(self):
      self.instance_attribute = 'I am instance attribute'

print (myClass.__dict__)

输出

执行上面给出的代码时,您可以观察到以下输出:

{'__module__': '__main__', 'class_attribute': 99, 'class_method': , '__dict__': , '__weakref__': , '__doc__': None}

实例属性myClass .__ dict__如图所示-

>>> a = myClass()
>>> a.class_method()
>>> print(a.__dict__)
{'instance_attribute': 'I am instance attribute'}