python的oop概述

2021/4/23 12:25:37

本文主要是介绍python的oop概述,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

python是面向对象的语言,那么究竟什么是面向对象?

首先理解类

类:在中文中的定义,许多相同或相似事物的综合。根据这个定义,类是许多相同或相似的实物聚在一起的。譬如,人类,鸟类,花类等。

面向对象的三个特征

类的单个具体实例可以称之为对象,把类具体化单个实体的过程,这个过程称为类的实例化!

面向对象程序设计中的术语对象基本上可以看做数据(特性)以及由一系列可以存取,操作这些数据的方法所组成的集合。

面向对象的三个基本特征:封装,继承,多态。

创建对象的过程称之为实例化,当一个对象被创建之后,包含三个方面的特性:对象的句柄,属性和方法。对象的句柄用于区分不同的对象,当对象被创建后,该对象会获取一块存储空间,存储空间的地址即为对象的标识。

  • 多态:对不同的类的对象使用同样的操作。
  • 封装:对外部世界隐藏对象的工作细节。
  • 继承:以普通的类为基础类建立专门的类对象。

通过实例理解面向对象的一些术语和三个基本特征:

构造方法与析构函数

  • 构造方法:在实例化时做的一些初始化工作。
  • 析构函数:在实例销毁时,执行的一些操作。
class People(object):    def __init__(self,country, name,age=23):  #构造方法
        self.country = country  #实例属性
        self.name = name
        self.__age = age        #私有属性

    def __del__(self):  #析构函数
        print("%s  has died" % self.name)    def get_info(self):  #实例方法
        print("The %s info".center(50,"-") % self.name)        print("The %s comes from %s, is %d old" % (self.name, self.country, self.__age))

实例化上面的类,

>>> a = People("China","hitler",20)   #实例化一个类时,这时候构造函数会自动执行>>> a.get_info()   #通过实例访问类中的实例方法-------------------The hitler info--------------------The hitler comes from China, is 20 old

在类中定义属性时,若属性是以双下划线开始的则为私有属性,例如self.__age属性,而像self.country和self.name属性则是公有属性,无论是私有属性还是公有属性,每个通过实例化得到的类都有这些属性。

在实例化时,我们可以像给函数传入参数那样,给类传入参数,而这些参数的最终被赋值的操作就是在构造函数中执行的。构造函数在类实例化的时候会自动执行。

注意私有属性和实例属性的访问方法的不同:

>>> a.name      #访问实例属性'hitler'>>> a.country   #访问实例属性'China'>>> a.__age     #方位私有属性Traceback (most recent call last):
  File "", line 1, in AttributeError: 'People' object has no attribute '__age'>>> a._People__age   #私有属性的访问方法,实例化名._类名__私有属性名20
>>> del a        #删除一个实例,这时候,析构函数会自动执行hitler  has died#析构函数:在实例销毁的时候自动执行的,通常用于做一些收尾的工作,关闭一些数据库连接或者关闭打开的临时文件。

析构函数:在实例销毁的时候自动执行的,通常用于做一些收尾的工作,关闭一些数据库连接或者关闭打开的临时文件。

在上面的例子中,使用del删除了实例a,然后会自动返回析构函数执行的结果。

 

可以对实例进行增加,删除,修改操作:

对象属性的增删改>>> A = People("USA", "jobs", "53")  
>>> A.country #可以通过实例修改对应的属性值'USA'>>> A.country = "UKA" >>> A._People__age = 55
>>> A.get_info()  ##可以看到实例的属性值已经修改-------------------The jobs info--------------------The jobs comes from UKA, is 55 old#可以通过del删除某个属性>>> del A.country>>> A.get_info()  #报错,没有对应的country属性Traceback (most recent call last):
  File "", line 1, in 
  File "E:\pycharm\class_method.py", line 14, in get_info    print("The %s comes from %s, is %d old" % (self.name, self.country, self.__age))
AttributeError: 'People' object has no attribute 'country'-------------------The jobs info--------------------

