Python学习笔记 for windows 二

时间 2019-12-20

标签 python 学习笔记 windows 栏目 Python 繁體版

原文原文链接

函数python

abs(-20) //结果为：20，绝对值函数git

def 函数名称（[参数1，参数2，参数3]）：程序员

执行语句算法

return 编程

def test(r):json

s=3.14*r*r设计模式

return sapi

s=test(1)网络

print s //结果为：3.14数据结构

cmp(x,y) //比较函数，若是x<y，返回-1，若是x==y，返回0，若是x>y，返回1

float('12.34') //结果为：12.34

str(123) //结果为：'123'

unicode(100) //结果为：u'100'

bool(1) //结果为：True

bool('') //结果为：False

空语句 pass ,至关于占位符，让代码先跑起来

据类型检查能够用内置函数isinstance实现：

isinstance

if not isinstance(x, (int, float)):         raise TypeError('bad operand type')

函数能够同时返回多个值，但其实就是一个tuple。
def test(a):
 x=a+1
 y=a+2
return x,y
r=test(1)
print r //结果为（2,3）

def enroll(name,gender,age=6,city='BeiJing')：    //参数后面加等号即为默认参数，调取函数时选填

print 'name:',name

print 'gender:',gender

print 'age:',age

print 'city:'city

enroll('Ling','F')

enroll('ling','M',7)

enroll('ling','M',city='ShangHai')

默认参数如用到[]，会有个坑，重复调用会记住上次的[]，写的时候最好这么写

def add_end(L=None)    //使用None这个不变的对象来实现

    if L is None:

        L=[]

.....

可变参数


面向对象最重要的概念就是类（class）和实例（instance），必须牢记类是抽象的模板，好比Student类，而实例是根据类建立出来的一个个具体的对象，每一个对象都有相同的方法，可是各自的数据可能不一样。
仍以Student类为例，在Python中，定义类是经过class关键字：
后面紧接着是类名，即，类名一般是大写开头的单词，紧接着是，表示该类是从哪一个类继承下来的，继承的概念咱们后面再讲，一般，若是没有合适的继承类，就使用类，这是全部类最终都会继承的类。
定义好了类，就能够根据类建立出的实例，建立实例是经过类名+()实现的：
能够看到，变量指向的就是一个Student的object，后面的是内存地址，每一个object的地址都不同，而自己则是一个类。
能够自由地给一个实例变量绑定属性，好比，给实例绑定一个属性：
因为类能够起到模板的做用，所以，能够在建立实例的时候，把一些咱们认为必须绑定的属性强制填写进去。经过定义一个特殊的方法，在建立实例的时候，就把，等属性绑上去：
注意到方法的第一个参数永远是，表示建立的实例自己，所以，在方法内部，就能够把各类属性绑定到，由于就指向建立的实例自己。
有了方法，在建立实例的时候，就不能传入空的参数了，必须传入与方法匹配的参数，但不须要传，Python解释器本身会把实例变量传进去：
普通的函数相比，在类中定义的函数只有一点不一样，就是第一个参数永远是实例变量，而且，调用时，不用传递该参数。除此以外，类的方法和普通函数没有什么区别，因此，仍然能够用默认参数、可变参数和关键字参数。
数据封装
面向对象编程的一个重要特色就是数据封装。在上面的类中，每一个实例就拥有各自的和这些数据。咱们能够经过函数来访问这些数据，好比打印一个学生的成绩：
可是，既然实例自己就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，能够直接在类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和类自己是关联起来的，咱们称之为类的方法：
要定义一个方法，除了第一个参数是外，其余和普通函数同样。要调用一个方法，只须要在实例变量上直接调用，除了不用传递，其余参数正常传入：
这样一来，咱们从外部看类，就只须要知道，建立实例须要给出和，而如何打印，都是在类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。
封装的另外一个好处是能够给类增长新的方法，好比：
一样的，方法能够直接在实例变量上调用，不须要知道内部实现细节：
小结
类是建立实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
方法就是与实例绑定的函数，和普通函数不一样，方法能够直接访问实例的数据；
经过在实例上调用方法，咱们就直接操做了对象内部的数据，但无需知道方法内部的实现细节。
和静态语言不一样，Python容许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不一样实例，但拥有的变量名称均可能不一样：
访问限制
在Class内部，能够有属性和方法，而外部代码能够经过直接调用实例变量的方法来操做数据，这样，就隐藏了内部的复杂逻辑。
可是，从前面Student类的定义来看，外部代码仍是能够自由地修改一个实例的、属性：
若是要让内部属性不被外部访问，能够把属性的名称前加上两个下划线，在Python中，实例的变量名若是以开头，就变成了一个私有变量（private），只有内部能够访问，外部不能访问，因此，咱们把Student类改一改：
改完后，对于外部代码来讲，没什么变更，可是已经没法从外部访问和了：
这样就确保了外部代码不能随意修改对象内部的状态，这样经过访问限制的保护，代码更加健壮。
可是若是外部代码要获取name和score怎么办？能够给Student类增长和这样的方法：
若是又要容许外部代码修改score怎么办？能够给Student类增长方法：
你也许会问，原先那种直接经过也能够修改啊，为何要定义一个方法大费周折？由于在方法中，能够对参数作检查，避免传入无效的参数：
须要注意的是，在Python中，变量名相似的，也就是以双下划线开头，而且以双下划线结尾的，是特殊变量，特殊变量是能够直接访问的，不是private变量，因此，不能用、这样的变量名。
有些时候，你会看到以一个下划线开头的实例变量名，好比，这样的实例变量外部是能够访问的，可是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我能够被访问，可是，请把我视为私有变量，不要随意访问”。
双下划线开头的实例变量是否是必定不能从外部访问呢？其实也不是。不能直接访问是由于Python解释器对外把变量改为了，因此，仍然能够经过来访问变量：
可是强烈建议你不要这么干，由于不一样版本的Python解释器可能会把改为不一样的变量名。
总的来讲就是，Python自己没有任何机制阻止你干坏事，一切全靠自觉。
继承和多态
在OOP程序设计中，当咱们定义一个class的时候，能够从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
好比，咱们已经编写了一个名为的class，有一个方法能够直接打印：
当咱们须要编写Dog和Cat类时，就能够直接从Animal类继承：
对于Dog来讲，Animal就是它的父类，对于Animal来讲，Dog就是它的子类。Cat和Dog相似。
继承有什么好处？最大的好处是子类得到了父类的所有功能。因为Animial实现了方法，所以，Dog和Cat做为它的子类，什么事也没干，就自动拥有了方法：
运行结果以下：
固然，也能够对子类增长一些方法，好比Dog类：
继承的第二个好处须要咱们对代码作一点改进。你看到了，不管是Dog仍是Cat，它们的时候，显示的都是，符合逻辑的作法是分别显示和，所以，对Dog和Cat类改进以下：
再次运行，结果以下：
当子类和父类都存在相同的方法时，咱们说，子类的覆盖了父类的，在代码运行的时候，老是会调用子类的。这样，咱们就得到了继承的另外一个好处：多态。
要理解什么是多态，咱们首先要对数据类型再做一点说明。当咱们定义一个class的时候，咱们实际上就定义了一种数据类型。咱们定义的数据类型和Python自带的数据类型，好比str、list、dict没什么两样：
判断一个变量是不是某个类型能够用判断：
看来a、b、c确实对应着list、Animal、Dog这3种类型。
可是等等，试试：
看来c不只仅是Dog，c仍是Animal！
不过仔细想一想，这是有道理的，由于Dog是从Animal继承下来的，当咱们建立了一个Dog的实例时，咱们认为的数据类型是Dog没错，但同时也是Animal也没错，Dog原本就是Animal的一种！
因此，在继承关系中，若是一个实例的数据类型是某个子类，那它的数据类型也能够被看作是父类。可是，反过来就不行：
Dog能够当作Animal，但Animal不能够当作Dog。
要理解多态的好处，咱们还须要再编写一个函数，这个函数接受一个Animal类型的变量：
当咱们传入Animal的实例时，就打印出：
当咱们传入Dog的实例时，就打印出：
当咱们传入Cat的实例时，就打印出：
看上去没啥意思，可是仔细想一想，如今，若是咱们再定义一个Tortoise类型，也从Animal派生：
当咱们调用run_twice()时，传入Tortoise的实例：
你会发现，新增一个Animal的子类，没必要对run_twice()作任何修改，实际上，任何依赖Animal做为参数的函数或者方法均可以不加修改地正常运行，缘由就在于多态。
多态的好处就是，当咱们须要传入Dog、Cat、Tortoise……时，咱们只须要接收Animal类型就能够了，由于Dog、Cat、Tortoise……都是Animal类型，而后，按照Animal类型进行操做便可。因为Animal类型有方法，所以，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的方法，这就是多态的意思：
对于一个变量，咱们只须要知道它是Animal类型，无需确切地知道它的子类型，就能够放心地调用方法，而具体调用的方法是做用在Animal、Dog、Cat仍是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，无论细节，而当咱们新增一种Animal的子类时，只要确保方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：容许新增Animal子类；
对修改封闭：不须要修改依赖Animal类型的等函数。
获取对象信息


