### 1. 什么是装饰器


>知乎大佬如是说：
内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤，有了长裤后宝宝再也不冷了，装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。
装饰器本质上是Python函数，可以为已存在的对象添加额外的功能，同时装饰器还可以抽离出与函数无关的重用代码。具体应用场景如：插入日志、性能测试、事务处理、缓存、权限校验等。
                   
换言之
>装饰器不能影响原函数的功能，装饰器是独立出来的函数。谁调用它，谁就可以使用它的功能。

### 2.举个栗子

add的功能是计算x和y的值，我们称作功能函数。
logger的作业是在执行add函数的同时再打印了其他的信息，这部分的作为add的功能增强，我们称为装饰。
在logger里我们可以加入其他类似的功能函数，也能包装它，可以进行复用。

#### 1.引子 


```
#功能函数
def add(x,y):
    return x+y

#装饰函数
def logger(fn):
    print('frist')
    x = fn(4,5)
    print('second')
    return x 

print(logger(add))

#把函数add传给logger  ，return x+y
#print('frist')
#print('secend')
#  x = fn(4,5)  ==> x = 4 y= 5  x= 4+5 = 9 
#return 9 

```

    frist
    second
    9


#### 2.提取参数

x,y的参数都放在logger函数内部了，影响函数的灵活性，此处我们可以提取出来。


```
def add(x,y):
    return x + y
 
def logger(fn,*args,**kwargs):
    print('frist')
    x = fn(*args,**kwargs)
    print('second')
    return x

print(logger(add,1,y=11))
```

    frist
    second
    12


#### 3.柯里化 


```
def add(x,y):
    return x + y
def logger(fn):
    def wrapper(*args,**kwargs):
        print('begin')
        x = fn(*args,**kwargs)
        print('end')
        return x
    return wrapper


print(logger(add)(5,y=11))
```

    begin
    end
    16


**懵逼ing**

以下为个人理解，左边为非柯里化函数，右边是柯里化函数。

<img src="http://qiniu.mykernel.cn/klh.png" alt="柯里化函数"/>

前面说过柯里化的定义，本来可以一次传入两个参数，柯里化之后。只需要传入一个函数了。。
左边传入add 和 两个参数。
右边的logger(add)是一个函数，只需要传入两个参数。logger(add)是个整体，结合成一个函数。当然这样写，我们看函数主题的部分也是不一样的。
函数的基础中说过，函数的传参必须和函数参数的定义一致。重点分析右边函数（柯里化）。
参数部分：参数传入的方式，logger函数需要传入个fn，fu的返回值是wrapper函数，wrapper函数的参数是(\*args,\**kwargs)所以此次就需要分两次传入参数。
第一次传入fn，再次传入wrapper函数需要的参数。所以就出现了最下边的调用方式。
print(logger(add)(5,y=50))。

返回值部分：右侧的logger函数是个嵌套函数，logger的返回值是wrapper，内层的wrapper函数返回值是x，x = fn(\*args,\**kwargs)。fn函数是最后调用时候传入的add函数。 

懵逼 X 2。。。。

```bash
def add(x,y):
    return x + y
  
def logger(fn,*args,**kwargs):        def logger(fn):  #参数剥离
                                           def newfunction(*args,**kwargs):  #新定义一个函数，logger函数返回也是这个函数名字
    print('frist')                           print('frist')
    x = fn(*args,**kwargs)  == >             x = fn(*args,**kwargs)
    print('second')                          print('second')
    return x                               return x
                                        return newfunction
                                                              
print(logger(add,1,y=11))           print(logger(add)(5,y=11)) #两次传入参数
```

效果如下：


```
def add(x,y):
    return x + y
  
def logger(fn):  #参数剥离
    def newfunction(*args,**kwargs):  #新定义一个函数，logger函数返回也是这个函数名字
   
        print('frist')
        x = fn(*args,**kwargs)
        print('second')
        return x
    
    return newfunction
                                                              
print(logger(add)(5,y=11)) #两次传入参数
```

    frist
    second
    16


