python 二——函数、装饰器、生成器、面向对象编程（初级）

本节内容

1、函数

2、装饰器

3、生成器

4、类

一、函数

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

def 函数名(参数):
 
    ...
    函数体
    ...
    返回值
---------------------------------
函数的定义主要有如下要点：
 
def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。

1、返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

2、参数

函数的有三中不同的参数：

普通参数
默认参数
动态参数

# name 叫做函数func的形式参数，简称：形参
def func(name):
    print name
 
# ######### 执行函数 #########
#  'wupeiqi' 叫做函数func的实际参数，简称：实参
func('wupeiqi')
 
----------------------------------------------
def func(name, age = 18):
 
    print "%s:%s" %(name,age)
 
# 指定参数
func('wupeiqi', 19)
 
# 使用默认参数
func('alex')
 
注：默认参数需要放在参数列表最后
 
------------------动态参数------------------------------
def func(*args, **kwargs):
 
    print args
    print kwargs

　二、装饰器

需要给原函数增加附加功能，但是又不改变源代码，同时不能修改调用方式的时候，可以用装饰器。

不带参数的装饰器
import time
 
def timer(func):
    def deco():
        print('deco start')
        func()#注意括号！
        print('deco end')
    return deco
 
@timer    　　　　# 等同于 test = timer(test)
def test():      # test（）括号里面带参数时，deco（）里面也要带参数
    time.sleep(3)
    print("in the test")
 
test()
 
------------------
结果：
    deco start
    in the test
    deco end

装饰器中带参数时：

需要在外层多加一层函数来接收装饰器的参数

import time
def outer(outer_args):  #用来接收装饰器的参数
 
    def timer(func):
        def deco():
            print('deco start',"装饰器里面的参数是：",outer_args)
            func()  #注意括号！
            print('deco end')
        return deco
 
    return timer
 
@outer(123)    #当装饰其中有参数时，和上一示例相比在外层多了一层函数来接收装饰器的参数。
def test():     # 括号里面带参数时，deco（）里面也要带参数
    time.sleep(3)
    print("in the test")
 
test()

运行结果：
 
deco start 装饰器里面的参数是： 123
in the test
deco end

装饰器顺序：

　一个函数还可以同时定义多个装饰器，比如：

@a
@b
@c
def f ():
    pass
 
----------------------
它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于
 
f = a(b(c(f)))

类装饰器：

没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
    def __init__(self, func):    #传入func
        self._func = func
 
    def __call__(self):
        print ('class decorator runing')
        self._func()    #在 __call__ 中调用函数
        print ('class decorator ending')
 
@Foo
def bar():
    print ('bar')
 
bar()

运行结果：
 
class decorator runing
bar
class decorator ending

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：

# 装饰器
def logged(func):
    def with_logging(*args, **kwargs):
        print func.__name__      # 输出 'with_logging'
        print func.__doc__       # 输出 None
        return func(*args, **kwargs)
    return with_logging
 
# 函数
@logged
def f(x):
   """does some math"""
   return x + x * x
 
logged(f)

不难发现，函数 f 被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器里面的 func 函数中，这使得装饰器里面的 func 函数也有和原函数 foo 一样的元信息了。

from functools import wraps
def logged(func):
 
    @wraps(func)     #加上此装饰器
 
    def with_logging(*args, **kwargs):
        print func.__name__      # 输出 'f'
        print func.__doc__       # 输出 'does some math'
        return func(*args, **kwargs)
    return with_logging
 
@logged
def f(x):
   """does some math"""
   return x + x * x

三、生成器

1、列表生成式：

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

2、生成器：generator

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

2.1创建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 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

2.2、定义generator的另一种方法：

　　如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

def fib(max):
    n,a,b = 0,0,1
 
    while n < max:
        # print(b)
        yield  b    #等同于print(b)，但不会打印，而是作为中断点
        a,b = b,a+b
        n += 1
    return 'done'
 
#调用方法一：
g = fib(8)
print(g)    #返回 <generator object fib at 0x01BF43F0>
print(g.__next__()) #返回1    要用__next__()不断的调用取结果
 
# 调用方法二：（推荐）
for n in fib(8):    #调用方法
    print(n)    #返回全部结果

generator和函数的执行流程不一样，generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

四、面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）　　

