其他分享
首页 > 其他分享> > 类与对象

类与对象

作者:互联网

一、类和对象理论

1.面向过程:

核心是"过程"二字

过程的终极奥义就是将程序流程化
过程是"流水线",用来分步骤解决问题的

2.面向对象:

核心是"对象(容器)"二字

对象的终极奥义就是将程序"整合"
对象是"容器",用来盛放数据与功能的;
			反过来说,什么是对象?能存放数据和功能的地方就是一个对象;
      什么又是面向对象思想?将具有相关联的数据和功能存放到一个容器中,就是面向对象思想
类也是"容器",该容器用来存放同类对象共有的数据与功能; 因此也会有人说类也是一个对象

1.什么是类

类是面向对象编程中存放一类对象共有属性和行为的容器;类也属于一个对象,因为他存放着属性和数据

2.什么是对象

能存放数据和功能的地方就是一个对象;比如一个py文件,又或者说是一个列表[ 属性变量,函数]

3.类和对象有什么区别

  1. 类是一类对象的模板,对象需要通过类创建,而类通过元类创建
  2. 类不占用存储空间,而创建出的对象会占用内存空间
  3. 类是存放一类对象共有属性和行为的容器,对象也是,算是相同点

二、类和对象的__dict__

类和对象都有__dict__属性,用于存储类和对象的所有属性。但是二者的__dict__是不一样的。
对象支持直接对__dict__进行属性增删改查,而类只支持属性访问
image.png
为了让类的__dict__没法被手动改,python把类的__dict__设定为 mappingproxy(python3)

1. 类和对象在__dict__中的属性存放

如下图所示
image.png
发现问题:根据上面的说法:类和对象的字典中分别存着各自的属性和方法,但实例字典中的实例方法show却在类的属性字典中?为什么

给出原因:这是因为创建对象的时候,会变化的都是实例属性,但是实例方法不会,为了某种优化,因此将原本放在实例字典中的实例方法,也放到了类的字典中;而实例的字典只存放着实例属性;

这一点不用刻意去记,用到的时候通过__dict__重新输出一遍,看看内容就想起来了

2.类和对象的属性访问顺序

python会先去对象字典中找,如果找不到再去类的字典中找,若有父类,则会进去父类中找; 还找不到就报错,报错方式会和字典的一样,提示不存在的key


三、类、对象的绑定方法与非绑定方法(深入解析)

明确一点:绑定方法与非绑定方法讲的内容研究的是:为什么实例对象调用实例方法,会自动传实例对象到形参self,类调用类方法会自动传类到形参cls;这里面的内容可以不看,但看了也好;下面的内容纯复制该博客: https://www.cnblogs.com/vipchenwei/p/7126772.html, 作为一个备份,详情可以进入博客看,博客中的颜色比较好看

(1)类中的方法严格意义上做区分可以分为两类:绑定方法与非绑定方法;这两种方法就概括了(类方法,实例方法,静态方法)
(2)绑定方法指的就是(类方法、实例方法),因为类方法和实例方法的方法内部都会调用到相关的属性或方法
(3)非绑定方法指的就是(静态方法),因为代码内部没有调用类或对象的属性或方法,单纯作为一个普通的函数一样

1.对象的绑定方法

首先我们明确一个知识点,凡是类中的方法,默认情况下都是绑定给对象使用的。下面,我们通过实例,来慢慢解析绑定方法的应用。

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        pass
    
p = People('xiaohua',18)
print(p.talk)

输出结果:根据结果显示“bound method”,可知道该方法属于绑定方法,而且绑定了People object这个对象
<bound method People.talk of <__main__.People object at 0x000000F802C69358>>

从上面的输出结果来看,talk()這个类中的方法,是绑定给对象使用的。下面,我在看看另外一种情况。

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
print(p.talk)

输出结果:
<bound method People.talk of <__main__.People object at 0x000000FF68F39358>>

现在,我们将talk()函数的self参数去掉,结果显示与上面是一样。这说明,不管是类中的方法,还是类中函数,默认情况下都是绑定给对象使用的。绑定给对象使用有一种好处,那就是不用手动将对象传入。对象是自动传到类中。如果你不信,我们来看看下面的例子:

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
print(People.talk)
print(p.talk)