**继续懵逼的话就这样用吧。。。用多了就悟道了。。**

#### 4.装饰器语法糖 


```
#再次变形。。。
def add(x,y):
    return x + y

def logger(fn):
    def wrapper(*args,**kwargs):
        print('begin')
        x = fn(*args,**kwargs)
        print('end')
        return x
    return wrapper

##调用方法1：
print(logger(add)(x=1111,y=1))

##调用方法2：
add = logger(add)
print(add(x=11,y=3))

##调用方法3： python给我们的语法糖 

@logger # 说明下边的函数，add 其实是 add = logger(add)
def add(x,y):
    return x + y


print(add(45,40))
```

    begin
    end
    1112
    begin
    end
    14
    begin
    end
    85


### 3.复杂的栗子


```
import datetime
import time 

def logger(fn):
    def warp(*arges,**kwarges):
        print("arges={},kwarges={}".format(arges,kwarges))  #打印函数的两个参数
        start = datetime.datetime.now()  #获取函数运行的开始时间
        ret = fn(*arges,**kwarges)  #传入两个参数，调用add函数  此处有个return的值，需要一层一层的返回出去
        
        duratime = datetime.datetime.now() - start  #获得函数的运行时间
        print("function {} took {}s".format(fn.__name__,duratime.total_seconds()))  #打印函数的运行时间

        return ret   #返回fn的结果 ，fn = x+y ==> 返回x+y的值。  x = 4 y= 11 ==> return 11
    return warp  #返回warp的 return ==> ret 的return ==> return 11 函数的最终结果为11  

@logger
def add(x,y):
    print("oooooook")
    time.sleep(1.5)
    return x+y

print(add(4,y=11))
   
#如果充分理解了每个小部件，这个简单的完整版本也是很好理解的了。
#1，logger是个装饰器，而且使用了柯里化技术
#2，add 传参给logger的fn 形参，add(4,y=5)的两个参数传入给warp函数的两个形参
#
#
```

    arges=(4,),kwarges={'y': 11}
    oooooook
    function add took 1.5017s
    15


**再次翻译**


```
import datetime
import time 

#####################################装饰开始############################################
def logger(fn):  #拿到函数名称
    def warp(*arges,**kwarges):  #拿到函数带过来的参数开始装饰
        print("arges={},kwarges={}".format(arges,kwarges))   #来试试打印两个参数
        start = datetime.datetime.now()  #
        ret = fn(*arges,**kwarges)   # 此处调用add函数。开始执行函数，发现return语句。。ret的结果就是return。 
        
        duratime = datetime.datetime.now() - start  #
        print("function {} took {}s".format(fn.__name__,duratime.total_seconds()))

        return ret   #加工完成开始返回。warp的返回值是ret ，ret的返回值是 add函数的执行结果（原函数的功能完整的保留了） 
    return warp  # logger的返回结果是warp，warp的返回值是ret ，ret的返回值是 add函数的执行结果（原函数的功能完整的保留了） 

#####################################装饰完成############################################

@logger  #装饰工厂
######add是需要被装饰的函数，当你有这个想法的事情，其实事情已经开始发生了。
def add(x,y): # 此时add = logger(add)  此处前面的@logger标记就是想要让logger装饰器像一个工厂一样对add函数进行加工。
    print("oooooook")
    time.sleep(1.5)
    return x+y

print(add(4,y=11))

```

    arges=(4,),kwarges={'y': 11}
    oooooook
    function add took 1.501604s
    15


### 4.带参装饰器

#### 1. 文档字符串

我们约定，在python函数的第一行需要对函数进行说明，使用三引号表示。
如果是英文说明，惯例首字母大写，第一行写概述，空一行，第三行写详细描述。
如果函数中有文档字符串，默认会放在函数的__doc__属性中，可以直接访问。


```
def add(x,y):
    """This is a function of addition"""
    a = x+y
    return x + y

print("function name is {}\nfunction doc = {}\n\n".format(add.__name__, add.__doc__))
print(help(add))
```

    function name is add
    function doc = This is a function of addition
    
    
    Help on function add in module __main__:
    
    add(x, y)
        This is a function of addition
    
    None


