精华内容
下载资源
问答
  • Python类和对象的理解

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

    Python类

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

    理解类和对象的关系

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

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

    类对象的实例化

    object=类名(参数)

    展开全文
  • 是抽象的,在使用的时候通常会找到这个的一个具体的存在,使用... 可以直接使用对象的关系: 就是创建对象的模板的构成: 1.的名称:类名 2.的属性:一组数据 3.的方法:允许对进行操作的...

    类:类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

    对象: 某一个具体事物的存在,在现实世界中可以是看的到摸得着的。 可以直接使用

    类与对象的关系: 类就是创建对象的模板

    类的构成:

                    1.类的名称:类名

                     2.类的属性:一组数据

                     3.类的方法:允许对进行操作的方法(行为)

    对象:当创建对象时,就是用一个模子,来制造一个实物


    类属性,实例属性

    类属性:类对象所拥有的属性,它被所有类对象的实例对象所共有,在内存中只存在一个副本。

    实例属性:实例对象所拥有的属性,则是以为self.开头 (实例也能访问类变量)


    实例方法:类的实例能使用的方法

    静态方法:普通函数就位于类定义的命名空间中,它不会对任何实例类型进行操作。需要使用装饰器@staticmethod定义静态方法 (类对象和实例都可以调用静态方法)

    类方法:将类本身作为对象进行操作的方法。使用@classmethod装饰器定义,其第一个参数是类,约定写为cls(类对象和实例都可以调用类方法)


    总结:

            类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;

            而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。

            静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用







    展开全文
  • 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学习笔记(13)-Python类对象示例

    千次阅读 多人点赞 2017-05-03 15:30:40
    Python是一种动态语言,所以它的面向对象机制的定义使用都挺有意思,所以本篇主要内容: Python类的定义 Python类的实例化 Python类中属性的访问控制 二,Python类的定义举个栗子先:class Car:#定义了 name=...
  • 学习笔记之——Python类和对象的理解

    千次阅读 多人点赞 2019-01-16 20:26:13
    学习笔记之——Python类和对象的理解一、 面向对象的含义特性二、1. Python的定义、结构、创建1. Python类的定义2. Python类的结构3. 的创建4. 的属性5. 的方法三、对象1. 对象的创建四、参考资料 ...
  • 一、类对象和实例对象 简短理论: 对象是将具有相似属性和方法的对象总结抽象为对象,可以定义相似的一些属性和方法,不同的实例对象去引用对象的属性和方法,能减少代码的重复率。 实例对象又称实例化对象,...
  • Python-封装对象类

    千次阅读 2018-11-10 19:31:42
    正因为如此,在Python中创建一个类和对象是很容易的,当然如果习惯面向过程或者函数的写法也是可以的,Python并不做硬性的限制。 接下来一步一步的大家分享一下Python是怎么样封装的。 版本一: 封装一个,最...
  • 属性 变量 ... #变量可以由所有的对象访问,但是对象只能访问,不可修改 #用来做资源共享 total = 0 name = 'python8期' #初始化函数,添加对象属性 def __init__(self,name,age,school):
  • Python学习笔记(九):类和对象

    万次阅读 热门讨论 2021-02-10 01:16:44
    类方法实例方法类方法静态方法静态方法和类方法的区别四.类命名空间 一.类和对象 类(class)和对象(object,也被称为实例,instance),可以把类理解成某种概念,对象是一个具体存在的实体 类的定义 class 类名: ...
  • 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 对象练习题

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

    千次阅读 2019-01-24 13:01:43
    # 定义C class C: count = 0 # 类对象C() a = C() ...# 实例对象a,b ...可以看出对实例对象a的count属性进行赋值之后,就相当于覆盖了类对象C的count属性。如果没有赋值覆盖,那么引用的是类对象的co...
  • 这篇文章主要介绍了Python 面向对象class和对象基本用法,结合实例形式详细分析了Python面向对象程序设计中class和对象基本概念、原理、使用方法与操作注意事项,需要的朋友可以参考下 本文实例讲述了Python ...
  • Python学习笔记(十一):类和对象

    万次阅读 2021-02-11 00:10:46
    Python学习笔记(十一):类和对象 关于类和对象Python学习笔记(十一):类和对象一.变量实例变量变量实例变量二.函数装饰器带参数的函数装饰器函数装饰器的嵌套三.property()四.封装机制五.继承机制 一....
  • python中的类和对象,属性方法

    万次阅读 多人点赞 2018-04-26 13:18:30
    一、面向对象的概述面向对象是一种描述业务问题、设计业务实体实体之间关系的方法二、类和对象1、类和对象得区别:是对客观世界中事物得抽象,而对象实例化后的实体 例如:汽车模型就是一个,制造出来的...
  • python 类对象的销毁

    千次阅读 2020-04-18 12:04:24
    python和Java一样都是垃圾自动回收,不需要我们显示地销毁对象。执行del obj时会调用对象的__del__方法,这样对象的引用计数会减1,当对象的引用计数为0时,对象就会被销毁,内存就会被回收。 继承object的del方法,...
  • Python 对象的练习题

    万次阅读 多人点赞 2018-10-28 19:13:01
    1、创建员工Employee,属性有姓名name、能力值...2、创建老板Boss,属性有金钱money,员工列表employeeList(存储员工类对象),工作量work,功能有雇佣员工addEmployee(),雇佣后将员工添加至列表中,雇佣一人mon...
  • Python中的对象和对象名

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

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

    千次阅读 2018-05-30 13:39:49
    什么是对象:从同一个中具体化描述的一个事物被称之为对象什么是:具有相同特性方法的抽象概念称之为类类和对象之间的关系:对象的抽象概念,对象的详细实例化python3中如何定义以及中的属性方法...
  • Python中的的定义和对象的创建

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

    千次阅读 2017-12-09 12:20:28
    python对象 一、 python的 可以比作是某种类型集合的描述 把一相同的事物叫做,其拥有相同的属性(其实就是变量)描述,里面封装了相同的方法。比如,汽车是一个,它包括价格、品牌等属性。   二、...
  • Description 设计一个长方形Rect,计算长方形的周长与面积。 成员变量:整型、私有的...要求:编写主函数,对Rect进行测试,输出每个长方形的长、宽、周长面积。 Input 输入多组数据; 一行中若有1个整数,表示正
  • 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...
  • Python类对象的JSON序列化处理

    千次阅读 2018-05-21 14:44:16
    Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。json.dumps() 将Python中的对象转换为JSON中的字符串对象json.loads() 将JSON中的字符串对象转换为Python中的对象通过一种简单的方式,用lambda...
  • python3 类对象的定义、方法

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

    千次阅读 2020-10-12 11:17:03
    所谓文件对象(file-like object),简单说就是类似文件对象对象,至少要具备read()write()两个方法。由于磁盘文件的写入读出速度远远小于内存的读写速度,当我们使用文件作为两个连续的处理过程的数据交换...
  • Python解析JSON对象

    千次阅读 多人点赞 2021-03-23 13:25:32
    本章节我们将为大家介绍如何使用 Python 语言来编码解码 JSON 对象。 json处理模块的主要任务,是将一个JSON对象,转换成Python数据类型数据进行处理,或者反之,将Python数据类型数据,转换成JSON对象(字符...
  • python基础

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,019,303
精华内容 407,721
关键字:

python类和对象

python 订阅