专栏首页python3python Class(类) and

python Class(类) and

Python类与面向对象    程序=指令+数据 (或算法+数据结构)。代码可以选择以指令为核心或以数据为核心进行编写。    两种类型        (1)以指令为核心:围绕“正在发生什么”进行编写(面向过程编程:程序具有一系列线性步骤;主体思想是代码作用于数据)以指令为中心,程序员的主要工作在于设计算法。        (2)以数据为核心:围绕“将影响谁”进行编写(面向对象编程OOP:围绕数据及为数据严格定义的接口来组织程序,用数据控制对代码的访问) 面向对象编程的核心概念     所有编程语言的最终目的都是提供一种抽像方法。     在机器模型("解空间"或"方案空间")与实际解决的问题模型("问题空间")之间,程序员必须建立一种联系。     (1)面向过程:程序=算法+数据结构     (2)面向对象:将问题空间中的元素以及它们在解空间中的表示物抽象为对象,并允许通过问题来描述问题而不是方案(可以把实例想象成一种新型变量,它保存着数据,但可以对自身的数据执行操作)     类是由状态集合(数据)和转换这些状态的操作集合组成     类:定义了被多个同一类型对象共享的结构和行为(数据和代码)     (1)类的数据和代码:即类的成员         数据:成员变量或实例变量         成员方法:简称为方法,是操作数据的代码,用于定义如何使用成员变量;因此一个类的行为和接口是通过方法来定义的。     (2)方法和变量:         私有:内部使用;公共:外部可见  面向对象的程序设计方法     所有东西都是对象;程序是一大堆对象的组合。     通过消息传递,各对象知道自己该做什么。

    消息:即调用请求,它调用的是隶属目标对象的一个方法     每个对象都有自己的存储空间,并可容纳其它对象;通过封装现有对象,可以制作成新型对象     每个对象都属于某一类型:         类型,也即类; 对象是类的实例;类的一个重要特性为“能发什么样的消息给它”。         同一个类的所有对象都能接收相同的消息。 对象的接口     定义一个类之后,可以根据需要实例化出多个对象     如何利用对象完成真正有用的工作呢?         必须有一种办法能向对象发出请求,令其做一些事情(方法)         每个对象仅能接受特定的请求(方法);能向对象发送的请求由其“接口”进行定义;对象的“类型”或“类”则规定了它的接口形式。   类     将同一种具体物事的共同特性抽象出来的表现。     类内部定义了其状态和转换这些状态的操作。     类被实例化为对象时才有相关的一些数据,才会对该对象的一些属性进行赋值,这些值就是所谓的数据。从某种角度理解这些对象属性就是变量。为对象属性赋值就是为变量赋值。这些对象的属性(即变量)都是在类中定义的数据结构体。     方法:就是函数,就是操作变量引用的数据代码。方法的作用就是为了操作数据。             类间的关系:         依赖("uses-a"):一个类的方法操纵另一个类的对象         聚合("has-a"):类A的对象包含类B的对象         继承("is-a"):描述特殊与一般关系 面向对象编程的原则     面向对象编程的模型机制有3个原则:封装、继承及多态 封装(encapsulation)         隐藏实现方案细节;将代码及其处理的数据绑定在一起的一种编程制作,用于保证程序和数据不受外部干扰且不会被误用。 继承(Inheritance)         一个对象获得另一个对象属性的过程;用于实现按层分类的概念         一个深度继承的子类继承了类层次中它的每个祖先的所有属性         超类、基类、父类;子类、派生类 多态性(Polymorphism)        允许一个接口被多个通用的类动作使用的特性,具体使用哪个动作与应用场景相关。        一个接口,多个访问:用于为一组相关的动作设计一个通用的接口,以降低程序复杂性。 Python的类和实例     类是一种数据结构,可用于创建实例。一般情况下,类封装了:数据和要用于该数据的方法     python类是一个可调用对象,即类对象;python2.2之后,类是一种自定义类型,而实例则是声明某个自定义类型的变量     实例初始化;通过调用类来创建实例         instance = ClassName(args...)         类在实例化时可以使用__init__和__del__两个特殊的方法 类本身是一个对象,被实例化出来的实例也是一种对象。也就是所谓的类对象与实例对象。     编写类的代码就是一个类对象,但这些代码不会自动执行,只有在被实例化之后,这些类对象的代码执行从而产生了一个具体的实例对象。         type(list)         type(l1) Python中创建类     python使用class关键字创建类,语法格式如下:

