Python has been an object-oriented language from the very beginning, and because of this, it is easy to create a class and object in Python.
class definition
The syntax format is as follows:
class ClassName:
<statement-1>
.
.
.
<statement-N>
class object
Class objects support two operations: property reference and instantiation.
Attribute references use the same standard syntax as all attribute references in Python: obj.name.
After the object is created, all names in the class namespace are valid property names. So if the class definition is like this:
class MyClass:
"""一个简单的类实例"""
i = 12345
def f(self):
return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
The output of executing the above program is:
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world
__init__() method
Many classes tend to create objects with an initial state. So a class might define a special method (constructor) called __init__() like this:
def __init__(self):
self.data = []
If the class defines the __init__() method, the instantiation operation of the class will automatically call the __init__() method. So in the following example, a new instance can be created like this:
x = MyClass()
Of course, the __init__() method can have parameters, which are passed to the instantiation of the class through __init__(). E.g:
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i) # 输出结果：3.0 -4.5
self represents the instance of the class, not the class
Methods of a class have only one special difference from ordinary functions - they must have an extra first parameter name, which by convention is named self.
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
The execution result of the above example is:
<__main__.Test instance at 0x100771878>
__main__.Test
It is obvious from the execution result that self represents the instance of the class, the address of the current object, and self.class points to the class.
self is not a python keyword , we can also execute it normally by replacing it with runoob:
class Test:
def prt(runoob):
print(runoob)
print(runoob.__class__)
t = Test()
t.prt()
The execution result of the above example is:
<__main__.Test instance at 0x100771878>
__main__.Test
class method
Inside the class, use the def keyword to define a method. Unlike the general function definition, the class method must contain the parameter self, which is the first parameter, and self represents the instance of the class.
#类定义
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('runoob',10,30)
p.speak()
The output of executing the above program is:
runoob 说: 我 10 岁。
inherit
class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>
It is necessary to pay attention to the order of the base classes in the parentheses. If the base class has the same method name, but it is not specified when the subclass is used, python searches from left to right, that is, when the method is not found in the subclass, it searches from left to right Whether the base class contains methods.
BaseClassName (the base class name in the example) must be defined in the same scope as the derived class. In addition to classes, expressions can also be used, which is useful when the base class is defined in another module:
class DerivedClassName(modname.BaseClassName):
Example
#类定义
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 output of executing the above program is:
ken 说: 我 10 岁了，我在读 3 年级
multiple inheritance
Python also has limited support for forms of multiple inheritance. A class definition for multiple inheritance looks like this:
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
Example
#类定义
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() #方法名同，默认调用的是在括号中排前地父类的方法
method overriding
If the function of your parent class method does not meet your needs, you can override your parent class method in the subclass, the example is as follows:
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
super() 函数是用于调用父类(超类)的一个方法。
The output of executing the above program is:
调用子类方法
调用父类方法
class properties and methods
class private properties
__private_attrs: Starting with two underscores, declares that the attribute is private and cannot be used or directly accessed outside the class. When using self.__private_attrs in a method inside a class.
class method
Inside the class, use the def keyword to define a method. Unlike the general function definition, the class method must contain the parameter self, which is the first parameter, and self represents the instance of the class.
The name of self is not intended to be dead, and this can also be used, but it is better to use self by convention.
class private method
__private_method: Starts with two underscores, declaring that the method is a private method, which can only be called inside the class, not outside the class. self.__private_methods.
Example 1
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) # 报错，实例不能访问私有变量
output result
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'
Example 2
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.runoob.com')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错
output result
Traceback (most recent call last):
File "D:\python-workspace\helloworld\learn\module\using_sys.py", line 20, in <module>
x.__foo() # 报错
AttributeError: 'Site' object has no attribute '__foo'
name : 菜鸟教程
url : www.runoob.com
这是公共方法
这是私有方法
Class-specific methods:
- __init__ : constructor, called when the object is generated
- __del__ : destructor, used when the object is released
- __repr__ : print, convert
- __setitem__ : assign value by index
- __getitem__: get value by index
- __len__: get the length
- __cmp__: comparison operation
- __call__: function call
- __add__: addition operation
- __sub__: Subtraction
- __mul__: Multiplication
- __div__: division operation
- __mod__: remainder operation
- __pow__: exponentiation
operator overloading
Python also supports operator overloading. We can overload the proprietary methods of the class. Examples are as follows:
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 result of executing the above code is as follows:
Vector(7,8)