当咱们拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？
使用type()
首先，咱们来判断对象类型，使用函数：
基本类型均可以用判断：
若是一个变量指向函数或者类，也能够用判断：
可是函数返回的是什么类型呢？它返回type类型。若是咱们要在语句中判断，就须要比较两个变量的type类型是否相同：
可是这种写法太麻烦，Python把每种type类型都定义好了常量，放在模块里，使用以前，须要先导入：
最后注意到有一种类型就叫，全部类型自己的类型就是，好比：
使用isinstance()
对于class的继承关系来讲，使用type()就很不方便。咱们要判断class的类型，可使用函数。
咱们回顾上次的例子，若是继承关系是：
那么，就能够告诉咱们，一个对象是不是某种类型。先建立3种类型的对象：
而后，判断：
没有问题，由于变量指向的就是Husky对象。
再判断：
虽然自身是Husky类型，但因为Husky是从Dog继承下来的，因此，也仍是Dog类型。换句话说，判断的是一个对象是不是该类型自己，或者位于该类型的父继承链上。
所以，咱们能够确信，仍是Animal类型：
同理，实际类型是Dog的也是Animal类型：
可是，不是Husky类型：
能用判断的基本类型也能够用判断：
而且还能够判断一个变量是不是某些类型中的一种，好比下面的代码就能够判断是不是str或者unicode：
因为和都是从继承下来的，因此，还能够把上面的代码简化为：
使用dir()
若是要得到一个对象的全部属性和方法，可使用函数，它返回一个包含字符串的list，好比，得到一个str对象的全部属性和方法：
相似的属性和方法在Python中都是有特殊用途的，好比方法返回长度。在Python中，若是你调用函数试图获取一个对象的长度，实际上，在函数内部，它自动去调用该对象的方法，因此，下面的代码是等价的：
咱们本身写的类，若是也想用的话，就本身写一个方法：
剩下的都是普通属性或方法，好比返回小写的字符串：
仅仅把属性和方法列出来是不够的，配合、以及，咱们能够直接操做一个对象的状态：
紧接着，能够测试该对象的属性：
若是试图获取不存在的属性，会抛出AttributeError的错误：
能够传入一个default参数，若是属性不存在，就返回默认值：
也能够得到对象的方法：
小结
经过内置的一系列函数，咱们能够对任意一个Python对象进行剖析，拿到其内部的数据。要注意的是，只有在不知道对象信息的时候，咱们才会去获取对象信息。若是能够直接写：
就不要写：
一个正确的用法的例子以下：
假设咱们但愿从文件流fp中读取图像，咱们首先要判断该fp对象是否存在read方法，若是存在，则该对象是一个流，若是不存在，则没法读取。就派上了用场。
请注意，在Python这类动态语言中，有方法，不表明该fp对象就是一个文件流，它也多是网络流，也多是内存中的一个字节流，但只要方法返回的是有效的图像数据，就不影响读取图像的功能。
使用__slots__
  
  
  
  
  
  
  
  
   
   
   
   正常状况下，当咱们定义了一个class，建立了一个class的实例后，咱们能够给该实例绑定任何属性和方法，这就是动态语言的灵活性。先定义class：
   
   
   
   
   
   
   
   而后，尝试给实例绑定一个属性：
   
   
   
       
    
    
    
     
     
     
     Try
    
    
    
    
   
   
   
   还能够尝试给实例绑定一个方法：
   
   
   
   
   
   
   
   可是，给一个实例绑定的方法，对另外一个实例是不起做用的：
   
   
   
   
   
   
   
   为了给全部实例都绑定方法，能够给class绑定方法：
   
   
   
   
   
   
   
   给class绑定方法后，全部实例都可调用：
   
   
   
   
   
   
   
   一般状况下，上面的方法能够直接定义在class中，但动态绑定容许咱们在程序运行的过程当中动态给class加上功能，这在静态语言中很难实现。
   
   
   
   使用__slots__
   
   
   
   可是，若是咱们想要限制class的属性怎么办？好比，只容许对Student实例添加和属性。
   
   
   
   为了达到限制的目的，Python容许在定义class的时候，定义一个特殊的变量，来限制该class能添加的属性：
   
   
   
   
   
   
   
   而后，咱们试试：
   
   
   
   
   
   
   
   因为没有被放到中，因此不能绑定属性，试图绑定将获得AttributeError的错误。
   
   
   
   使用要注意，定义的属性仅对当前类起做用，对继承的子类是不起做用的：
   
   
   
   
   
   
   
   除非在子类中也定义，这样，子类容许定义的属性就是自身的加上父类的。
   
   
   
   
   
   
   
   使用@property
   
   
   
   

   
   
   
   
  
  
  
  