>>> A.country = "China" #添加属性>>> A.get_info()  #可以看到属性添加成功-------------------The jobs info--------------------The jobs comes from China, is 55 old

注意上面的通过实例对属性的增加,删除,修改操作仅对当前的实例有效;而对于类的其余实例则没有效果。可以做如下测试以证明:

>>> a = People(,,)  >>> a.pos =                 >>> a.pos                           >>> B = People(,,)   >>>
  File , line 1,

解释:

  创建类的时候python会在内存中为类开辟一段内存空间,实例化的时候,python会为每一个实例开辟一段内存空间,每个实例的内存空间都是相互独立的,因此更改了a的内存空间,并不会影响B的内存空间。
  若想使更改的效果,对类的每一个实例都生效,可以使用类变量。

在类变量之前,先说一下self参数。在类中定义的方法,每个方法都有一个self参数,那么self参数该如何理解?

  • 在上面的实例中,通过类实例化了两个对象a和b,那么这两个对象都有get_info()方法,但是在调用的时候并没有出错,我们只能通过某一个具体对象得到这个对象的信息,也就是说我们只能通过a的get_info()方法得到对象a的相关信息,而不是得到b的信息。这个的实现就是因为self参数的作用。
  • 在实例化的过程时,python会执行构造函数,做一些初始化的工作,这时候python会为这个实例开辟一段内存空间,会把这个实例名(通过self参数传递)和一些属性信息一起存入内存,这样调用的时候,通过self参数来区分不同的实例可以准确的调用到对应的属性信息。

类变量:

  首先满足上面提到的,让更改对每一个实例都生效。

class People(object):
    addr = "Earth"  # 类变量

    def __init__(self, country, name, age=23):
        self.country = country
        self.name = name
        self.__age = age

然后对上面的类进行实例化操作,如下:

>>> a = People("USA","swift", 29)  #实例化两个类>>> b = People("China","wxz", 24)  
>>> a.addr                         #这两个类都有一个addr属性,注意addr类变量在类中定义的方法'Earth'>>> b.addr'Earth'>>> a.addr = "Moon"                #注意这样做只是在实例a中添加了实例属性addr,而不是修改类变量addr。>>> a.addr                         #实例a访问的是实例属性中的addr。'Moon'         >>> b.addr                         #而实例b访问的是类变量addr。因此结果不同'Earth'>>> People.addr = "Moon"           #修改类变量,这时候实例a仍然访问的是实例属性addr,而实例b访问的是类变量addr。>>> a.addr'Moon'>>> b.addr'Moon'#再实例化一个实例对象c,可以发现c的addr属性已经是修改之后的属性。>>> c = People("UKA", "King",88)>>> c.addr                        #实例对象c访问的是类变量addr。'Moon'

在上面的实例中,我们给实例a添加一个实例属性addr,而这时候类变量也有一个属性addr,那么在访问的时候实例会怎么去调用对应的值呢?

通过以上的例子可以得出如下结论:属性查找,首先查找实例本身是否有对应的属性,若找到则返回结果,停止查找;否则就继续查找类中的属性变量。

在这里实例a因为添加了add实例r属性,因此实例a只会返回实例本身的addr结果;而实例b和实例c,因为本身的没有addr实例属性(构造函数中没有定义),因此会返回类变量addr的值。

类变量是类的各个实例共有的属性。当然这个属性也可以放在构造函数中,在每个实例初始化的时候,就会自动生成这个属性。
但是上面提到过python会为每个实例开辟一个内存空间,因此当实例非常巨大的时候,这样做会占用存储空间。采用类变量的形式更节省空间。

封装:

  在这个实例中有一个简单的方法就是get_info()。对于一个对象也就是实例来说,要想得到这个对象的具体信息,只需要调用get_info()这个方法即可,然后就会返回对象的具体信息。但是具体是怎么样得到这些信息的,这个实例是不知道的。这种形式就是封装。把一些功能实现的细节不对外暴露,隐藏起来就是封装。

