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)
0 1 4 9 16 25 36 49 64 81
所以，我们创建了一个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、多态
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 表白了
名词列表：
管理员、校区、课程、班级、上课纪录、作业、成绩、讲师、学员
加属性
连关系
有了类,也有了属性,接下来自然就是找出它们的关系了。
浙公网安备 33010602011771号