在绑定属性时，若是咱们直接把属性暴露出去，虽然写起来很简单，可是，没办法检查参数，致使能够把成绩随便改：
这显然不合逻辑。为了限制score的范围，能够经过一个方法来设置成绩，再经过一个来获取成绩，这样，在方法里，就能够检查参数：
   
   
   
   
    
    
    
    Try
   
   
   
   
如今，对任意的Student实例进行操做，就不能为所欲为地设置score了：
可是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。
有没有既能检查参数，又能够用相似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来讲，这是必需要作到的！
还记得装饰器（decorator）能够给函数动态加上功能吗？对于类的方法，装饰器同样起做用。Python内置的装饰器就是负责把一个方法变成属性调用的：
的实现比较复杂，咱们先考察如何使用。把一个getter方法变成属性，只须要加上就能够了，此时，自己又建立了另外一个装饰器，负责把一个setter方法变成属性赋值，因而，咱们就拥有一个可控的属性操做：
注意到这个神奇的，咱们在对实例属性操做的时候，就知道该属性极可能不是直接暴露的，而是经过getter和setter方法来实现的。
还能够定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：
上面的是可读写属性，而就是一个只读属性，由于能够根据和当前时间计算出来。
小结
普遍应用在类的定义中，可让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减小了出错的可能性。
  
  
  def calc(numbers):     sum = 0     for n in numbers:         sum = sum + n * n     return sum可是调用时须要先组装出一个list或者tuple
  
 
  calc([1, 2, 3])  

 
   
   
   

  
 
  calc((1, 3, 5, 7))  
 
  在参数numbers前面加个*，就变为可变参数，调用时就不须组装list和tuple 

 
   
   
   

  
 
  
      
      
      
   
     
      
    
def calc(*numbers):
calc(1,2,3)
calc()
此时若已有list或者tuple，能够这样调取
nums=[1,2,3]
calc(*nums)
关键字参数
       
       
       
    
     
        
        
        
     
      def person(name, age, **kw):     print 'name:', name, 'age:', age, 'other:', kw 
       
       
       
    
     
       
       
       
    
     
        
        
        
     
      person('Michael', 30)            //结果为：name: Michael age: 30 other: {} 
       
       
       
    
     
       
       
       
    
     
        
        
        
     
       kw = {'city': 'Beijing', 'job': 'Engineer'}
        
        
        
     
      person('Jack', 24, **kw)         //结果为：name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} 
       
       
       
    
     
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既能够直接传入：func(1, 2, 3)，又能够先组装list或tuple，再经过*args传入：func(*(1, 2, 3))；
关键字参数既能够直接传入：func(a=1, b=2)，又能够先组装dict，再经过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，固然也能够用其余参数名，但最好使用习惯用法。

递归函数
       
       
       
    
     
        
        
        
     
      def fact(n):     if n==1:         return 1     return n * fact(n - 1)
       
       
       
    
     
使用递归函数须要注意防止栈溢出。在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出
解决递归调用栈溢出的方法是经过尾递归优化，事实上尾递归和循环的效果是同样的，因此，把循环当作是一种特殊的尾递归函数也是能够的。
尾递归是指，在函数返回的时候，调用自身自己，而且，return语句不能包含表达式。这样，编译器或者解释器就能够把尾递归作优化，使递归自己不管调用多少次，都只占用一个栈帧，不会出现栈溢出的状况。
切片
L=[1,2,3,4,5,6,7,8]
L[0:3]                    //结果为：[1,2,3],从索引0开始取，直到取到索引3，但不包括索引3
L[:3]                     //结果为：[1,2,3]，索引0可省略
L[-8:]                    //结果为：[1,2,3,4,5,6,7,8],从倒数第八个开始取，冒号后省略就取到最后一个
L[::2]                    //结果为：[1,3,5,7],第三个参数是每隔几个取一个 

 'ABCDEFG'[1:5:2]          //结果为：'BD',可对字符串进行切片calc([1, 2, 3])calc((1, 3, 5, 7))
  
 
   

 
def calc(*numbers):
calc(1,2,3)
calc()
此时若已有list或者tuple，能够这样调取
nums=[1,2,3]
calc(*nums)
关键字参数
       
       
       
 
  
        
        
        
  
   def person(name, age, **kw):     print 'name:', name, 'age:', age, 'other:', kw 
       
       
       
 
  
       
       
       
 
  
        
        
        
  
   person('Michael', 30)            //结果为：name: Michael age: 30 other: {} 
       
       
       
 
  
       
       
       
 
  
        
        
        
  
    kw = {'city': 'Beijing', 'job': 'Engineer'}
        
        
        
  
   person('Jack', 24, **kw)         //结果为：name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} 
       
       
       
 
  
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既能够直接传入：func(1, 2, 3)，又能够先组装list或tuple，再经过*args传入：func(*(1, 2, 3))；
关键字参数既能够直接传入：func(a=1, b=2)，又能够先组装dict，再经过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，固然也能够用其余参数名，但最好使用习惯用法。

递归函数
       
       
       
 
  
        
        
        
  
   def fact(n):     if n==1:         return 1     return n * fact(n - 1)
       
       
       
 
  
