精华内容
下载资源
问答
  • 类对象是将具有相似属性方法的对象总结抽象为类对象,可以定义相似的一些属性方法,不同的实例对象去引用类对象的属性方法,能减少代码的重复率。 实例对象又称实例化对象,不是抽象而是一类对象中具体的一例...

    Y14


    一、类对象和实例对象
    简短理论:

    1. 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象去引用类对象的属性和方法,能减少代码的重复率。
    2. 实例对象又称实例化对象,不是抽象而是一类对象中具体的一例对象。

    比喻理解:
      我相信有的人觉得有点绕,在这里我以比喻说明,希望你能明白。首先,要明白,在python中,“万物皆对象”。个人理解:

      类对象,好比有一篮“水果”,篮子里面的水果没有重复,那么这一篮中的“水果”就属于一个类,是抽象的,就像有人对你说“给我水果”,你的第一反应一定是“什么水果?”,所以是不确定性的。

      实例对象,好比篮子里面的“苹果”,是一个具体的对象,即一个实例。我想有人对你说“给我苹果”,你应该不会想选择哪个水果吧


    二、类变量和实例变量
    简短理论:

    1. 类变量:可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。
    2. 实例变量:实例化之后,每个实例单独拥有的变量。实例变量:实例化之后,每个实例单独拥有的变量。

    比喻理解:
      其实,如果你理解了类对象和实例对象,在看过类变量和实例变量的理论,应该就能明白区别。

      类变量,接上面一篮水果比喻,好比是说“洗洗水果”(洗这个新加的动作就是你定义的一个类变量),你肯定是篮子里面的所有水果都会洗。也就是所有的水果都共享了“洗”这个新加的动作。即“类变量的值,实例可以共享”

      实例变量,这个简单,好比说“洗洗苹果”,这个洗的动作是有针对性的,是作用于一个苹果(实例)。即为“实例化后,每个实例单独拥有的变量”


    大家需要注意,以上问题也是python中常见面试题,若需代码理解,推荐:https://www.cnblogs.com/loleina/p/5409084.html ,愿你理解。

    个人小结,定有不足之处,欢迎指点。
    谢谢~

    展开全文
  • Python类和对象的理解

    千次阅读 2018-12-12 19:48:43
    理解类和对象的关系 好比制造飞机的图纸,对象好比飞机实例。需要注意的是中有的属性方法,在对象中也有,并且不能多也不能少 的定义: class 类名: #大驼峰命名发 def 方法1(self ,参数列表)  ...

    Python类

    是对一群具有相同特征 或者行为的事物的一个统称。是抽象的,不能直接使用。
    因此类的主要作用是表示某些特征和行为,在Python中
    特征被称为属性
    行为被称为方法

    理解类和对象的关系

    类好比制造飞机的图纸,对象好比飞机实例。需要注意的是类中有的属性和方法,在对象中也有,并且不能多也不能少
    类的定义:

    class 类名: #大驼峰命名发
    def 方法1(self ,参数列表)
      pass
    def 方法2(self ,参数列表)
      pass

    类对象的实例化

    object=类名(参数)

    展开全文
  • Python 对象

    万次阅读 多人点赞 2019-04-10 16:49:40
    对象的理解与封装特性 面向对象编程语言 - : 一个模板, (人类)---是一个抽象的, 没有实体的 - 对象: (eg: 张三, 李四) - 属性: (表示这东西的特征, 眼睛, 嘴巴, 鼻子) - 方法: (表示这物体可以...

    类与对象的理解与封装特性

     面向对象编程语言
       - 类: 一个模板, (人类)---是一个抽象的, 没有实体的
       - 对象: (eg: 张三, 李四)
       - 属性: (表示这类东西的特征, 眼睛, 嘴巴, 鼻子)
       - 方法: (表示这类物体可以做的事情, eg: 吃饭, 睡觉,学习)
    

    1). 定义类:class: 类

    from collections import  Counter
    

    例子: str, list, dict, Counter

    object代表是, 人类继承于哪一个类, 如果不知道继承哪个类, 就写object;
    class 人类(object):
        # print('hello')
    
        # 构造方法(魔术方法), 当创建对象的时候, 自动执行的函数
        def __init__(self, name, age, gender):
            # python解释器自动将对象传给self这个形参.
            # 看self到底是什么东西?
    
            # 将对象与该对象的属性绑定在一起.
            #  调用对象的属性两种方式:
            #       - 张三.name
            #       - self.name
            self.name = name     # 属性
            self.age = age       # 属性
            self.gender = gender # 属性
            print(self)  # 实质上是一个对象, <__main__.人类 object at 0x7f4fdc4864a8>
    
        # 方法(在类里面定义的函数, 叫做方法)
        def eat(self):
            print("%s 正在吃饭..." %(self.name))
    

    创建对象====根据模板(类)创建对象(真实存在)

    张三 = 人类("张三",  10, 'male')
    print("张三:", 张三)
    

    看对象的属性

    print(张三.name)
    print(张三.age)
    print(张三.gender)
    

    让对象执行方法

    张三.eat()
    

    这里写图片描述

    对象与类掌握练习

    应用练习1
    创建一个类People,拥有的方法为砍柴,娶媳妇,回家;实例化对象,执行相应的方法
    显示如下:
        老李,18岁,男,开车去娶媳妇
        校思浩,22岁,男,上山去砍柴
        唐浩,10岁,女,辍学回家
    提示:
        属性:name,age,gender
        方法:goHome(), kanChai(),quXiFu()
    
    class People(object):
        def __init__(self,name,age,gender):
            self.name = name
            self.age = age
            self.gender = gender
        def huiJia(self):
            print("%s,%d,%s,辍学回家" %(self.name,self.age,self.gender))
        def quXiFu(self):
            print("%s,%d,%s,开车去娶媳妇" %(self.name,self.age,self.gender))
        def kanChai(self):
            print("%s,%d,%s,上山砍柴" %(self.name,self.age,self.gender))
    Laoli = People('老李',18,'男')
    zhangsan = People('校思浩',22,'男')
    lisi = People('唐浩',10, '女')
    
    Laoli.quXiFu()
    zhangsan.kanChai()
    lisi.huiJia()
    

    这里写图片描述

    类的私有属性与私有方法

    类的私有属性:
        __private_attrs:两个下划线开头,声明该属性为私有,
        不能在类地外部被使用或直接访问。
        在类内部的方法中使用时 self.__private_attrs。
    类的方法:
        在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,
        类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。
        self 的名字并不是规定死的(因为是形参),也可以使用 this,但是最好还是按照约定是用 self。
    类的私有方法
        __private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,
        不能在类地外部调用。self.__private_methods。
    
    
    class People(object):
        def __init__(self,name,age,gender, money):
            self.name = name
            self.age = age
            self.gender = gender
            self.__money = money
    
        def __play(self):
            print("王者荣耀正在进行时")
    
    p1 = People('user1', 10, 'male', 1000000)
    print(p1.gender)
    p1.__play
    

    这里写图片描述

    栈数据结构的封装

    应用练习2:栈的数据结构
    class Stack:
        栈的方法:
        入栈(push), 出栈(pop), 栈顶元素(top),
        栈的长度(lenght), 判断栈是否为空(isempty)
        显示栈元素(view)
        操作结果:
        栈类的实例化
        入栈2次
        出栈1次
        显示最终栈元素
    
    
    class Stack(object):
        # 构造函数
        def __init__(self):
            self.stack = []
        def push(self, value):
            """
            :param value: 入栈元素
            :return:
            """
            self.stack.append(value)
            return True
    
        def pop(self):
            # 判断栈是否为空
            if self.stack:
                # 获取出栈元素, 并返回
                item = self.stack.pop()
                return  item
            else:
                return  False
    
        def top(self):
            if self.stack:
                return  self.stack[-1]
            else:
                return  False
        def length(self):
            return  len(self.stack)
    
        def isempty(self):
            return self.stack==[]
    
        def view(self):
            return  ",".join(self.stack)
    
    s = Stack()
    s.push('1')
    s.push('2')
    s.push('3')
    s.push('4')
    print(s.top())
    print(s.length())
    print(s.isempty())
    s.pop()
    print(s.view())
    

    这里写图片描述

    队列数据结构的封装

    class Queue(object):
        # 构造函数
        def __init__(self):
            self.queue = []
        def push(self, value):
            self.queue.append(value)
            return True
        def pop(self):
            if self.queue:
                del self.queue[-1]
            else:
                return  False
    
        def front(self):
            if self.queue:
                return  self.queue[0]
            else:
                return  False
        def rear(self):
            if self.queue:
                return  self.queue[-1]
            else:
                return  False
        def length(self):
            return  len(self.queue)
    
        def isempty(self):
            return self.queue==[]
    
        def view(self):
            return  ",".join(self.queue)
    s = Queue()
    s.push('1')
    s.push('2')
    s.push('3')
    s.push('4')
    print(s.front())
    print(s.rear())
    print(s.length())
    print(s.isempty())
    s.pop()
    print(s.view())
    

    这里写图片描述

    第二个特性之继承

    概念:

    - 父类与子类/基类和派生类

    from io import TextIOWrapper

    class Animals(object):
        def __init__(self, name, age):
            self.name = name
            self.age= age
        def eat(self):
            print('eating......')
    
    
    class Dog(Animals):  # 当Dog没有构造方法时,执行Animals里面的构造方法
        def __init__(self, name, age, power):
            # self.name = name
            # self.age = age
            # 执行Dog的父类的构造方法;
            super(Dog, self).__init__(name, age)
            self.power = power
        def eat(self):
            print(self.power)
            super(Dog, self).eat()
    
    
    #  1. 如果子类没有的属性和方法, 则去父类找, 如果父类也没有, 就报错。
    d1 = Dog("大黄",3,100)
    print(d1.name)
    print(d1.age)
    print(d1.power)
    d1.eat()
    
    

    这里写图片描述

    多继承原理

    #coding:utf-8
    
    # # 经典类
    # class Person1:
    #     pass
    # p1 = Person1()
    # print(p1)
    #
    # # 新式类
    # class Person2(object):
    #     pass
    # p2 = Person2()
    # print(p2)
    
    
    # 在python2中既有新式类也有经典类;
    #
    #
    #       经典类的继承算法: 深度优先算法
    #       新式类的继承算法: 广度优先算法
    # python3全部都是新式类;
    
    class D:
        def test(self):
            print("D test")
    class C(D):
        pass
        def test(self):
            print("C test")
    class B(D):
        pass
        # def test(self):
        #     print("B test")
    class A(B,C):
        pass
        # def test(self):
        #     print("A test")
    a = A()
    a.test()
    

    这里写图片描述

    三,多态性

    #子类和父类存在相同方法时,子类会覆盖父类方法
    #运形时总会调用子类方法--> 多态
    
    
    class Animal(object):
        def run(self):
            print('running...')
        def cry(self):
            print('crying...')
    
    class Dog(Animal):
        def run(self):
            print('dog running...')
    
        def eat(self):
            print('dog eating...')
    
    class Cat(Animal):
        def run(self):
            print('cat running...')
    
    cat = Cat()
    cat.run()
    
    dog = Dog()
    dog.run()
    

    在这里插入图片描述

    图书管理系统

    # 假设每本书只有一本
    
    class Book(object):
        def __init__(self, name, author, state, bookIndex):
            self.name = name
            self.author = author
            # 0:'已借出' 1:'未借出'
            self.state = state
            self.bookIndex = bookIndex
    
    
        def __str__(self):
            return  'Book(%s, %d)' %(self.name, self.state)
    
    class   BookManage(object):
        # 存放所有书籍信息, 列表里面存放的是Book对象
        books = []
    
        def start(self):
            """图书管理系统初始化数据"""
            self.books.append(Book('python', 'Guido', 1, 'IN23445'))
            self.books.append(Book('java', 'Guido1', 1, 'IN23445'))
            self.books.append(Book('C++', 'Guido2', 1, 'IN23445'))
            print("初始化数据成功!")
    
        def Menu(self):
            """图书管理菜单栏"""
            while True:
                print("""
                            图书管理操作
                            
                1). 添加书籍
                2). 删除数据
                3). 查询书籍
                4). 退出
                """)
                choice = input("请输入你的选择:")
                if choice == '1':
                    self.addBook()
                elif choice == '2':
                    self.delBook()
                elif choice == '3':
                    self.borrowBook()
                elif choice == '4':
                    exit()
                else:
                    print("请输入正确的选择!")
    
        def addBook(self):
            print("添加书籍".center(0, '*'))
            name = input("书籍名称:")
            bObj = self.isBookExist(name)
            if bObj:
                print("书籍%s已经存在" %(bObj.name))
            else:
                self.books.append(Book(name,input("作者:"), 1, input("存放位置:")))
                print("书籍%s添加成功" %(name))
    
        def delBook(self):
            print("删除书籍".center(50,'*'))
            for i in self.books:
                print(i)
            name = input("删除书籍名称:")
            a = self.isBookExist(name)
            if a:
                self.books.remove(a)
                print("删除%s成功" %(a))
            else:
                print("书籍不存在")
    
        def borrowBook(self):
            print("查询书籍".center(50,'*'))
            for i in self.books:
                print(i)
            name = input("查询书籍名称:")
            b = self.isBookExist(name)
            for book in self.books:
                if book == b:
                    print(book)
                    break
                else:
                    print("%s不存在" %(b))
                    break
        def isBookExist(self, name):
            """检测书籍是否存在"""
            # 1. 依次遍历列表books里面的每个元素
            # 2. 如果有一个对象的书名和name相等, 那么存在;
            # 3. 如果遍历所有内容, 都没有发现书名与name相同, 书籍不存在;
            for book in self.books:
                if book.name == name:
                    # 因为后面需要
                    return book
            else:
                return  False
    
    if __name__ == "__main__":
        bManger = BookManage()
        bManger.start()
        bManger.Menu()
    
    

    这里写图片描述

    展开全文
  • Python-类对象方法和类实例对象方法

    千次阅读 2018-06-05 13:33:26
    自己总结python类中类对象方法和类实例对象方法,其判断的方法是: (1)首先看方法定义是否引用了self,带了self,肯定为实例对象方法。 (2)其次,看是否带参数,如果不带参数,肯定是类对象方法。 (3)除了...

        自己总结python类中类对象方法和类实例对象方法,其判断的方法是:

     (1)首先看方法定义是否引用了self,带了self,肯定为实例对象方法。

     (2)其次,看是否带参数,如果不带参数,肯定是类对象方法。

     (3)除了以上两条外,至少带一个参数的方法定义,且没有classmethod标识的,肯定为实例对象方法(第一个参数实际上是类实例对象self,比较隐含),其他类对象方法。

       关于类对象方法怎么使用,大家可以参考我写的类对象方法一篇博文:https://blog.csdn.net/weixin_42039090/article/details/80580012,。

    请大家分析如下代码:

    # -*- coding: utf-8 -*-

    class Person(object):
        Count=0;
        _income=0;
        __Tel="13088888888"
        def __init__(self,name,number):
            self.name=name              #实例对象可以引用的两个成员:name和number,且公有的。
            self.number=number
        def __scolia__(self):   #这是实例对象方法,因为引用了self变量,当然,其他也可以哦。
            print("scola")
            return "scola"  
        def think(a):
            #这里用a,可以代替self。不加特别说明,这里默认think方法是实例方法。
            #判断根据是:要不没参数,要不加装饰器@classmethod,或者classmethod标识。
            print("name:",a.__class__.__name__)
            print("I am thinking")
        def Work():         #类方法,不是实例对象方法。
           print(Person.__Tel)
    #      print(Person.number)  类对象方法不能直接访问类实例对象的成员,即使是公有的,也不行。
           Person.__Tel="13562334563"
           print(" I am working!")
           print(Person.__Tel)
        def _Eat():              #保护类对象方法,也不是实例对象方法,在类继承中要注意。
            print("I am Eating")
        def __Sleep():           #私有类对象方法,不是类实例对象方法。
            print('I am Sleeping')
    #--------------类对象------------------------
    print(Person.Count)
    Person.Count+=1
    print(Person.Count)
    Person._income+=1000
    print(Person._income)
    #Person.__Tel #只能在类定义中引用,外部不能引用
    Person.Work()
    Person._Eat()
    #Person.__Sleep() 只能在类定义中引用,外部不能引用
    #---------------类实例化对象-------------------
    a=Person()
    Person.Count+=1 #类成员,实例一般不要轻易修改值。实例不改动类的属性值。a.Count没意义。
    print(Person.Count)
    a.think()       #定义时必须带参数。
    a.__scolia__()  #定义时必须带参数。

    #a.__Sleep()#更不能用。

    大家,加油!

    展开全文
  • Python-封装对象类

    千次阅读 2018-11-10 19:31:42
    正因为如此,在Python中创建一个类和对象是很容易的,当然如果习惯面向过程或者函数的写法也是可以的,Python并不做硬性的限制。 接下来一步一步的大家分享一下Python是怎么样封装的。 版本一: 封装一个,最...
  • Python2和Python3的区别,以及为什么选Python3的原因

    万次阅读 多人点赞 2018-06-29 12:28:13
    任何关于算法、编程、AI行业知识或博客内容的问题,可以随时扫码关注公众号「图灵的猫」,加入”学习小组“,沙雕博主在线答疑~此外,公众号内还有更多AI、算法、编程大数据知识分享,以及免费的SSR节点学习资料...
  • Python学习笔记(九):类和对象

    万次阅读 热门讨论 2021-02-10 01:16:44
    类方法实例方法类方法静态方法静态方法和类方法的区别四.类命名空间 一.类和对象 类(class)和对象(object,也被称为实例,instance),可以把类理解成某种概念,对象是一个具体存在的实体 类的定义 class 类名: ...
  • 是抽象的,在使用的时候通常会找到这个的一个具体的存在,使用... 可以直接使用对象的关系: 就是创建对象的模板的构成: 1.的名称:类名 2.的属性:一组数据 3.的方法:允许对进行操作的...
  • 属性 变量 ... #变量可以由所有的对象访问,但是对象只能访问,不可修改 #用来做资源共享 total = 0 name = 'python8期' #初始化函数,添加对象属性 def __init__(self,name,age,school):
  • Python学习:类对象和实例对象

    千次阅读 2019-01-24 13:01:43
    # 定义C class C: count = 0 # 类对象C() a = C() ...# 实例对象a,b ...可以看出对实例对象a的count属性进行赋值之后,就相当于覆盖了类对象C的count属性。如果没有赋值覆盖,那么引用的是类对象的co...
  • Python对象和类序列化到MySQL

    万次阅读 2020-01-07 23:21:49
    pickle序列化对象和类到数据库,需修改mysql数据库表结构,字段类型设为二进制,如blob类型,参考: https://www.cnblogs.com/wangchunlan1299/p/7725062.html | test | CREATE TABLE `test` ( `id` int(10) unsigned ...
  • Python类变量实例变量区别

    万次阅读 2014-03-11 14:43:13
    深入理解python类的实例变量和类变量 Python变量的本质:被赋值 1 普通python变量(非类相关变量)很容易理解,在被赋值后即变量存在,可读可写 2 Python类的变量(类变量和实例对象变量)以某种方式在某地方被赋值...
  • python中的类和对象,属性方法

    万次阅读 多人点赞 2018-04-26 13:18:30
    一、面向对象的概述面向对象是一种描述业务问题、设计业务实体实体之间关系的方法二、类和对象1、类和对象区别是对客观世界中事物得抽象,而对象实例化后的实体 例如:汽车模型就是一个,制造出来的...
  • 这篇文章主要介绍了Python 面向对象class和对象基本用法,结合实例形式详细分析了Python面向对象程序设计中class和对象基本概念、原理、使用方法与操作注意事项,需要的朋友可以参考下 本文实例讲述了Python ...
  • python 对象练习题

    万次阅读 2018-11-18 18:46:54
    1、创建Person,属性有姓名、年龄、性别,创建方法personInfo,打印这个人的信息 2、创建Student,继承Person...创建方法study参数为Teacher对象,调用Teacher的teachObj方法,接收老师教授的知识点,然后打...
  • Python学习笔记(十一):类和对象

    万次阅读 2021-02-11 00:10:46
    Python学习笔记(十一):类和对象 关于类和对象Python学习笔记(十一):类和对象一.变量实例变量变量实例变量二.函数装饰器带参数的函数装饰器函数装饰器的嵌套三.property()四.封装机制五.继承机制 一....
  • 为了能够更好的解释属性和对象属性的区别,先创建People两个对象student1student2如下: class People(object):  # 属性是指定义在的内部而且在方法的外部的属性  money = 10000  def __init__...
  • Python中的对象和对象

    千次阅读 2017-07-05 16:18:25
    今天我们介绍Python中的对象和对象名:Python中所有的变量都是对象对象python里,其实是一个指针,指向一个数据结构,数据结构里有属性,有方法。对象通常就是指变量。从面向对象OO的概念来讲,对象的一个...
  • Python变量和对象变量声明解析

    千次阅读 2018-02-14 23:43:57
    Python类和C++一样,也都是存在两种类型的变量,变量和对象变量!前者由拥有,被所有对象共享,后者由每个对象独有。这里我主要想讨论一下他们的声明办法。 首先说的是对象变量: 只要是声明在的语句块...
  • Python 对象的练习题

    万次阅读 多人点赞 2018-10-28 19:13:01
    1、创建员工Employee,属性有姓名name、能力值...2、创建老板Boss,属性有金钱money,员工列表employeeList(存储员工类对象),工作量work,功能有雇佣员工addEmployee(),雇佣后将员工添加至列表中,雇佣一人mon...
  • python类的实例方法、静态方法和类方法区别及其应用场景 一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。 ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一...
  • Python中的的定义和对象的创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    面向对象中两个重要的概念: 1. :对一事物的描述,是抽象的、概念上的定义。...1.创建类和创建类对象 1.创建主要由类名,属性,方法组成,当然创建一个时,属性方法可以选择的。 cla...
  • Python新式类和经典区别

    万次阅读 2015-07-15 18:04:04
    Python2.2开始,Python 引入了 new style class(新式) 新式跟经典的差别主要是以下几点: 新式类对象可以直接通过__class__属性获取自身类型:type # -*- coding:utf-8 -*- class E: #经典...
  • Python之面向对象和面向过程的区别

    千次阅读 2019-03-15 10:48:28
  • python对象

    千次阅读 2017-12-09 12:20:28
    python对象 一、 python的 可以比作是某种类型集合的描述 把一相同的事物叫做,其拥有相同的属性(其实就是变量)描述,里面封装了相同的方法。比如,汽车是一个,它包括价格、品牌等属性。   二、...
  • Python 3.5 2.7区别

    万次阅读 2016-08-07 20:02:17
    Python 2.7 中,将Dict对象存储序列化,然后可以自由的发序列化,具体代码大致如下: 但是在Python 3.5 调用上述代码时会报如下错误: 这是应为2.7pickle.load函数读取时默认为bytes读取,而3.5读取时默认为...
  • python基础

    万次阅读 多人点赞 2018-06-17 01:14:53
    什么是面向对象编程 1、面向对象编程(oop)是一种程序设计思想。...1、(Class): 用来描述具有相同的属性方法的对象的集合。它定义了该集合中每个对象所共有的属性方法。对象的实例。 2、...
  • python 类对象转json字符串

    千次阅读 2019-07-31 14:31:05
    使用实例的 __dict__属性,将类对象转为json格式字符串 import json class Person(object): def __init__(self): self.name = 'John' self.age = 25 self.id = 1 person = Person() s = json.dumps(pe...
  • python3 类对象的定义、方法

    万次阅读 2017-10-26 22:09:28
    Class 对象、定义、方法面向对象的定义 Class: 用来描述具体相同的属性方法的对象的集合。定义了该集合中每个对象所共有的属性方法。对象的示例。变量:变量在整个实例化的对象中是公用的。变量...
  • python load loads 区别

    千次阅读 2019-04-08 13:59:06
    一句话,load通过json.load(open(’*.json’))这样的...因此,loadloads都是实现“反序列化”,区别在于(以Python为例)。loads针对内存对象,即将Python内置数据序列化为字串。 如使用json.dumps序列化的对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,028,477
精华内容 411,390
关键字:

python类和对象的区别

python 订阅