为了账号安全，请及时绑定邮箱和手机立即绑定
首页 免费课 Python-面向对象 笔记

Python-面向对象

剑圣OMG Linux系统工程师
难度中级
时长59分
学习人数
综合评分9.13
144人评价 查看评价
9.4 内容实用
9.0 简洁易懂
9.0 逻辑清晰
最热 最新
  • qq_守护本心_03787056

    调用父类的方法用super（）


    查看全部
    0 采集 收起 来源：Python面向对象-类的继承

    2018-08-08

  • 鲨鱼丶 04:20

    fqgqe ef

    查看全部
    0 采集 收起 来源：Python面向对象-定义类的属性

    2018-07-31

  • qq_莫以天涯问路远_0

    类的特性：

    封装性

    继承

    多态


    查看全部
    0 采集 收起 来源：Python-面向对象概念

    2018-07-23

  • 东来往北

    函数和方法最大的区别在于：

    函数仅仅是一段供人调用代码串，处于游离状态：

    而方法，是依附于某个类中，供其他程序调用

    查看全部
    0 采集 收起 来源：Python面向对象-定义类的方法

    2018-07-21

  • 小呆爱分析

    • 设置对象属性：通常不必定义，调用从父类继承的方法

    def __setattr__(self, name, value):
    self.__dict__[name] = value

    • 查询对象属性：

    __getattr__(self, name)：访问属性在默认情况下没有被查询到的情况下调用

    __getattribute__(self, name)：每次访问属性一定会调用，容易引起无限递归，最好调用父类的getattribute

    • 删除对象属性

    __delattr__(self, name)


    class Programer(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def __getattribute__(self, name):
        return super(Programer, self).__getattribute__(name)
        
    def __setattr__(self, name, value):
        self.__dict__[name] = value
     
if __name__ = '__main__':
    p = Programer('Albert', 25)
    print n.name


    查看全部
    1 采集 收起 来源：Python面向对象-类的属性控制

    2018-07-09

  • 小呆爱分析 03:49

    在print的过程中，将对象转换为字符串，包括三种方法：

    1. __str__：转换成适合人看的字符串

    2. __repr__：转换成适合机器看的字符串

    3. __unicode__

    展现对象属性：__dir__

    class Programer(object):
    def __init__(self, name, age):
        self.name = name
        if isinstance(age, int):
            self.age = age
        else:
            raise Exception('age must be int')
    def __str__(self):
        return '%s is %s years old' % (self.name, self.age)
        
    def __dir__(self):
        return self.__dict__.keys()
        
if __name__ = '__main__':
    p = Programer('Albert', 25)
    print p
    print dir(p)


    查看全部
    1 采集 收起 来源：Python面向对象-类的展现

    2018-07-09

  • 小呆爱分析

    比较运算符

    __cmp__(self, other)：包括以下所有比较情况

    __eq__(self, other)：判断等于情况

    __lt__(self, other)：判断小于情况

    __gt__(self, other)：判断大于情况


    数字运算符

    __add__(self, other)：加

    __sub__(self, other)：减

    __mul__(self, other)：乘

    __div__(self, other)：除


    逻辑运算符

    __or__(self, other)：或

    __and__(self, other)：与

    class Programer(object):
    def __init__(self, name, age):
        self.name = name
        if isinstance(age, int):
            self.age = age
        else:
            raise Exception('age must be int')
            
    def __eq__(self, other):
        if isinstance(other, Programer):
            if self.age == other.age:
                return True
            else:
                return False
        else:
            raise Exception('the type of object must be Programer')
            
    def __add__(self, other):
        if isinstance(other, Programer):
            return self.age + other.age
        else:
            raise Exception('the type of object must be Programer')


    查看全部
    0 采集 收起 来源：Python面向对象-类与运算符

    2018-07-09

  • 小呆爱分析 03:45

    构造对象的过程：

    1. 首先调用__new__方法创建类的对象：def __new__(cls)，通常不必定义（继承父类，父类会创建类对象），返回一个类的初始对象

    2. 将返回的对象交给__init__，对属性进行设置：def __init__(self)

    class Programer(object):
    def __new__(cls, *args, **kwargs): #改写new方法
        print 'call __new__ method'
        print args
        return super(Programer, self).__new__(cls, *args, **kwargs)
    def __init__(self, name, age):
        print 'call __init__ method'
        self.name = name
        self.age = age
        
if __name__ = '__main__':
    programer = Programer('Albert', 25)
    print programer.__dict__
    查看全部
    1 采集 收起 来源：Python面向对象-对象的实例化

    2018-07-09

  • 小呆爱分析

    多态的要素：

    1. 继承

    2. 方法重写

    class Programer(object):
    hobby = 'Play Computer'
    
    def __init__(self, name, age, weight):
        self.name = name
        self._age = age
        self.__weight = weight
        
    def self_introduction(self):
        print 'My name is %s \nI am %s years old\n' % (self.name, self._age)
    
class BackendProgramer(Programer):
    def __init__(self, name, age, weight, language):
        super(BackendProgramer, self).__init__(name, age, weight)
        self.language = language    
    
    def self_introduction(self):
        print 'My name is %s \nMy favorite language is %s' % (self.name, self.language)

def introduce(programer):
    if isinstance(programer, Programer):
        programer.self_introduction()
                   
if __name__ == '__main__':
    programer = Programer('Albert', 25, 80)
    backend_programer = BackendProgramer('Tim', 30, 70, 'Python')
    introduce(programer)
    introduce(backend_programer)
    查看全部
    1 采集 收起 来源：类的多态

    2018-07-09

  • 小呆爱分析 04:42

    继承使得大量代码被复用，是面向对象的优势。

    Object类是一切类的父类。


    继承的子类会继承父类的属性和方法，也可以自己定义，覆盖父类的属性和方法。

    在重写父类时，需要调用父类里的方法-->super()

    class A(object):
    def method(self, arg):
        pass
class B(A):
    def method(self, arg):
        super(B, self).method(arg)

    子类的类型判断：

    1. isinstance：判断类型

    2. issubclass：判断是否是子类

    class Programer(object):
    hobby = 'Play Computer'
    def __init__(self, name, age, weight):
        self.name = name
        self._age = age
        self.__weight = weight
        
    def self_introduction(self):
        print 'My name is %s \nI am %s years old\n' % (self.name, self._age)
        
class BackendProgramer(Programer):
    def __init__(self, name, age, weight, language):
        super(BackendProgramer, self).__init__(name, age, weight)
        self.language = language
        
if __name__ == '__main__':
    programer = BackendProgramer('Albert', 25, 80, 'Python')
    print dir(programer)
    print programer.__dict__
    print type(programer) #-->属于BackendProgramer
    print isinstance(programer, Programer) #-->True
    查看全部
    0 采集 收起 来源：Python面向对象-类的继承

    2018-07-09

  • 小呆爱分析 05:50

    函数与方法的区别：

    1. 函数：直接调用函数名的方式

    2. 方法：必须与对象结合使用，依附于类

    类的方法可以看做类的属性，也没有访问控制（与类的属性一致）。

    两个装饰器：

    1. @classmethod，类似直接在类里定义属性，调用时用类名，而不是某个对象

    2. @property，原调用方法：对象名.方法名()，现调用方法：像访问属性一样调用方法

    class Programer(object):
    hobby = 'Play Computer'
    def __init__(self, name, age, weight):
        self.name = name
        self._age = age
        self.__weight = weight
        
    @classmethod
    def get_hobby(cls):
        return cls.hobby
        
    @property
    def get_weight(self):
        return self.__weight
        
    def self_introduction(self):
        print 'My name is %s \nI am %s years old\n' % (self.name, self._age)
        
if __name__ == '__main__':
    programer = Programer('Albert', 25, 80)
    print dir(programer)
    print Programer.get_hobby() #用类名Programer调用
    print programer.get_weight #像访问属性一样，不用加括号
    programer.self_introduction()


    查看全部
    0 采集 收起 来源：Python面向对象-定义类的方法

    2018-07-09

  • 小呆爱分析 04:56

    定义类的属性：

    1. 在类里定义，类里所有对象共享该属性

    2. 在构造函数里定义，在构造对象时将属性值传入

    3. 没有访问控制（JAVA：Public&Private），没有提供私有属性的功能

    class Programer(object):
    hobby = 'Play Computer'
    
    def __init__(self, name, age, weight):
        self.name = name #无下划线-->可以公开访问
        self._age = age #有一个下划线-->私有属性，仍可访问
        self.__weight = weight #两个下划线-->部分私有属性，需要改变属性名访问
        
    def get_weight(self): #定义获取weight属性的方法
        return self.__weight
        
if __name__ == '__main__':
    programer = Programer('Albert', 25, 80) #对象实例化
    print dir(programer)
    print programer.__dict__ #从构造函数里获得的属性
    print programer.get_weight()
    print programer._Programer__weight #“对象名._类名__属性名”的方法访问
    查看全部
    1 采集 收起 来源：Python面向对象-定义类的属性

    2018-07-09

  • 小呆爱分析

    定义类

    class ClassName:
    def __init__(self, [……) #构造函数：设置类的属性
        pass
    def __del__(self, [……) #析构函数：销毁对象时调用
        pass

    旧式类：

    class OldStyle:
    pass

    新式类：（在python2中，若一个类没有继承别的类，最好继承object类；在python3中，所有类皆是新式类）

    class NewStyle(object):
    pass

    类的内建函数：

    1. dir()：返回对象的属性

    2. type()：获取对象的类型

    查看全部
    1 采集 收起 来源：用Python定义类

    2018-07-09

  • 小呆爱分析

    面向对象的两个基本概念：

    1. 类：定义了一件事物的抽象特点，例如现实生活中的某个群体

    2. 对象：类的实例，例如某个群体中的个体

    面向对象的基本要素：

    1. 属性（变量），例如某个群体的信息：年龄、性别、身高

    2. 方法（函数），例如某个群体的功能：写代码、修电脑

    面向对象的特性：

    1. 封装性：对外暴露了功能，隐藏了具体的实现细节

    2. 继承：对庞大群体进行细微分类，子类继承父类的属性和方法，分为单继承与多重继承，例如前端程序员、后端程序员

    3. 多态：由同一个类继承的几个类，在调用同一个方法时，会有不同的反应，例如同一类群体对同一件事有不同的看法

    查看全部
    1 采集 收起 来源：Python-面向对象概念

    2018-07-09

  • freeeWilll

    比较运算符：

    __cmp__(self,other)、__eq__(self,other) 、__lt__(self,other) 、__gt__(self,other)

    数字运算符：

    __add__(self,other) 、 __sub__(self,other)   、 __mul__(self,other)  、  __div__(self,other)

    逻辑运算符：

    __or__(self,other) 、  __and__(self,other)


    查看全部
    0 采集 收起 来源：Python面向对象-类与运算符

    2018-07-02

首页上一页891011121314下一页尾页

举报

0/150
提交
取消
开始学习
课程须知
热爱编程，对Python基础知识已经掌握。
老师告诉你能学到什么？
1.面向对象的理论基础 2.Python基本的面向对象特性 3.深入的了解Python面向对象

微信扫码，参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示：

您好，此课程属于迁移课程，您已购买该课程，无需重复购买，感谢您对慕课网的支持！

查看已购买的课程