#### 2. 前面装饰器的副作用 

前面装饰器基本上已经可以完成对函数进行加强的功能了，但是还有些瑕疵。比如原来函数的原属性已经被替换为装饰器的属性了。如下：


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

def logger(fn):
    "This is logger doc"
    def wrapper(*args,**kwargs):
        "This is wrapper doc"
        print('begin')
        x = fn(*args,**kwargs)
        print('end')
        return x
    return wrapper


@logger # add = logger(add)
def add(x,y):
    "This is add doc "
    print("name = {}\ndoc = {}".format(add.__name__,add.__doc__))
    return x + y


print(add(45,40))

#可以看出来add被装饰出来的函数（新的add）的属性已经全部改变了。
```

    begin
    name = wrapper
    doc = This is wrapper doc
    end
    85


#### 3. 解决方案一 

三个函数：
1. copy原函数的属性 copy_properties
2. 装饰器 logger
3. 功能函数 add


```
def copy_properties(src, dst): # 把src的相关属性赋值给dst  (fn,wrap)
    dst.__name__ = src.__name__
    dst.__doc__ = src.__doc__

    
def logger(fn):
    """'This is a function of logger'"""
    def wrap(*arges,**kwarges): # 
        """'This is a function of wrap'"""
        print('<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>')
        x = fn(*arges,**kwarges)
        #print("name={}\ndoc={}".format(add.__name__,add.__doc__))
        print('<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>')   
        return x  
    copy_properties(fn,wrap)    #思考1：为什么放在这个位置调用
    return wrap

@logger
def add(x,y):
        """'This is a function of add'"""
        print("name={}\ndoc={}".format(add.__name__,add.__doc__))
        return x+y


print(add(4,6))
```

    <>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>
    name=add
    doc='This is a function of add'
    <>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>-<>
    10


#### 4. 解决方案二 

但凡使用装饰器都会出现属性的这个问题，为什么不把copy_properties也做成装饰器呢？

三个函数：
1. copy原函数的装饰器 copy_properties1
2. 装饰器 logger
3. 功能函数 add


```
def copy_properties(src, dst): # 把src的相关属性赋值给dst  (fn,wrap)
    dst.__name__ = src.__name__
    dst.__doc__ = src.__doc__
    
#利用前面的知识我们可以对copy_properties轻松进行变形
def copy_properties1(src): #  把src的相关属性赋值给dst  (fn,wrap)  
    def _copy(dst):
        dst.__name__ = src.__name__
        dst.__doc__ = src.__doc__
        return dst 
    return _copy
```

**带参装饰器：**


```
def logger(fn): 
    """'This is a function of logger'"""
    @copy_properties1(fn) #wrap = copy_properties(fn)(wrap)  
    #== > 柯里化 两次传入参数 src = fn ， dst = wrap 新的wrap函数的属性已经替换为原函数的。
    
    def wrap(*arges,**kwarges): #wrap = copy_properties(fn)(wrap)(*arges,**kwarges)     
        """'This is a function of wrap'"""
        print('>->->->->->->->->->->->->->->->->->->->->->->->->->')
        x = fn(*arges,**kwarges)
        print('<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<')
        return x 

    return wrap

@logger  #add =logger(add)
def add(x,y):
        """'This is a function of add'"""
        print("name={}\ndoc={}".format(add.__name__,add.__doc__))
        return x+y