使用递归函数须要注意防止栈溢出。在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出
解决递归调用栈溢出的方法是经过尾递归优化，事实上尾递归和循环的效果是同样的，因此，把循环当作是一种特殊的尾递归函数也是能够的。
尾递归是指，在函数返回的时候，调用自身自己，而且，return语句不能包含表达式。这样，编译器或者解释器就能够把尾递归作优化，使递归自己不管调用多少次，都只占用一个栈帧，不会出现栈溢出的状况。
切片
L=[1,2,3,4,5,6,7,8]
L[0:3]                    //结果为：[1,2,3],从索引0开始取，直到取到索引3，但不包括索引3
L[:3]                     //结果为：[1,2,3]，索引0可省略
L[-8:]                    //结果为：[1,2,3,4,5,6,7,8],从倒数第八个开始取，冒号后省略就取到最后一个
L[::2]                    //结果为：[1,3,5,7],第三个参数是每隔几个取一个
def calc(*numbers):calc(1,2,3)calc()def person(name, age, **kw):     print 'name:', name, 'age:', age, 'other:', kwperson('Michael', 30)            //结果为：name: Michael age: 30 other: {}kw = {'city': 'Beijing', 'job': 'Engineer'}person('Jack', 24, **kw)         //结果为：name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}*args**kwfunc(1, 2, 3)*argsfunc(*(1, 2, 3))func(a=1, b=2)**kwfunc(**{'a': 1, 'b': 2})*args**kwdef fact(n):     if n==1:         return 1     return n * fact(n - 1)迭代若是给定一个list或tuple，咱们能够经过for循环来遍历这个list或tuple，这种遍历咱们称为迭代（Iteration）。
默认状况下，dict迭代的是key:

   
   
   

  
 
  d = {'a': 1, 'b': 2, 'c': 3} for key in d:     print key a c b  
 
  若是要迭代value能够用for value in d.itervalues()，若是要同时迭代key和value，能够用for k, v in d.iteritems()。 

 
字符串也可迭代

   
   
   

  
 
  那么，如何判断一个对象是可迭代对象呢？方法是经过collections模块的Iterable类型判断： 
 
  >>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True  

 
   
   
   

  
 
  最后一个小问题，若是要对list实现相似Java那样的下标循环怎么办？Python内置的enumerate函数能够把一个list变成索引-元素对，这样就能够在for循环中同时迭代索引和元素自己： 
 
  >>> for i, value in enumerate(['A', 'B', 'C']): ...     print i, value ... 0 A 1 B 2 C  
 
  
      
      
      
   
     
     列表生成式 
     range（1，11）即为list[1,2,3,4,5,6,7,8,9,10] 
    
      
      
      
   
     
      
       
       >>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]  
       for循环后面还能够加上if判断，这样咱们就能够筛选出仅偶数的平方： 
       
       
       >>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]  
       还可使用两层循环，能够生成全排列： 
       
       
       >>> [m + n for m in 'ABC' for n in 'XYZ'] ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']  
       
       
       >>> d = {'x': 'A', 'y': 'B', 'z': 'C' } >>> [k + '=' + v for k, v in d.iteritems()] ['y=B', 'x=A', 'z=C']  
      
生成器 
    
      
      
      
   
     
      
       
       经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。 
       因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。 
       要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator： 
       >>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x104feab40> 
       建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。 
       咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？ 
       若是要一个一个打印出来，能够经过generator的next()方法： 
       >>> g.next() 0 >>> g.next() 1 >>> g.next() 4 >>> g.next() 9 >>> g.next() 16 >>> g.next() 25 >>> g.next() 36 >>> g.next() 49 >>> g.next() 64 >>> g.next() 81  
       
       
       咱们讲过，generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。 
       固然，上面这种不断调用next()方法实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象： 
       >>> g = (x * x for x in range(10)) >>> for n in g: ...     print n ... 0 1 4 9 16 25 36 49 64 81  
       
       
       斐波拉契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易： 
       def fib(max):     n, a, b = 0, 0, 1     while n < max:         print b         a, b = b, a + b         n = n + 1  
       
       
       >>> fib(6) 1 1 2 3 5 8  
       
       
       仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。 
       也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print b改成yield b就能够了： 
       def fib(max):     n, a, b = 0, 0, 1     while n < max:         yield b         a, b = b, a + b         n = n + 1 
       这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator： 
       >>> fib(6) <generator object fib at 0x104feaaa0> 
       这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。 
       举个简单的例子，定义一个generator，依次返回数字1，3，5： 
       >>> def odd(): ...     print 'step 1' ...     yield 1 ...     print 'step 2' ...     yield 3 ...     print 'step 3' ...     yield 5 ... >>> o = odd() >>> o.next() step 1 1 >>> o.next() step 2 3 >>> o.next() step 3 5  
      
变量可指向变量 
    
      
      
      
   
    
      f=abs 
    
      
      
      
   
    
      f(-10)结果为10 
    
既然变量能够指向函数，函数的参数能接收变量，那么一个函数就能够接收另外一个函数做为参数，这种函数就称之为高阶函数。

 

 
   
   
   

  
 
  map/reduce 

 
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次做用到序列的每一个元素，并把结果做为新的list返回。
如
def f(x):
 return x*x
map(f,range(10))
   
   
   

  
 
  map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])  

 
再看reduce的用法。reduce把一个函数做用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素作累积计算，其效果就是：
   
   
   

  
 
  reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)  

 

   
   
   

  
 
  比方说对一个序列求和，就能够用reduce实现： 
 
  >>> def add(x, y): ...     return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25  

 首字母大写   'LING'.capitalize()相似的还有大小写upper(),lower()ford = {'a': 1, 'b': 2, 'c': 3} for key in d:     print key a c bfor value in d.itervalues()for k, v in d.iteritems()>>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 Trueenumeratefor>>> for i, value in enumerate(['A', 'B', 'C']): ...     print i, value ... 0 A 1 B 2 C
  
 
  列表生成式 
 
  range（1，11）即为list[1,2,3,4,5,6,7,8,9,10] 

 
      
      
      

  
 
   
    
    >>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]  
    for循环后面还能够加上if判断，这样咱们就能够筛选出仅偶数的平方： 
    
    
    >>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]  
    还可使用两层循环，能够生成全排列： 
    
    
    >>> [m + n for m in 'ABC' for n in 'XYZ'] ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']  
    
    
    >>> d = {'x': 'A', 'y': 'B', 'z': 'C' } >>> [k + '=' + v for k, v in d.iteritems()] ['y=B', 'x=A', 'z=C']  
   
生成器 

 
      
      
      

  
 
   
    
    经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。 
    因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。 
    要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator： 
    >>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x104feab40> 
    建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。 
    咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？ 
    若是要一个一个打印出来，能够经过generator的next()方法： 
    >>> g.next() 0 >>> g.next() 1 >>> g.next() 4 >>> g.next() 9 >>> g.next() 16 >>> g.next() 25 >>> g.next() 36 >>> g.next() 49 >>> g.next() 64 >>> g.next() 81  
    
    
    咱们讲过，generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。 
    固然，上面这种不断调用next()方法实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象： 
    >>> g = (x * x for x in range(10)) >>> for n in g: ...     print n ... 0 1 4 9 16 25 36 49 64 81  
    
    
    斐波拉契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易： 
    def fib(max):     n, a, b = 0, 0, 1     while n < max:         print b         a, b = b, a + b         n = n + 1  
    
    
    >>> fib(6) 1 1 2 3 5 8  
    
    
    仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。 
    也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print b改成yield b就能够了： 
    def fib(max):     n, a, b = 0, 0, 1     while n < max:         yield b         a, b = b, a + b         n = n + 1 
    这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator： 
    >>> fib(6) <generator object fib at 0x104feaaa0> 
    这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。 
    举个简单的例子，定义一个generator，依次返回数字1，3，5： 
    >>> def odd(): ...     print 'step 1' ...     yield 1 ...     print 'step 2' ...     yield 3 ...     print 'step 3' ...     yield 5 ... >>> o = odd() >>> o.next() step 1 1 >>> o.next() step 2 3 >>> o.next() step 3 5  
   
