在python中一切皆为对象。
例： int为一个类，int i 中的 i为 int 类的对象/一个实例
类的属性： 方法和域。 域分两种类型：属于每个对象和属于类本身。分别称为 实例变量和 类变量。
class关键字创建。类的 域和方法被列在一个缩进块中。
self
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身， 按照惯例它的名称是self。
（相当于C++中的this指针）
调用时不需为给self赋值以及为何不需要给它赋值 原理：
自动转为MyClass.method( MyObject, arg1, arg2)——这就是self的原理了。
提醒：定义一个不需要参数的方法，同样还是得给这个方法定义一个self参数。
__int__方法
__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对对象做一些 初始化 。注意，这个名称的开始和结尾都是双下划线。（相当于C++中的构造函数）
两种类型的域
类的变量和对象的变量，它们根据是类还是对象 拥有 这个变量而区分。类的变量 由一个类的所有对象（实例）共享使用。
对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。
__del__方法
同C++中的析构函数作用
所有的类成员（包括数据成员）都是 公共的
只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。
惯例：可以将欲作为私有变量的成员前加单下划线前缀，其他名称作为公共的
#!/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()
Person.__doc__()
Person.howMany().__doc()
输出
$ python objvar.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.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.
Represents a person.
Prints the current population.
分析：population 属于类的域，为各实例共享。 类的域，使用时通过 className.field调用，实例的域在函数定义时，通过self.field调用。
使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串
继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承 机制。
示例：
#!/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
输出
$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)
Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"
基本类 或 超类 。而Teacher和Student类被称为 导出类 或 子类
输入/输出
文件与储存器
文件 （创建一个file类的对象来打开一个文件，分别使用file类的read、readline或write方法来恰当地读写文件。'w'--写，'r'--读，'a'--追加）
#!/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 Python! '
''
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
$ python using_file.py
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
储存器
Python提供一个标准的模块，称为pickle。可以在一个文件中储存任何Python对象，之后又可以把它完整无缺地取出来。这被称为 持久地 储存对象。
还有另一个模块称为cPickle，它的功能和pickle模块完全相同，只不过它是用C语言编写的，因此要快得多（比pickle快1000倍）。
示例（储存与取储存）
#!/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
输出
$ python pickling.py
['apple', 'mango', 'carrot']
分析：import cPickle as p 将模块cPickle命名为 p 优点：1. 方便更换模块，只需修改cPickle 2.方便方法调用 p.dump(),而非 cPickle.dump()
异常
try..except
引发异常
raise语句 引发 异常。需指明错误/异常的名称和伴随异常 触发的 异常对象。可以引发的错误或异常应该分别是一个 Error或Exception类的直接或间接导出类。
#!/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.'
输出
$ python raising.py
Enter something -->
Why did you do an EOF on me?
$ python raising.py
Enter something --> ab
ShortInputException: The input was of length 2, was expecting at least 3
$ python raising.py
Enter something --> abc
No exception was raised.
try..finally
假如你在读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件，该怎么做呢？这可以使用finally块来完成。
示例：
#!/usr/bin/python# Filename: finally.pyimport timetry: 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'
输出：
正常运行
$ python finally.py
Programming is fun
When the work is done
Cleaning up...closed the file
运行中 ctrl+c中断/取消程序
$ python finally.py
Programming is fun
When the work is done
Cclose the file
Traceback (most recent call last):
File "finally.py", line 12, in ?
time.sleep(2)
KeyboardInterrupt
分析：观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭
