python是面向对象语言,一切皆对象。
面向过程:
变量和函数。 “散落” 在文件的各个位置,甚至是不同文件中。看不出变量与函数的相关性,非常不利于维护,设计模式不清晰。
经常导致程序员,忘记某个变量的相关性,而导致无法检测的错误。
面向对象:
相关的变量和函数都“封装” 在对象里,以对象为单位来管理代码。变量与函数的相关性清晰,利于维护,设计模式清晰。
程序员可以配合“继承” 来提高代码的可重用性,加强合作开发。
类与实例之间的关系:
例如:小明是个人类,小明是真实存在的,而人这个属性是个抽象的类。所以小明是人类里面的具体的实例。
类:是一类事物的抽象,不是真是存在的。描绘了该类事物的共性,例如:“人”、“动物”、“家具”。
实例:某类事物的具体个体,是该类事物的具体表现,它是真实存在的。例如:“小明”是具体的某个“人”, “加菲猫”是具体的某个“动物”。
创建类:
class Person: #使用class关键字定义一个类,这里定义一个Person类。
pass #使用pass占位,保证不会出现语法错误。
创建实例:
>>> class Person: pass >>> p1 = Person() #类似于函数调用,返回一个具体的实例(实例化一个具体的人)
>>> p2 = Person() #在实例化一个人
>>> print(p1 is p2) #比较两个人是不是同一个。明显不是同一个。
False
>>>
isinstance 判别函数
想象一下,当你不确定一个变量是什么类的实例时,如何确定你的猜测呢?
方法:isinstance(obj, class_or_tuple, /) #同时比较多个类,如:isinstance(d1,(Person,Dog))
详细用法: help(isinstance)
>>> class Person: #定义一个Person类
pass
>>> class Dog: #定义一个Dog类
pass
>>> p1 = Person() #实例化一个人类p1
>>> d1 = Dog() #实例化一个狗类d1
>>> print(isinstance(p1,Person)) #使用isinstance判断p1这个实例是不是Person实例化来的
True
>>> print(isinstance(d1,Person)) #使用isinstance判断p1这个实例是不是Person实例化来的,这个d1是Dog实例化的。
False
>>> print(isinstance(d1,(Person,Dog))) #可以同时判断多个,只要属于其中一个就可以。
True
封装变量:
类就是一个独立存放变量的空间与属性查找。
>>> class Person: #本身是一个独立的空间 var2 = '变量2' #赋值语句,将变量封装在这个类空间里(封装变量) pass >>> Person.var1 = '变量1' #这种方式使用的少 >>> print(Person.var1) 变量1 >>> print(Person.var2) #也可以是 变量2 >>>
属性查找规则:
属性就是封装在“实例”里面的变量,表征了实例的特点或特征。
查找变量时,先在实例中查找,然后再到类里面去查找(先实例再类)。
>>> p =Person() #实例也是一个独立的变量空间
>>> print(p.var2) #尽管这个实例 p 里面没有变量 var2,但是这个实例也可以看到对应类里面封装的变量。
变量2
>>>
>>> class Person:
var2 = '变量2'
>>> p = Person()
>>> p.var2 = '变量'
>>> print(p.var2) #它会打印 '变量',而不是 '变量2',因为它查找var2时先在实例p里面的空间查找,找到之后 就不去类里面查找了。
变量
>>>
实例也是一个独立存放变量的空间
每个实例都是一个独立的变量空间。不同实例之间的空间互相不可见。
>>> class Person: #定义一个类,里面没有任何变量。 pass >>> p1 = Person() #实例化对象 p1 >>> p2 = Person() #实例化对象 p2 >>> p1.var1 = '变量1' #实例 p1 里面添加一个变量 var1 >>> p2.var2 = '变量2' #实例 p2 里面添加一个变量 var2 >>> print(p1.var1) #变量 var1 在实例 p1 这个空间里。 变量1 >>> print(p1.var2) #变量 var2 不在实例p1这个空间里。然后它会去Person类里面去找,所以最终报错是 ”提示类的问题“。 Traceback (most recent call last): File "<pyshell#52>", line 1, in <module> print(p1.var2) AttributeError: 'Person' object has no attribute 'var2' >>>
一个“实例”的“特征”(注意:不是类的特征),就是“属性”
小明是人,tom也是人。但是小明是小明,tom是tom。
>>> class Person: pass >>> p1 = Person() #实例化对象p1,每个实例的属性是不同的。如:每个人的姓名和年龄不同。 >>> p2 = Person() >>> p1.name = '小明' #实例p1的特征 name >>> p2.name = 'tom' >>> p1.age = 18 #实例p1的特征 age >>> p2.age = 25 >>>
实例方法:
就是封装在类里的一种特殊的函数。
>>> class Person: #定义一个类 def func(): #在类中封装一个函数 print('Just do a test!') >>> Person.func() #通过变量空间的方式调用函数。使用类调用函数不会报错,不会把类当作参数传到函数中。 Just do a test! >>> p = Person() #声明一个实例 >>> p.func() #通过实例调用函数,结果会报错,因为实例调用封装在类里面的函数时会把实例自己 "p" 当作一个参数传到函数func()里面去,结果就是 "func(p)" Traceback (most recent call last): File "<pyshell#67>", line 1, in <module> p.func() #通过实例调用函数 TypeError: func() takes 0 positional arguments but 1 was given >>>
使用实例调用函数:
通过实例调用函数时,会把实例本身当成一个参数传入到封装在类中的函数。如:p.fun(),最终结果是fun(p).
如果使用类直接调用函数,是不会把类自己当成一个参数传入到函数中。
>>> class Person: def func(a): print(a) #打印出参数,方便鉴定这个参数是啥? >>> p = Person() #实例化对象p >>> p.func(123) #按照正常思维,调用函数func(a)时应该传个参数进去;结果却报错?这是因为使用实例p调用函数func(a)时,
它会把实例 p 当成第一个参数参数,传入到函数func(a)中。
Traceback (most recent call last): File "<pyshell#91>", line 1, in <module> p.func(123) TypeError: func() takes 1 positional argument but 2 were given >>> >>> p.func() #使用实例 p 调用函数func(a)时,它会把自己当成第一个参数,传入到函数func(a)中。 <__main__.Person object at 0x0000029252E5CCF8> >>> print(p) #验证这个参数是不是实例p。 <__main__.Person object at 0x0000029252E5CCF8>
>>> class Person: def func(a): print(id(a)) #打印出参数的 id >>> p = Person() #实例化一个对象 p >>> p.func() #使用实例p 调用函数func(a) 2827479273312 >>> print(id(p)) #单独打印实例p 的id,发现和函数参数里面的id 一样;说明实例p在调用函数func(a)时,把自己当成第一个参数传入到函数。 2827479273312 >>> Person.func() #使用类调用函数func(a)时,类不会把自己当成参数传入到函数中,所以报错缺少参数。通过类调用函数和普通调用函数是一样的。 Traceback (most recent call last): File "<pyshell#85>", line 1, in <module> Person.func() TypeError: func() missing 1 required positional argument: 'a' >>> Person.func(123) #使用类调用函数func(a)时,手动传个参数就不会报错。 1450736928
如何利用实例调用函数时,会自动把自己当成第一个参数传入到函数里?
>>> class Person: def eat(a): print(a.name,'在eating...') #注意这里的a.name,其实就是实例的属性。 >>> p1 =Person() #实例化对象p1 >>> p1.name = '小明' #实例p1的属性 >>> p2 =Person() >>> p2.name = '花花' >>> p1.eat() #使用实例p1调用函数 eat(a),它会自动把p1当成第一个参数传入到函数eat(a)中。最终是eat(p1)。所以a.name就是p1.name 小明 在eating... >>> p2.eat() 花花 在eating... >>>
“实例方法” 的调用过程:
实例.方法(参数)
类.方法(实例,参数)
self:
因为实例调用函数时会把自己当成第一个参数传进函数func(),所以这里第一个参数的变量名就使用约定俗成的 self
>>> class Person:
def func(self,w): #因为实例调用函数时会把自己当成第一个参数传进函数func(),所以这里第一个参数的变量名就使用约定俗成的 self
print(self.name,'在eating:',w)
>>> p1 =Person() #实例化对象
>>> p1.name = '小明' #实例p1的属性
>>> p1.func('apple') #使用实例.方法(参数)调用实例方法。
小明 在eating: apple
>>> Person.func(p1,'apple') #使用类.方法(实例,参数)调用实例方法。
小明 在eating: apple
>>>