print(add(4,11))
```

    >->->->->->->->->->->->->->->->->->->->->->->->->->
    name=add
    doc='This is a function of add'
    <-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<
    15



python之装饰器

本文主要介绍常用的各类开源软件的安装，持续更新。。因为经常需要搭建各类服务，安装步骤背下来是不可能的了，这辈子都不可能了。所以开个博文记录下。
目前主要涉及的软件有：python、nodejs、nextcloud、jupyter

<div class="note danger no-icon"><p>说明：所有操作均在centos7.x版本完成，其他发行版无研究。</p></div>

### 1. 通过pyenv安装python

#### 1. 安装依赖软件 

```bash
[root@localhost ~]#  yum install git  install gcc make patch gdbm-devel openssl-devel  sqlite-devel  readline-devel zlib-devel bzip2-devel -y
```

#### 2.创建python用户 

```bash
[root@localhost ~]# useradd python
[root@localhost ~]# su python
```

#### 3. 安装pyenv 

```bash
#安装pyenv
[python@localhost ~]$ curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash
#安装完成后在~/.bash_profile文件最后追加相关环境变量
export PATH="/home/python/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
#刷新配置或者重新开一个终端
[python@localhost ~]$ source ~/.bash_profile
#详细配置参考https://github.com/pyenv/pyenv
```

#### 4. 安装指定版本的python （在线）

```bash
#查看可以安装的版本
[python@localhost ~]$ pyenv install --list

#查看当前环境安装了的版本
[python@localhost ~]$ pyenv versions

#安装指定的版本
[python@localhost ~]$ pyenv install 3.6.3 -v 

#更新pyenv及其插件
[python@localhost ~]$ pyenv update
```

#### 5. 设置指定的python版本

三种方式：
1. global #：#后为指定的版本号，指定全局生效，普通用户指定就是普通用户全局生效，root用户指定就是普通用户生效。（影响范围最大）
2. shell #：指定只在当前shell生效的权限（影响范围最小）
3. local #：指定文件夹的权限（建议采用方式）

```
 [python@localhost ~]$ pyenv local 3.6.3
```

#### 6. 安装指定版本的python（离线） 

但由于文件很大，通常下载需要很久。
如果网速不好，建议的做法是，先执行以上命令然后马上中断安装，这样就知道 pyenv 要下载的文件的链接。然后用户自己用其他更快的方式（比如wget、迅雷等等）从该链接中下载安装文件，并将安装文件移动到 ~/.pyenv/cache目录。
最后执行pyenv install命令。

#### 7. python包管理器 

pip是python的包管理器。一般国内机器使用官方源比较慢，可以使用国内的镜像。

```bash
#更新pip默认源
[python@localhost ~]$ mkdir ~/.pip
[python@localhost ~]$ vim ~/.pip/pip.conf
[global]
index-url = http://mirrors.aliyun.com/pypi/simple/

[install]
trusted-host=mirrors.aliyun.com

##或者可以使用豆瓣的镜像：
[global]
index-url = http://pypi.douban.com/simple

[install]
trusted-host=pypi.douban.com

```

pip相关命令：

```bash
#查看pip版本
[python@localhost py]$ pip -V
#此处如果出现以下错误，说明需要配置环境，参考第5点。
[python@localhost ~]$ pip3 -V
pyenv: pip3: command not found

    The `pip3` command exists in these Python versions:
  3.6.3
  
#安装python的包
[python@localhost py]$ pip install pkgname
## 安装包的时候可以检测前面的源是否配置成功


```

### 2. 通过nvm安装nodejs

#### 1.安装node版本控制器nvm 

```bash
[root@localhost ~]# wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
#详细配置可参考官网
```

#### 2. nvm安装nodejs 

```bash
#版本查看
[root@localhost ~]# nvm -v

#安装当前最新的稳定版
[root@localhost ~]# nvm install stable

#安装指定版本
[root@localhost ~]# nvm install 8.9.1

#查看已经安装的版本
[root@localhost ~]# nvm ls
default -> v8.2.0  #当前环境的版本
->       v8.2.0  #-> 指向的就是正在使用的版本
#切换node的版本
[root@localhost ~]# nvm use 8.9.1
Now using node v8.9.1 (npm v5.5.1)

