Python基础教程

摘要：函数内的变量被称为局部变量，这是与全局变量相反的概念。有一些进行函数式编程的机制。继承以通用的类为基础建立专门的类对象。

假设有如下函数：

def add(x,y): return x+y

比如说有个包含由两个相加的数字组成的元组：

params = (1,2)

使用*运算符对参数进行“分配”，不过是在调用而不是在定义时使用：

>>> add(*params)
3

======

同样，可以使用 双星号 运算符来处理字典。

假设之前定义了hello_3，那么可以这样使用：

>>> params = {"name":Sir Robin","greeting":"Well met"}
>>> hello_3(**params)
Well met.Sir Robin

星号只在 定义函数（允许使用不定数目的参数）或者 调用（“分割”字典或者序列)时才有用。

在执行x=1赋值语句后，名称x引用到值1。这就像是使用字典一样，键引用值。当然，变量和所对应的值用的是个“不可见”的字典。

內建的vars函数可以返回这个字典：

>>> x = 1
>>> scope = vars()
>>> scope["x"]
1
>>> scope["x"] += 1
>>> x
2

这类“不可见字典”叫做 命名空间 或者 作用域 。除了全局作用域外，每个函数调用都会创建一个新的作用域：

>>> def foo(): x = 42
...
>>> x = 1
>>> foo()
>>> x
1

这里的foo函数改变（重绑定）了变量x，但是在最后的时候，x并没有变。这是因为当调用foo的时候，新的命名空间就被创建了，它作用于foo内的代码块。赋值语句x=42只在内部作用域（局部命名空间）起作用，所以它并不影响外部（全局）作用域中的x。

函数内的变量被称为局部变量（local variable），这是与全局变量相反的概念。参数的工作原理类似于局部变量，所以用全局变量的名字作为参数名并没有问题。

>>> def output(x): print x
...
>>> x = 1
>>> y = 2
>>> output(y)
2

======

重绑定全局变量：

如果在函数内部将值赋予一个变量，它将会自动成为局部变量——除非告知Python将其声明为全局变量：

>>> x = 1
>>> def change_global():
        global x
        x = x + 1
        
>>> change_global()
>>> x
2

======

Python的函数是可以嵌套的：

def foo():
    def bar():
        print "Hello,World！"
    bar()

函数嵌套有一个很突出的应用，例如需要一个函数“创建”另一个。也就意味着可以像下面这样（在其他函数内）书写函数：

def multiplier(factor):
    def multiplier(number):
        return number*factor
    returnmultiplyByFactor

一个函数位于另外一个里面，外层函数返回里层函数。也就是说函数本身被返回了，但并没有被调用。重要的是返回的函数还可以访问它的定义所在的作用域。换句话说，它“带着”它的环境（和相关的局部变量）。

每次调用外层函数，它内部的函数都被重新绑定。factor变量每次都有一个新的值。由于Python的嵌套作用域，来自（`multiplier的)外部作用域的这个变量，稍后会被内层函数访问：

>>> double = multiplier(2)
>>> double(5)
10
>>> triple = multiplier(3)
>>> triple(3)
9
>>> multiplier(5)(4)
20

类似multiplayByFactor函数存储子封闭作用域的行为叫做闭包（closure）。

递归的定义（包括递归函数定义）包括它们自身定义内容的引用。

关于递归，一个类似的函数定义如下：

def recursion():
    return recursion()

理论上讲，上述程序应该永远地运行下去，然而每次调用函数都会用掉一点内存，在足够的函数调用发生后（在之前的调用返回后），空间就不够了，程序会以一个“超过最大递归深度”的错误信息结束。

这类递归就做无穷递归（infinite recursion），类似于以while True开始的无穷循环，中间没有break或者return语句。因为（理论上讲）它永远不会结束。

有用的递归函数包含以下几个部分：

当函数直接返回值时有基本实例（最小可能性问题）

递归实例，包括一个或者多个问题较小部分的递归调用。

这里的关键就是将问题分解成小部分，递归不可能永远继续下去，因为它总是以最小可能性问题结束，而这些问题又存储在基本实例中的。

当每次函数被调用时，针对这个调用的新命名空间会被创建，意味着当函数调用“自身”时，实际上运行的是两个不同的函数（或者说是同一个函数具有两个不同的命名空间）。实际上，可以将它想象成和同种类的一个生物进行对话的另一个生物对话。

计算数n的的阶乘：

def factorial(n):
    result = n
    for i in range(1,n):
        result *= 1
        return result

递归实现：

1的阶乘是1；

大于1的数n的阶乘是n乘n-1的阶乘。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

======

计算幂

例子：power(x,n)(x为n的幂次）是x自乘n-1次的结果（所以x用作乘数n次。

def power(x,n):
    result = 1
    for i in range(n):
        result *= x
    return result

递归实现：

对于任意数字x来说，`power(x,0)是1；

对于任何大于0的书来说，power(x,n)是x乘以(x,n-1)的结果。

