The Python Tutorial 9——Classes
Python类概况：多继承、override、多态
9.1. A Word About Names and Objects
9.2. Python Scopes and Namespaces
三种namespace，不同namespace间同名member互不影响A namespace is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that’s normally not noticeable in anyway (except for performance), and it may change in the future. Examples of namespaces are: the set of built-in names (containing functions such asabs(), and built-in exception names);the global names in a module; and the local names ina function invocation.
The important thing to know about namespaces is that there is absolutely no relation between names in different namespaces; for instance, two different modules may both define a functionmaximize without confusion —users of the modules must prefix it with the module name.
生存周期
Namespaces are created at different moments and have different lifetimes. The namespace containing the built-in names is created when the Python interpreter starts up, and is never deleted. The global namespace for a module is created when the module definition is read in; normally, module namespaces also last until the interpreter quits. The statements executed by the top-level invocation of the interpreter, either read from a script file or interactively,are considered part of a module called__main__, so they have their ow nglobal namespace. (The built-in names actually also live in a module; this iscalled__builtin__.)
The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function.9.3. A First Look at Classes
9.3.1. Class Definition Syntax
class ClassName:
<statement-1>
.
.
.
<statement-N>
9.3.2. Class Objects
类对象支持两种操作：引用和实例化
Class objects support two kinds of operations: attribute references andinstantiation.
Attribute references use the standard syntax used for all attribute referencesin Python:obj.name.
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'then
MyClass.i and
MyClass.f are valid attribute references, returning an integer and a function object, respectively.
Class instantiation uses function notation.
x = MyClass()
9.3.3. Instance Objects
There are two kinds of validattribute names, data attributes and methods.Data attributes need not be declared
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
print x.counter
del x.counter
A method is a function that “belongs to” an object.
9.3.4. Method Objects
A method object can be stored away and called at a later time 个人感觉是方法可以别名，方便后面简化调xf = x.f
while True:
print xf()函数调用时类实例作为第一个参数隐式传入
9.3.5. Class and Instance Variables
9.4. Random Remarks
Often, the first argument of a method is called self. This is nothing more than a convention: the name self has absolutely no special meaning to Python.Methods in the same class may call other methods by using method attributes of theself argument:
class Bag:
def __init__(self):
self.data = []
def add(self, x):
self.data.append(x)
def addtwice(self, x):
self.add(x)
self.add(x)
9.5. Inheritance
class DerivedClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>Derived classes may
override methods of their base classes.(For C++ programmers:
all methods in Python are effectively virtual.)
9.5.1. Multiple Inheritance
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
9.6. Private Variables and Class-local References
没太看懂o(╯□╰)o
9.7. Odds and Ends
class Employee:
pass
john = Employee() # Create an empty employee record
# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000
9.8. Exceptions Are Classes Too
A class in an except clause is compatible with an exception if it is the same class or a base class thereof. Forexample, the following code will print B, C, D in that order:class B:
pass
class C(B):
pass
class D(C):
pass
for c in [B, C, D]:
try:
raise c()
except D:
print "D"
except C:
print "C"
except B:
print "B"
Note that if the except clauses were reversed (with except B first), it would have printed B, B, B — the first matching except clause is triggered.
9.9. Iterators
By now you have probably noticed that most container objects can be looped over using a for statement:
for element in [1, 2, 3]:
print element
for element in (1, 2, 3):
print element
for key in {'one':1, 'two':2}:
print key
for char in "123":
print char
for line in open("myfile.txt"):
print line,
另一种方式 the
for statement calls
iter()
>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> it.next()
'a'
>>> it.next()
'b'
>>> it.next()
'c'
>>> it.next()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
it.next()
StopIteration
9.10. Generators
Generators are a simple and powerful tool for creating iterators. Theyare written like regular functions but use the yield statement whenever they want to return data. Each time next() is called on it, the generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print char
...
f
l
o
g