#指定系统默认的版本
[root@localhost ~]# nvm alias default 8.9.1
```

### 3. 通过docker安装nextcloud

#### 1. 安装docker 

docker是当下流行的容器技术

```bash
#安装docker
[root@localhost ~]# yum install -y docker
#启动docker
[root@localhost ~]# systemctl  start docker
```

为了更加方便进入容器，可以在~/.bashrc文件末尾追加以下代码：

```bash
#the implementation refs from https://github.com/jpetazzo/nsenter/blob/master/docker-enter
function docker-enter() {
    #if [ -e $(dirname "$0")/nsenter ]; then
    #Change for centos bash running
    if [ -e $(dirname '$0')/nsenter ]; then
        # with boot2docker, nsenter is not in the PATH but it is in the same folder
        NSENTER=$(dirname "$0")/nsenter
    else
        # if nsenter has already been installed with path notified, here will be clarified
        NSENTER=$(which nsenter)
        #NSENTER=nsenter
    fi
    [ -z "$NSENTER" ] && echo "WARN Cannot find nsenter" && return

    if [ -z "$1" ]; then
        echo "Usage: `basename "$0"` CONTAINER [COMMAND [ARG]...]"
        echo ""
        echo "Enters the Docker CONTAINER and executes the specified COMMAND."
        echo "If COMMAND is not specified, runs an interactive shell in CONTAINER."
    else
        PID=$(sudo docker inspect --format "{{.State.Pid}}" "$1")
        if [ -z "$PID" ]; then
            echo "WARN Cannot find the given container"
            return
        fi
        shift

        OPTS="--target $PID --mount --uts --ipc --net --pid"

        if [ -z "$1" ]; then
            # No command given.
            # Use su to clear all host environment variables except for TERM,
            # initialize the environment variables HOME, SHELL, USER, LOGNAME, PATH,
            # and start a login shell.
            #sudo $NSENTER "$OPTS" su - root
            sudo $NSENTER --target $PID --mount --uts --ipc --net --pid su - root
        else
            # Use env to clear all host environment variables.
            sudo $NSENTER --target $PID --mount --uts --ipc --net --pid env -i $@
        fi
    fi
}

##项目开源地址：https://github.com/jpetazzo/nsenter/blob/master/docker-enter

```


**docker-enter 'CONTAINER ID' 进入指定的容器，exit退出**

#### 2. 安装nextcloud

nextcloud是新一代私有网盘

```bash
#安装nextcloud
~]#  docker run -d -p 11211:80 -v nextcloud:/var/www/html registry.cn-hangzhou.aliyuncs.com/mykernel/nextcloud:v1
# -p 11211 是本地端口，需要开放机器的防火墙
# -v nextcloud 是本地的一个目录，主要是为了让存储的文件持久化
# registry.cn-hangzhou.aliyuncs.com/mykernel/nextcloud:v1 docker官方的镜像速度太慢，是我通过阿里云做的一个中转镜像

```

#### 3. 使用nextcloud

访问地址：ip+11211； 
进去后，根据配置设置好相关的账号密码。
下载客户端登录，就可以实现实时同步了。。
这里需要说明的是如何传文件：
1. 通过客户端传文件
任何一个客户端传入数据，其他登录的客户端都可以自动同步过来。
2. 在linux系统后台传文件
此处通过直接往后台传文件，在各个客户端是看不到这个文件的。
所以需要通过nextcloud自带的扩展功能实现： External storage support，
具体操作可以百度。


#### 4. 备份

我们通过docker -v 命令将容器内的卷持久化了。这就可以对数据进行备份，从而更加确保其安全性。
先在客户端任意上传一个文件，我此处上传一个名字叫aaabbb的文件夹；
然后通过find命令在linux上查找这个文件，就可以定位这个持久卷的位置了。
```bash
[root@iZpo45bh60h6bsZ /]# find / -name aaabbb
/var/lib/docker/volumes/nextcloud/_data/data/mykernel/files/aaabbb
```
找到之后我们可以使用若干种办法将其备份，我就不一一赘述了。

### 4. 通过docker安装jupyter

jupyter是一个基于浏览器的python数据分析工具，使用起来非常方便，具有极强的交互方式和富文本的展示效果。能实现自动补全、自动缩进、支持shell、增加函数(%%time)等功能。

#### 1. docker安装jupyter

a.pull镜像

```bash
[root@iZpo45bh60h6bsZ /]# docker pull tensorflow/tensorflow
```

b.run 镜像，生成容器实例，第一次进入会执行 /run_jupyter.sh，会有 token 让你进入 localhost:8888 页面是可以输入并登录

```bash
[root@iZpo45bh60h6bsZ /]# docker run -it -p 8888:8888 tensorflow/tensorflow
```

c. 进入容器修改jupyter的默认密码（参考前面进入容器的办法）

```bash
[root@iZpo45bh60h6bsZ /] vim ~/.jupyter/jupyter_notebook_config.py