def power(x,n):
    if n == 0:
        return 1
    else:
        return x * power(x,n-1)

递归实现：

如果上下限相同，那么就是数字所在位置，返回；

否则找到两者的中点（上下限的平均值），查找数字是在左侧还是在右侧，继续查找数字所在的那半部分。

def search(sequence,number,lower,upper):
    if lower == upper:
        assert number == sequence[upper]
        return upper
    else:
        #整数除法//,浮点数除法/
        middle = (lower + upper) // 2 
        if number > sequence[middle]:
            return search(sequence,number,middle+1,upper)
        else:
            return search(sequence,number,lower,middle)

提示：标准库中的bisect模块可以非常有效地实现二分查找。

Python在应对“函数式编程”方面有一些有用的函数：map、filter和reduce函数（Python3.0中都被移至fuctools模块中）。

map和filter在目前版本的Python并非特别有用，并且可以使用列表推导式代替。不过可以使用map函数将序列中的元素全部传递给一个函数：

>>> map(str,range(10))        #Equivalent to [str(i) for i in range(10)]
["0","1","2","3","4","5","6","7","8","9"]

filter函数可以基于一个返回布尔值的函数对元素进行过滤。

#island 判断字符变量是否为字母或数字，
#若是则返回非零，否则返回零

>>> def fun(x):
        return x.isalnum()
        
>>> seq = ["foo","x41","?!","***"]
>>> filter(func,seq)
["foo","x41"]

本例中，使用列表推导式可以不用专门定义一个函数：

>>> [x for x in seq if x.isalnum()]
["foo","x41"]

事实上，还有个叫做lambda表达式的特性，可以创建短小的函数。

>>> filter(lambda x: x.isalnum().seq)
["foo","x41"]

=======

reduce函数一般来说不能轻松被列表推导式替代，但是通常用不到这个功能。它会将序列的前两个元素与给定的函数联合使用，并且将它们的返回值和第3个元素继续联合使用，直到整个序列都处理完毕，并且得到一个最终结果。

可以使用reduce函数加上lambda x,y:x+y（继续使用相同的数字）:

>>> numbers = [72,101,108,108,111,44,32,119,111,114,108,100,33]
>>> reduce(lambda x,y:x+y,numbers)
1161

当然，这里也可以使用内建函数sum。

抽象。抽象是隐藏多余细节的艺术。定义处理细节的函数可以让程序更抽象。

函数定义。函数使用def语句定义。它们是由语句组成的块，可以从“外部世界”获取值（参数），也可以返回一个或者多个值作为运算的结果。

参数。函数从参数中得到需要的信息，也就是函数调用时设定的变量。Python中有两类参数：位置参数 和 关键数参数。参数在给定默认值时是可选的。

作用域。变量存储在作用域（也叫作命名空间）中。Python有两类主要的作用域——全局作用域 和 局部作用域。作用域可以嵌套。

递归。 函数可以调用自身即递归。一切用递归实现的功能都能用循环实现，但是有些时候递归函数更易读。

函数式编程。Python有一些进行函数式编程的机制。包括lambda表达式以及map、filter和reduce函数。

