Python笔记（四）

夜勿眠

　　在《Python笔记（三）》中，我记录关于Python中序列问题的知识。个人觉得确实比Java中的集合框架简单。之前也说了，Python是一种高级面向对象的语言，它的每一个变量都称为对象。今天我接触了面向对象的编程。下面是这篇博客的目录：
　　1.类与对象
　　2.输入输出
　　3.异常
　　
　　　　类与对象：
　　　　 我们都知道面向对象的语言具备四个特性：抽象，继承，封装，多态。Java，C++是这样，Python也不例外。在Python中，我们定义一个类，使用关键字class。形式如下：class classname:。首先先看下面这段代码，然后我们对照代码进行学习。



1 class Person:
2     def sayhello(self):
3         print("Hello,how are you~!")        
4 p = Person()
5 p.sayhello()
　　
　　在上面的代码中，我们定义了一个类Person。在类中，我们定义了一个函数sayhello()，该函数接受一个参数：self。请注意，这个参数不需要你在调用的时候对他赋值，我们的Python会对它进行赋值，并且它需要位于参数的第一个。这个特别的变量作用和C中的self，Java，C#中的this指针一样，指向对象本身。只要你在类中定义函数，那么所有的函数第一个参数都应该是self。回到代码，在函数中，我们打印出一句话。接下来，我们创建一个对象p，然后对象p调用函数sayhello()。请注意，调用函数并没有传值。这就是一个简单的例子。下面是运行结果：
　　下面我们来说说Python中的__init__函数。看到这个函数的名字，我们心里其实就应该有猜测了，这个函数就是进行初始化工作的函数。进行初始化工作的函数都具有这样的特性：在类的一个对象被建立的时候，该函数会马上被执行。回想一下Java中的构造函数，当然在Java中static块也能有同样的作用，但是他们执行的顺序是不一样的，关于Java中static，请参看的我另一篇博客《Java静态代码块的用法 static用法详解》，在这里不多做解释。下面我们来学习一下这个__init__函数。



1 class Person:
2     def __init__(self,name,age):
3         self.name = name
4         self.age = age
5     
6     def printInfo(self):
7         print("this is your info: name = ",self.name,",age = ",self.age)
8         
9 p = Person('zhouxy',22)
10 p.printInfo()
　　在上面的代码中，我们使用了__init__函数，它虽然有3个参数，但是在函数内部却只是对name和age进行了赋值。这段代码和下面这段Java代码作用一样：



1 public class Person{
2     String name;
3     int age;
4     public Person(){}  
5     public Person(String name,int age){
6         this.name = name;
7         this.age = age;
8     }
9 }
　　然后我们还定义了一个函数printInfo()，对信息进行打印。之后我们创建了一个对象，初始化并打印信息。下面是结果：
　　我们知道，一个对象是具备属性的。有的属性是对象所私有的，每创建一个对象，他们就会有属于自己的属性。然而有的属性是共有的，这就是类的属性。我们知道在Java中类的属性是由static关键字修饰。而在Python中在类中不是这样。请看下来代码：



1 class Person:
2     '''Represents a person.'''    #文档字符串
3     total = 0    #类的变量
4     
5     def __init__(self,name):    #__init__方法
6         self.name = name
7         print('name = ',self.name)
8         Person.total += 1
9         print('Person.total = ',Person.total)
10     
11     def __del__(self):        #__del__方法,作用和__init__相反,在对象被销毁的时候调用
12         print('%s says bye.'%self.name)
13         Person.total -= 1
14         print('Person.total = ',Person.total)
15     
16     def sayHello(self):
17         print('Hello,everybody,I am ',self.name)
18     
19 p1 = Person('zhouzhou')
20 p1.sayHello()
21 p2 = Person('zhouxy')
22 p2.sayHello()
23 del p1    #手动销毁
　　在上面的代码，我们的total属性就是类的属性。在第19行代码中，我们创建了p1，并调用sayHello()函数，接着又创建了一个p2，也调用了该函数。最后使用del手动将p1销毁。下面是结果：

　　从结果我们可以看出，total的值与p1,p2都有关系。当我们的对象不再被使用的时候，__del__方法会运行，但是很难保证这个方法究竟在什么时候运行，如果你想指明它的运行，请使用del。在上面的结果中是p1先执行__del__函数，但是或许你再执行一次，p2就会先被销毁从而先执行__del__函数。因为p2的销毁时间不能确定。最后再来说说继承，在Java中，我们继承是使用关键字extends关键。而在Python中，我们在子类名后面跟上父类的元组。就像这样：class Student(Person):这样申明之后，就表明Student类继承与Person类。看下面这个例子程序：