输出结果:
<function People.talk at 0x000000C54E3D0A60>  类来调用仅仅是当作函数使用
<bound method People.talk of <__main__.People object at 0x000000C54E249358>>  而对象来调用则为绑定方法

上面很好说明了,如果类来调用类中的方法,那么这个方法仅仅只是一个函数,那么既然是函数,就不会有自动传值这一功能。来看看下面代码:

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        pass

p = People('xiaohua',18)
People.talk() 1
p.talk() 2

#代码1处报错
talk() missing 1 required positional argument: 'self'
#代码2处正常

从上面输出结果来看,当类调用类中的方法时候i,是不会进行自动传值的,也就是说,函数有几个参数,我们就得传递进去几个参数。如果想结果正常运行,那么在类名调用talk()的时候,将参数一一都传递进去。即:

People.talk(312312)

這个参数可以是任意的,但是,必须传递进去。而,当对象调用类中方法时候,则不用传递,如上面的2正常执行。既然知道了区别,那么,我们来看看下面代码:

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
People.talk() 1
p.talk() 2

# 1处正常执行
# 2 处报错
talk() takes 0 positional arguments but 1 was given

从输出结果来看,People来调用talk()方法时候,并不需要传递参数;而当对象来调用talk()的时候,由于对象调用自己的绑定方法,会自动将对象当作第一个参数传递进去,所以,当类中talk()方法没有带参数时,而你又给它传递了一个,显然是会报错的。
**综上所述,我们可以得出以下结论: **
1.凡是类中的方法和函数,都是绑定给对象使用的;
2.绑定方法都有自动传值的功能。传递进去的值,就是对象本身。
3.如果类想调用绑定方法,就必须遵循函数的参数规则,有几个参数,就必须传递几个参数。
聪明的你,可能会问,既然类中的方法都是绑定给对象使用的,那么有没有方法是绑定给类使用的呢?

答案是,当然有!

2.类的绑定方法

既然类中的方法,默认都是绑定给对象使用,那么,我们要采取一点措施,将类中的绑定方法解除对象绑定关系,进而绑定到类上。
在python中,引入了@classmethod方法,将类中的方法绑定到类身上。下面看看代码:

class People:
    @classmethod
    def talk(cls):
        pass

p = People()
print(People.talk)

#输出结果
<bound method People.talk of <class '__main__.People'>>

从上述结果可以看出,我们加上了一个装饰器,将类中绑定给对象的方法,绑定到类身上了。我们之前分析过,如果一个方法绑定到谁身上,那么在调用该函数的时候,将自动将该调用者当作第一个参数传递到函数中。但是,绑定到类的方法与绑定到对象方法有一点点不同:

class People:
    def __init__(self,name):
        self.name = name

    @classmethod
    def talk(cls):
        pass

p = People('xiaohua')
print(People.talk)
print(p.talk)

#输出结果
<bound method People.talk of <class '__main__.People'>>
<bound method People.talk of <class '__main__.People'>>

也就是说,当对象在调用类的绑定方法时,也会默认把类当作参数传递进去!所以下面执行正常,并不会因为這个方法绑定到类身上,而对象调用没有传递参数,报错!

class People:
    @classmethod
    def talk(cls):
        pass

p = People()
People.talk()
p.talk()

但是,如果talk()没有参数,则下面代码均会报错。

class People:
    @classmethod
    def talk():
        pass

p = People()
People.talk()
p.talk()
#报错结果
talk() takes 0 positional arguments but 1 was given

两者报错结果一致,这就说明了,当对象来调用类的绑定方法时,也是自动将类传递进去,并不需遵循函数参数传递的规则。
对于类中的绑定方法,也基本上就这两种,不管怎么变化,只要记住以下规则,遇到这种情况,都不会再错。
类中方法默认都是绑定给对象使用,当对象调用绑定方法时,会自动将对象作为第一个参数传递进去;而类来调用,则必须遵循函数参数一一对应的规则,有几个参数,就必须传递几个参数。如果一个方法是用了@classmethod装饰器,那么這个方法绑定到类身上,不管是对象来调用还是类调用,都会将类作为第一个参数传递进去。
类的绑定方法运用实例:单例模式

3.非绑定方法

上面说了,类中的方法要么是绑定给对象使用,要么是绑定给类使用,那么有没有不绑定给两者使用的函数?
答案:当然有,python给我们提供了@staticmethod,可以解除绑定关系,将一个类中的方法,变为一个普通函数。
下面,我们来看看代码示例:

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.clock()).encode('utf-8'))
        return m.hexdigest()


