Latest web development tutorials

Python3 Object-Oriented

Python has been designed from the start is an object-oriented language, and as such, create a class and objects in Python is very easy. This section we will detail the object-oriented programming in Python.

If you have not been exposed to object-oriented programming language, then you may need to first understand some of the basic features of object-oriented languages, formed in the mind inside a basic concept of object-oriented, which helps you more easily learn the Python object-oriented programming.

Next, let's take a simple understanding of object-oriented under some basic features.


Object-Oriented Technology Overview

  • Class (Class): used to describe the collection have the same properties and methods of objects. It defines a set of properties and methods common to each object. Objects are instances of classes.
  • Class variables: class variables is common throughout the instantiated object. Class variables defined and outside the function in the class in. Class variables not normally used as instance variables.
  • Data members: class variables or instance variables for the associated data processing classes and instance objects.
  • Overrides: If you can not meet the needs of a subclass inherits from the parent class method, it can be rewritten, a process called overlay method (override), also known as the overriding method.
  • Examples of variables: variables defined in the method, only the role of the class of the current instance.
  • Inheritance: That is a derived class (derived class) inherits the base class (base class) fields and methods. Inheritance also allows a derived class object as a base class object treat. For example, there is such a design: an object type that is derived from a Dog Animal class, which is an analog "is a (is-a)" relationship (Fig example, is a Dog Animal).
  • Instantiate: create an instance of a class, the specific object class.
  • Methods: The class-defined functions.
  • Object: data structure instance through the class definition. Data objects include two members (class and instance variables) and methods.

And other programming languages, Python at a minimum of new syntax and semantics of the situation to join the class mechanism.

Python classes in object-oriented programming provides all the basic functions: the class inheritance mechanism allows multiple base classes, the base class in derived classes can override any methods, you can call the base class method of the same name.

Objects can contain any number and type of data.

Class definition

Syntax is as follows:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

After the class is instantiated, you can use its properties, in fact, after you create a class, you can access its properties via the class name.

Class object

Class objects support two kinds of operations: attribute references and instantiation.

Attribute references use Python for all attribute references the standardsyntax: obj.name.

After the class object was created class namespace attribute all the names are valid names. So, if the class definition looked like this:

#!/usr/bin/python3

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为:", x.i)
print("MyClass 类的方法 f 输出为:", x.f())

Instantiate the class:

# 实例化类
x = MyClass()
# 访问类的属性和方法

Above creates a new instance of the class and assigns this object to the local variable x, x empty object.

The above program output is:

MyClass 类的属性 i 为: 12345
MyClass 类的方法 f 输出为: hello world

Many classes like to create objects in a known initial state. Therefore a class may define a named __init __ () special method (constructor), like this:

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

Class defines __init __ () method, then the class instantiation operator will automatically call __init __ () method. So in this example, it can be to create a new instance:

x = MyClass()

Of course, __init __ () method may have arguments, parameters __init __ () is passed to the class instantiation operator. E.g:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Class methods

In the terrestrial interior, use def keyword can be defined as a class method, different definitions and general functions, class methods must include the parameter self, and as the first parameter:

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('w3big',10,30)
p.speak()

The above program output is:

w3big 说: 我 10 岁。

inherit

Python also supports class inheritance, if a language does not support inheritance, the class has little meaning. Definition of the derived class as follows:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

Note that the order of the base class in parentheses, if the base class has the same method name, but without specifying subclasses, python from left to right search method that is not found in the sub-class, from left to right to find base class contains methods.

BaseClassName (example base class name) must be defined in a derived class scope. In addition to classes, you can use the expression, the base class is defined in another module, which is very useful for:

class DerivedClassName(modname.BaseClassName):

Examples

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))



s = student('ken',10,60,3)
s.speak()

The above program output is:

ken 说: 我 10 岁了,我在读 3 年级

Multiple Inheritance

Python supports a limited form of multiple inheritance. Multiple inheritance class definition looks as follows:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

Note that the order in parentheses parent class, if the parent class have the same method name, but without specifying subclasses, python from left to right search method that is not found in the sub-class, from left to right to find parent class contains methods.

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类,多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s,我是一个演说家,我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同,默认调用的是在括号中排前地父类的方法

The above program output is:

我叫 Tim,我是一个演说家,我演讲的主题是 Python

Method overrides

If the function you are the parent class method can not meet your needs, you can rewrite your parent class method in a subclass, examples are as follows:

#!/usr/bin/python3

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

The above program output is:

调用子类方法

Class attributes and methods

Private property class

__private_attrs: beginning two underscores stating that the property is private and can not be used or accessed directly in the class externally. Self .__ private_attrs when used within a class method.

Class methods

In the terrestrial interior, use def keyword can be defined as a class method with the general definition of the different functions, class methods must include the parameter self, and as the first parameter

Private methods of class

__private_method: the first two underscore, the method is declared as private methods in the class can not call externally. Internal class call slef .__ private_methods.

Examples

Private property instance of the class as follows:

#!/usr/bin/python3

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错,实例不能访问私有变量

The above program output is:

1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错,实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

Private method instance of the class as follows:

#!/usr/bin/python3

class Site:
	def __init__(self, name, url):
		self.name = name       # public
		self.__url = url   # private

	def who(self):
		print('name  : ', self.name)
		print('url : ', self.__url)

	def __foo(self):          # 私有方法
		print('这是私有方法')

	def foo(self):            # 公共方法
		print('这是公共方法')
		self.__foo()

x = Site('本教程', 'www.w3big.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

The results of the above examples:

Proprietary methods of the class:

  • __init__: constructor is called when an object is generated
  • __del__: destructor, the release objects
  • __repr__: printing, conversion
  • __setitem__: according to the index assignment
  • __getitem__: Gets the value in index
  • __len__: get length
  • __cmp__: comparison operation
  • __call__: function call
  • __add__: add operation
  • __sub__: subtraction
  • __mul__: multiplication
  • __div__: division operation
  • __mod__: remainder operator
  • __pow__: called party

Operator Overloading

Python also supports operator overloading, what I can be overloaded class proprietary methods, examples are as follows:

#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

The above code execution results are as follows:

Vector(7,8)