python基础教程——抽象

斐波那契数列：每个数都是前两个数的和。
fib[k] = fib[k-1] + fib[k-2]
例子：

fibs = [0, 1]
for i in range(8):
… fibs.append(fibs[-2]+fibs[-1])
…
fibs
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

判断某个对象是否可调用，可以使用内置的callable函数。
例子：

import math
x = 1
y = math.sqrt
callable(x)
False
callable(y)
True

文档字符串：放在函数开头的字符串被称为文档字符串，将作为函数的一部分存储起来。
例如：

def square(x):
… ‘Calculates the square of the number x.’
… return x*x
…
square.doc
‘Calculates the square of the number x.’
内置函数help很有用，可使用它获取有关函数的信息，包括函数的文档字符串。
help(square)
Help on function square in module main:

square(x)
Calculates the square of the number x.

如果参数不可变，可以将参数作为返回值，可以得到改变后的值，或者把它放到一个列表中，去改变值。
例子1：

def inc(foo):
… return foo+1
…
foo = 10
foo = inc(foo)
foo
11
例子2：
def inc(foo):
… foo[0] += 1
…
foo = [10]
inc(foo)
foo
[11]

• 收集参数
  参数前面的星号将提供的所有值放到一个元组中，也就是将这些值收集起来。如果没有可供收集的参数，那么它将是一个空元组。星号不会收集关键字参数。
  例子：

>>> def print_param_1(title, *param):
...     print(title)
...     print(param)
...     
>>> print_param_1('Params', 1, 2, 3)
Params
(1, 2, 3)
>>> print_param_1('Params')
Params
()

要收集关键字参数需要使用两个星号。这样得到的是一个字典而不是元组。
例子：

>>> def print_param_2(**param):
...     print(param)
...     
>>> print_param_2(x=1, y=2, z=3)
{'x': 1, 'y': 2, 'z': 3}

>>> def print_param_3(x, y, z=3, *pospar, **keypar):
...     print(x, y, z)
...     print(pospar)
...     print(keypar)
...     
>>> print_param_3(1, 2, 3, 4, 5, 6, 7, foo=1, bar=2)
1 2 3
(4, 5, 6, 7)
{'foo': 1, 'bar': 2}
>>> print_param_3(1, 2)
1 2 3
()
{}

• 分配参数
  通过在调用函数（而不是定义函数）时使用运算符*实现的。这种做法也可用于参数列表的一部分，条件是这部分位于参数列表末尾。使用运算符**可将字典中的值分配给关键字参数。
  例子：

>>> def add(x, y):
...     return x+y
... 
>>> param = (1, 1)
>>> add(*param)
2

>>> def hello(greeting, name):
...     print('{}, {}!'.format(greeting, name))
...     
>>> param = {'name': 'Sir Robin', 'greeting': 'Well met'}
>>> hello(**param)
Well met, Sir Robin!

• 作用域
  如果要访问与局部变量同名的全局变量，则使用globals()[‘parameters’]来访问它。
  例子：

def combine(parameter):
...     print(parameter + globals()['parameter'])
...     
parameter = 'berry'
combine('Shrub')
Shrubberry

使用global可以关联全局变量。

嵌套可以用一个函数来创建另一个函数。以下函数中，外面的函数返回里面的函数，而不是调用它，返回函数可以访问其定义所在的作用域，换言之，它携带着自己所在的环境。
每当外部函数被调用时，都将重新定义内部的函数，而变量factor的值也可能不同，由于python嵌套作用域，可在内部函数中访问这个来自外部局部作用域的变量。
通常不能直接给外部作用域内的变量赋值，但如果一定要这样做，可使用关键字nonlocal，这个关键字用法与global很像，可以给外部作用域（非全局作用域）内的变量赋值。
例子：

def multiplier(factor):
...     def multiplyByFactor(number):
...         return factor * number
...     return multiplyByFactor
... 
double = multiplier(2)
double
<function multiplier.<locals>.multiplyByFactor at 0x108647f28>
double(5)
10
multiplier(5)(4)
20

• 类
  要让方法或属性成为私有，只需让其名称以两个下划线打头即可。两个下划线打头的方法类似于其他语言中的标准私有方法，但是对该方法进行转换，即在开头加上一个下划线和类名，就能从类外访问该私有方法。如果不希望名称被修改，又想发出不要从外部修改属性火方法的信号，可以用一个下划线打头，from module import *不会导入以一个下划线打头的名称。
  例子：

class Secretive:
    def __init__(self):
        self.a = 0
        self.b = 1

    def _inaccessible1(self):
        self.b = 2
        print('aaa')

    def __inaccessible2(self):
        self.a = 1
        print("Bet you can't see me...")

    def accessible(self):
        print("The secrete message is:")
        self.__inaccessible2()
        self._inaccessible1()

if __name__ == '__main__':
    s = Secretive()
    s.accessible()
    print(1)
    s._Secretive__inaccessible()
    print(2)
    s._inaccessible1()
    print(3)

要确定一个类是否是另一个类的子类，可以用内置方法：issubclass
如果有一个类，想要知道它的基类，可访问其特殊属性__base__
要确定对象是否是特定类的实例，可使用isinstance
如果想获取对象是哪个类的，可以使用属性__class__
检查所需方法是否存在，使用hasattr(tc, ‘talk’)
通过获取对象属性，可以获取对象的属性值，进而判断属性是否可调用：callable(getattr(tc, ‘talk’, None))
设置对象的属性可使用setattr，setattr(tc, ‘name’, ‘Mr. Gumby’)
要查看对象中存储的所有值，可以检查__dict__属性
通过register方法，可以把一个类注册到另一个类上，成为其子类。