斐波那契数列是由 0, 1, 1, 2, 3, 5, 8...构成

      a,b,L = 0,1,[]

        for i in range(num):

            L.append(a)

            a,b = b,a+b

1：当实例属性和类属性重名时，实例属性优先级高

它将屏蔽掉对类属性的访问。

2：

del p1.address

；作用：用于删除   这里删除了address属性

3：可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性

1:绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

try:

except:当try错误是执行这个语句块

1:在类的变量名前加双下划线不能直接被外部访问

最大公约数问题 

#递归解决最大公约数问题 
def gcd(x , y):
   if y == 0:
       return x
   else:
       gcd(y, x%y)

x = int(input('请输入第一个数字：')) 
y = int(input('请输入第二个数字：')) 
print('%d 和 %d 的最大公约数为：' %(x,y),gcd(x,y))

#非递归 
def gcd(x, y):
    while y:
        x, y = y, x%y
    return x

import：普通的调用模块；

for xxxx import xx:  从模块中调用出类，函数或者属性

import xxx as xx :   将模块名称用另一个关键字替代，用这个关键字就是在用这个模块的内容，模块性能不变 

请修改 Student 的 __cmp__ 方法，让它按照分数从高到底排序，分数相同的按名字排序。

• ?不会了怎么办

• 需要先比较 score，在 score 相等的情况下，再比较 name。

  参考代码:

  class Student(object):
      def __init__(self, name, score):
          self.name = name
          self.score = score
  
      def __str__(self):
          return '(%s: %s)' % (self.name, self.score)
  
      __repr__ = __str__
  
      def __cmp__(self, s):
          if self.score == s.score:
              return cmp(self.name, s.name)
          return -cmp(self.score, s.score)
  
  L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 99)]
  print sorted(L)

class Rational(object):

    def __init__(self, p, q):

        self.p = p

        self.q = q

    def __add__(self, r):

        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)

    def __sub__(self, r):

        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)

    def __mul__(self, r):

        return Rational(self.p  * r.p, self.q * r.q)

    def __div__(self, r):

        return Rational(self.p * r.q , self.q * r.p)

    def __str__(self):

        if abs(self.p) < abs(self.q):

            mi = abs(self.p)

        else:

            mi = abs(self.q)

        for i in range(1,mi+1):

            if self.p%i ==0 and self.q%i == 0:

                m = i

        return '%s/%s' % (self.p/m, self.q/m)

    __repr__ = __str__

r1 = Rational(1, 2)

r2 = Rational(1, 4)

print r1 + r2

print r1 - r2

print r1 * r2

print r1 / r2

Python的继承

总是从某个类继承，object

不要忘记调用super().__init__ 

has 关系应该使用组合而非继承

self.book = Book(bookName)

继承的特点：

子类和父类是 is 关系：

p = Person()
s = Student()
p是一个Person,但不是一个Student
s是一个Student，也是一个Person

要在class中定义类方法，需要这么写：

class Person(object):
    count = 0    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1

print Person.how_many()
p1 = Person('Bob')
print Person.how_many()

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：

import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

p1 = Person('Bob', 90)p1.get_grade = types.MethodType(fn_get_grade, p1, Person)print p1.get_grade()# => Ap2 = Person('Alice', 65)
print p2.get_grade()# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 因为p2实例并没有绑定get_grade

调用实例方法必须在实例上调用

在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。