python面向对象2

七月 15, 2021 2785

1.1 面向对象的一些内置函数

hasattr函数用于判断对象是否包含对应的属性。返回True或False。

1
hasattr(判断的对象, 判断的属性)

getattr函数用于返回指定属性的返回值。

1
2
3
4
5
6
7
>>> class A:
	    def __init__(self, score=100):
	        self.score = score

>>> a = A()
>>> getattr(a, 'score')
100

当getattr函数找不到属性名的时候，可自定义报错。

1
getattr(判断的对象, 指定的属性, 自定义报错)

setattr函数设定指定属性的值，如果属性不存在则创建这个新属性。

1
setattr(判断的对象,指定的属性,指定的值)

delattr函数用于删除属性。

1
delattr(判断的对象,指定的属性)

值得注意的是，在函数内部书写属性的时候要加单或双引号。

property函数，将已有的特定作用（特定作用指得到属性，设置属性，删除属性和属性描述信息）的方法（函数）进行封装。通过只改property指定的性质就可以修改内部属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> class B:
	def __init__(self, score=100):
		self.score = 100
	def getScore(self):
		return self.score
	def setScore(self, value):
		self.score = value
	def delScore(self):
		del self.score
	x = property(getScore, setScore, delScore)

	
>>> b = B()
>>> b.x
100
>>> b.x = 50
>>> b.x
50
>>> del b.x
>>> b.score
Traceback (most recent call last):
  File "<pyshell#85>", line 1, in <module>
    b.score
AttributeError: 'B' object has no attribute 'score'

1.2属性访问

对于一般的类，可直接设置性质。这样可以对这个性质直接进行访问修改等。例中创建了score属性，可进行访问，也可进行修改。

1
2
3
4
5
6
7
8
9
>>> class A:
	score = 90
	
>>> a = A()
>>> a.score
90
>>> a.score = 100
>>> a.score
100

同时，python提供了加密方法使属性不可访问。即在属性前加双下划线。

1
2
3
4
5
6
7
8
9
>>> class B:
	__score = 90	
	
>>> b = B()
>>> b.__score
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    b.__score
AttributeError: 'B' object has no attribute '__score'

当不可访问的时候，要相对属性进行访问、修改和删除就要使用方法。但注意调用时调用的是方法名称，而不是属性名称。

1
2
3
4
5
6
7
8
>>> class C:
	__score = 90
	def getName(self):
		return self.__score

>>> c = C()
>>> c.getName()
90

1.3 属性访问的几种魔法方法

__getattribute__函数：当一个属性被调用的时候会触发的函数。参数为self，name（调用的属性名字）。
__getattr__函数：当一个不存在的属性被调用触发的函数。参数为self，name。
（也就意味着当调用一个不存在的属性时，先会调用getattribute函数，然后也要调用getattr函数）
__setattr__函数：当一个属性被设置时，会调用setattr函数。参数为self，name，value。
__delattr__函数：当一个属性被删除时，会调用delattr函数。参数为self，name。
用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> class C:
	def __getattribute__(self, name):
		print('现在正在调用属性')
		return super().__getattribute__(name)
	def __getattr__(self, name):
		print('现在正在调用一个不存在的属性')
	def __setattr__(self, name, value):
		print('现在正在修改一个属性')
		super().__setattr__(name, value)
	def __delattr__(self, name):
		print('现在正在删除一个属性')
		super().__delattr__(name)

>>> c = C()
>>>> c.x
现在正在调用属性
现在正在调用一个不存在的属性
>>> c.x = 1
现在正在修改一个属性
>>> c.x
现在正在调用属性
1
>>> del c.x
现在正在删除一个属性

值得注意的是，函数后的return super().__xxx__是为了让我们设定的函数不要影响原来函数的意思，比如__getattribute__后面的return是为了不只让这个函数被我们定义为一个打印函数，而是让他兼有“调用属性就会调用该函数”的性质和打印的功能。

查看评论