1、类的定义：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# _*_ coding:utf-8_*_
class Student(object):# 继承object类，不写也可以，不写就不能调用object类里面的方法，一般写上
def __init__(self, name, score):
self.name = name
self.score = score
def print_msg(self): # 没有返回值
print '姓名：%s ，分数：%s' % (self.name, self.score)
def return_name(self): # 有返回值
return '姓名：%s ，分数：%s' % (self.name, self.score)
if __name__ == "__main__":
s = Student("zhangsan",60) # 实例化一个对象
print Student # <class '__main__.Student'>
print s # <__main__.Student object at 0x0255A9D0>
print s.print_msg() # 姓名：zhangsan ，分数：60，None；注意还会打出一个None，因为这个方法没有返回值
print s.return_name() # 姓名：zhangsan ，分数：60，这个就没有None了
复制代码
1
2
3注意： __init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
2、类的访问限制(加__)：
复制代码
1
2
3
4
5
6
7从前面Student类的定义来看，外部代码还是可以自由地修改一个实例的name、score属性 例如我可以 s.name = "lisi" 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__ 在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。 修改如下：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
class Student(object):# 继承object类，不写也可以，不写就不能调用object类里面的方法，一般写上
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_msg(self):
print '姓名：%s ，分数：%s' % (self.__name, self.__score)
def return_name(self):
return '姓名：%s ，分数：%s' % (self.__name, self.__score)
# 这样在外部调用 s.name = "lisi"就无效了，确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。
复制代码
1
2
3如果外部代码要获取name和score怎么办？可以通过提供get set方法解决 例如：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Student(object):# 继承object类，不写也可以，不写就不能调用object类里面的方法，一般写上
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_msg(self):
print '姓名：%s ，分数：%s' % (self.__name, self.__score)
def return_name(self):
return '姓名：%s ，分数：%s' % (self.__name, self.__score)
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score): # 可以通过条件判断给定的参数是否合法
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
#外面可以直接通过get_name() 和 get_score来访问内部数据。
复制代码
1
2
3
4
5
6
7
8
9
10特别注意： a.在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量。 所以，不能用__name__、__score__这样的变量名。 如果用__score__,在外部是可以通过 s.__score__访问到的。 b.有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的. 但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。 c.双下划线开头的实例变量是不是一定不能从外部访问呢？ 其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访 例如：print s._Student__name # zhangsan
3、继承和多态：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Animal(object): # 父类
def run(self):
print 'Animal running...'
def run_1(animal):
animal.run()
class Dog(Animal): # 子类
def run(self): # 重写方法
print 'Dog running...'
class Cat(Animal): # 子类
def run(self):
print 'Cat running...'
def test_extend():
dog = Dog()
dog.run() # Dog running...
cat = Cat()
cat.run() # Cat running...
# 多态，可以传入不同的对象，会自动调用对应对象的run方法
Animal.run_1(dog)
Animal.run_1(cat)
if __name__ == "__main__":
test_extend()
复制代码
1
2
3
4继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写； 注意调用父类的方法
复制代码
1
2
3
4
class Dog(Animal):
def run(self):
print 'Dog running...'
super(Dog, self).run() # 通过Dog找到父类Animal，再将self传到父类初始化4、获取对象的信息
复制代码
1
2
3a.type() 通过type可以判断一个对象的数据类型
复制代码
1
2
3
4
5
6
import types
def test_type():
print type(123) # <type 'int'>
print type('str') # <type 'str'>
print type(None) # <type 'NoneType'>
print type('abc') == types.StringType # True复制代码
1
2
3b.isinstance() 对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。
复制代码
1
2
3
dog = Dog()
print isinstance(dog,Animal) # True
5、@property使用：
复制代码
1
2
3
4
5
6
7
8a.使用get set的问题？ 在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改 例如： s = Student() s.score = 9999 为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数 例如：
复制代码
1
2
3
4
5
6
7
8
9
10
class Student(object):
def get_score(self):
return self._score
def set_score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
复制代码
1
2
3
4
5
6但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。 b.@property解决方案 Python内置的@property装饰器就是负责把一个方法变成属性调用的。 例如：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
class Studentt(object):
@property #修饰get方法
def score(self):
return self.__score
@score.setter #修饰set方法
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self.__score = value
复制代码
1
2
3注意：还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性。 例如：
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Studentt(object):
@property # 只修饰get方法，没有修饰set方法
def score(self):
return self.__score
if __name__ == "__main__":
s = Studentt()
s.score = 60
print s.score
这样运行会报错，提示没有set属性
Traceback (most recent call last):
File "D:/test_class.py", line 96, in <module>
s.score = 60
AttributeError: can't set attribute
最后
以上就是娇气寒风最近收集整理的关于python面向对象的全部内容，更多相关python面向对象内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复