python学习备忘录--2

1，前言
前面的备忘录提到了python的基本教程，基本上本文例子都是沈洁元的简明教程里面的内容，这两篇都是读书笔记，算不上派生，主要也是自己备忘用的，译者见谅。
基本上本文的解释是自己的理解，没有采用书本中的讲解，觉得自己解释可能更容易记住。

上篇备忘主要是面向过程来讲述的，其实python是凡事都是对象的一种解释语言。包括类型int啊等等都是对象，与C/C++显然不同，在这两个语言中，类型是作为原子来定义的，主要是用来分配内存字节而用，没有所谓方法，当然这点在VC中做了一定改变，比如对字符串的处理显然是比C要方便一些。

python和perl，还是Python容易懂些，效率差了

2，面向对象的python
2.1,类创建一个新类型，而对象这个类的 实例。
2.2，对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。域和方法可以合称为类的属性。
2.3，域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。类使用class关键字创建。类的域和方法被列在一个缩进块中。

3,类

3.1，self参数

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。

self 本身不需要赋值，由python自动完成功能，如果你的实例调用一个方法，例如：假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)
3.2，创建一个类
我们看下面这个例子：
#!/usr/bin/python # Filename: simplestclass.py class Person: pass # An empty block p = Person() print p 如果你去掉pass前面的缩进，会提示错误，期待一个缩进，一定要记住python是由缩进来区别语句块的，习惯C的人要留心。
结果打印的是这个实例的内存地址。

再者要注意的是：python中表示空语句必须写个pass，而不是像C中括号一括完事，因为python是用缩进来区别语句块的。所以你不缩进，解释器就不懂了。
3.3，对象的方法
对象方法与函数类似，只不过多了一个额外的self变量。
我们来看一个方法：
#!/usr/bin/python # Filename: method.py class Person: def sayHi(self): print 'Hello, how are you?' p = Person() p.sayHi() # This short example can also be written as Person().sayHi()
要注意sayHi方法没有任何参数。我个人觉得之所以需要一个self做方法默认参数可能是由于python是门解释型语言，便于解释器解释。刚学这只是种感觉，不对之处请指正。

3.4，一些特殊方法
这里面其实涉及了一些并不陌生的概念
3.4.1 __init__方法
这个方法其实就是构造函数啊，大家懂了吧，而且上篇没有提到,python是变量不需要事前声明的，说实话看到下面这个例子，还是多少有点不适应
#!/usr/bin/python # Filename: class_init.py class Person: def __init__(self, name): self.name = name def sayHi(self): print 'Hello, my name is', self.name p = Person('Swaroop') p.sayHi() # This short example can also be written as Person('Swaroop').sayHi()这里面的属性域没有声明啊，也不说什么类型，在语法严格C++中显的是相当糟糕。

创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。

这个你要是习惯C++/Java之类的强制类型申明语言，看到这个self.name很不适应。还是把self参数当成系统需要的参数就好了。

下面这个例子可以解释一下为什么实例的属性域可以不用声明，对于python而已，创建实例适合，调用的__init__方法
#!/usr/bin/python # Filename: objvar.py class Person: '''Represents a person.''' population = 0 def __init__(self, name): '''Initializes the person's data.''' self.name = name print '(Initializing %s)' % self.name # When this person is created, he/she # adds to the population Person.population += 1 def __del__(self): '''I am dying.''' print '%s says bye.' % self.name Person.population -= 1 if Person.population == 0: print 'I am the last one.' else: print 'There are still %d people left.' % Person.population def sayHi(self): '''Greeting by the person. Really, that's all it does.''' print 'Hi, my name is %s.' % self.name def howMany(self): '''Prints the current population.''' if Person.population == 1: print 'I am the only person here.' else: print 'We have %d persons here.' % Person.population swaroop = Person('Swaroop') swaroop.sayHi() swaroop.howMany() kalam = Person('Abdul Kalam') kalam.sayHi() kalam.howMany() swaroop.sayHi() swaroop.howMany() 观察可以发现__init__方法用一个名字来初始化Person实例。在这个方法中，我们让population增加1，这是因为我们增加了一个人。同样可以发现，self.name的值根据每个对象指定，这表明了它作为对象的变量的本质。

运行上述脚本，提示Exception AttributeError: "'NoneType' object has no attribute 'population'" in <bound method Person.__del__ of <__main__.Person instance at 0xb7746eec>> ignored；

原因是对象销毁时，全局变量的问题。

我另写了一篇备注，记录学习一下错误和心得，这里先列出遇到的问题。记住一点，不要使用__def__方法。

你只能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。
在这个程序中，我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。
就如同__init__方法一样，还有一个特殊的方法__del__，它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。在这个方法里面，我们只是简单地把Person.population减1。

当对象不再被使用时，__del__方法运行，但是很难保证这个方法究竟在 什么时候 运行。

我们正常运行一次：

