26.Python3面向对象编程｜菜鸟教程

​​​​​​参考文章Python3 面向对象 | 菜鸟教程

第三遍梳理

目录

1.技术简介

2.类定义

3.类对象

4.self代表类的实例，而非类 

5.类的方法

代码实例：

运行结果：

6.继承

代码实例：

运行结果：

7.多继承

代码实例：

 运行结果：

8.方法重写

代码实例：

 运行结果： 

super()函数

9.类属性与方法

类的私有属性

类的方法

类的私有方法

类的私有属性实例如下：

 运行结果： 

类的私有方法实例如下：

运行结果：  

类的专有方法

运算符重载

代码实例：

运行结果：  

---

1.技术简介

类：描述具有相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

方法：类中定义的函数。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量称为实例变量，实例变量就是一个用self修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.类定义

class ClassName:
    
    ·
    ·
    ·
    

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

3.类对象

类对象支持两种操作：属性引用和实例化；属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。

如果类定义如下：

class MyClass:
    i = 12345
    def f(self):
        return 'hello world'

#实例化类
x = MyClass()

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

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

类有一个名为__init__()的特殊方法（构造方法），该方法在类实例化时会自动调用：

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

类定义了 __init__()方法，类的实例化操作会自动调用__init__()方法。如下实例化MyClass, 对应的 __init__() 方法就会被调用:

x = MyClass()

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上,eg: 

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

4.self代表类的实例，而非类 

类的方法与普通的函数只有一个特别的区别，它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
t = Test()
t.prt()
#output = 
# <__main__.Test object at 0x1081afc70>
# 

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

class Test:
    def prt(runoob):
        print(runoob)
        print(runoob.__class__)
t = Test()
t.prt()
#output = 
# <__main__.Test object at 0x103f9f1f0>
# 

5.类的方法

在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例。

代码实例：

#类定义

class people:
    #定义基本属性
    __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()

运行结果：

6.继承

Python同样支持类的继承，如果一种语言不支持继承，类就没意义。派生类的定义如下所所示：

class DerivedClassName(BaseClassName):
    
    .
    .
    .
    

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法，BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

代码实例：

#类定义

from multiprocessing import set_forkserver_preload


class people:
    #定义基本属性
    __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()

#单继承示例
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()

运行结果：

 

7.多继承

Python同样有限的支持多继承形式，多继承的类定义如下：

class DerivedClassName(Base1,Base2,Base3)
    
    ·
    ·
    ·
    

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。

代码实例：

#类定义

from multiprocessing import set_forkserver_preload


class people:
    #定义基本属性
    __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()

#单继承示例
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,"小奏鸣曲")
test.speak()  #方法名同默认调用的是在括号中参数位置排前父类的方法

 运行结果：

8.方法重写

如果你的父类方法的功能不能满足你的需求，可以在子类中重写父类的方法。

代码实例：

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

class Child(Parent): #定义子类
    def myMethod(self):
        print('调用子类方法')
c = Child()  #子类实例
c.myMethod() #子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

 运行结果： 

super()函数

super()函数是用于调用父类(超类)的一个方法。

9.类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例。

self的名字并不是固定的，也可以使用this，但是最好还是按照约定使用self。

类的私有方法

__private_method：两个下划线开头，声明该私有方法只能在类的内部调用，不能在类的外部调用。在类内部的方法中使用时 self.__private_methods 。

类的私有属性实例如下：

from typing import Counter


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) #报错，实例不能访问私有变量

 运行结果： 

类的私有方法实例如下：

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):  #secret method
        print('这是私有方法')

    def __foo(self):  #public method
        print('这是公有方法')
        self.__foo()

x = Site('博客社区','www.csdn.com')
x.who() #正常输出
x.foo() #正常输出
x.__foo()  #报错

运行结果：  

类的专有方法

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载。

代码实例：

from pyrsistent import v


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)

运行结果：  

---

学习参考：Python 子类继承父类构造函数说明 | 菜鸟教程

Python3 面向对象 | 菜鸟教程