经典类与新式类:

  • python2中默认创建的都是经典类,但创建类时使用object参数时,就是新式类。
  • python3中创建的类都是新式类,但习惯上使用object参数。
  • 经典类与新式类的区别在多种继承中可以用到,附上一片博文链接,经典类与新式类的异同。

继承:

  • 继承就是一个类继承了另一个类,继承的新类拥有父类属性和方法,实现代码的重复使用和代码的扩展。
  • 再继承时,可以对父类的一些属性和方法进行重写。
  • 需要特别注意的是构造方法的重写。
class People(object):    def __init__(self,name,pos=None):
        self.name = name
        self.pos = pos    def get_info(self):        print("My name is %s, I have not a work" % self.name)class Teacher(People):    def __init__(self,name, pos, school):
        super(Teacher,self).__init__(name, pos) #重写构造方法的两种形式,推荐使用super的形式,构造方法重写时注意参数传递。
        # People.__init__(self, name, pos)
        self.school = school    def get_info(self):        print("My name is %s, I am a %s" % (self.name, self.pos))        print("The colleage is %s" % self.school)class Student(People):    def __init__(self,name,pos, score, course):
        super(Student, self).__init__(name, pos)
        self.score = score
        self.course = course    def get_info(self):        print("My name is %s, I am a %s" % (self.name, self.pos))        print("My score is %d" % self.score)        print("I have learned the %s %s %s" % self.course)

上面定义了一个父类People,两个子类teacher和student,都继承了people。

实例化操作:

a = People("wxz")
b = Teacher(name="steve", pos="teacher", school="Peking university")
d = Student(name="job", pos="Stuent", score=88, course=("数学","语文","物理"))

In [6]: a.get_info()
My name is wxz, I have not a work

In [7]: b.get_info()
My name is steve, I am a teacher
The colleage is Peking university

In [8]: d.get_info()
My name is job, I am a Stuent
My score is 88I have learned the 数学 语文 物理

实例化的每一个对象都可以调用get_info()方法,得到其对应的信息。这三个对象是不一样的,分别为people, teacher,student对象。
若有一个函数,只要传入对应的对象,然后就可以调用函数得到对应的信息。如下这种形式:

In [9]: def print_info(obj):   ##在只要传入对象信息,我们不知道这个对象是什么类型,但是他依然可以得到对象的信息   ...:     obj.get_info()
   ...:     

In [10]: print_info(a)
My name is wxz, I have not a work

In [11]: print_info(b)
My name is steve, I am a teacher
The colleage is Peking university

In [12]: print_info(d)
My name is job, I am a Stuent
My score is 88I have learned the 数学 语文 物理

在这个例子中,并不知道a,b,d是什么样的对象,要做的只是把这三个对象传入了print_intfo函数,然后函数会自动返回对应的对象信息。

这里只有一个print_info的接口,但是不同的对象都可以调用这个接口,这种行为就叫做多态。

多态就是一种接口的多种使用。

下面一个简单的多态实例

list1
Out[22]: ['a', 'f', 'd', 's', 'f', 'a', 's', 'd', 'f'] #列表tuple1
Out[23]: ('f', 'g', 'a', 'g', 'f', 'd', 'g', 'd', 'f') #元组len(list1)
Out[24]: 9len(tuple1)
Out[25]: 9

对于len()函数来说并不知道list1是列表,tuple1是元组,len()函数只是接受一个参数对象,然后返回这个参数对象的长度。也可以理解为多态的一种使用。

 

面向对象的三个基本特征:封装,继承,多态。

面向的对象的属性:

  • 静态属性
    •   私有属性
    •        实例属性
    •        类属性(类变量)

       

  • 动态属性(就是方法)
    •   实例方法
    •        私有方法--和私有属性一样是双下划线开始的,调用形式和私有属性一样,只能通过类中的方法调用

       

 



这篇关于python的oop概述的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程