Python 【面向对象（类）】 学习笔记

对象  ： 属性（变量） + 方法（函数）

类（class） ： 具有相同属性及方法的对象集合

继承 ： 子类（derived class）继承父类、基类（base class）的全部内容，如同时继承多个基类，如子类使用相同函数名，且未指定基类的情况下，按集成时从左至右的方式查找。

类的私有制  :   私有属性（变量）和方法（函数）都是以__（双下划线开头），只能在类的作用域内调用。    

#私有的方式实际上是伪私有，python将加了__的变量及函数改变了名称为“_类名__变量名”，故使在类作用域外可用更改后的名称调用私有化的变量及函数。

------------------------------------------------------------------------------------------------------------

self  :  类中的方法与函数的区别在于多了一个必须的第一参数，名称可以随意使用，但依照惯例用self。

class Temp:

    def setname(self,name):

        self.name = name

    def roll(self):

        print("%s rolling in the deep ! % self.name")

a = Temp()    #将类实例化

a.setname("Jack")    #用类的方法传入参数    如用__init__方法可直接在实例化时赋值，不再单独调用类方法传入对象

a.roll()    #执行类的方法

Jack rolling in the deep !

------------------------------------------------------------------------------------------------------------

super() 函数 ： #调用父类的方法

class A:

    def __init__(self):

        print("我是父类！")

class B(A):

    pass

class C(A):

    def __init__(self):      #此时子类C的__init__被重新定义，故无法再显示父类的__init__内容

        super().__init__()     #使用super函数即可调用未绑定的父类内容。

                                     #另一种方法为“A.__init__(self)”其中self为子类的实例对象，而非父类的。

        print("我是子类！")

>>> a = A()
我是父类！
>>> b = B()
我是父类！
>>> c = C()
我是父类！
我是子类！
>>> 

------------------------------------------------------------------------------------------------------------

类相关的BIF

1.----

issubclass(class,classinfo)        #判断参数class,是否是classinfo的子类

                                                #class为需要判断的子类，子类会被认为是自身的子类。

                                                #classinfo为被判断的基类，可以是元组中的多个基类，并逐一判断。

返回值    布尔值True or False

2.----

isinstance(object,classinfo)         #判断对象object是否是classinfo中已知的类型

                                                    #object为需要判断的实例对象。

                                                    #classinfo为被判断的类或基本类型，可以是元组中的多个类逐一判断。

返回值    布尔值True or False

3.----

hasattr(object,name)      #判断object是否为类内对应的属性

                                        #object为需要判断的实例对象

                                        #name为被判断的类属性（变量名），name需要是字符串形式“ ”。

返回值    布尔值True or False

4.----

getattr(object,name[,default])   #返回一个对象的属性值 

                                                    #object为需要返回的实例对象

                                                    #name为被判断的类属性（变量名），并返回属性的值，name需要是字符串形式“ ”。

                                                    #default为默认返回值，如属性不存在则返回该值

返回值    类属性的值 or 默认返回值（如未设置default则触发AttributeError。）

5.----

setattr(object,name,value)    #修改或创建一个实例对象在类中的属性值

                                               #object为需要赋值的实例对象

                                               #name为被赋值的类属性（变量名），不存在则创建该属性，name需要是字符串形式“ ”。

                                               #value为被修改或创建的属性值。

返回值    类属性的值 or 默认返回值（如未设置default则触发AttributeError）。

6.----

delattr(object,name)    #删除实例对象在类中的属性

                                      #object为需要删除类属性的实例对象，等同于（del object."name"）

                                      #name为被删除的类属性（变量名），name需要是字符串形式“ ”。

返回值    无（如未name不存在则触发AttributeError）。

7.----

property(fget=none,fset=none,fdel=none,doc=none)      #集合类中多个方法于一个被赋值的对象。    

                                                                                            #fget 获取函数值

                                                                                            #fset 设置函数值

                                                                                            #fdel 删除函数值

                                                                                            #doc 属性描述信息

