面向对象笔记总结

Posted on 2018-12-17 20:34  爱你的毕加索  阅读(183)  评论(0编辑  收藏  举报

面向对象(oop):

  类:抽象概念(类型)例如人类

  对象:实际物体,类实例化对象(人类中的学生和老师就是对象)

  属性:

    描述类——>类属性

    描述对象——>实例属性

def __init__(self,score):# 构造函数:实例化对象时自动调用的 # self:当前对象

def __del__(self):# 析构方法:对象销毁的时候自动调用

self.__score = score # 私有属性,只允许在本类中访问

def __privateFun(self):# 私有方法

限制实例属性

__slots__ = ('name','age')# 只允许有‘name’和‘age’属性

继承:

  子类继承父类的属性和方法(私有属性继承但不能修改)

  可用super()函数或父类名.方法名

多继承:__mro__(获取类的继承顺序) 

  super()方法与类名.方法的区别:在于广度(super先广度在深度,类名.方法直接找到父类)

访问器(@property)和设置器(.setter

访问器的好处就是可以直接访问私有属性,不用调用第三方函数

class Student(object):
    def __init__(self,age):
        self.__age = age
    @property # 访问器(可单独存在)通过访问器可访问__age属性,__age和@property下def后age相同(名字必须相同)
    def age(self):
        return self.__age
s1 = Student(20)
print(s1.age)
class Student(object):
    def __init__(self):
        self.__number = 20181214
    def set_number(self,value):
        self.__number = value
    def get_number(self):
        return self.__number
    @property
    def number(self):
        return self.__number
    @number.setter # 设置器(不单独存在,一定要有property)
    def number(self,value):
        self.__number = value
s1 = Student()
s1.number = 20201214
print(s1.number)

总结:

1、只有@property表示只读(只可以访问私有属性)

2、同时有@property和@*.setter表示可读可写(既可以访问又可以改写私有属性值)

多态(多态用一句话概括就是,有这种方法,并且传入相应的参数就行。)

class Person(object):
    def who(self):
        print('I am a person')
class Student(object):
    def who(self):
        print('I am a student')
class Teacher(object):
    def who(self):
        print('I am a teacher')
def whoami(x):
    x.who()
a = Person()
b = Student()
c = Teacher()
whoami(a)
whoami(b)
whoami(c)

python魔法方法

class Student(object):
    def __init__(self, name = 'python'):
        self.__name = name

    def __str__(self):
        '''打印本类对象时,自动调用'''
        return 'hello, %s' % self.__name

    def __repr__(self):
        '''在解释器环境下直接输出本对象,自动调用的方法'''
        return self.__str__()

    def __len__(self):
        '''调用len函数的时候自动调用的方法'''
        return 100

    def __call__(self):
        '''调用本类对象的时候自动调用的方法'''
        print('Student object name:%s' % self.__name)

print(dir(Student))
s = Student()
print(s)
print(len(s))
s()
class Fib(object):
    cnt = 0
    def __init__(self):
        self.a = 0
        self.b = 1

    def __iter__(self):
        '''返回可迭代对象'''
        return self

    def __next__(self):
        '''随着循环自动调用的'''
        self.a, self.b = self.b, self.a+self.b
        
        if self.a >= 100:
            '''循环遍历终止'''        
            raise StopIteration()
        Fib.cnt += 1
        
        return self.a

    def __len__(self):
        return Fib.cnt

    def __getitem__(self, n):
        '''索引时自动调用的方法'''
        if isinstance(n, int):
            a, b = 0, 1
            while n >= 0:
                a, b = b, a+b
                n -= 1
            return a    

        if isinstance(n, slice):
            '''切片类型 start:end'''
            if n.start == None:
                start = 0
            else:
                start = n.start    
            if n.stop == None:
                return 'error'
            stop = n.stop
            l = []
            for i in range(start, stop):
                l.append(self[i])
            return l

f = Fib()
print(dir(f))
for i in f:
    print(i, end=' ')
print()
print(len(f))
for i in range(20):
    print(f[i], end=' ')
print()
print(f[0:3])
print(f[1:10])

枚举类

INSERT=1 # 缺点就是本质是变量,可以改变

from enum import Enum, unique #Enum 不可以改变变量的值

@ unique # 防止枚举成员的重复
class Menu(Enum):
    INSERT=1
    DELETE=2
    UPDATE=3
    SHOW=4
    # CHOOSE=4

print(Menu.INSERT.value)
# Menu.INSERT.value = 2
print(Menu['INSERT'])

元类(metaclass)

# type()构建一个类

def f(self, name='python'):
    print('hello %s'% name)

Test = type('Test', (object,), dict(show=f))

t = Test()
t.show()

# 另一种构建类的方法,是先构建元类,以元类为模板构建类

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        '''类方法'''
        attrs['add'] = lambda self, value : self.append(value)
        return type.__new__(cls, name, bases, attrs)

class Mylist(list, metaclass=ListMetaclass):
    pass

l = Mylist()
print(type(l))
l.add(1)
l.add('hello')
print(l)

 

 

 

面向对象(oop):

类:抽象概念(类型)例如人类

对象:实际物体,类实例化对象(人类中的学生和老师就是对象)

属性:

描述类——>类属性

描述对象——>实例属性