python学生类的使用_Python类的使用总结

Python是一个面向对象的解释型语言，所以当然也有类的概念。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象，自定义的对象数据类型就是面向对象中类(Class)的概念。

之前接触类的概念是在学习C++时，现在学习了Python之后，觉得两者还是有很大的区别的。面向对象的思想是一样的，但是python作为更高级的语言，在类的定义与使用更加简便。

类的定义

Python中，定义类是通过class关键字，例如我们定义一个存储学生信息的类：

classStudent(object):pass

class后面紧接着是类名，即Student，类名通常是大写字母开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就是用object类，这是所有类最终都会继承的类。

定义好了Student类，就可以根据Student类创建出student的实例，创建实例是通过类名+()实现的：

classStudent(object):pass

if __name__ == '__main__':

xiaoming=Student()print(xiaoming)print(Student)

输出结果为：

可以看到，变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。

可以自由的给一个实例变量绑定属性，比如，给实例xiaoming绑定一个name属性：

classStudent(object):pass

if __name__ == '__main__':

xiaoming=Student()

xiaoming.name= "xiaoming"

print(xiaoming.name)

这点与静态语言，比如C++是不一样的。我们可以随时给一个对象添加属性。

在Python中，类的属性就等同于C++类的成员变量，类的方法等同于类的成员函数。

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法，在创建实例的时候，就把name,score等属性绑上去：

classStudent(object):def __init__(self,name,score):

self.name=name

self.score= score

对比C++，__init__函数就等同于C++类的构造函数，注意：特殊方法“init”前后有两个下划线

注意到init方法的第一个参数永远是self,表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

classStudent(object):def __init__(self,name,score):

self.name=name

self.score=scoreif __name__ == '__main__':

xiaoming= Student("xiaoming",59)print(xiaoming.name)print(xiaoming.score)

输出结果为：

xiaoming59

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递参数。除此之外，类的方法和普通函数没有什么区别，所以，你依然可以使用默认参数、可变参数、关键字参数和命名关键字参数。

我们可以给我们定义的Student类增加新的方法，比如get_grade:

classStudent(object):def __init__(self,name,score):

self.name=name

self.score=scoredefget_grade(self):if self.score >= 90:return "A"

elif self.score >= 60:return "B"

else:return "C"

访问限制：

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。

但是，从前面Student类的定义来看，外部代码还是可以自由的修改一个实例的name,score属性：

classStudent(object):def __init__(self,name,score):

self.name=name

self.score=scoredefget_grade(self):if self.score >= 90:return "A"

elif self.score >= 60:return "B"

else:return "C"

if __name__ == '__main__':

xiaoming= Student("xiaoming",59)print(xiaoming.name)print(xiaoming.score)

xiaoming.name= "xiaohei"xiaoming.score= 99

print(xiaoming.name)print(xiaoming.score)

倒数第三行和倒数第四行就修改了属性的值：

如果要让内部属性不被外部访问，可以把属性的名称加上两个下划线__，在Python中，实例变量名如果以__开头，就变成了一个私有变量(private)，只有内部可以访问，外部不能访问，所以我们把Student类改一改：

classStudent(object):def __init__(self,name,score):

self.__name =name

self.__score =scoredefprint_socre(self):print("%s:%s"%(self.__name,self.__score))defget_grade(self):if self.score >= 90:return "A"

elif self.score >= 60:return "B"

else:return "C"

if __name__ == '__main__':

xiaoming= Student("xiaoming",59)print(xiaoming.__name)

输出结果为：

Traceback (most recent call last):

File"D:/Tools/code/Update-SH/ifocus/tse/entity/Student.py", line 25, in

print(xiaoming.__name)

AttributeError:'Student' object has no attribute '__name'

改完之后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量__name和__score了。

但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

classStudent(object):def __init__(self,name,score):

self.__name =name

self.__score =scoredefprint_socre(self):print("%s:%s"%(self.__name,self.__score))defget_name(self):return self.__name

defget_score(self):return self.__score

如果又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：

1 classStudent(object):2 def __init__(self,name,score):3 self.__name =name4 self.__score =score5