# 修改里面的 password 配置，我这里注释掉了使用环境变量 PASSWORD，直接明文密码 mykernel，password()函数是个 hash函数


# sets a password if PASSWORD is set in the environment


#if 'PASSWORD' in os.environ:

c.NotebookApp.password = passwd("mykernel")

#  del os.environ['PASSWORD']



```

#### 2. jupyter使用

a. windows访问
jupyter --ip=0.0.0.0 --no-browser
http://<ip>:8888
此时笔记所在目录为--notebook-dir=指定的目录,或运行命令所在目录

b. 基本命令
先在页面上按下esc键
dd：删除选择的cell （cell就是看到的框）
m：进入markdown编辑模式
crtl+回车：运行该框中的代码，不开启新行
alt+回车：运行该框中的代码，开启新行
数字（1-6）：直接设置md的标题格式
h：查看帮助
我一般就用到这几个命令了。

开源软件安装集锦

### 1. 可迭代对象 

可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象。


```
from collections import Iterable
print(isinstance([], Iterable)) #列表是可迭代对象
print(isinstance({}, Iterable)) #字典是
print(isinstance('abc', Iterable)) #字符串是
print(isinstance((x for x in range(10)), Iterable)) #生成器是可迭代对象
print(isinstance(100, Iterable)) #整数不是可迭代对象
print(isinstance((), Iterable)) #元组是
```

    True
    True
    True
    True
    False
    True


### 2. 迭代器 

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象。


```
from collections import Iterator
print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

```

    True
    False
    False
    False


所以生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

### 3. 生成器 

**生成器指的就是生成器对象：**
生成器其实是一种特殊的迭代器。



1. 可以由生成器表达式得到；
```
#(expr for iter_var in iterable) 

L= (i +1 for i in range(10) if i %2)
print(type(L))
print(next(L))
print(next(L))
print(next(L))

#generator  生成器

<class 'generator'>
2
4
6
```
2. 可以使用yield关键字得到一个生成器函数，调用这个函数得到一个生成器对象。

* 函数体中包含yield语句的函数，反正生成器对象
* 生成器对象，是延迟计算、惰性求值的。


```
#实现计数器
def inc():
    def counter():
        i = 0 
        while True:
            i += 1
            yield i 
    c= counter()  #c是生成器，可以使用next求值
    return lambda : next(c)

foo = inc()

print(foo())
print(foo())
```

    1
    2



```
#打印斐波那契数列
def fib():
    x = 0
    y = 1
    while True:
        yield y
        x, y = y, x+y
        
foo = fib() #调用了yield的函数才是生成器  
print(type(foo)) #foo是个生成器

for _ in range(5):
    print(next(foo))  #打印5次 next(foo)

for _ in range(100):
    next(foo)  #先执行100次next(foo)
print(next(foo))  #再打印出第101次
```

    <class 'generator'>
    1
    1
    2
    3
    5
    6356306993006846248183


### 4. 总结

关系图：

<img src="http://qiniu.mykernel.cn/%E7%94%9F%E6%88%90%E5%99%A8.png"  alt="生成器"/>


python的生成器

我们将文章的分类、标签、url和发布时间等称为文章的元数据；
在文章的最开头部分，上下三横线`---`的之间按照既定的格式指定相关属性，就可以用最快的方式来给自己的博文定个位。
本文让你更加灵活的定义自己的博文。

##### 元数据支持的字段

参数	|描述|	默认值
:--:|--|---
layout	|布局|	
title	|标题	|
date	|建立日期	|文件建立日期
updated	|更新日期	|文件更新日期
comments|	开启文章的评论功能|	true
tags|	标签（不适用于分页）|	
categories|	分类（不适用于分页）|	
permalink|	覆盖文章网址|	

`title`,`date`,`update` 三个关键字对应文章的标题、文章的创建时间和文章的更新时间。

##### 1，设置文章的分类



###### setp1：生成分类的页面

`# hexo new page categories`

