2019-04-15 Python中的面向对象学习总结

Posted ymzm204

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2019-04-15 Python中的面向对象学习总结相关的知识,希望对你有一定的参考价值。

一.面向对象总结:

  (1)三要素:封装,继承,多态                                       详细介绍链接:https://www.jianshu.com/p/68ab35298a59

    one.封装:所谓封装,也就是把 客观事物 封装成 抽象的 类,并且 类 可以把自己的数据和方法只让可信的类或者对象操作。 简而言之就是将内容封装到某个地方,以后再去调用被封装在某处的内容

      测试代码:

#封装测试例子
class Foo:#定义一个类
    def __init__(self,name,age): #称为构造方法,根据类创建对象时自动执行
        self.name = name      #name和age是对象的 属性
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)

obj.Foo(wupeiqi,18)
obj.detail() 

>>>>输出结果
wupeiqi 17

 

    two.继承:将多个类共有方法提取到父类,子类仅需继承父类而不必一一实现每个方法         注:除了子类和父类的称谓,你可能看到过 派生类 和 基类 ,他们与子类和父类只是叫法不同而已。

      测试代码:

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)

class son(Foo):#子类继承父类,即拥有了父类的所有方法
    pass
obj = son(wupeiqi,17)
obj.detail()

》》》输出结果
wupeiqi 17

    需要说明的是:python可以继承多个类,如果python继承了多个类那么它有两种方式寻找,分别是 深度优先和广度优先。以后再作详细介绍

    three.多态:所谓多态就是指一个类实例的 相同方法 在不同情形有不同 表现形式

  (2)类成员的修饰符:下划线

      xxx :公有成员,在任何地方都能访问

      __xxx  or  ...__xxx:私有成员,只有类对象自己能访问,子类对象不能直接访问,但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。

      _xxx:受保护成员,不能用‘from module import *‘导入

      __xxx__:系统定义的特殊成员

     注:Python中不存在严格意义上的私有成员

  (3)名词解析

    1. 类:类就是一个模板,模板里可以包含多个函数,每个函数都能实现一些功能。

    2. 对象:根据模板(类)创建的实例,通过这个实例(对象)可以执行类中的函数。

    3. 属性:类中所定义的变量

    4. 方法:类中所定义的函数

    5. 实例化:通过类创建对象的过程

     总结:对象的抽象是类,类的具体化就是对象;也可以说类的实例化是对象,对象是类的实例,例如 奥斑马和梅西可以抽象为人(类),人的实例化是奥斑马和梅西,此外,类也可以作为 其父类的实例化,例如:人和猫可以抽象为动物,动物的实例化是人和猫。

  (4)类的成员:字段,方法,属性

    注:类和对象在内存中如何保存?

    答:类以及类中的方法在内存中只占一份内存,而根据类创建的每一个对象在内存中都需要一份内存。如下图:

技术图片

    one.字段:分为普通字段和静态字段(本质区别是在内存中保存的位置不同)。注意:在所有成员中,只有字段中的普通字段保存于对象中,因此创建多少个对象在内存中就有几个普通字段;而其他成员都保存在类中,也只占用一份内存空间。

技术图片

    two.方法:普通方法,静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方法不同。

      1.

      2.

      3.

      4.

 

    three.属性 其实是普通方法的变种

技术图片

   (5)类的特殊成员

      (1) __init__:构造方法,通过类创建对象时,自动触发执行。

 

      (2) __del__:析构方法,当对象在内存中被释放时,自动触发执行,此方法一般无需定义。

 

      (3) 类的属性

 

        dir(类名):查出的是一个名字列表

 

        类名.__dict__:查出的是一个字典,key为属性名,value为属性值

 

      (4) 特殊的类属性

 

        类名.__name__:类的名字(字符串)

 

        类名.__doc__:类的文档字符串

 

        类名.__base__:类的第一个父类(在讲继承时会讲)

 

        类名.__bases__:类所有父类构成的元组(在讲继承时会讲)

 

        类名.__dict__:类的字典属性

 

        类名.__module__:类定义所在的模块

 

        类名.__class__:实例对应的类(仅新式类中)

    (6)self

        在Python中,在类中定义实例方法时将第一个参数定义为“self”只是一个习惯,而实际上类的实例方法中第一个参数的名字是可以变化的,而不必须使用“self”这个名字,尽管如此,建议编写代码时仍以self作为方法的第一个参数名字。        

