python class 成员变量 赋值 python怎么用class

3.1

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类定义，像函数定义一样，在执行时才会起作用。你可以把类定义放在任何地方比如if语句的分支，或者在函数内部。 在实际应用时，定义在类中的语句通常都是函数定义，但是其它语句也是允许出现的，并且有的时候非常有用。 当进入一个类定义时，一个新的名称空间被创建，并且被当作局部域来使用。

3.2

类对象提供两种操作，属性引用和实例化。 属性引用使用标准句法：obj.name. 有效的属性名是类对象创建时类的名称空间内的所有名字。 例如下面的类定义中,MyClass.i和MyClass.f都是有效的属性名。

>>> class MyClass:
...     """A simple example class"""
...     i = 123
...     def f(self):
...         return 'hello world'
... 
>>> MyClass.i
123
>>> MyClass.i = 10

类的实例化使用函数记号，例如：

>>> x = MyClass()
>>> x.i
10

这个实例化操作创建了一个空对象，许多类在实例化时定义了一些初始化操作。例如：

>>> class MyClass():
...     def __init__(self):
...          self.data = []

当一个类定义了__ init __ 方法后，类实例化时会自动调用 __ init __ ().

__ init __ 函数还可以有其它参数,例如:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

3.3

现在我们可以用实例化的对象做些什么呢？它唯一可以进行的操作是属性引用。有两类有效的属性名，数据属性和方法。 数据属性(data attributes)对应c++中的数据成员，数据属性无需声明，第一次给它赋值时就表明了它的存在。 另一种实例化的属性引用叫做方法(Method).方法是对象内的一个函数。

3.4

通常我们调用一个方法的方式是：

x.f()

但是，由于x.f是一个方法对象，所以它可以存储起来，以便以后调用

>>> class MyClass:
...     """A simple example class"""
...     i = 12345
...     def f(self):
...         return 'hello world'
... 
>>> x = MyClass()
>>> x.f()
'hello world'
>>> xf = x.f
>>> xf()
'hello world'

你可能已经发现，f名名有一个参数，但是调用时为什么没有使用呢。其实，原因在于 x.f() 与 MyClass.f(x) 是等价的。

>>> MyClass.f(x)
'hello world'

并不是所有方法都能通过类名取调用

4

数据属性如果和方法属性名称相同，前者会覆盖后者。所以为了避免名称冲突，最好养成一些习惯，比如方法名称大写，数据属性 名称前加一个短小，唯一的前缀。或者数据属性用名词，方法属性用动词。 数据属性可以被方法引用，也可以被对象的使用者引用。换句话说，类不能实现为纯抽象数据类型。 通常，方法的第一个参数是self.虽然这只是一个习惯用法，但是遵循一些习惯用法会让你的程序可读性更强。 函数定义没有必要非在类里面，例如：

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1
    def g(self):
        return 'hello world'
    h = g

一个方法可以通过self参数调用其它方法，

>>> 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)
... 
>>> b = Bag()
>>> b.data
[]
>>> b.add('1')
>>> b.data
['1']
>>> b.addtwice('x')
>>> b.data
['1', 'x', 'x']

5

派生类的形式如下：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

BaseClassName必须在包含派生类的域内定义，BaseClassName可以是一个表达式，例如：

class DerivedClassName(modname.BaseClassName):

当派生类的对象引用了一个属性时，会先在派生类内查找这个属性名，如果找不到，再到基类中查找。 派生类可以覆盖基类中的方法，即使基类中的方法被覆盖了，也可以使用下面的方法来调用

BaseClassName.methodname(self, arguments)

6

Python 支持有限的多重继承：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

在旧风格的类中，唯一的规则是深度优先，从左到右。以上述类定义为例，如果一个属性没有在 DerivedClassName中被 找到，那么会继续搜索Base1,Base2等等 在新风格的类中，对方法的解析次序是动态改变的，这是因为类的继承关系会呈现出一个或多个菱形。例如新风格的类都由 object类派生出，这样就会就多条路径通向object。为了避免基类被多次搜索，使用了线性化算法将所有基类排列成从左 到右的顺序

7

实例的私有变量只能在对象内部使用，python中常常使用例如 _ spam 的形式来代表API的非公有部分，无论是函数，方法还是 数据成员。类私有成员的特性的一种有效的用法是可以避免与子类中定义的名字冲突，这种机制叫做 mangling:

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update # private copy of original update() method


class MappingSubclass(Mapping):
    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)

注意上述代码中 __ update 的使用，避免了子类中对update的覆盖影响到基类 __ init__ 中的 update.

8

有时候我们可能需要像C中的struct那样的数据类型，把少量的数据项放在一起。Python中可以使用定义一个空类来实现这一点：

# filename:p.py
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

>>> import p
>>> p.john
<p.Employee instance at 0xb71f50ac>
>>> p.john.name
'John Doe'
>>> p.john.dept
'computer lab'
>>> p.john.salary
1000

9

用户定义的异常也可以用类来表示，使用这种机制可以创建出可扩展，层次化的异常。 raise 语句有两种新的形式

raise Class, instance
raise instance

第一种形式中，instance必须是Class的一个实例，或者是由它派生出的类。 第二种形式是下面这种形式的缩写

raise instance.__class__, instance

下面这个例子会依次打印出B,C,D

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"

>>> import f
B
C
D

注意如果 B写在最前面，会打印出BBB,这是因为raise C和raise D时，执行到except B是都会 print "B". 因为B是C,D的基类.

10

现在你可能已经注意到了多数容器对象都可以使用for语句来循环

>>> for elem in [1,2,3]:
...     print elem
... 
1
2
3
>>> for elem in (1,2,3):
...     print elem
... 
1
2
3

这一风格清晰，简捷，方便。迭代器的使用在Python中非常普便。for语句的背后，其实是对容器对象调用 iter(). 这个函数返回一个迭代器对象，它定义了next()函数，每次访问容器中的一个元素。当没有元素的时候，next()返回一个 StopIteration异常，告诉for语句循环结束了。

>>> s = 'asdf'
>>> it = iter(s)
>>> it
<iterator object at 0xb71f590c>
>>> it.next()
'a'
>>> it.next()
's'
>>> it.next()
'd'
>>> it.next()
'f'
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

理解了迭代机制，就可以很容易地把迭代器加入你的类中，定义__ iter__ ()方法，返回一个有next()方法的对象。 如果一个类定义了next()函数，__ iter__ () 可以仅返回 self:

# q.py
class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def next(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index -1
        return self.data[self.index]

>>> import q >>> rev = q.Reverse('spam') >>> iter(rev) <q.Reverse instance at 0xb71f588c> >>> for char in rev: ... print char ... m a p s

11

生成器是创建迭代器的一个简单而强大的工具。它们像正常函数一样，只是需要返回数据时使用 yield语句。

# d.py
def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

>>> import d
>>> for char in d.reverse('golf'):
...     print char
... 
f
l
o
g

任何可以使用生成器做的事，都可以使用前一版本的reverse实现，生成器之所以实现紧凑是因为自动创建了 __ iter() 和 next() 方法。