class  class_name(bases):
    'class documentation string'
    class_suite

    超类是一个或多个用于继承的父类的集合     类体可以包含:声明语句、类成员定义、数据属性、方法         注意:如果不存在继承关系,ClassName后面的"(bases)"可以不提供;类文档为可选     class 语句的一般形式

class class_name(bases):
    data = value                定义数据(类属性)
    self method(self,....):     定义方法
        self.member = value     定义实例属性

class TestClass():              定义类对象
    pass
                
type(TestClass)
obj1 = TestClass()              被实例化出来的实例对象

 例:Python中,class语句类似def,是可执行代码;直到运行class语句后类才会存在

class FirstClass():        定义类名为FirstClass
    spam = 30              定义数据属性
    def display(self):     定义类方法,属于可调用的属性
        print self.spam
        
x = FirstClass()           实例化出一个对象x
x.display()                调用x对象的display方法
                           class语句内,任何赋值语句都会创建类的属性;每个实例对象都会继承类的属性并获得自己的名称空间。

class SecClass():
    data = 'hello SecClass'
    def printdata(self):
    print "Content from method: %s" % self.data
    
inst2 = SecClass()  
inst2.data              获取对象的data属性
inst2.printdata()       执行对象的printdata()方法
        
class ThirdClass():
    data = 'hello Thirdclass'
    def setdata(self,x)
        self.str1 = x
    def printdata(self):
        print self.str1
        
inst3 = ThirdClass()
inst3.data              返回对象的属性
inst3.setdata('test')   调用对象的setdata()方法,并传递参数'test'
inst3.getdata()         调用对象的getdata()方法

