Python类的使用总结

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

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

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

 

类的定义

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

class Student(object):
    pass

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

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

class Student(object):
    pass


if __name__ == '__main__':
    xiaoming = Student()
    print(xiaoming)
    print(Student)

 

输出结果为：

<__main__.Student object at 0x01DB4AB0>
<class '__main__.Student'>

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

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

class Student(object):
    pass


if __name__ == '__main__':
    xiaoming = Student()
    xiaoming.name = "xiaoming"
    print(xiaoming.name)

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

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

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

class Student(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解释器自己会把实例变量传进去：

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score



if __name__ == '__main__':
    xiaoming = Student("xiaoming",59)
    print(xiaoming.name)
    print(xiaoming.score)

输出结果为：

xiaoming
59

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

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

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score

    def get_grade(self):
        if self.score >= 90:
            return "A"
        elif self.score >= 60:
            return "B"
        else:
            return "C"

访问限制：

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

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

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score

    def get_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类改一改：

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score

    def print_socre(self):
        print("%s:%s"%(self.__name,self.__score))

    def get_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 <module>
    print(xiaoming.__name)
AttributeError: 'Student' object has no attribute '__name'

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

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

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score

    def print_socre(self):
        print("%s:%s"%(self.__name,self.__score))

    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score

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

 1 class Student(object):
 2     def __init__(self,name,score):
 3         self.__name = name
 4         self.__score = score
 5 
 6     def print_socre(self):
 7         print("%s:%s"%(self.__name,self.__score))
 8 
 9     def get_name(self):
10         return self.__name
11     def get_score(self):
12         return self.__score
13     def set_score(self,score):
14         self.__score = score

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

 

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

 

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

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

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score

    def print_socre(self):
        print("%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):
        self.__score = score



if __name__ == '__main__':
    xiaoming = Student("xiaoming",59)
    print(xiaoming._Student__name)

输出结果为：

xiaoming

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

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

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

 1 class Student(object):
 2     def __init__(self,name,score):
 3         self.__name = name
 4         self.__score = score
 5 
 6     def print_socre(self):
 7         print("%s:%s"%(self.__name,self.__score))
 8 
 9     def get_name(self):
10         return self.__name
11     def get_score(self):
12         return self.__score
13     def set_score(self,score):
14         self.__score = score
15 
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中，类也是支持多继承的。只需要在定义类的括号里面把继承的所有类名写入就可以。

例如：

class Dog(Mammal,Runaable):
    pass

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

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

1 class Animal(object):
2     def run(self):
3         print("Animal is running...")

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

class Animal(object):
    def run(self):
        print("Animal is running...")

class Dog(Animal):
    pass

class Cat(Animal):
    pass

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

 1 class Animal(object):
 2     def run(self):
 3         print("Animal is running...")
 4 
 5 class Dog(Animal):
 6     pass
 7 
 8 class Cat(Animal):
 9     pass
10 
11 if __name__ == '__main__':
12     def run_twice(animal):
13         animal.run()
14         animal.run()
15     run_twice(Animal())
16     run_twice(Dog())

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

Animal is running...
Animal is running...

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

Animal is running...
Animal is running...

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

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

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

 1 class Animal(object):
 2     def run(self):
 3         print("Animal is running...")
 4 
 5 class Dog(Animal):
 6     pass
 7 
 8 class Cat(Animal):
 9     pass
10 
11 class Timer(object):
12     def run(self):
13         print("Start...")
14 
15 if __name__ == '__main__':
16     def run_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))

输出结果：

<class 'int'>
<class 'str'>
<class 'NoneType'>

 

转载于:https://www.cnblogs.com/LoganChen/p/11404729.html