1、创建类：

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class是关键字，表示类
创建对象，类名称后加括号即可

ps：类中的函数第一个参数必须是self（详细见：类的三大特性之封装），类中定义的函数叫做 “方法”

# 创建类
class Foo:
 
    def Bar(self):
        print 'Bar'
 
    def Hello(self, name):
        print 'i am %s' %name
 
# 根据类Foo创建对象obj
obj = Foo()
obj.Bar()            #执行Bar方法
obj.Hello('marymarytang') #执行Hello方法

2、面向对象的三大特性

面向对象的三大特性是指：封装、继承和多态。

2.1、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

将内容封装到某处
从某处调用被封装的内容

第一步：将内容封装到某处

self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

　　当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用
通过self间接调用

1、通过对象直接调用被封装的内容

调用被封装的内容：对象.属性名

class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = Foo('wupeiqi', 18)
print(obj1.name)     # 直接调用obj1对象的name属性
print(obj1.age)      # 直接调用obj1对象的age属性

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def detail(self):
        print(self.name)
        print(self.age)
 
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

　综上所述 : 对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。　

　如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了... ；而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。　

2.2、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

实例：

　　动物：吃、喝、拉、撒
 
　　   猫：喵喵叫（猫继承动物的功能）
 
　　   狗：汪汪叫（狗继承动物的功能）
-------------------------------------------------
class Animal:
 
    def eat(self):
        print "%s 吃 " %self.name
 
    def drink(self):
        print "%s 喝 " %self.name
 
    def shit(self):
        print "%s 拉 " %self.name
 
    def pee(self):
        print "%s 撒 " %self.name
 
class Cat(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'
 
    def cry(self):
        print '喵喵叫'
 
class Dog(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
 
    def cry(self):
        print '汪汪叫'
 
# ######### 执行 #########
 
c1 = Cat('小白家的小黑猫')
c1.eat()
 
c2 = Cat('小黑的小白猫')
c2.drink()
 
d1 = Dog('胖子家的小瘦狗')
d1.eat()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过派生类和基类，他们与子类和父类只是叫法不同而已。

多继承：

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先　　

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，如果当前类或者父类继承了object类，那么该类便是新式类，按照广度优先查找，否则便是经典类。

对新式类：

class D(object):
 
    def bar(self):
        print 'D.bar'
 
class C(D):
 
    def bar(self):
        print 'C.bar'
 
class B(D):
 
    def bar(self):
        print 'B.bar'
 
class A(B, C):
 
    def bar(self):
        print 'A.bar'
 
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()
 
新式类多继承

2.3、多态

　　多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

Pyhon 很多语法都是支持多态的，比如 len(),sorted(), 你给len传字符串就返回字符串的长度，传列表就返回列表长度。

Python多态示例

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name
 
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")
 
class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)
 
class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' %self.name)
 
def func(obj): #一个接口，多种形态，实现接口重用
    obj.talk()
 
c1 = Cat('小晴')
d1 = Dog('李磊')
 
func(c1)
func(d1)

面向对象设计利器：领域建模，更通俗的讲法是业务模型。

领域建模的三字经方法:找名词、加属性、连关系。　　

----------------------------------------------------------------------------------------------------------------

示例：

找名词

who : 学员、讲师、管理员

用例：

1. 管理员 创建了北京和上海两个校区

2. 管理员创建了 Linux \ Python \ Go 3个课程

3. 管理员创建了北京校区的Python 16期， Go开发第一期，和上海校区的Linux 36期班级

4. 管理员创建了北京校区的学员小晴，并将其分配在了班级 python 16期

5. 管理员创建了讲师 Alex , 并将其分配给了班级 python 16期和全栈脱产5期

6. 讲师 Alex 创建了一条 python 16期的 上课纪录 Day6

7. 讲师 Alex 为Day6这节课所有的学员批了作业，小晴得了A, 李磊得了C-, 严帅得了B

8. 学员小晴在 python 16 的 day6里提交了作业

9. 学员李磊查看了自己所报的所有课程

10 学员李磊在查看了自己在 py16期的成绩列表，然后自杀了

11. 学员小晴跟讲师 Alex 表白了

名词列表：

管理员、校区、课程、班级、上课纪录、作业、成绩、讲师、学员

加属性

连关系

有了类,也有了属性,接下来自然就是找出它们的关系了。