python类方法及调用     实例(对象)通常包含属性         可调用的属性:方法             object.method()             数据属性 在OOP中,实例就像是带有"数据"的记录,而类是处理这些记录的"程序"     通过实例调用方法相当于调用所属类的方法来处理当前实例。类似instance.method(args...)会被自动转换为class.method(instance,args...)。如前面的例子,x.display()会被自动转换为FirstClass.display(x),即调用类的方法来处理实例x。     因此,类中每个方法必须具有self参数,它隐含当前实例之意。在方法内对self属性做赋值运算会产生每个实例自己的属性。 python规定,没有实例,方法不允许被调用,此即为“绑定”     class语句中的赋值语句会创建类属性,如前面例子中的spam     在类方法中对传给该方法的特殊参数self进行赋值会创建实例属性。     例        class Myclass():            gander = 'Thompson'            def setName(self,who):                self.name = who                        x = Myclass()        y = Myclass()        x.gender    返回x对象的gender属性,通过爬树搜索,gender属性会从MyClass类中获取到        x.name      在SetName方法调用之前,Myclass类不会把name属性附加到实例x上,当然也可以重载__init__创建构造器直接为实例提供。所以系统提示错误        x.setName('tom')        y.setName('jerry')      调用y对象的setName方法,并传递参数给name属性                y.gender, y.name        x.gender, x.name Python构造器     python中都有一个构造器的方法     __varname__() 方法,会被python解释器自动调用。当类被实例化成对象时,这些访问就会被自动调用。 创建实例时,python会自动调用类中的__init__方法,以隐性地为实例提供属性。__init__方法被称为构造器。如果类中没有定义__init__方法,实例创建之初仅是一个简单的名称空间。        例        class Myclass():            gender = 'Male'            def __init__(self,who):                self.name = who        x = Myclass('tom')        y = Myclass('jerry')        x.gender, x.name        y.gender, y.name 析构器        class Animal:            name = 'someone'    定义数据属性(成员变量)            def __init__(self,voice='HI'):  定义构造函数,参数设置默认值                self.voice = voice            def __del__(self):      定义析构函数                pass            del saySomething(self):     定义方法(成员函数)                print self.voice                tom = Animal()        tom.saySomething()                jerry = Animal("Hello")        jerry.saySomething() 类的特殊属性        可以使用类的__dict__字典属性或python内置的dir()函数来获取类的属性        dir(MyClass)        MyClass.__dict__        每个对象自己的__dict__属性中保存了本对象支持的所有属性和方法        Class.__name__      以字符串方式返回类的名字        Class.__doc__           返回类class的文档字符串        Class.__bases__         返回类class的所有父类构成的元组        Class.__module__        返回类c定义所在的模块 (python1.5后期版本新增功能)        Class.__class__             返回实例Class对应的类(仅新式类中) 实例的属性     实例仅拥有数据属性(严格意义上来说,方法是类属性)         通常通过构造器"__init__"为实例提供属性;这些数据属性独立于其它实例或类;实例释放时,其属性也将被清除         内建函数dir()或实例的特殊属性__dict__可用于查看实例属性            dir(inst1)         实例的特殊属性:            Inst1.__class__     实例化Inst1的类            Inst1.__dict__      Inst1的属性 Python类方法中可用的变量     方法的可用变量         实例变量:指定变量名称及实例自身进行引用             self.变量名         局部变量:方法内部创建的变量,可直接使用         类变量(也称为静态变量):在类中定义的变量;只有通过指定变量名与类名进行引用             类名.变量名             全局变量:直接使用                    例:        In [1]: class c1():           ...:     d1 = 'hello c1 class'           ...:     def __init__(self,x):           ...:         self.instdata = x           ...:                In [2]: inst1 = c1(50)        In [3]: inst1.d1        Out[3]: 'hello c1 class'        In [4]: inst1.instdata        Out[4]: 50        In [5]: inst2 = c1(60)        In [6]: inst2.d1        Out[6]: 'hello c1 class'        In [7]: inst2.instdata        Out[7]: 60        In [8]: inst1.d1 = 'instance1 new value'        In [9]: inst1.d1        Out[9]: 'instance1 new value'        In [10]: inst2.d1        Out[10]: 'hello c1 class'        In [11]: c1.d1 = 'class c1 new value'        In [12]: inst1.d1        Out[12]: 'instance1 new value'        In [13]: inst2.d1        Out[13]: 'class c1 new value' 继承     继承描述了基类的属性如何“遗传”给派生类        子类可以继承它的基类的任何属性,包括数据属性和方法;一个未指定基类的类,其默认有一个名为object的基类;python允许多重继承        创建子类:创建子类时,只需要在类名后跟一个或从其中派生的父类            class SubClassName(ParentClass1[, ParentClass2, ...])                'optional class documentation string'                class_suite            例:        In [14]: class ParentClass(object):           ....:     'Parent Class'           ....:     gender = 'Male'           ....:     def setName(self,who):           ....:         self.name = who           ....:        In [15]: class ChildClass(ParentClass):           ....:     'Child Class'           ....:     def displayInfo(self):           ....:         print self.gender, self.name           ....:        In [16]: x = ChildClass()        In [17]: x.setName('tom')       该方法是继承父类的        In [18]: x.displayInfo()        Male tom        In [19]: dir(ParentClass)        Out[19]:        ['__class__',         '__delattr__',         '__dict__',         '__doc__',         '__format__',         '__getattribute__',         '__hash__',         '__init__',         '__module__',         '__new__',         '__reduce__',         '__reduce_ex__',         '__repr__',         '__setattr__',         '__sizeof__',         '__str__',         '__subclasshook__',         '__weakref__',         'gender',         'setName']        In [20]: dir(ChildClass)        Out[20]:        ['__class__',         '__delattr__',         '__dict__',         '__doc__',         '__format__',         '__getattribute__',         '__hash__',         '__init__',         '__module__',         '__new__',         '__reduce__',         '__reduce_ex__',         '__repr__',         '__setattr__',         '__sizeof__',         '__str__',         '__subclasshook__',         '__weakref__',         'displayInfo',         'gender',         'setName']        In [21]: x.name        Out[21]: 'tom'    继承方法专用化:继承会先在子类寻找变量名,然后才查找超类,因此,子类可以对超类的属性重新定义来取代继承而来的行为。    子类可以完全取代从超类继承而来的属性;也可以通过已覆盖的方法回调超类来扩展超类的方法            例:            In [22]: class ParClass(object):               ....:     def setInfo(self, sex='Male'):               ....:         self.gender = sex               ....:            In [23]: class ChiClass(ParClass):               ....:     def setInfo(self,who):         此方法名与父类方法名相同,所以覆盖父类中的方法               ....:         self.name = who               ....:            In [24]: x = ChiClass()            In [26]: x.setInfo('tom')            In [27]: x.name            Out[27]: 'tom'            In [28]: x.gender    由此子类中的setInfo方法已经覆盖父类中的setInfo方法,而子类中的setInfo方法并无gender属性,所以系统提示错误信息            ---------------------------------------------------------------------------            AttributeError                            Traceback (most recent call last)            <ipython-input-28-dcfdb2ec694c> in <module>()            ----> 1 x.gender            AttributeError: 'ChiClass' object has no attribute 'gender'            In [29]:            例:            In [29]: class ParClass(object):               ....:     def setInfo(self,sex='Male'):               ....:         self.gender = sex               ....:            In [30]: class ChiClass(ParClass):               ....:     def setInfo(self,who):         子类中的setInfo方法覆盖父类中的setInfo方法               ....:         self.name = who               ....:         ParClass.setInfo(self)     在子类中再次回调其父类中的setInfo方法               ....:            In [31]: x = ChiClass()            In [32]: x.setInfo('tom')            In [33]: x.name            Out[33]: 'tom'            In [34]: x.gender           由于子类中再次调用父类中的setInfo方法,所以此时实例x可以使用父类继承来的gender属性            Out[34]: 'Male'            In [35]:        例:        class father:                def __init__(self):                self.name="father class"                print "father __init__"            def fa_method(self):                print "father method test"                    def bad(self):                print "smoke、drink"        class son(father):                def __init__(self):                self.name="son class"                print "son __init__"                father.__init__(self)   #在子类中调用父类的构造函数              #super(son,self).__init__()  #通过supper函数也可以调用父类中的构造函数,但父类必须指明是(object)的子类            def son_method(self):                print "son method test"                          #def bad(self):     #实现基类(父类)重写            #    print "smoke"            def bad(self):                father.bad(self)    #引用父类中的bad方法                print "gamble"        s1=son()    #实例化一个s1对象        s1.son_method()        print s1.name        s1.fa_method()      #继承父类的方法        s1.bad()            #调用bad方法,该方法默认继承父类,但如果子类中实现了重写,则调用子类中的新方法    python类的继承和属性搜索        python中几乎所有属性的获取都可以使用“object.attribute”的格式;不过,此表达式会在python中启动搜索--搜索连续的树        class语句会产生一个类对象,对class的调用会创建实例,实例自动连结至创建了此实例的类        派生类连结至其基类的方式:将基类列在派生类头部的括号内,其从左至右的顺序会决定树中的次序;由下至上,由左至右 经典类与新式类    如果类继承了object类,称为新式类;新式类兼容经典类;如果类没有指明继承object,称为经典类    新式类多出了一些内置方法和属性;通过新式类可以设置访问权限        对于其它语言来说,object类默认就是所有任何类的基类,不需要手工指明    继承基类的搜索顺序:经典类深度优先,而新式类广度优先        例1:        class A:            def __init__(self):                print 'This is A class'            def save(self):                print 'save method from A'        class B(A):            def __init__(self):                print 'This is B class'            #在B类中没有定义Save方法,它会继承父类A        class C(A):            def __init__(self):                print 'This is C class'            def save(self):                print 'save method from C---'        class D(B,C):            def __init__(self):                print 'This is D class'        d1=D()        d1.save() #本例为经典类,在调用d1对象的save()时,它的继承搜索路径是自左至右(先搜索B类中的save方法,B类又继承了A类)        #所以本例的输出结果为:        This is D class        save method from A        例2:        class A(object):            def __init__(self):                print 'This is A class'            def save(self):                print 'save method from A'        class B(A):            def __init__(self):                print 'This is B class'            #在B类中没有定义Save方法,它会继承父类A        class C(A):            def __init__(self):                print 'This is C class'            def save(self):                print 'save method from C---'        class D(B,C):            def __init__(self):                print 'This is D class'        d1=D()        d1.save()  #本例为新式类,新式类的搜索为:广度优先(先搜索B,B类没有定义save方法,再搜索C)        #所以输出结果为:        This is D class        save method from C---        例:        class class3:                def __init__(self):                pass                def __del__(self):                print "销毁中..."            def go(self):                print "Go"            def __call__(self):     #内置__call__方法的使用                print "Call"        c3=class3()        c3.go()        c3()                        #通过call方法可以调用类的默认方法 特性:经典类和新式类中的特性的区别 ,经典类中的特性全部都是可读可写的(没有只读的功能)        class Person:            def __init__(self):                self.__name__ = 'Thompson'            @property            def Name(self):                return self.__name        p1 = Person()        print p1.name        #通过特性Name,读取self.__name的值        p1.Name = 'xxx'     #通过特性Name,设置self.__name的值 #新式类中的特性默认都是只读,如果想要设置,那么就需要再创建一个被装饰@xxxx.setter修饰的特性         class Person(object):            def __init__(self):                self.__name = 'alex'            @property            def Name(self):                return self.__name                        p1 = Person()        print p1.Name      #通过特性Name,读取self.__name的值        p1.Name = 'xx'     # Error 通过特性Name设置self.__name 的值时,会出现错误        #新式类这么做好处是什么呢?通过这样来防止对私有变量的修改,所有的对象就只能读取,不能修改        #应用场景:        class Person(object):            def __init__(self,gene,clothes):                self.__gene = gene                self.__clothes = clothes                            @property            def Gene(self):         #通过该方法读取__gene属性                return self.__gene                        @property            def Clothes(self):      #通过该方法读取__clothes属性                return self.__clothes                            @Clothes.setter         #此处的名称必须与上面的读取函数名称相同            def Clothes(self,value):                self.__clothes = value        p1 = Person('AB','bikini')      #创建基因为AB的人,衣服是比基尼        print p1.Gene               #可以获取人的基因        print p1.Clothes            # 通过Clothes方法读取衣服属性        p1.Clothes = 'skirt'        #修改p1的衣服为skirt        print p1.Clothes            #再次读取Clothes属性        p1.Gene='O'                 #修改基因时系统提示错误,无法修改。 类、实例和其它对象常见的内建函数        issubclass()    布尔函数,判断一个类是否同另一个类派生,语法:issubclass(sub,sup)        isinstance()    布尔函数,判断一个对象是否是给定类的实例,语法:isinstance(obj1, class_obj2)        hasattr()       布尔函数,判断一个对象是否拥有指定的属性,语法:hasattr(obj,'attr');同类的函数还有getattr()、setattr()和delattr()        super()            在子类中找出其父类以便于调用其属性;一般情况下仅能采用非绑定方式调用祖先类方法            而super()可用于传入实例或类型对象,语法:super(type[, obj])        例:        In [36]: issubclass(ChiClass,ParClass)        Out[36]: True        In [37]: issubclass(ParClass,object)        Out[37]: True        In [38]: isinstance(x,ChiClass)     #x为对象名        Out[38]: True        In [39]: hasattr(x,'name')        Out[39]: True        In [40]: hasattr(x,'gender')        Out[40]: True 运算符重载     运算符重载是指在方法(如__name__的方法)中拦截内置的操作--当类的实例出现在内置操作中,python会自动调用自定义的方法,并且返回自定义方法的操作结果。     运算符重载让类拦截常规的python运算         类可重载所有python表达式运算符; 类也可重载打印、函数调用、属性点号运算等内置运算         重载使类实例的行为像内置类型;重载通过提供特殊名称的类方法实现     运算符重载并非必需,并且通常也不是默认的     类可以重载python的操作符,重载使我们的对象与内置的一样。     __x__的名字的方法是特殊的挂钩(hook),python通过这 种特殊的命名来拦截操作符,以实现重载。     python在计算操作符时会自动调用这样的方法,例如: 如果对象继承了__add__方法,当它出现在+表达式中时会调用这个方法。     通过重载,用户定义的对象就像内置的一样。 在类中重载操作符        1、操作符重载使得类能拦截标准的python操作。        2、类可以重载所有的python的表达式操作符。        3、类可以重载对象操作:print,函数调用,限定等。        4、重载使得类的实例看起来更像内置的。        5、重载是通过特殊命名的类方法来实现的。        方法名        重载的操作说明        调用表达式        __init__        构造函数            创建对象:class()        __del__        析构函数             释放对象的时候        __add__        “+”                      x + y        __or__           “|”                        x | y        __repr__        打印,转换         print x, `x`        __call__        函数调用                x()        __getattr__    属性引用             x.undefined        __getitem__    索引                   x[key],for循环,in测试        __setitem__    索引赋值             x[key] = value        __getslice__    分片                    x[low:high]        __len__         长度                      len(x)        __cmp__        比较                     x == Y ,x < y        __radd__      右边的操作符"+"      非实例 + x 例子:        例:        class indexer:            def __getitem__(self,index):                return index**2        x=indexer()        for i in range(5):            print x[i]        print ":",__getitem__(x,5)        输出结果为:        0        1        4        9        16        : 25        例:        In [13]: class test:           ....:     def __init__(self,x):           ....:         self.x=x           ....:     def __add__(self,y):           ....:         return x+y           ....:            In [14]: c1=test(5)        In [15]: print c1.__add__(6)        11        In [16]: print c1.x        5        In [17]: dir(c1)        Out[17]: ['__add__', '__doc__', '__init__', '__module__', 'x'] 基于特殊的方法定制类     除了__init__和__del__之外,python类支持使用许多的特殊方法         特殊方法都以双下划线开头和结尾,有些特殊方法有默认行为,没有默认行为的是为了留到需要的时候再实现。         这些特殊方法是python中用来扩充类的强大工具,它们可以实现:模拟标准类型、重载操作符         特殊方法允许类通过重载标准操作符+,*,甚至包括分段下标及映射操作[]来模拟标准类型。 抽象类        from abc import ABCMeta,abstractmethod        class Alert:            __metaclass__=ABCMeta            @abstractmethod            def send(self):pass        class Email(Alert):                        def __init__(self):                self.name='email alter'                          def send(self):                print 'test'        notify=Email()        notify.send() #抽象类+抽象方法=定义接口 总结    可调用对象:函数(内置函数/自定义函数)、类、类方法 (支持调用操作,支持小括号的方法)        函数的属性:            __doc__            __name__            __dict__            __code__            __globals__        实例方法/ 类方法 / 静态方法        方法的属性:            __doc__            __name__            __class__  方法所属的类            __func__  实现该方法的函数对象            __self__ 调用此方法的实例        内置函数:            __doc__            __name__            __self__    类:        __doc__        __name__        __bases__        __dict__        输出对象所有的属性        __module__  定义了当前类的模块名称    实例:        __class__        __dict__    对象都有特殊方法:        __init__        __new__()        __del__()        __ge__()    a >= b      a.__ge__(b)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python全栈开发之面向对象

    类是对一群具有相同特征或者行为的事物统称,是抽象的,不能直接使用,特征被称为属性,行为被称为方法,类就是一个模板

    py3study
  • Python堡垒机实现之基础知识

        说明:根据不同的登录用户分配不同的可管理的主机组。(再细分的权限就是根据不同的用户控制可在主机上执行的命令,一般不会限制的这么严格)

    py3study
  • python3学习之对象

    py3study
  • python类的继承与运算符重载

    Officially, CPython has no rule at all for when exactly overridden method of sub...

    哒呵呵
  • Python全栈开发之面向对象

    类是对一群具有相同特征或者行为的事物统称,是抽象的,不能直接使用,特征被称为属性,行为被称为方法,类就是一个模板

    py3study
  • (二十九) 初遇python OOP面向对象编程-属性装饰器

    各位读者大大们大家好,今天学习python的面向对象编程-属性装饰器,并记录学习过程欢迎大家一起交流分享。

    亚乐记
  • swoole框架-swoft初体验swoft环境搭建体验http服务体验ws服务初体验

    没有swoole之前,php一直被"誉“为世界上最好的语言。swoole横空出世后,php就成了宇宙最好的语言了...

    章鱼喵
  • 慕课网Flask高级编程实战-10.鱼书业务处理

    我们的首页会显示最近的赠送书籍列表。这个列表有三个限制条件: 1.数量不超过30 2.按照时间倒序排列,最新的排在最前面 3.去重,同一本书籍的礼物不重复...

    Meet相识
  • [情人节] jieba分词介绍

    jieba 分词我觉得是Python中文分词工具中最好用的一个工具包。想要入门自然语言处理,jieba分词有必要好好掌握一下,今天带大家入门一下jieba分词包...

    用户1622570
  • 剖析交换机市场大变动:白盒、裸机交换机蚕食传统市场 & 交换机路由器大融合

    过去,网络交换设备需要搭配专有软件或操作系统。2011年,随着Facebook主导的Open Compute Project(OCP)的开展,网络设备绑定专属软...

    SDNLAB

扫码关注云+社区

领取腾讯云代金券