#将porperty在类中赋值一个对象后，外部调取此对象即可执行括号内的全部方法，从而达到方便被外部作用域调用的目的。

例：

class Temp(object):
    def __init__(self,x=10):
        self._x = x
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):

        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")    

c = Temp()

c.x    #获取类内的属性x的值为：10  等同于c.getx()

c.x = 20    #设置类内的属性x值为：20  等同于 c.setx(20)

del c.x    #删除类中的属性x    等同于 c.delx()

8.---

super(type[,object or type])    #函数调用父类的一个方法

                                                 #type为类

                                                 #object or type 为类，一般用self

例：

>>> class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)

>>> class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)

>>> fooChild = FooChild()
Parent
Child
>>> fooChild.bar('HelloWorld')
HelloWorld from Parent
Child bar fuction
I'm the parent.
>>> 

------------------------------------------------------------------------------------------------------------

引用类的静态属性（变量）可以使用“类名.属性名”

例：

>>> class C:

count = 0
def __init__(self):
C.count = C.count + 1    #使用C.count 引用count的值
def getCount(self):
return C.count

使用类的静态方法（函数）可以在方法前一行代码输入@staticmethod修饰符即可

例：

>>> class C:
@staticmethod     #该修饰符表示下面的方法属于静态方法
def function1(a,b):    #没有self参数
print(a,b,a+b)
def function2(self):
print("我是普通方法（函数）！")

>>> c1 = C()
>>> c2 = C()
>>> c1.function1 is C.function1
True
>>> c1.function2 is C.function2

False

#静态方法不会绑定在实例上，节省资源

>>> c1.function1        
<function C.function1 at 0x0000000002BCBA60>
>>> c2.function1
<function C.function1 at 0x0000000002BCBA60>
>>> C.function1
<function C.function1 at 0x0000000002BCBA60>

>>> c1.function2

#普通方法的每一个实例对象都有一个独立的位置

<bound method C.function2 of <__main__.C object at 0x0000000002BD9198>>
>>> c2.function2
<bound method C.function2 of <__main__.C object at 0x0000000002BD99E8>>
>>> C.function2

<function C.function2 at 0x0000000002BCBAE8>

#静态方法不需要self，即使实例对象访问self也不会传入

>>> c1.function1(1,2)
1 2 3
>>> C.function1(1,2)
1 2 3

>>> 

------------------------------------------------------------------------------------------------------------

类的专属方法（魔法方法）：

魔法方法	含义
	基本的魔法方法
__new__(cls[, ...])	1. __new__ 是在一个对象实例化的时候所调用的第一个方法 2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法 3. __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用 4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__init__(self[, ...])	构造器，当一个实例被创建的时候调用的初始化方法
__del__(self)	析构器，当一个实例被销毁的时候调用的方法
__call__(self[, args...])	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self)	定义当被 len() 调用时的行为
__repr__(self)	定义当被 repr() 调用时的行为
__str__(self)	定义当被 str() 调用时的行为
__bytes__(self)	定义当被 bytes() 调用时的行为
__hash__(self)	定义当被 hash() 调用时的行为
__bool__(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec)	定义当被 format() 调用时的行为
	有关属性
__getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)	定义当该类的属性被访问时的行为
__setattr__(self, name, value)	定义当一个属性被设置时的行为
__delattr__(self, name)	定义当一个属性被删除时的行为
__dir__(self)	定义当 dir() 被调用时的行为
__get__(self, instance, owner)	定义当描述符的值被取得时的行为
__set__(self, instance, value)	定义当描述符的值被改变时的行为
__delete__(self, instance)	定义当描述符的值被删除时的行为
	比较操作符
__lt__(self, other)	定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other)	定义小于等于号的行为：x <= y 调用 x.__le__(y)
__eq__(self, other)	定义等于号的行为：x == y 调用 x.__eq__(y)
__ne__(self, other)	定义不等号的行为：x != y 调用 x.__ne__(y)
__gt__(self, other)	定义大于号的行为：x > y 调用 x.__gt__(y)
__ge__(self, other)	定义大于等于号的行为：x >= y 调用 x.__ge__(y)
	算数运算符
