day8-20180417笔记

笔记：Python的装饰器、class类

一、Python的装饰器

!!!!!!!start!!!!!!!!
hello world   (hello)
!!!!!!!!end!!!!!!!!!

在学装饰器前，如何输出以上结果：

直接写函数，写三个print

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/4/18 13:09
# @Author  : yangyuanqiang
# @File    : demon1.py


def hello():
    print("!!!!!!!start!!!!!!!!")
    print("hello world")
    print("!!!!!!!!end!!!!!!!!!")

嗯，使用这种方法，确实能实现，但是特low逼，以上实例输出的结果

!!!!!!!start!!!!!!!!
hello world
!!!!!!!!end!!!!!!!!!

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/4/17 14:09
# @Author  : yangyuanqiang
# @File    : demon1.py

#  !!!!!!!start!!!!!!!!
#  hello world   (hello)
# !!!!!!!!end!!!!!!!!!


def hello():
    print("!!!!!!!start!!!!!!!!")
    print("hello world")
    print("!!!!!!!!end!!!!!!!!!")



a = hello()
print("-------------------------")
b = hello


b()

a 代表什么     hello函数把返回这给到a  None
b 代表什么     b是一个函数, b()相当于hello()

以上实例输出的结果：

!!!!!!!start!!!!!!!!
hello world
!!!!!!!!end!!!!!!!!!
-------------------------
!!!!!!!start!!!!!!!!
hello world
!!!!!!!!end!!!!!!!!!

装饰器

装饰器的作用：在不改变源代码的情况下，给现有的函数增加新的功能
装饰器通过@进行使用 ,相当于把hello() 函数作为参数，传给startEnd()

第一步：从最简单的例子开始

扫描二维码关注公众号，回复： 30965 查看本文章

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/4/18 14:26
# @Author : yangyuanqiang
# @File : test1.py

'''示例1: 使用语法糖@来装饰函数，相当于“myfunc = deco(myfunc)”
但发现新函数只在第一次被调用，且原函数多调用了一次'''

def deco(func):
    print("before myfunc() called.")
    func()
    print("  after myfunc() called.")
    return func

@deco

def myfunc():
    print(" myfunc() called.")

# myfunc = deco(myfunc)
myfunc()
myfunc()

这是一个最简单的装饰器的例子，但是这里有一个问题，就是当我们两次调用myfunc()的时候，发现装饰器函数只被调用了一次。为什么会这样呢？要解释这个就要给出破解装饰器的关键钥匙了。
这里@deco这一句，和myfunc = deco(myfunc)其实是完全等价的，只不过是换了一种写法而已
一定要记住上面这句！！！！
好了，从现在开始，只需要做替换操作就可以了。
将@deco 替换为 myfunc = deco(myfunc)
程序首先调用deco(myfunc)，得到的返回结果赋值给了myfunc （注意：在Python中函数名只是个指向函数首地址的函数指针而已）
而deco(myfunc)的返回值就是函数myfunc()的地址
这样其实myfunc 没有变化，也就是说，最后的两次myfunc()函数调用，其实都没有执行到deco()。
大家亲自动手试一下就会发现” myfunc() called.” 这句打印输出了三次。多的那次就是@deco这里输出的，因为@deco 等价于myfunc = deco(myfunc)，这里已经调用了deco()函数了。

以上实例输出的结果

before myfunc() called.
 myfunc() called.
  after myfunc() called.
 myfunc() called.
 myfunc() called.

第二步：确保装饰器被调用

怎么解决装饰器没有被调用的问题呢

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/4/18 14:26
# @Author : yangyuanqiang
# @File : test1.py

'''示例2: 使用内嵌包装函数来确保每次新函数都被调用，
内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象'''

def deco(func):
    def _deco():
        print("before myfunc() called.")
        func()
        print("  after myfunc() called.")
        # 不需要返回func，实际上应返回原函数的返回值
    return _deco

@deco
def myfunc():
    print(" myfunc() called.")
    return 'ok'

myfunc()
myfunc()

这里其实不需要我解释了，还是按照第一步中的方法做替换就可以了。
@deco 替换为 myfunc = deco(myfunc)
程序首先调用deco(myfunc)，得到的返回结果赋值给了myfunc ，这样myfunc 就变成了指向函数_deco()的指针
以后的myfunc()，其实是调用_deco()

以上实例输出的结果

before myfunc() called.
 myfunc() called.
  after myfunc() called.
before myfunc() called.
 myfunc() called.
  after myfunc() called.

第三步：对带参数的函数进行装饰

过程和第一步、第二步完全一致，不再重复了

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/4/18 14:26
# @Author : yangyuanqiang
# @File : test1.py

'''示例3: 对带参数的函数进行装饰，
内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象'''

def deco(func):
    def _deco(a, b):
        print("before myfunc() called.")
        ret = func(a, b)
        print("  after myfunc() called. result: %s" % ret)
        return ret
    return _deco

@deco
def myfunc(a, b):
    print(" myfunc(%s,%s) called." % (a, b))
    return a + b

myfunc(1, 2)
myfunc(3, 4)

以上实例输出的结果

before myfunc() called.
 myfunc(1,2) called.
  after myfunc() called. result: 3
before myfunc() called.
 myfunc(3,4) called.
  after myfunc() called. result: 7

第四步：让装饰器带参数

'''示例7: 在示例4的基础上，让装饰器带参数，
和上一示例相比在外层多了一层包装。
装饰函数名实际上应更有意义些'''

def deco(arg):
    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, arg))
            func()
            print("  after %s called [%s]." % (func.__name__, arg))
        return __deco
    return _deco

@deco("mymodule")
def myfunc():
    print(" myfunc() called.")

@deco("module2")
def myfunc2():
    print(" myfunc2() called.")

myfunc()
myfunc2()

以上实例输出的结果

before myfunc called [mymodule].
 myfunc() called.
  after myfunc called [mymodule].
before myfunc2 called [module2].
 myfunc2() called.
  after myfunc2 called [module2].

这种带参数的装饰器怎么解释呢。其实是一样的，还是我们的替换操作
@deco(“mymodule”)替换为myfunc = deco(“mymodule”)(myfunc )
注意啊，这里deco后面跟了两个括号。
其实很简单，先执行deco(“mymodule”)，返回结果为_deco
再执行_deco(myfunc)，得到的返回结果为__deco
所以myfunc = __deco

二、Python的class类

面向过程和面向对象

面向过程编程：函数式编程，C程序等

面向对象编程：C++，Java，Python等

类和对象

类和对象：是面向对象中的两个重要概念

类：是对事物的抽象，比如：人类、球类

对象：是类的一个实例，比如：足球、篮球

实例说明：

球类可以对球特征和行为进行抽象，然后可以实例化一个真实的球实体出来。

Python类定义

类定义：

类把需要的变量和函数组合成一起，这种包含称为“封装“

class A(object):

类的结构：

class 类名：

　　成员变量 - 属性

　　成员函数 - 方法

面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类定义，格式如下：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类的创建

class ActionSelect():
    def hello(self):
        print("hello world")

actionSelect = ActionSelect()
actionSelect.hello()

类的方法中至少有一个参数self

类的组成

类由属性和方法组成，类的属性是对数据的封装，类的方法是对类的行为的封装。

　　成员变量 - 静态属性

　　成员函数 - 动态方法

总结：

1、装饰器比较难理解，而且容易忘记，所以要多写，并理解调用的方法

2、class类，只讲了一些简单的方法，还需要多找找资料，操作，理解

猜你喜欢