print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数

从上面的输出结果,我们可以看出,使用了@staticmethod装饰了一个函数,那么这个函数跟普通函数没有什么区别。既然是普通函数,那么就遵从函数参数传递规则,有几个参数就传递几个参数。

四、对象的创建与初始化

以下为较深入的一些博客解析,现阶段可以不用看,只要知道init不是用来创建对象的,而是对new方法创建出来的对象做赋值操作的即可

python中一切皆为对象,python类本身也是一种对象,我们可以称其为类对象。对象=属性+方法,对象是类的实例,准确地来说,应该是:实例对象是类对象的实例
《python编程:从入门到实践》中是这么说的:面向对象编程是最有效的软件编写方法之一。在面向对象编程中,你编写表示现实世界的实物和情景的类,定义一大类对象都有的通用行为。基于类创建对象时,每个对象都自动兼备这种通用行为,然后可根据需要赋予每个对象独特的个性。根据类创建对象被称为实例化,这让你能够使用类的实例。end
类主要是定义对象的结构,然后我们以类为模板创建对象。类不但包含方法定义,还包含所有实例共享的数据。
接下来,进入正题。
大家应该对__init__()方法都很熟悉,它的第一个参数一定是self,init()方法负责对象的初始化,系统执行该方法前,其实该实例对象已经存在,要不然初始化什么呢,
先看一小段代码:

class Dog():
    def __new__(cls, *args, **kwargs):
        print("run the new of dog")
        #return super(Dog,cls).__new__(cls)
        return object.__new__(cls)  #两条return语句作用相同

    def __init__(self):
        print("run the init of dog")
        print(self)
        print(self.__class__)

a = Dog()
# run the new of dog
# run the init of dog
# <__main__.Dog object at 0x00000197AAA3A8D0>
# <class '__main__.Dog'>

可以看出,

  1. 当我实例化Dog类对象时,python中首先调用的是类对象的__new__()方法,如果该对象没有定义__new__()方法,则去父类中依次查找,直到object类(object类是所有类的基类哦)。

  2. new()的返回语句中,object.new(cls)意思是调用父类(object)的__new__(),super()是一个特殊函数,帮助python将父类和子类关联起来,父类也成超类,名称super因此得名。

  3. new()需要传递一个参数cls,init()需要传递一个参数self,self代表的就是实例对象本身,cls代表的是类对象本身。python中的self相当于C++的this指针。
    new()必须要有返回值,返回实例化出来的实例对象。

  4. 看一下阿里云天池python训练营对这两个魔法方法的教学:
    image.png

通常来说,类开始实例化时,new()方法会返回cls(cls指代当前类)的实例_,然后该类的__init_()方法会接收这个示例(即self)作为自己的第一个参数,然后依次转入__new__()方法中接收的位置参数和命名参数。
notice:如果__new__()没有返回cls(即当前类的实例),那么当前类的__init__()方法是不会被调用的,如果__new__()返回了其他类的实例,那么只会调用被返回的那个类的构造方法。
上代码:



class A(object):
    def __init__(self, *args, **kwargs):
        print("run the init of A")
    def __new__(cls, *args, **kwargs):
        print("run thr new of A")
        return object.__new__(B, *args, **kwargs)

class B(object):
    def __init__(self):
        print("run the init of B")
    def __new__(cls, *args, **kwargs):
        print("run the new of B")
        return object.__new__(cls)

a = A()
print(type(a))
# run thr new of A
# <class '__main__.B'>
b = B()
print(type(b))
# run the new of B
# run the init of B
# <class '__main__.B'>

五、@staticmethod,@classmethod,@property使用场景

  1. 如果代码内部有调用到类的属性或方法,使用classmethod
  2. 如果代码内部有调用到实例的属性或方法,保持默认即可,因为默认就是实例方法
  3. 如果代码内部既没有用到类的属性或方法,也没有用到对象的属性或方法,单纯就是一个普通函数一样,使用@staticmethod

image.png

  1. 如果你想让类中的某个实例方法的调用方式和调用实例属性一样,则使用@property

如下所示
image.png

六、生活中的类与对象

image.png

标签:__,对象,self,绑定,方法,talk
来源: https://www.cnblogs.com/zhongzhouyun/p/14967505.html