1 class SchoolMember:
2     '''Represents any School member.'''
3     def __init__(self,name,age):
4         self.name = name
5         self.age = age
6         print('''initialized SchoolMember :%s'''%self.name)
7         
8     def tell(self):
9         '''Tell my details.'''
10         print("name = ",self.name,",age = ",self.age,',',end = '')
11         
12 class Student(SchoolMember):
13     '''Represents student.'''
14     def __init__(self,name,age,id):
15         SchoolMember.__init__(self,name,age)    #调用父类的__init__函数,类似于Java中的super()
16         self.id = id
17     
18     def tell(self):
19         SchoolMember.tell(self)    #调用父类的tell()函数
20         print('id = ',self.id)
21         
22 class Teacher(SchoolMember):
23     '''Represents Teacher.'''
24     def __init__(self,name,age,salary):
25         SchoolMember.__init__(self,name,age)
26         self.salary = salary
27     
28     def tell(self):
29         SchoolMember.tell(self)
30         print('salary = ',self.salary)
31
32 t = Teacher('zhouxy',40,6000)
33 s = Student('hujn',22,5)
34
35 members = [t,s]        
36 for member in members:    #遍历列表
37     member.tell()
　　上面我们新定义了两个类Student和Teacher。它们都继承与Person类。具有共同的属性name和age。所以Student类初始化时可以使用父类的__init__函数对共同属性进行赋值，之后再对Student类所特有的属性赋值。Teacher类也类似。下面是结果：
　　Python类与对象就简单了解到这里吧。
　　输入输出：
　　　　　下面来看看Python中的输入输出。在Python中，我们可以通多创建一个file类的对象类 打开一个文件，并进行读取。不用的指定参数对文件的读写能力不一样。下面是通过help()命令来查看Python中的不同参数。
　　
　　　　我们可以看到，'r'表示read，也是默认的；'w'表示write，当然还有其他模式。下面这段代码是创建一个.txt文件，写进内容，然后把写进去的内容读取到控制台。



1 #filename:using_file.py
2
3 content = '''good good study ,day day up .
4 good good study ,day day up .
5 good good study ,day day up .'''
6
7 f = open('content.txt','w')        #创建content.txt,'w'表示我们即将写进内容
8 f.write(content)    #将content字符串写进文件
9 f.close()            #关闭流
10
11 f = open('content.txt')        #打开content.txt文件，并读取内容
12 while True:
13     line = f.readline()
14     if not line:
15         break
16     print (line)
17     
18 f.close()        #关闭流
　　
　　在上面代码中，我们创建的是open对象，因为在Python3.x中，file类被open类取代了。运行结果之后，我们会发现在与我们程序的相同目录中出现了一个content.txt文件，打开之后就会看见我们所写的内容。同时我们的控制台也读取出来了其中的内容。
　　Python中提供一个标准的模块，叫做pickle。使用它我们可以将任何一个Python对象写进文件，之后也可以将其完整无缺的读出来。这被称为持久地存储对象。请看下面的代码：



1 import pickle
2 shoplistfile = 'shoplist.data'
3 # the name of the file where we will store the object
4
5 shoplist = ['apple', 'mango', 'carrot']
6
7 # Write to the file
8 f = open(shoplistfile, 'wb')
9 pickle.dump(shoplist, f) # dump the object to a file
10 f.close()
11
12 del shoplist # remove the shoplist
13
14 # Read back from the storage
15 f = open(shoplistfile,'rb')
16 storedlist = pickle.load(f)
17 print (storedlist)
　　我们将一个列表永久的存进了后缀名为.data的文件中，之后又读取出来了。这和上面写文件的代码差不多，我们使用了pickle模块中的dump()和load()函数。程序运行之后，同样会在同级目录中出现一个名为shoplist.data的文件。下面是结果：
　　异常
　　　　处理异常就是当你的程序出现某些异常的状况的时候采取的一些措施。在Python中，处理异常使用try...except语句，我们将可能出现异常的语句放在try中，将错误处理语句放在except中。当异常发生的时候，程序就会跳到except语句中执行，你还可以让try...except语句块关联一个else块，当没有异常发生的时候，else块中的语句将被执行。在某些时候，我们还可以使用raise引发一个异常。当然，有些时候不管异常是否发生，我们都希望执行一些语句，比如在读取文件的时候，不管我们读取是否成功，我们都希望在最后能执行close()方法，将流关闭。这个时候我们就可以使用finally块。
　　　　今天就学习了这么多，由于之前对Java掌握的比较熟练，所以在学习Python时，相对比较轻松。如果你在阅读我的博客时有什么疑惑或者觉得我们有些地方写的不够详细，欢迎指出。我会和你一个探讨。