变量可指向变量 

 
      
      
      

 
  
  f=abs 

 
      
      
      

 
  
  f(-10)结果为10 

 
既然变量能够指向函数，函数的参数能接收变量，那么一个函数就能够接收另外一个函数做为参数，这种函数就称之为高阶函数。

>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]for循环后面还能够加上if判断，这样咱们就能够筛选出仅偶数的平方：
>>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]还可使用两层循环，能够生成全排列：
>>> [m + n for m in 'ABC' for n in 'XYZ'] ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']>>> d = {'x': 'A', 'y': 'B', 'z': 'C' } >>> [k + '=' + v for k, v in d.iteritems()] ['y=B', 'x=A', 'z=C'][]()>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x104feab40>Lg[]()Lgnext()>>> g.next() 0 >>> g.next() 1 >>> g.next() 4 >>> g.next() 9 >>> g.next() 16 >>> g.next() 25 >>> g.next() 36 >>> g.next() 49 >>> g.next() 64 >>> g.next() 81next()next()for>>> g = (x * x for x in range(10)) >>> for n in g: ...     print n ... 0 1 4 9 16 25 36 49 64 81def fib(max):     n, a, b = 0, 0, 1     while n < max:         print b         a, b = b, a + b         n = n + 1>>> fib(6) 1 1 2 3 5 8fibfibprint byield bdef fib(max):     n, a, b = 0, 0, 1     while n < max:         yield b         a, b = b, a + b         n = n + 1yield>>> fib(6) <generator object fib at 0x104feaaa0>next()yieldyield>>> def odd(): ...     print 'step 1' ...     yield 1 ...     print 'step 2' ...     yield 3 ...     print 'step 3' ...     yield 5 ... >>> o = odd() >>> o.next() step 1 1 >>> o.next() step 2 3 >>> o.next() step 3 5map()mapmap(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)>>> def add(x, y): ...     return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25Python内建的filter()函数用于过滤序列。
和map()相似，filter()也接收一个函数和一个序列。和map()不一样的时，filter()把传入的函数依次做用于每一个元素，而后根据返回值是True仍是False决定保留仍是丢弃该元素。
排序算法filter()map()filter()map()filter()TrueFalse一般规定，对于两个元素x和y，若是认为x < y，则返回-1，若是认为x == y，则返回0，若是认为x > y，则返回1xyx < y-1x == y0x > y1
  
 
  >>> sorted([36, 5, 12, 9, 21]) [5, 9, 12, 21, 36]  

 
   
   
   

  
 
  此外，sorted()函数也是一个高阶函数，它还能够接收一个比较函数来实现自定义的排序。好比，若是要倒序排序，咱们就能够自定义一个reversed_cmp函数： 
 
  def reversed_cmp(x, y):     if x > y:         return -1     if x < y:         return 1     return 0  
 
  
      
      
      
   
     
     传入自定义的比较函数reversed_cmp，就能够实现倒序排序： 
     >>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]  
     返回函数 
     
         
         
         
      
        
        def lazy_sum(*args):     def sum():         ax = 0         for n in args:             ax = ax + n         return ax     return sum 
        当咱们调用lazy_sum()时，返回的并非求和结果，而是求和函数： 
        >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function sum at 0x10452f668> 
        调用函数f时，才真正计算求和的结果： 
        >>> f() 25 
        在这个例子中，咱们在函数lazy_sum中又定义了函数sum，而且，内部函数sum能够引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。 
        请再注意一点，当咱们调用lazy_sum()时，每次调用都会返回一个新的函数，即便传入相同的参数： 
        >>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False  
       
匿名函数 
     
         
         
         
      
        
        map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 
       
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。
装饰器
def now():    
         print '2015-3-28' 
     f=now 
     f()     
     f.__name__                        //结果为：'now',函数对象有个__name__属性，能够拿到函数的名字 
     
 
     在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式须要经过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator能够用函数实现，也能够用类实现。
decorator能够加强函数的功能，定义起来虽然有点复杂，但使用起来很是灵活和方便。
如今，假设咱们要加强now()函数的功能，好比，在函数调用先后自动打印日志，但又不但愿修改now()函数的定义，这种在代码运行期间动态增长功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。因此，咱们要定义一个能打印日志的decorator，能够定义以下：
        
        
        
     
      
         
         
         
      
       def log(func):     def wrapper(*args, **kw):         print 'call %s():' % func.__name__         return func(*args, **kw)     return wrapper 
        
        
        
     
      
        
        
        
     
      
         
         
         
      
       观察上面的log，由于它是一个decorator，因此接受一个函数做为参数，并返回一个函数。咱们要借助Python的@语法，把decorator置于函数的定义处：
         
         
         
      
       @log def now():     print '2013-12-25' 
        
        
        
     
      
        
        
        
     
      
         
         
         
      
       调用now()函数，不只会运行now()函数自己，还会在运行now()函数前打印一行日志：
         
         
         
      
       >>> now() call now(): 2013-12-25
         
         
         
      
       把@log放到now()函数的定义处，至关于执行了语句：
         
         
         
      
       now = log(now) 
        
        
        
     
      
因为log()是一个decorator，返回一个函数，因此，原来的now()函数仍然存在，只是如今同名的now变量指向了新的函数，因而调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，所以，wrapper()函数能够接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
若是decorator自己须要传入参数，那就须要编写一个返回decorator的高阶函数，写出来会更复杂。 
     

 >>> sorted([36, 5, 12, 9, 21]) [5, 9, 12, 21, 36]sorted()reversed_cmpdef reversed_cmp(x, y):     if x > y:         return -1     if x < y:         return 1     return 0
  
 
  传入自定义的比较函数reversed_cmp，就能够实现倒序排序： 
 
  >>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]  
 
  返回函数 
 
  
         
         
         
   
     
     def lazy_sum(*args):     def sum():         ax = 0         for n in args:             ax = ax + n         return ax     return sum 
     当咱们调用lazy_sum()时，返回的并非求和结果，而是求和函数： 
     >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function sum at 0x10452f668> 
     调用函数f时，才真正计算求和的结果： 
     >>> f() 25 
     在这个例子中，咱们在函数lazy_sum中又定义了函数sum，而且，内部函数sum能够引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。 
     请再注意一点，当咱们调用lazy_sum()时，每次调用都会返回一个新的函数，即便传入相同的参数： 
     >>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False  
    