6 defprint_socre(self):7 print("%s:%s"%(self.__name,self.__score))8

9 defget_name(self):10 return self.__name

11 defget_score(self):12 return self.__score

13 defset_score(self,score):14 self.__score = score

需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量。

有些时候，你会看到以一个下划线开头的实例变量，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

类的私有成员一定不可以在外部访问吗？其实也不是。

不能直接访问的变量__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：

classStudent(object):def __init__(self,name,score):

self.__name =name

self.__score =scoredefprint_socre(self):print("%s:%s"%(self.__name,self.__score))defget_name(self):return self.__name

defget_score(self):return self.__score

defset_score(self,score):

self.__score =scoreif __name__ == '__main__':

xiaoming= Student("xiaoming",59)print(xiaoming._Student__name)

输出结果为：

xiaoming

但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。

总的来说，Python本身没有任何机制阻止你干坏事，一切全靠自觉。

最后注意下面的这种错误写法：

1 classStudent(object):2 def __init__(self,name,score):3 self.__name =name4 self.__score =score5

6 defprint_socre(self):7 print("%s:%s"%(self.__name,self.__score))8

9 defget_name(self):10 return self.__name

11 defget_score(self):12 return self.__score

13 defset_score(self,score):14 self.__score =score15

16

17

18 if __name__ == '__main__':19 xiaoming = Student("xiaoming",59)20 print(xiaoming.get_name())21 xiaoming.__name = "xiaohei"

22 print(xiaoming.__name)23 print(xiaoming.get_name())

输出结果为：

xiaoming

xiaohei

xiaoming

表面上看，外部代码“成功”地设置了__name变量，但是实际上这个__name变量和class内部的__name变量不是同一个变量，内部的__name变量已经被Python解释器自动的改成了_Student__name,而外部代码给xiaoming新增了一个__name变量。

多继承

在Python中，类也是支持多继承的。只需要在定义类的括号里面把继承的所有类名写入就可以。

例如：

classDog(Mammal,Runaable):pass

上面的例子定义了一个名为Dog的类，同时继承了Mammal和Runaable类。

我们再看一个例子，比如骂我们已经编写了一个名为Animal的类，有一个run()方法可以直接打印：

1 classAnimal(object):2 defrun(self):3 print("Animal is running...")

当我们需要编写Dog和Cat类时：就可以直接从Animal类继承：

classAnimal(object):defrun(self):print("Animal is running...")classDog(Animal):pass

classCat(Animal):pass

我们再编写一个函数，这个函数接受一个Animal类型的变量：

1 classAnimal(object):2 defrun(self):3 print("Animal is running...")4

5 classDog(Animal):6 pass

7

8 classCat(Animal):9 pass

10

11 if __name__ == '__main__':12 defrun_twice(animal):13 animal.run()14 animal.run()15 run_twice(Animal())16 run_twice(Dog())

我们传入Animal的实例时，run_twice()函数就打印出：

Animal isrunning...

Animalis running...

我们传入Dog的实例时，同样会打印出：

Animal isrunning...

Animalis running...

因为Dog类继承了Animal类，是Animal类的子类，在执行run函数时，由于Dog类实例没有定义自己的run函数，执行的是Animal类的run函数。

但是如果我们传入一个跟Animal类没有任何关系的一个类实例时，会出现什么情况呢？

我们定义一个Timer的类，该类也有一个名为run的方法。

1 classAnimal(object):2 defrun(self):3 print("Animal is running...")4

5 classDog(Animal):6 pass

7

8 classCat(Animal):9 pass

10

11 classTimer(object):12 defrun(self):13 print("Start...")14

15 if __name__ == '__main__':16 defrun_twice(animal):17 animal.run()18 animal.run()19 run_twice(Timer())

输出结果为：

Start...

Start...

我们会发现该函数仍可以正常运行。

对于静态(C++)来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者他的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以看做是鸭子。

获取对象类型

当我们拿到一个对象的引用时，如何知道这个对象的什么类型、有哪些方法呢？

使用type

首先，我们来判断对象类型，使用type()函数：

基本类型都可以用type()判断：

print(type(123))print(type("str"))print(type(None))

输出结果：