The best Python3 Object-Oriented Tutorial In 2024, In this tutorial you can learn Object-Oriented Technology Overview,Class definition,Class object,Class methods,inherit,Multiple Inheritance,Method overrides,Class attributes and methods,
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.
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.
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 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: /en. def __init__(self, realpart, imagpart): /en. self.r = realpart /en. self.i = imagpart /en. >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
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 岁。
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):
#!/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 年级
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
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:
调用子类方法
__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.
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_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.
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.w3write.com') x.who() # 正常输出 x.foo() # 正常输出 x.__foo() # 报错
The results of the above examples:
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)