匿名函数 
 
  
         
         
         
   
     
     map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 
    
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。
装饰器
def now():    
 
      print '2015-3-28' 
 
  f=now 
 
  f()     
 
  f.__name__                        //结果为：'now',函数对象有个__name__属性，能够拿到函数的名字 
 
  
 
 
  在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式须要经过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator能够用函数实现，也能够用类实现。
decorator能够加强函数的功能，定义起来虽然有点复杂，但使用起来很是灵活和方便。
如今，假设咱们要加强now()函数的功能，好比，在函数调用先后自动打印日志，但又不但愿修改now()函数的定义，这种在代码运行期间动态增长功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。因此，咱们要定义一个能打印日志的decorator，能够定义以下：
        
        
        
  
   
         
         
         
   
    def log(func):     def wrapper(*args, **kw):         print 'call %s():' % func.__name__         return func(*args, **kw)     return wrapper 
        
        
        
  
   
        
        
        
  
   
         
         
         
   
    观察上面的log，由于它是一个decorator，因此接受一个函数做为参数，并返回一个函数。咱们要借助Python的@语法，把decorator置于函数的定义处：
         
         
         
   
    @log def now():     print '2013-12-25' 
        
        
        
  
   
        
        
        
  
   
         
         
         
   
    调用now()函数，不只会运行now()函数自己，还会在运行now()函数前打印一行日志：
         
         
         
   
    >>> now() call now(): 2013-12-25
         
         
         
   
    把@log放到now()函数的定义处，至关于执行了语句：
         
         
         
   
    now = log(now) 
        
        
        
  
   
