Python基础学习笔记FromImooc.com

缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

注意: if 语句后接表达式，然后用:表示代码块开始。【！！！！！！！！！！！】

利用倒序切片对 1 - 100 的数列取出：

* 最后10个数；

* 最后10个5的倍数。

类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return ‘I am a Person, my name is %s‘ % self.name

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return ‘I am a Student, my name is %s‘ % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return ‘I am a Teacher, my name is %s‘ % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：

def who_am_i(x):
    print x.whoAmI()

p = Person(‘Tim‘, ‘Male‘)
s = Student(‘Bob‘, ‘Male‘, 88)
t = Teacher(‘Alice‘, ‘Female‘, ‘English‘)

who_am_i(p)
who_am_i(s)
who_am_i(t)

运行结果：

I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice

由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可：

class Book(object):
    def whoAmI(self):
        return ‘I am a book‘

这是动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。

多重继承的继承链就不是一棵树了，它像这样：

class A(object):
    def __init__(self, a):
        print ‘init A...‘
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print ‘init B...‘

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print ‘init C...‘

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print ‘init D...‘

看下图:

像这样，D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A虽然被继承了两次，但__init__()只调用一次：

函数了：

>>> getattr(s, ‘name‘)  # 获取name属性
‘Bob‘

>>> setattr(s, ‘name‘, ‘Adam‘)  # 设置新的name属性

>>> s.name
‘Adam‘

>>> getattr(s, ‘age‘)  # 获取age属性，但是属性不存在，报错：
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘Student‘ object has no attribute ‘age‘

>>> getattr(s, ‘age‘, 20)  # 获取age属性，如果属性不存在，就返回默认值20：
20

如果要把一个类的实例变成 str，就需要实现特殊方法__str__()：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return ‘(Person: %s, %s)‘ % (self.name, self.gender)

现在，在交互式命令行下用 print 试试：

>>> p = Person(‘Bob‘, ‘male‘)
>>> print p
(Person: Bob, male)

但是，如果直接敲变量 p：

>>> p
<main.Person object at 0x10c941890>

似乎__str__() 不会被调用。

因为 Python 定义了__str__()和__repr__()两种方法，__str__()用于显示给用户，而__repr__()用于显示给开发人员。

有一个偷懒的定义__repr__的方法：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return ‘(Person: %s, %s)‘ % (self.name, self.gender)
    __repr__ = __str__

如果要把 Rational 转为 int，应该使用：

r = Rational(12, 5)
n = int(r)

要让int()函数正常工作，只需要实现特殊方法__int__():

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __int__(self):
        return self.p // self.q

结果如下：

>>> print int(Rational(7, 2))
3
>>> print int(Rational(1, 3))
0

同理，要让float()函数正常工作，只需要实现特殊方法__float__()。

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError(‘invalid score‘)
        self.__score = score

注意: 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。

现在，就可以像使用属性一样设置score了：

>>> s = Student(‘Bob‘, 59)
>>> s.score = 60
>>> print s.score
60
>>> s.score = 1000
Traceback (most recent call last):
  ...
ValueError: invalid score

说明对 score 赋值实际调用的是 set方法。

__slots__

class Student(object):
    __slots__ = (‘name‘, ‘gender‘, ‘score‘)
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

>>> s = Student(‘Bob‘, ‘male‘, 59)
>>> s.name = ‘Tim‘ # OK
>>> s.score = 99 # OK
>>> s.grade = ‘A‘
Traceback (most recent call last):
  ...
AttributeError: ‘Student‘ object has no attribute ‘grade‘

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

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

    def __call__(self, friend):
        print ‘My name is %s...‘ % self.name
        print ‘My friend is %s...‘ % friend

现在可以对 Person 实例直接调用：

>>> p = Person(‘Bob‘, ‘male‘)
>>> p(‘Tim‘)
My name is Bob...
My friend is Tim...

单看 p(‘Tim‘) 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。