>>> class A:
    def __init__(hahaha, v):
        hahaha.value = v
    def show(hahaha):
        print(hahaha.value)
>>> a = A(3)
>>> a.show()
3

    (7)混入机制

# -*- encoding:utf-8 -*-
‘‘‘ 实例说明 —— 混入机制 ‘‘‘
import types
class Stu:                  #定义类
    where = China       #定义类属性,属于静态字段,只保存于类中
    def __init__(self, c):
        self.name = c      #定义实例属性

stu = Stu("wupeiqi")             #实例化对象
print(stu.name, Stu.where)       #查看实例属性和类属性的值
Stu.where = Guangdong                    #修改类属性的值
Stu.age = 18                  #动态增加类属性,属于静态字段,只保存于类中
stu.name = "woshiname"                 #修改实例属性的值
print(Stu.where, Stu.age, stu.name)

def setGender(self, s):
    self.Gender = s

stu.setGender = types.MethodType(setGender, stu) #动态增加成员方法
stu.setGender(boy)                                 #调用成员方法
print(stu.Gender)

#利用特殊的类属性查看类与对象的属性与行为 
print("Stu类的属性与行为如下:
",Stu.__dict__)  #字典属性
print("
")
print("stu对象的属性与行为如下:
",stu.__dict__)

》》》输出如下

wupeiqi China
Guangdong 18 woshiname
boy
Stu类的属性与行为如下:
{‘__module__‘: ‘__main__‘, ‘where‘: ‘Guangdong‘, ‘__init__‘: <function Stu.__init__ at 0x000002CDD020A9D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Stu‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Stu‘ objects>, ‘__doc__‘: None, ‘age‘: 18}


stu对象的属性与行为如下:
{‘name‘: ‘woshiname‘, ‘setGender‘: <bound method setGender of <__main__.Stu object at 0x000002CDD0224320>>, ‘Gender‘: ‘boy‘}

 

二.三维向量类

  (1).实现向量的增减乘除

    代码如下:

class vecter3:
    def __init__(self,x=0,y=0,z=0):
        self.X = x
        self.Y = y
        self.Z = z
    def Print(self):
        print((self.X,self.Y,self.Z))
    def __add__(self,n):      # +  __add__意味着+号,系统自动识别 
        r = vecter3()           #创建一个V3类的实例r
        r.X = self.X -n.X
        r.Y = self.Y - n.Y
        r.Z = self.Z - n.Z
        return r
    def __sub__(self,n):
        r = vecter3()
        r.X = self.X - n.X
        r.Y = self.Y - n.Y
        r.Z = self.Z - n.Z
        return r
    def __mul__(self,n):
        r = vecter3()
        r.X = self.X*n
        r.Y = self.Y*n
        r.Z = self.Z*n
        return r
    def __truediv__(self, n):
        r = vecter3()
        r.X = self.X / n
        r.Y = self.Y / n
        r.Z = self.Z / n
        return r
        
        
v1 = vecter3(4,8,12)
v2 = vecter3(2,3,4)
v3=v1/2  #+自动识别为__add__
v3.Print()

 

以上是关于2019-04-15 Python中的面向对象学习总结的主要内容,如果未能解决你的问题,请参考以下文章

python学习面向对象组合

Python中面向对象(学习笔记)

Python--oop面向对象的学习1

Python学习笔记-面向对象进阶

python学习之路-第七天-python面向对象编程简介

学习 Python 之 面向对象