我们在这个脚本里面添加：
print Person.__doc__
print Person.sayHi.__doc__
我们看下运行结果：
b2c@b2c-server:~$ python demo.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Represents a person.
Greeting by the person.


Really, that's all it does.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

有没有发现什么？可以看到我们的文档字符串或者说是说明文字不是最后显示，而脚本中其实是最后两条语句，这个是因为__del__方法，脚本执行最后，实例被销毁，所以方法执行，出现提示。明白了没。
所以这个__del__是析构函数，类似概念。

这里面多说一句，python其实类中成员默认都是公开的，私有成员是后来语言加入的特性，以双下划线__作为标志。如一个变量__var为私有变量，包括子类在内的外部调用都是无效的。python 是采用从新命名这个私有变量名字而避开外部调用的，非常简单，所以会提示你找不到。

缩进要注意逻辑对齐！

3.5,继承

面向对象的核心概念之一，为了代码重用和逻辑相关性而定义。有过OOP基础的都应该不陌生。
子类型实例可以自然的被当作父类型使用，支持多重继承。
#!/usr/bin/python # Filename: inherit.py class SchoolMember: '''Represents any school member.''' def __init__(self, name, age): self.name = name self.age = age print '(Initialized SchoolMember: %s)' % self.name def tell(self): '''Tell my details.''' print 'Name:"%s" Age:"%s"' % (self.name, self.age), class Teacher(SchoolMember): '''Represents a teacher.''' def __init__(self, name, age, salary): SchoolMember.__init__(self, name, age) self.salary = salary print '(Initialized Teacher: %s)' % self.name def tell(self): SchoolMember.tell(self) print 'Salary: "%d"' % self.salary class Student(SchoolMember): '''Represents a student.''' def __init__(self, name, age, marks): SchoolMember.__init__(self, name, age) self.marks = marks print '(Initialized Student: %s)' % self.name def tell(self): SchoolMember.tell(self) print 'Marks: "%d"' % self.marks t = Teacher('Mrs. Shrividya', 40, 30000) s = Student('Swaroop', 22, 75) print # prints a blank line members = [t, s] for member in members: member.tell() # works for both Teachers and Students这个例子可以看出继承的基本含义。另外说一点，子类构造函数必须人工构造父类的构造函数，不能自动完成，这点与其他OOP语言有点区别。
Python不会自动调用基本类的constructor，你得亲自专门调用它。

4，I/O

4.1，文件

你可以通过创建一个file类的对象来打开一个文件。

这个IO操作还是比较方便，能直接调用file()

#!/usr/bin/python # Filename: using_file.py poem = '''\ Programming is fun When the work is done if you wanna make your work also fun: use Perl! ''' f = file('poem.txt', 'w') # open for 'w'riting f.write(poem) # write text to file f.close() # close the file f = file('poem.txt') # if no mode is specified, 'r'ead mode is assumed by default while True: line = f.readline() if len(line) == 0: # Zero length indicates EOF break print line, # Notice comma to avoid automatic newline added by Python f.close() # close the file 我们通过指明我们希望打开的文件和模式来 创建一个file类的实例。模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）。事实上还有多得多的模式可以使用，你可以使用help(file)来了解它们的详情。
如果没有指定模式，读将作为默认模式。

在一个循环中，我们使用readline方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以，当一个 空的 字符串被返回的时候，即表示文件末已经到达了，于是我们停止循环。

这里面有个小疑问就是while语句的true是根据上下文来判断的么？我改成f也是可以的.

注意，因为从文件读到的内容已经以换行符结尾，所以我们在print语句上使用逗号来消除自动换行。最后，我们用close关闭这个文件。

4.2 存储器

Python提供一个标准的模块，称为pickle。使用它你可以在一个文件中储存任何Python对象，之后你又可以把它完整无缺地取出来。这被称为 持久地 储存对象。
还有另一个模块称为cPickle，它的功能和pickle模块完全相同，只不过它是用C语言编写的，因此要快得多（比pickle快1000倍）。C就是牛逼啊。哈哈
#!/usr/bin/python # Filename: pickling.py import cPickle as p #import pickle as p shoplistfile = 'shoplist.data' # the name of the file where we will store the object shoplist = ['apple', 'mango', 'carrot'] # Write to the file f = file(shoplistfile, 'w') p.dump(shoplist, f) # dump the object to a file f.close() del shoplist # remove the shoplist # Read back from the storage f = file(shoplistfile) storedlist = p.load(f) print storedlist首先，请注意我们使用了import..as语法。这是一种便利方法，以便于我们可以使用更短的模块名称。在这个例子中，它还让我们能够通过简单地改变一行就切换到另一个模块（cPickle或者pickle）！在程序的其余部分的时候，我们简单地把这个模块称为p。

为了在文件里储存一个对象，首先以写模式打开一个file对象，然后调用储存器模块的dump函数，把对象储存到打开的文件中。这个过程称为 储存 。