因为log()是一个decorator，返回一个函数，因此，原来的now()函数仍然存在，只是如今同名的now变量指向了新的函数，因而调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，所以，wrapper()函数能够接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
若是decorator自己须要传入参数，那就须要编写一个返回decorator的高阶函数，写出来会更复杂。 

 reversed_cmp>>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]返回函数
  
 
  def lazy_sum(*args):     def sum():         ax = 0         for n in args:             ax = ax + n         return ax     return sum 
 
  当咱们调用lazy_sum()时，返回的并非求和结果，而是求和函数： 
 
  >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function sum at 0x10452f668> 
 
  调用函数f时，才真正计算求和的结果： 
 
  >>> f() 25 
 
  在这个例子中，咱们在函数lazy_sum中又定义了函数sum，而且，内部函数sum能够引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。 
 
  请再注意一点，当咱们调用lazy_sum()时，每次调用都会返回一个新的函数，即便传入相同的参数： 
 
  >>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False  

 匿名函数def lazy_sum(*args):     def sum():         ax = 0         for n in args:             ax = ax + n         return ax     return sumlazy_sum()>>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function sum at 0x10452f668>f>>> f() 25lazy_sumsumsumlazy_sumlazy_sumsumlazy_sum()>>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False
  
 
  map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 

 
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。
装饰器
def now():map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])lambdaxreturnprint '2015-3-28'now()now()def log(func):     def wrapper(*args, **kw):         print 'call %s():' % func.__name__         return func(*args, **kw)     return wrapperlog@log def now():     print '2013-12-25'now()now()now()>>> now() call now(): 2013-12-25@lognow()now = log(now)log()now()now()log()wrapper()wrapper()(*args, **kw)wrapper()wrapper()一个完整的decorator的写法以下：
import functools  def log(func):     @functools.wraps(func)     def wrapper(*args, **kw):         print 'call %s():' % func.__name__         return func(*args, **kw)     return wrapper
import functools  def log(text):     def decorator(func):         @functools.wraps(func)         def wrapper(*args, **kw):             print '%s %s():' % (text, func.__name__)             return func(*args, **kw)         return wrapper     return decorator 
import functools是导入functools模块。模块的概念稍候讲解。如今，只需记住在定义wrapper()的前面加上@functools.wraps(func)便可。
偏函数
functools.partial就是帮助咱们建立一个偏函数的，不须要咱们本身定义int2()，能够直接使用下面的代码建立一个新的函数int2：
>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85
因此，简单总结functools.partial的做用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
import functools  def log(func):     @functools.wraps(func)     def wrapper(*args, **kw):         print 'call %s():' % func.__name__         return func(*args, **kw)     return wrapperimport functools  def log(text):     def decorator(func):         @functools.wraps(func)         def wrapper(*args, **kw):             print '%s %s():' % (text, func.__name__)             return func(*args, **kw)         return wrapper     return decoratorimport functoolsfunctoolswrapper()@functools.wraps(func)functools.partialint2()int2>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85functools.partial模块#!/usr/bin/env python # -*- coding: utf-8 -*-  ' a test module '  __author__ = 'Michael Liao'  import sys  def test():     args = sys.argv     if len(args)==1:         print 'Hello, world!'     elif len(args)==2:         print 'Hello, %s!' % args[1]     else:         print 'Too many arguments!'  if __name__=='__main__':     test() 
第1行和第2行是标准注释，第1行注释可让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件自己使用标准UTF-8编码；
第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
第6行使用__author__变量把做者写进去，这样当你公开源代码后别人就能够瞻仰你的大名；
以上就是Python模块的标准文件模板，固然也能够所有删掉不写，可是，按标准办事确定没错。
后面开始就是真正的代码部分。
你可能注意到了，使用sys模块的第一步，就是导入该模块：
import sys 
导入sys模块后，咱们就有了变量sys指向该模块，利用sys这个变量，就能够访问sys模块的全部功能。
sys模块有一个argv变量，用list存储了命令行的全部参数。argv至少有一个元素，由于第一个参数永远是该.py文件的名称，例如：
运行python hello.py得到的sys.argv就是['hello.py']；
运行python hello.py Michael得到的sys.argv就是['hello.py', 'Michael]。
最后，注意到这两行代码：
if __name__=='__main__':     test() 
当咱们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而若是在其余地方导入该hello模块时，if判断将失败，所以，这种if测试可让一个模块经过命令行运行时执行一些额外的代码，最多见的就是运行测试。
咱们能够用命令行运行hello.py看看效果：
$ python hello.py Hello, world! $ python hello.py Michael Hello, Michael! 
若是启动Python交互环境，再导入hello模块：
$ python Python 2.7.5 (default, Aug 25 2013, 00:04:04)  [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import hello >>> 
导入时，没有打印Hello, word!，由于没有执行test()函数。
调用hello.test()时，才能打印出Hello, word!：
>>> hello.test() Hello, world!
别名
导入模块时，还可使用别名，这样，能够在运行时根据当前环境选择最合适的模块。好比Python标准库通常会提供StringIO和cStringIO两个库，这两个库的接口和功能是同样的，可是cStringIO是C写的，速度更快，因此，你会常常看到这样的写法：
try:     import cStringIO as StringIO except ImportError: # 导入失败会捕获到ImportError     import StringIO 
这样就能够优先导入cStringIO。若是有些平台不提供cStringIO，还能够降级使用StringIO。导入cStringIO时，用import ... as ...指定了别名StringIO，所以，后续代码引用StringIO便可正常工做。
还有相似simplejson这样的库，在Python 2.6以前是独立的第三方库，从2.6开始内置，因此，会有这样的写法：
try:     import json # python >= 2.6 except ImportError:     import simplejson as json # python <= 2.5 
因为Python是动态语言，函数签名一致接口就同样，所以，不管导入哪一个模块后续代码都能正常工做。
若是采用面向对象的程序设计思想，咱们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。若是要打印一个学生的成绩，首先必须建立出这个学生对应的对象，而后，给对象发一个print_score消息，让对象本身把本身的数据打印出来。
class Student(object):      def __init__(self, name, score):         self.name = name         self.score = score      def print_score(self):         print '%s: %s' % (self.name, self.score) 
     
     
     
  
   
      
      
      
   
    Try
     
     
     
  
   
给对象发消息实际上就是调用对象对应的关联函数，咱们称之为对象的方法（Method）。面向对象的程序写出来就像这样：
bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score() 
面向对象的设计思想是从天然界中来的，由于在天然界中，类（Class）和实例（Instance）的概念是很天然的。Class是一种抽象概念，好比咱们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，好比，Bart Simpson和Lisa Simpson是两个具体的Student：
因此，面向对象的设计思想是抽象出Class，根据Class建立Instance。
面向对象的抽象程度又比函数要高，由于一个Class既包含数据，又包含操做数据的方法。
数据封装、继承和多态是面向对象的三大特色。
类和实例#!/usr/bin/env python # -*- coding: utf-8 -*-  ' a test module '  __author__ = 'Michael Liao'  import sys  def test():     args = sys.argv     if len(args)==1:         print 'Hello, world!'     elif len(args)==2:         print 'Hello, %s!' % args[1]     else:         print 'Too many arguments!'  if __name__=='__main__':     test()hello.py__author__sysimport syssyssyssyssyssysargvargvpython hello.pysys.argv['hello.py']python hello.py Michaelsys.argv['hello.py', 'Michael]if __name__=='__main__':     test()hello__name____main__helloififhello.py$ python hello.py Hello, world! $ python hello.py Michael Hello, Michael!hello$ python Python 2.7.5 (default, Aug 25 2013, 00:04:04)  [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import hello >>>Hello, word!test()hello.test()Hello, word!>>> hello.test() Hello, world!StringIOcStringIOcStringIOtry:     import cStringIO as StringIO except ImportError: # 导入失败会捕获到ImportError     import StringIOcStringIOcStringIOStringIOcStringIOimport ... as ...StringIOStringIOsimplejsontry:     import json # python >= 2.6 except ImportError:     import simplejson as json # python <= 2.5Studentnamescoreprint_scoreclass Student(object):      def __init__(self, name, score):         self.name = name         self.score = score      def print_score(self):         print '%s: %s' % (self.name, self.score)bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score()class Student(object):     passclassStudent(object)objectStudentStudentStudent>>> bart = Student() >>> bart <__main__.Student object at 0x10a67a590> >>> Student <class '__main__.Student'>bart0x10a67a590Studentbartname>>> bart.name = 'Bart Simpson' >>> bart.name 'Bart Simpson'__init__namescoreclass Student(object):      def __init__(self, name, score):         self.name = name         self.score = score__init__self__init__selfself__init____init__self>>> bart = Student('Bart Simpson', 59) >>> bart.name 'Bart Simpson' >>> bart.score 59selfStudentnamescore>>> def print_score(std): ...     print '%s: %s' % (std.name, std.score) ... >>> print_score(bart) Bart Simpson: 59StudentStudentStudentclass Student(object):      def __init__(self, name, score):         self.name = name         self.score = score      def print_score(self):         print '%s: %s' % (self.name, self.score)selfself>>> bart.print_score() Bart Simpson: 59StudentnamescoreStudentStudentget_gradeclass Student(object):     ...      def get_grade(self):         if self.score >= 90:             return 'A'         elif self.score >= 60:             return 'B'         else:             return 'C'get_grade>>> bart.get_grade() 'C'>>> bart = Student('Bart Simpson', 59) >>> lisa = Student('Lisa Simpson', 87) >>> bart.age = 8 >>> bart.age 8 >>> lisa.age Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute 'age'namescore>>> bart = Student('Bart Simpson', 98) >>> bart.score 98 >>> bart.score = 59 >>> bart.score 59____class Student(object):      def __init__(self, name, score):         self.__name = name         self.__score = score      def print_score(self):         print '%s: %s' % (self.__name, self.__score)实例变量.__name实例变量.__score>>> bart = Student('Bart Simpson', 98) >>> bart.__name Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute '__name'get_nameget_scoreclass Student(object):     ...      def get_name(self):         return self.__name      def get_score(self):         return self.__scoreset_scoreclass Student(object):     ...      def set_score(self, score):         self.__score = scorebart.score = 59class Student(object):     ...      def set_score(self, score):         if 0 <= score <= 100:             self.__score = score         else:             raise ValueError('bad score')__xxx____name____score___name__name__name_Student__name_Student__name__name>>> bart._Student__name 'Bart Simpson'__nameAnimalrun()class Animal(object):     def run(self):         print 'Animal is running...'class Dog(Animal):     pass  class Cat(Animal):     passrun()run()dog = Dog() dog.run()  cat = Cat() cat.run()Animal is running... Animal is running...class Dog(Animal):     def run(self):         print 'Dog is running...'     def eat(self):         print 'Eating meat...'run()Animal is running...Dog is running...Cat is running...class Dog(Animal):     def run(self):         print 'Dog is running...'  class Cat(Animal):     def run(self):         print 'Cat is running...'Dog is running... Cat is running...run()run()run()run()a = list() # a是list类型 b = Animal() # b是Animal类型 c = Dog() # c是Dog类型isinstance()>>> isinstance(a, list) True >>> isinstance(b, Animal) True >>> isinstance(c, Dog) True>>> isinstance(c, Animal) Trueccc>>> b = Animal() >>> isinstance(b, Dog) Falsedef run_twice(animal):     animal.run()     animal.run()run_twice()>>> run_twice(Animal()) Animal is running... Animal is running...run_twice()>>> run_twice(Dog()) Dog is running... Dog is running...run_twice()>>> run_twice(Cat()) Cat is running... Cat is running...class Tortoise(Animal):     def run(self):         print 'Tortoise is running slowly...'>>> run_twice(Tortoise()) Tortoise is running slowly... Tortoise is running slowly...run()run()run()run()run()run_twice()type()type()>>> type(123) <type 'int'> >>> type('str') <type 'str'> >>> type(None) <type 'NoneType'>type()>>> type(abs) <type 'builtin_function_or_method'> >>> type(a) <class '__main__.Animal'>type()if>>> type(123)==type(456) True >>> type('abc')==type('123') True >>> type('abc')==type(123) Falsetypes>>> import types >>> type('abc')==types.StringType True >>> type(u'abc')==types.UnicodeType True >>> type([])==types.ListType True >>> type(str)==types.TypeType TrueTypeTypeTypeType>>> type(int)==type(str)==types.TypeType Trueisinstance()object -> Animal -> Dog -> Huskyisinstance()>>> a = Animal() >>> d = Dog() >>> h = Husky()>>> isinstance(h, Husky) Trueh>>> isinstance(h, Dog) Truehhisinstance()h>>> isinstance(h, Animal) Trued>>> isinstance(d, Dog) and isinstance(d, Animal) Trued>>> isinstance(d, Husky) Falsetype()isinstance()>>> isinstance('a', str) True >>> isinstance(u'a', unicode) True >>> isinstance('a', unicode) False>>> isinstance('a', (str, unicode)) True >>> isinstance(u'a', (str, unicode)) Truestrunicodebasestring>>> isinstance(u'a', basestring) Truedir()>>> dir('ABC') ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']__xxx____len__len()len()__len__()>>> len('ABC') 3 >>> 'ABC'.__len__() 3len(myObj)__len__()>>> class MyObject(object): ...     def __len__(self): ...         return 100 ... >>> obj = MyObject() >>> len(obj) 100lower()>>> 'ABC'.lower() 'abc'getattr()setattr()hasattr()>>> class MyObject(object): ...     def __init__(self): ...         self.x = 9 ...     def power(self): ...         return self.x * self.x ... >>> obj = MyObject()>>> hasattr(obj, 'x') # 有属性'x'吗？ True >>> obj.x 9 >>> hasattr(obj, 'y') # 有属性'y'吗？ False >>> setattr(obj, 'y', 19) # 设置一个属性'y' >>> hasattr(obj, 'y') # 有属性'y'吗？ True >>> getattr(obj, 'y') # 获取属性'y' 19 >>> obj.y # 获取属性'y' 19>>> getattr(obj, 'z') # 获取属性'z' Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'MyObject' object has no attribute 'z'>>> getattr(obj, 'z', 404) # 获取属性'z'，若是不存在，返回默认值404 404>>> hasattr(obj, 'power') # 有属性'power'吗？ True >>> getattr(obj, 'power') # 获取属性'power' <bound method MyObject.power of <__main__.MyObject object at 0x108ca35d0>> >>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn >>> fn # fn指向obj.power <bound method MyObject.power of <__main__.MyObject object at 0x108ca35d0>> >>> fn() # 调用fn()与调用obj.power()是同样的 81sum = obj.x + obj.ysum = getattr(obj, 'x') + getattr(obj, 'y')def readImage(fp):     if hasattr(fp, 'read'):         return readData(fp)     return Nonehasattr()read()read()>>> class Student(object): ...     pass ...>>> s = Student() >>> s.name = 'Michael' # 动态给实例绑定一个属性 >>> print s.name Michael>>> def set_age(self, age): # 定义一个函数做为实例方法 ...     self.age = age ... >>> from types import MethodType >>> s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法 >>> s.set_age(25) # 调用实例方法 >>> s.age # 测试结果 25>>> s2 = Student() # 建立新的实例 >>> s2.set_age(25) # 尝试调用方法 Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute 'set_age'>>> def set_score(self, score): ...     self.score = score ... >>> Student.set_score = MethodType(set_score, None, Student)>>> s.set_score(100) >>> s.score 100 >>> s2.set_score(99) >>> s2.score 99set_scorenameage__slots__>>> class Student(object): ...     __slots__ = ('name', 'age') # 用tuple定义容许绑定的属性名称 ...>>> s = Student() # 建立新的实例 >>> s.name = 'Michael' # 绑定属性'name' >>> s.age = 25 # 绑定属性'age' >>> s.score = 99 # 绑定属性'score' Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute 'score''score'__slots__scorescore__slots____slots__>>> class GraduateStudent(Student): ...     pass ... >>> g = GraduateStudent() >>> g.score = 9999__slots____slots____slots__s = Student() s.score = 9999set_score()get_score()set_score()class Student(object):      def get_score(self):         return self._score      def set_score(self, value):         if not isinstance(value, int):             raise ValueError('score must be an integer!')         if value < 0 or value > 100:             raise ValueError('score must between 0 ~ 100!')         self._score = value>>> s = Student() >>> s.set_score(60) # ok! >>> s.get_score() 60 >>> s.set_score(9999) Traceback (most recent call last):   ... ValueError: score must between 0 ~ 100!@propertyclass Student(object):      @property     def score(self):         return self._score      @score.setter     def score(self, value):         if not isinstance(value, int):             raise ValueError('score must be an integer!')         if value < 0 or value > 100:             raise ValueError('score must between 0 ~ 100!')         self._score = value@property@property@property@score.setter>>> s = Student() >>> s.score = 60 # OK，实际转化为s.set_score(60) >>> s.score # OK，实际转化为s.get_score() 60 >>> s.score = 9999 Traceback (most recent call last):   ... ValueError: score must between 0 ~ 100!@propertyclass Student(object):      @property     def birth(self):         return self._birth      @birth.setter     def birth(self, value):         self._birth = value      @property     def age(self):         return 2014 - self._birthbirthageagebirth@property

Python学习笔记 for windows 二

数据封装

小结

访问限制

继承和多态

获取对象信息

使用type()

使用isinstance()

使用dir()

小结

使用slots

使用slots

使用@property

小结

列表生成式

range（1，11）即为list[1,2,3,4,5,6,7,8,9,10]

map/reduce

列表生成式

range（1，11）即为list[1,2,3,4,5,6,7,8,9,10]

别名