| 函数 | 描述 |
| ------------- |:-------------|
| map(func,seq[,seq,...])| 对序列中的每个元素应用函数 |
| filter(fuc,seq) | 返回其函数为真的元素的列表 |
| reduce(func,seq[,initial]) | 等同于func(func(func(seq[0],seq[1],se1[2]... |
| sum(seq) | 返回seq所有元素的和 |
| apply(func,args[,kwargs]] | 调用函数，可以提供参数 |

在面对对象程序设计中，术语对象（object）基本上可以看做数据（特性）以及由一系列可以存取、操作这些数据的方法所组成的集合。使用对象替代全局变量和函数的原因可能有很多，其中对象最重要的优点包括以下几方面：

多态（Polymorphism）：意味着可以对不同类的对象使用同样的操作，它们会像“被施了魔法一般”工作。

封装（Encapsulation）：对外部世界隐藏对象的工作细节。

继承（Inheritance)：以通用的类为基础建立专门的类对象。

术语多态的意思是“有多种形式”。多态意味着就算不知道变量所引用的对象类型是什么，还是能它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。

repr函数是多态特性的代表之一，可以对任何东西使用：

def length_message(x):
    print "The length of",repr(x),"is",len（x）

>>> length_message("Fnord")
The length of "Fnord" is 5
>>> length_message([1,2,3])
The length of [1,2,3] is 3

很多函数和运算符都是多态的——你写的绝大多数程序可能都是，只要使用多态函数和运算符，就会与“多态”发生关联。事实上，唯一能毁掉多态的就是使用函数显式地检查类型，比如type、isinstance以及issubclass函数等等。如果可能的话，应该尽力避免使用这些毁掉多态的方式。真正重要的是如何让对象按照你所希望的方式工作，不管它是不是真正的类型（或者类）。

封装是指向程序中的其他部分隐藏对象的具体实现细节的原则。

但是封装并不等同于多态，多态可以让用户对于不知道什么是类（对象类型）的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。

基本上，需要将对象进行抽象，调用方法的时候不用关心其他的东西，比如它是否干扰了全局变量。

可以将其作为 特性（attribute） 存储。特性是作为变量构成对象的一部分，事实上方法更像是绑定到函数上的属性。

对象有着自己的状态（state）。对象的状态由它的特性（比如名称）来描述。对象的方法可以改变它的特性。所以就像是将一大堆函数（方法）捆在一起，并且给予他们访问变量（特性）的权力。它们可以在函数调用之间保持保存的值。

略

类是一种对象，所有的对象都属于某一个类，称为类的实例（instance）。

当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的 子类（subclass），所以“百灵鸟类”是“鸟类”的子类。相反，“鸟类”是“百灵鸟类”的“超类”（superclass）。但是，在面向程序设计中，子类的关系是隐式的，因为一个类的定义取决于它所支持的方法。类的所有实例都会包含这些方法，所以所有子类的所有实例都有这些方法。定义子类只是个定义更多（也有可能是重载已经存在的）方法的过程。

事实上，self参数正是方法和参数的区别。方法（更专业一点可以称为绑定方法）将它们的第一个参数绑定到所属的实例上，因此无需显式提供该参数。当然也可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了：

>>> class Class:
    def method(self):
        print "I hava a self"

>>> def function():
    print "I don"t..."
 
>>> instance = Class()
>>> instance.method()
I hava a self!
>>> instance.method =function
>>> instance.method()
I don"t...   

注意，self参数并不依赖于调用方法的方式，前面使用的是instance.method(实例.方法)的形式，可以随意使用其他变量引用同一个方法：

>>> class Bird:
    song = "Squaawk!"
    def sing(self):
        print self.song

>>> bird = Bird()
>>> bird.sing()
Squaawk!

>>> birdsong = bird.sing
>>> birdsong()
Squaawk!

尽管最后一个方法调用看起来与函数调用十分相似，但是变量birdsongs引用绑定方法bird.sing上，也就意味着这还是会对self参数进行访问（也就是说，它仍旧绑定到类的相同实例上）。

默认情况下，程序可以从外部访问一个对象的特性：

>>> c.name
"Sir Lancelot"
>>> c.name = "Sir Gumby"
>>> c.getName()
"Sir Gumby"

为了避免这类事情的发生，应该使用私有（private）特性，这是外部对象无法访问到，但getName和setName等访问器（accessor）能够访问的特性。

Python并不直接支持私有防暑，为了让方法或者特性变为私有（从外部无法访问），只要在它的名字前面加上双下划线即可。

class Secretive:
    def __inacessible(self):
        print "Bet you can"t see me.."
       
    def accessible(self):
        print "The secret message is:"
        self.__inaccessible

现在，__inaccessible从外界是无法访问的，而在类内部还能使用（比如从accessible）访问：

>>> s = Secretive()
>>> s.__inaccessible()
Traceback (most recent call last):
    File "",;ine 1, in ?
    s.__inaccessible()
AttributeError: Secretive instance has no attribute "__inaccessible"
>>> s.accessible()
The secret message is:
Bet you can"t see me...

尽管双下划线有些奇怪，但是看起来像是其他鱼鱼中的标准的私有方法。而在类的内部定义中，所有以双下划线开始的名字都被“翻译”成前面加上单下划线类名的形式。

>>> Secretive._Secret__inaccsible

但实际上还是能够在类外访问这些私有方法，尽管不应该这么做：

>>> s._Secretive.__inaccessible
Bet you can"t see me..

简而言之，确保他人不会访问对象的方法和特性是不可能的，但是这类“名称变化”是提醒他们不应该访问这些函数或者特性的强有力信号。

如果不需要使用这种方法但是又想让其他对象不要访问内部数据，那么可以使用单下划线，这不过是个习惯，但的确有实际效果。例如，前面有下划线的名字都不会被带星号的import语句（from module import *）导入。

下面的两个语句几乎等价：

def foo(x):return x*x
foo = lambda X:x*x

两者都创建了返回参数平方的函数，而且都将变量foo绑定到函数上。变量foo可以在全局（模块）范围内进行定义，也可处在局部的函数或方法内。定义类时，太阳的事情也会发生，所有位于class语句中的代码块都在特殊的命名空间中执行——类命名空间（class namespace）。这个命名空间可由类内所有成员访问。但并不是所有Python程序员都知道类的定义其实就是执行代码块。

子类可以拓展超类的定义。将其他类名写在class语句后的圆括号内可以指定超类。

如果想要查看一个类是否是另一个的子类，可以使用内建的issubclass函数。

如果想要知道已知类的基类（们），可以直接使用它的特殊特性__base__:

同样，还能使用isinstance方法检查一个对象是否是一个类的实例：