接下来，我们使用pickle模块的load函数的返回来取回对象。这个过程称为 取储存 。
这个是涉及I/O操作用的

5，异常处理
应该说高级语言里面都有异常处理的内容。
我们程序出现问题的适合，解释器会告诉我们出错了，有些时候对用户显示这些显然是不友好的。所以，有点类似catch...throw，这里面有try...except。
#!/usr/bin/python # Filename: try_except.py import sys try: s = raw_input('Enter something --> ') except EOFError: print '\nWhy did you do an EOF on me?' sys.exit() # exit the program except: print '\nSome error/exception occurred.' # here, we are not exiting the program print 'Done'这个程序运行以后，按“Ctrl+C”或者“Ctrl+D”看看结果。。


5.2，自定义异常
可以自己定义异常来显示。
你可以使用raise语句 引发 异常。你还得指明错误/异常的名称和伴随异常 触发的 异常对象。你可以引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类。
自己定义的异常类要是Exception类的子类。

这里，我们创建了我们自己的异常类型，其实我们可以使用任何预定义的异常/错误。这个新的异常类型是ShortInputException类。它有两个域——length是给定输入的长度，atleast则是程序期望的最小长度。

在except从句中，我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参和实参概念类似。在这个特别的except从句中，我们使用异常对象的length和atleast
#!/usr/bin/python # Filename: raising.py class ShortInputException(Exception): '''A user-defined exception class.''' def __init__(self, length, atleast): Exception.__init__(self) self.length = length self.atleast = atleast try: s = raw_input('Enter something --> ') if len(s) < 3: raise ShortInputException(len(s), 3) # Other work can continue as usual here except EOFError: print '\nWhy did you do an EOF on me?' except ShortInputException, x: print 'ShortInputException: The input was of length %d, \ was expecting at least %d' % (x.length, x.atleast) else: print 'No exception was raised.' 这里，我们创建了我们自己的异常类型，其实我们可以使用任何预定义的异常/错误。这个新的异常类型是ShortInputException类。它有两个域——length是给定输入的长度，atleast则是程序期望的最小长度。

在except从句中，我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参和实参概念类似。在这个特别的except从句中，我们使用异常对象的length和atleast域来为用户打印一个恰当的消息.


5.3，try..finally
单词意思可知，finally是无论异常发生与否都要完成的动作。
#!/usr/bin/python # Filename: finally.py import time try: f = file('poem.txt') while True: # our usual file-reading idiom line = f.readline() if len(line) == 0: break time.sleep(2) print line, finally: f.close() print 'Cleaning up...closed the file'睡了2秒，是故意延长时间，好让你按“Ctrl+C”，按了你也发现，文件还是关闭了最后。

6，python标准库
6.1，sys模块
顾名思义，系统库。
#!/usr/bin/python # Filename: cat.py import sys def readfile(filename): '''Print a file to the standard output.''' f = file(filename) while True: line = f.readline() if len(line) == 0: break print line, # notice comma f.close() # Script starts from here if len(sys.argv) < 2: print 'No action specified.' sys.exit() if sys.argv[1].startswith('--'): option = sys.argv[1][2:] # fetch sys.argv[1] but without the first two characters if option == 'version': print 'Version 1.2' elif option == 'help': print '''\ This program prints files to the standard output. Any number of files can be specified. Options include: --version : Prints the version number --help : Display this help''' else: print 'Unknown option.' sys.exit() else: for filename in sys.argv[1:]: readfile(filename)这里面说明一下：argv自动将脚本文件名认为是argv[0],从0开始计数，与C语言一样，如果出现argv[1][2:]则是第二个参数，用户角度是第一个参数抛弃前两个字符，截取剩余字符的意思。
至于argv[1:]则应该是从用户角度的第一个参数依次到参数列表的最后。
readfile（）函数输出文件内容，首先判断参数数量，少于2个显然是没有输入文件名称，给出提示反馈，如果参数是以--开头的则抛弃前两个字符，截取剩下字符通过流程匹配分别输出提示。最后，把参数列表中的文件一个个输出就是了

这里面有三个模块比较常用先记下：sys.stdin、sys.stdout和sys.stderr它们分别对应你的程序的标准输入、标准输出和标准错误流。

6.2，OS模块
这个模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤为重要的。即它允许一个程序在编写后不需要任何改动，也不会发生任何问题，就可以在Linux和Windows下运行。一个例子就是使用os.sep可以取代操作系统特定的路径分割符。
这个对于我那是相当重要了，毕竟现在用LINUX桌面的人简直是凤毛麟角啊。
os模块里面有很多方法很有用，平时可以查看一下文档。
os.name字符串指示你正在使用的平台. os.getcwd()函数得到当前工作目录。 os.linesep字符串给出当前平台使用的行终止符。 os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。类似地，os.path.existe()函数用来检验给出的路径是否真地存在。基本上python基本东西都在这里么了，当然讲的也是皮毛，在以后真正开发中我会不断添加内容和学习备忘的。