此时会生成一个新的文件`INFO  Created: /hexo/source/categories/index.md`，
在该index.md文件的末三个小横线上添加字典`type: "categories"`。


###### setp2：给文件添加分类属性 

此操作是把每一个文件放在对应的分类下。
在文章的开头部分添加

`categories: `
`- web前端`

其中web前端就是该文章所在的分类。

##### 2，设置文章的标签


###### setp1：生成标签页

`# hexo new page tags`

` INFO  Created: /hexo/source/tags/index.md`

在该index.md文件的末三个小横线上添加字典type: "tags"。

###### setp2：给文件添加分类属性 

此操作给文件打个标签，一篇文章可以添加多个标签。在文章的元数据部分添加：
`tags: `
`- next`

其中next就是该文章的标签。

##### 3，网页地址永久链接


此处仅仅说明下本博客的相关设置：

###### step1：修改hexo站点配置文件（_config.yml）默认的链接


`#permalink: :year/:month/:day/:title/`
`permalink: :title.html`                   
`permalink_defaults:`


###### step2：本文设置的自定义url

文章元数据设置：
`permalink: my-next-1`

本文所呈现的url：http://hexo.mykernel.cn/my-next-1.html
这样就可以设置每篇博客的url了，虽然麻烦，但是足够随心所欲。

参考链接：https://darrenliuwei.coding.me/hexo-next-blog/hexo/permalinks.html

hexo文章元数据相关设置

kvm是linux下的一款虚拟机软件，KVM的虚拟化需要硬件支持（如Intel VT技术或者AMD V技术)。是基于硬件的完全虚拟化。而Xen早期则是基于软件模拟的Para-Virtualization，新版本则是基于硬件支持的完全虚拟化。但Xen本身有自己的进程调度器，存储管理模块等，所以代码较为庞大。广为流传的商业系统虚拟化软件VMware ESX系列是基于软件模拟的Full-Virtualization。

众所周知，运行一个操作系统需要传统的五大部件。

### 1.创建虚拟机的基本操作


#### 1.创建磁盘 

```bash
root@mykernel:/zz/images # qemu-img create -f qcow2 -o preallocation=metadata,size=80G c7_pxr.img

```

#### 2.运行虚拟机

```bash
root@mykernel:/zz/images # virt-install --name c-pxr-7-2 --ram 2048 --vcpus 4 --disk  /zz/images/c7_pxr.img  --cdrom  CentOS1511.iso --network bridge=br-int --graphics vnc,listen=0.0.0.0

#/zz/images/c7_pxr.img 为1中创建的虚拟机
# --cdrom  CentOS1511.iso  指定使用的系统镜像文件
# --network 指定网络模型
# --graphics 控制台链接模式
# listen 监听的地址
```

#### 3.链接虚拟机 

```bash
root@mykernel:/zz/images  # virsh list  
 Id    Name                           State
----------------------------------------------------
 15    c-pxr-7-2                      running

# virsh console c-pxr-7-2

#说明1：此处建议使用虚拟机的名称进行连接，因为每次destroy后在start虚拟机，其id会变化。

#说明2：如果此处敲回车无效需要进入虚拟机内运行。
#
## systemctl enable serial-getty@ttyS0.service
## systemctl start serial-getty@ttyS0.service
```

### 2. 进阶操作 

#### 1.网卡相关操作 