__add__(self, other)	定义加法的行为：+
__sub__(self, other)	定义减法的行为：-
__mul__(self, other)	定义乘法的行为：*
__truediv__(self, other)	定义真除法的行为：/
__floordiv__(self, other)	定义整数除法的行为：//    #返回整数
__mod__(self, other)	定义取模算法的行为：%    #返回余数
__divmod__(self, other)	定义当被 divmod() 调用时的行为    #divmod(a,b)返回元组（a//b,a%b）
__pow__(self, other[, modulo])	定义当被 power() 调用或 ** 运算时的行为
__lshift__(self, other)	定义按位左移位的行为：<<
__rshift__(self, other)	定义按位右移位的行为：>>
__and__(self, other)	定义按位与操作的行为：&
__xor__(self, other)	定义按位异或操作的行为：^
__or__(self, other)	定义按位或操作的行为：|
	反运算
__radd__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rsub__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmul__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rtruediv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rfloordiv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rdivmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rpow__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rlshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rrshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rxor__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__ror__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
	增量赋值运算
__iadd__(self, other)	定义赋值加法的行为：+=
__isub__(self, other)	定义赋值减法的行为：-=
__imul__(self, other)	定义赋值乘法的行为：*=
__itruediv__(self, other)	定义赋值真除法的行为：/=
__ifloordiv__(self, other)	定义赋值整数除法的行为：//=
__imod__(self, other)	定义赋值取模算法的行为：%=
__ipow__(self, other[, modulo])	定义赋值幂运算的行为：**=
__ilshift__(self, other)	定义赋值按位左移位的行为：<<=
__irshift__(self, other)	定义赋值按位右移位的行为：>>=
__iand__(self, other)	定义赋值按位与操作的行为：&=
__ixor__(self, other)	定义赋值按位异或操作的行为：^=
__ior__(self, other)	定义赋值按位或操作的行为：|=
	一元操作符
__neg__(self)	定义正号的行为：+x
__pos__(self)	定义负号的行为：-x
__abs__(self)	定义当被 abs() 调用时的行为
__invert__(self)	定义按位求反的行为：~x
	类型转换
__complex__(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
__int__(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
__float__(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
__round__(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
__index__(self)	1. 当对象是被应用在切片表达式中时，实现整形强制转换 2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__ 3. 如果 __index__ 被定义，则 __int__ 也需要被定义，且返回相同的值
	上下文管理（with 语句）
__enter__(self)	1. 定义当使用 with 语句时的初始化行为 2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
__exit__(self, exc_type, exc_value, traceback)	1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么 2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
	容器类型
__len__(self)	定义当被 len() 调用时的行为（返回容器中元素的个数）
__getitem__(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)	定义当迭代容器中的元素的行为
__reversed__(self)	定义当被 reversed() 调用时的行为
__contains__(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为

------------------------------------------------------------------------------------------------------------

很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：

def __init__ ( self ) :

    self . data = [ ]

类定义了 __init__() 方法的话，类的实例化操作会自动调用 __init__() 方法。所以在下例中，可以这样创建一个新的实例:

x = MyClass()

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

实例(Python 3.0+)

#!/usr/bin/python3

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

------------------------------------------------------------------------------------------------------------

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

实例(Python 3.0+)

#!/usr/bin/python3

class Parent : # 定义父类

def myMethod ( self ) :

    print ( ' 调用父类方法 ' )

class Child ( Parent ) : # 定义子类

def myMethod ( self ) :

print ( ' 调用子类方法 ' )

c = Child ( ) # 子类实例

c . myMethod ( ) # 子类调用重写方法

super ( Child , c ) . myMethod ( ) #用子类对象调用父类已被覆盖的方法

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

------------------------------------------------------------------------------------------------------------