• 面向对象笔记总结


    面向对象(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):

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

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

    属性:

    描述类——>类属性

    描述对象——>实例属性

  • 相关阅读:
    [noip2010]关押罪犯 并查集
    双栈排序 noip2008
    欧拉函数
    中国剩余定理(孙子定理)
    求组合数
    线性素数筛
    洛谷 P2661 信息传递
    图的最短路
    Mzc和男家丁的游戏
    最佳旅游线路
  • 原文地址:https://www.cnblogs.com/wt1103/p/10133728.html
Copyright © 2020-2023  润新知