```bash
#a.添加网卡
root@mykernel:/zz/images # virsh attach-interface c-pxr-7-2  bridge  br-int

#加--config参数，直接写入配置文件，永久生效，重启生效。
root@mykernel:/zz/images # virsh attach-interface c-pxr-7-2  bridge  br-int --config
#其中br-int 是宿主机上的桥

#b.删除网卡
root@mykernel:/zz/images # virsh detach-interface c-pxr-7-2 bridge --mac  52:54:00:c1:a1:61 
#加--config参数，直接写入配置文件，永久生效，重启生效。
root@mykernel:/zz/images # virsh detach-interface c-pxr-7-2 bridge --mac  52:54:00:c1:a1:61  --config
#--mac 是虚拟机中的网卡mac地址
```

#### 2. 磁盘相关操作

```bash
#a.命令行添加磁盘 
#创建需要添加的磁盘
root@mykernel:/zz/images # qemu-img create -f qcow2 -o size=20G,preallocation=metadata /images/test.qcow2
#添加磁盘到虚拟机中
root@mykernel:/zz/images # virsh attach-disk c-pxr-7-2  /images/test.qcow2 vdb --targetbus virtio
#vdb为磁盘在虚拟机内显示的名称，不能与虚拟机中已经有的磁盘重名。

#b.删除磁盘
root@mykernel:/zz/images # virsh  detach-disk 15 vdb
#以上的修改都是临时生效的，重启或者克隆的虚拟机将会被销毁。所以若要永久有效，需要重新保存下配置文件。
root@mykernel:/zz/images # virsh dumpxml  c-pxr-7-2 >  /etc/libvirt/qemu/c-pxr-7-2.xml
```

#### 3.克隆虚拟机 

```bash
##命令行克隆虚拟机 
#a.关闭虚拟机
root@mykernel:/zz/images # virsh destroy 15

#b. 克隆
root@mykernel:/zz/images # virt-clone -o  c-pxr-7-2 -n c7_clone -f  /zz/images/c7_pxr_clone1.img

#-o是源虚拟机名称
#-n是新虚拟机名称
##说明：修改网卡设备文件/etc/udev/rules.d/70-persistent-net.rules，或者直接将其删除，再重启克隆的目的虚拟机
```

#### 4. 快照与恢复

```bash
#命令行快照与恢复 
#a.创建快照
root@mykernel:/zz/images # virsh snapshot-create-as c-pxr-7-2 kz kuaizhao
##kz：快照别名
##kuaizhao：描述

#b. 查看虚拟机快照
root@mykernel:/zz/images # virsh snapshot-list c-pxr-7-2
##running 表示运行时建立的快照
##shutoff 表示虚拟机关闭时的快照

#c.快照恢复（回滚）
root@mykernel:/zz/images # virsh snapshot-revert --domain c-pxr-7-2 kz 
##说明1：内置磁盘快照可以随意回滚,比如先回滚到sn1,在回滚到sn3都是OK的
##说明2：注意一点是虚拟机开启状态下,不能回滚到State为running的快照点

#d.快照删除
root@mykernel:/zz/images # virsh snapshot-delete c-pxr-7-2 kz
或者
root@mykernel:/zz/images # virsh snapshot-delete --domain  c-pxr-7-2 --snapshotname kz
```

### 3. 其他相关命令

```bash
#a. 启动虚拟机 
root@mykernel:/zz/images # virsh start vm_name 
##vm_name 可以使用virsh list –all 命令查看到 

#b.删除虚拟机和磁盘 
root@mykernel:/zz/images # virsh undefine centos7.2 –remove-all-storage 

#c.编辑虚拟机的配置文件 
root@mykernel:/zz/images # virsh edit c-pxr-7-2 

#d.导出虚拟机配置文件 
root@mykernel:/zz/images # virsh dumpxml c-pxr-7-2 > /kvm/config/c7.xml 

#e.进入Virtual Machine Manager管理界面 
root@mykernel:/zz/images # virt-manager 

#f.关闭虚拟机 
root@mykernel:/zz/images # virsh destroy c-pxr-7-2
```

### 4.排错 

在windows上链接虚拟机需要安装xmanager套件。 
如果键盘失灵请检查相关配置。

<img src="http://qiniu.mykernel.cn/kvm-vnc.jpg" alt="kvm/">