类学习笔记

面相对象

类

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法
类中定义的函数
类变量
类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
继承：
即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系

类 对象

class a:
    i = 123
    def b(self):
        return "abc"

#实体化
x = a()
#访问类的属性和方法
print("属性i",x.i)
print("方法",x.b())

带参数的写法

class a:
    i = 123
    def b(s,aa):
        s.aa = aa
        return s.aa

#实体化
x = a()
#访问类的属性和方法
print("属性i",x.i)
print("方法",x.b(22))

类的特殊构造函数

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

方法实例化时自动调用

class Complex:
    def __init__(self,r,i):#类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用
        self.r = r
        self.i = i


y = Complex(111,"abc")
print(y.r,y.i)

注：不需要return，写return后会报错，提醒函数return为空

self代表类的实例，而非类

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

class a:
    def b(self):
        return s


#实体化
x = a()
print("方法",x.b())

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。self 不是 python 关键字

类的方法

定义私有属性,私有属性在类外部无法直接进行访问

继承

继承
class a:#父类
    i = 123
    def __init__(self,i,j):
        self.i = i
        self.j = j
    def B(self):
        return "abc"
    def c(self,i,j):
        self.i = i
        self.j = j
        return self.i + self.j

class A(a):
    I = 456
    def __init__(self,i,j,z):
        a.__init__(self,i,j)
        self.z = z
    #覆盖父类方法
    def c(self,i,j):
        self.i = i
        self.j = j
        return self.i * self.j
y = a(9,8)
print("父类",y.i,y.j)

print("父类",y.B())#父类
print("父类c函数",y.c(4,5))
print("-----------------")
x = A(5,6,7)
print("子类",x.i,x.j,x.z)

print("子类",x.B())#子类
print("子类c函数",x.c(4,5))

多继承

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

class a1:#父类1
    i = 123
    def __init__(self,i,j):
        self.i = i
        self.j = j
    def B(self):
        return "a1的B方法"
    def c(self,i,j):
        self.i = i
        self.j = j
        return [self.i + self.j,"a1的c方法"]


class a2:#父类2
    i = 123
    def __init__(self,i,j):
        self.i = i
        self.j = j
    def B(self):
        return "a2的B方法"
    def c(self,i,j):
        self.i = i
        self.j = j
        return [self.i * self.j,"a2的c方法"]
    def d(self):
        return "a2的d方法"

class A(a1,a2):#子类
    I = 456
    def __init__(self,i,j,z):
        a1.__init__(self,i,j)
        self.z = z
    #覆盖父类方法
    def c(self,i,j):
        self.i = i
        self.j = j
        return [(self.i+1) * self.j,"子类的c方法"]

x = A(1,2,3)
print(x.B())#类使用时未指定，python从左至右搜索
print(x.c(4,5))
print(x.d())

类的私有属性

私有变量
私有变量，在变量名前加两个下划线
私有变量在类外部可调用

class justCount:
    __numi = 1#私有变量
    numj = 2#公开变量
    def Count(self):
        self.__numi += 1
        self.numj += 2
        print("Count方法中的输出",self.__numi,self.numj)

a = justCount()
print("主函数调用Count方法之前的a.numj",a.numj)
print("----------")
a.Count()
print("主函数调用Count方法后的a.numj",a.numj)
# print("a.__numi",a.__numi)#私有变量在类外部不可调用

私有方法
只能在类的内部调用 ，不能在类的外部调用。

class justCount:
    def __init__(self,num1,num2):
        self.num1 = num1   #public
        self.__num2 = num2 #private
    def Num(self):
        print("Num方法输出num1",self.num1)
        print("Num方法输出num2",self.__num2)
    def __Count(self):
        print("私有方法")
    def Count(self):
        print("公开方法")
        self.__Count()

a = justCount(4,5)
print(a.num1)
# print(a.__num2)#私有
a.Num()
a.Count()
a.__Count()#私有方法不可再外调用

类的专有方法：

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

运算重载

可以对类的专有方法进行重载
加减乘除

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)

    def __sub__(self, other):
        return Vector(self.a - other.a, self.b - other.b)

    def __mul__(self, other):
        return Vector(self.a * other.a, self.b * other.b)

    def __truediv__(self, other):
        return Vector(self.a / other.a, self.b / other.b)



v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)
print(v1 - v2)
print(v1 * v2)
print(v1 / v2)

比较<

class Vector:
    def __init__(self, a = 0.0):
        self._a = a

    def __lt__(self, other):
        return self._a < other._a

v1 = Vector(2)
v2 = Vector(5)
print(v1 < v2)

len()

class long:
    def __init__(self,a):
        self.a = a
    def __len__(self):
        return len(self.a)

x = long('12242345')
print(len(x))