## 环境搭建(Windows)

### 创建虚拟环境

    virtualenv django_env
    django_envScriptsactivate # 激活虚拟环境
    django_envScriptsdeactivate # 退出

### 依赖包安装

    pip install django
    pip install djangorestframework
    pip install PymySQL
    pip install pillow
    pip install django-redis
    pip list # 查看虚拟环境中安装的包
    pip freeze > requirements.txt # 收集当前环境中安装的包及其版本
    pip install -r requirements.txt # 安装项目使用到的模块

## 项目搭建

    mkdir django
    cd django
    django-admin startproject siteapi

使用PyCharm打开新建的项目siteapi，点击 「File」->「Settings」->「Project: siteapi」->「Python Interpreter」。

点击右上角的⚙️-> 「Add...」->「Existing environment」，找到虚拟环境下的Python解释器（django_envScriptspython.exe）。

打开manage.py，右键 「Run 'manage'」，点击右上角 「manage」->「Edit Configurations...」，在Parameters: 填入参数：`runserver 0.0.0.0:8000`。

重新运行manage.py，然后浏览器访问 `http://127.0.0.1:8000/`。

### 调整目录结构

在项目文件夹下新建logs目录，用来存放日志文件；新建scripts包，用来存放项目运行时的脚本文件。

在siteapi目录下新建包：apps、libs、utils（分别用来存放开发的代码、第三方库、开发的组件）。

在siteapi目录下新建settings包，包下面新建文件：dev.py、prod.py（分别用来存放项目开发时的本地配置、项目上线时的运行配置），然后把settings.py重命名为settings_origin.py。把settings_origin.py文件的内容复制到dev.py中。

修改manage.py文件中的os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'siteapi.settings')为`os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'siteapi.settings.dev')`。

### 创建代码版本

    cd django
    git init
    git add .
    git commit -m '项目搭建和调整目录结构'
    git remote add origin 远程仓库地址
    git push -u origin "master"
    git branch dev # 创建分支
    git checkout dev # 切换分支

### 日志配置

在siteapisettingsdev.py文件尾部添加：

    ## 日志配置
    LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    # 日志格式
    'formatters': {
    'verbose': {
    'format': '%(levelname)s %(asctime)s %(module)s %(lineno)d %(message)s',
    },
    'simple': {
    'format': '%(levelname)s %(message)s',
    },
    },
    # 日志过滤信息
    'filters': {
    'require_debug_true': {
    '()': 'django.utils.log.RequireDebugTrue',
    },
    },
    # 日志处理方式
    'handlers': {
    'console': {
    'level': 'DEBUG',
    'filters': ['require_debug_true'],
    'class': 'logging.StreamHandler',
    'formatter': 'simple'
    },
    'file': {
    'level': 'INFO',
    'class': 'logging.FileHandler',
    'filename': Path.joinpath(BASE_DIR.parent, 'logs/site.log'),
    'formatter': 'verbose'
    },
    },
    'loggers': {
    'django': {
    'handlers': ['console', 'file'],
    'propagate': True,
    },
    }
    }

### 异常处理

在siteapiutils目录下新建文件：exceptions.py，输入以下内容：

    from rest_framework.views import exception_handler
    from django.db import DatabaseError
    from rest_framework.response import Response
    from rest_framework import status
    import logging
    logger = logging.getLogger('django')
    def custom_exception_handler(exc, context):
    """
    自定义异常处理
    exc：本次请求发生的异常信息
    context：本次请求发生异常的执行上下文
    """
    response = exception_handler(exc, context)
    if response is None:
        &quot;&quot;&quot;
        到这里只有2种情况：
        要么程序没出错
        要么出错了而Django或者restframework不识别
        &quot;&quot;&quot;
        view = context['vies']
        if isinstance(exc, DatabaseError):
            # 数据库异常
            logger.error('[%s] %s' % (view, exc))
            response = Response({'message': '服务器内部错误，请联系客服工作人员！'}, status=status.HTTP_507_INSUFFICIENT_STORAGE)
    return response</code></pre><p>在siteapisettingsdev.py文件尾部添加：</p><pre><code>## 异常处理
    
    REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'siteapi.utils.exceptions.custom_exception_handler'
    }

### 数据库配置

    ## 连接数据库
    mysql -u root -p
    创建数据库
    create database siteapi charset=utf8mb4;
    创建数据库用户
    create user siteapi_user identified by '123';
    grant all privileges on siteapi.* to 'siteapi_user'@'%';
    flush privileges;

接下来，在siteapisettingsdev.py文件中进行配置和修改：

    DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME': 'siteapi',
    'USER': 'siteapi_user',
    'PASSWORD': '123',
    'HOST': '127.0.0.1',
    'PORT': 3306,
    }
    }

在siteapi__init__.py文件中添加如下代码：

    import pymysql
    pymysql.install_as_MySQLdb()

## 前端搭建

Node.js安装，官网下载地址：[https://nodejs.org/en/download/](https://nodejs.org/en/download/)

    npm config set registry https://registry.npm.taobao.org
    npm install --global vue-cli
    vue -V # 检查是否安装成功

### 创建项目

    cd django
    vue init webpack site_pc
    ? Project name site_pc
    ? Project description A Vue.js project
    ? Author google <qq@qq.com>
    ? Vue build standalone
    ? Install vue-router? Yes
    ? Use ESLint to lint your code? No
    ? Set up unit tests No
    ? Setup e2e tests with Nightwatch? No
    ? Should we run npm install for you after the project has been created? (recommended) npm
    cd site_pc
    npm run dev

打开浏览器，访问`http://localhost:8080`，查看效果。

使用 PyCharm 打开新建的项目 site_pc，点击右上角 [Add Configurations...] -> 左上角 [+]，找到 npm选中，在Scripts:填入：`dev`。

### 初始化

删掉srcrouterindex.js文件里面的如下代码：

    import HelloWorld from '@/components/HelloWorld'
    name: 'HelloWorld',
    component: HelloWorld

清除srcAPP.vue中的默认样式：img标签和#app。

删除默认的HelloWorld组件（srccomponentsHelloWorld.vue）。

### 前端首页

在srccomponents目录下新建文件：Home.vue，然后到srcrouterindex.js文件进行引入：

    import Home from "../components/Home"
    export default new Router({
    mode: "history",
    routes: [
    {
    path: '/',
    name: 'Home',
    component: Home
    }, {
    path: '/home',
    name: 'Home',
    component: Home
    }
    ]
    })

### 初始化全局变量和方法

在src目录下新建文件：settings.js，并添加：

    export default {
    "HOST": "http://localhost:8080/",
    }

在srcmain.js中引入：

    import settings from "./settings"
    Vue.prototype.$settings = settings

### 引入ElementUI

    npm i element-ui -S

在srcmain.js中导入ElementUI，并调用：

    // element-ui 配置
    import ElementUI from 'element-ui'
    import 'element-ui/lib/theme-chalk/index.css'
    // 调用插件
    Vue.use(ElementUI)

成功引入ElementUI，就可以开始进入前端页面开发，首先是首页。

在static目录下新建目录：css，在css目录下新建文件：reset.css，写入：

    /* 声明全局样式和项目的初始化样式 /
    body, h1, h2, h3, h4, p, table, tr, td, ul, li, a, form, input, select, option, textarea{
    margin: 0;
    padding: 0;
    font-size: 15px;
    }
    a{
    text-decoration: none;
    color: #333;
    }
    ul, li{
    list-style: none;
    }
    table{
    / 合并边框 */
    border-collapse: collapse;
    }
    /* 工具的全局样式 */
    .full-left{
    float: left!important;
    }
    .full-right{
    float: right!important;
    }
    [class*="el-icon-"], [class^=el-icon-]{
    font-size: 50px;
    }
    .el-carousel__arrow{
    width: 120px;
    height: 120px;
    }
    .el-checkbox__input.is-checked .el-checkbox__inner,
    .el-checkbox__input.is-indeterminate .el-checkbox__inner{
    background: #ffc210;
    border-color: #ffc210;
    border: none;
    }
    .el-checkbox__inner:hover{
    border-color: #9b9b9b;
    }
    .el-checkbox__inner{
    width: 16px;
    height: 16px;
    border: 1px solid #9b9b9b;
    border-radius: 0;
    }
    .el-checkbox__inner:after{
    height: 9px;
    width: 5px;
    }
    在 srcmain.js 中导入css初始化样式：
    import '../static/css/reset.css'

srccomponents 目录下新建文件：Header.vue、Banner.vue、Footer.vue。


Vue+Django前后端分离实战项目

复制文件的函数在os模块中不存在。原因是复制文件并非由操作系统提供的系统调用。

shutil模块提供了copyfile()函数，可以看做是os模块的补充。

## 删除

    import os
    import shutil
    base_path = os.path.dirname(file)
    path = os.path.join(base_path, 'img')
    删除文件夹
    shutil.rmtree(path)

## 拷贝

    ## 拷贝文件夹
    shutil.copytree("./img","./img2")
    src = os.path.abspath(file)
    dst = os.path.join(os.path.dirname(file), "aaa.py")
    文件到文件的拷贝，其中dst必须是文件
    shutil.copyfile(src, dst)
    文件拷贝，src必须是文件，dst可以是文件或者目录
    shutil.copy(src, dst)
    同上，但是拷贝的文件带着原有属性，类似于Linux系统里的cp -p命令
    shutil.copy2(src, dst)

## 重命名/移动

移动一个文件或者目录到指定的位置，src和dst都可以是文件或者目录。

    shutil.move("./img/1.txt","./img/new.txt")
    shutil.move("./img","./img_new")

## 压缩文件

    ## 压缩文件
    base_name 压缩后的文件
    format 压缩格式，例如：zip tar gztar bztar xztar
    root_dir 要压缩的文件夹路径
    shutil.make_archive(base_name='datafile', format='zip', root_dir=path)
    解压文件
    filename 要解压的压缩包文件
    extract_dir 解压的路径
    format 压缩文件格式
    shutil.unpack_archive(filename='datafile.zip', extract_dir='./imgs', format='zip')


Python高级文件操作模块shutil

Vue 中的指令按照不同的用途可分为6大类：

1. 内容渲染指令
2. 属性绑定指令
3. 事件绑定指令
4. 双向绑定指令
5. 条件渲染指令
6. 列表渲染指令

## 内容渲染

内容渲染指令用来辅助开发者渲染 DOM 元素的文本内容。常见的内容渲染指令有3个：v-text、{{ }}、v-html。

### v-text

会覆盖掉元素里面的内容。

### {{ }}

专业名称是插值表达式（Mustache），专门用来解决 v-text 会覆盖默认文本内容的问题。

插值表达式可以使用过滤器：

    <div id="app">
      <p>{{message | capitalize}}</p>
    </div>
    <script>
      const app = new Vue({
        el: "#app",
        data: {
          message: "i love vue！",
        },
        filters: {
          capitalize(str) {
            return str.charAt(0).toUpperCase() + str.slice(1);
          },
        },
      });
    </script>

过滤器仅在 vue 2.x 和 1.x 中受支持，在 vue 3.x 的版本中剔除了过滤器相关的功能。

3.x 版本的 vue，官方建议使用计算属性或方法代替被剔除的过滤器功能。

### v-html

用来输出html元素内容，会覆盖掉元素里面的内容。

## 属性绑定指令

### v-bind

给元素属性动态绑定属性值，可简写为`:`。

    <img v-bind:src="imageUrl">
    <img :src="imageUrl">

v-bind属于单向绑定，即JS修改->HTML修改。

v-bind动态绑定多个值：

    <template>
      <div v-bind="obj">测试一下</div>
    </template>
    <script>
    export default {
    data() {
    return {
    obj: {
    id: 'id',
    class: 'class',
    },
    }
    },
    }
    </script>

v-bind操作class：

- :class="{类名1: 布尔值, 类名2: 布尔值}"
- :class="[类名1, 类名2, 类名3]"

## 事件绑定指令

### v-on

事件相关的指令，如：

- v-on:click
- v-on:dblclick
- v-on:mouseover
- v-on::mouseout
- v-on:change
- v-on:focus
- v-on:input
- v-on:keyup

v-on:可简写为`@`。Vue中的Event对象，就是原生JS的Event对象。

## 双向绑定指令

### v-model

可以在表单input、textarea以及select元素上创建双向数据绑定。

    <body>
    <div id="app">
    <div>
    用户名：<input type="text" v-model="user">
    </div>
    <div>
    密码：<input type="password" v-model="pwd">
    </div>
    <input type="button" value="登录" v-on:click="clickMe">
    <input type="button" value="重置" v-on:click="resetForm">
    </div>
    <script>
    const app = new Vue({
    el: '#app',
    data: {
    user: "",
    pwd: ""
    },
    methods: {
    clickMe: function () {
    console.log(this.user, this.pwd)
    },
    resetForm: function () {
    this.user = '';
    this.pwd = '';
    }
    }
    });
    </script>
    </body>

为了方便对用户输入的内容进行处理，Vue 为 v-model 指令提供了 3 个修饰符，分别是：

- .number，自动将用户的输入值转为数值类型
- .trim，自动过滤用户输入的首尾空白字符
- .lazy，在“change”时而非“input”时更新

用法如下：

    <input type="text" v-model.number="n1" /> +
    <input type="text" v-model.number="n2" /> =
    <span>{{n1 + n2}}</span>

## 条件渲染指令

### v-if

动态地创建或移除 DOM 元素，从而控制元素在页面上的显示与隐藏。

v-if 可以单独使用，或配合 v-else（v-else-if）指令一起使用。

### v-show

动态为元素添加或移除 style="display: none;" 样式，从而控制元素的显示与隐藏。

### 区别

v-if 有更高的切换开销，而 v-show 有更高的初始渲染开销。因此：

- 如果需要非常频繁地切换，则使用 v-show 较好
- 如果在运行时条件很少改变，则使用 v-if 较好

## 列表渲染指令

### v-for

    <div id="app">
    <ul>
    <li v-for="(p,index) in persons" :key="p.id">
    {{index}}: {{p.name}} - {{p.age}}
    </li>
    </ul>
    </div>
    <script>
    const app = new Vue({
    el: "#app",
    data: {
    persons: [
    { id: "001", name: "张三", age: 18 },
    { id: "002", name: "李四", age: 19 },
    { id: "003", name: "王五", age: 20 },
    ],
    },
    });
    </script>

也可以使用 of 作为分隔符来替代 in ，这更接近JavaScript的迭代器语法：`v-for="item of items"`。

循环尽量不要和v-if同时使用，因为v-if的优先级更高。


Vue常见指令

## 基本介绍

NumPy：Numerical Python的缩写，提供了底层基于C语言实现的数值计算库，与Python内置的list数据结构相比，其支持更加规范的数据类型和极其丰富的操作接口，速度也更快。

## 安装NumPy

NumPy是第三方库，所以在使用前必须先安装NumPy。可以使用pip命令安装：`pip install numpy`。

安装完就可以写NumPy代码了。一般流程是先`import numpy`，为了后续调用方便，通常在import完之后，还给它一个缩写形式`as np`。

## 创建NumPy数组ndarray

NumPy默认ndarray所有元素的类型是相同的。如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str > float > int。

### 使用np.array()

    import numpy as np
    n = np.array([1, 2, 3])
    print(n.shape)  # 形状：(3,)

### 使用np.ones()

创建一个所有元素都为1的多维数组。

    n = np.ones((3, 2), dtype=np.int8)  # 默认是float类型
    print(n.shape)  # 形状：(3, 2)

创建一个所有元素都为0的多维数组，使用np.zeros()。

创建一个所有元素都为指定元素的多维数组，使用np.full()：

    n = np.full((3, 2), fill_value=6)
    print(n)
    输出：
    [[6 6]
    [6 6]
    [6 6]]

### 使用np.eye()

创建一个单位矩阵：主对角线都是1，其他都是0的二维数组。

    n = np.eye(5, 5, dtype=np.int8)
    print(n)
    输出：
    [[1 0 0 0 0]
    [0 1 0 0 0]
    [0 0 1 0 0]
    [0 0 0 1 0]
    [0 0 0 0 1]]
    k=1向右偏移1个位置，k=-1向左偏移1个位置
    n = np.eye(5, 5, k=1, dtype=np.int8)
    print(n)
    [[0 1 0 0 0]
    [0 0 1 0 0]
    [0 0 0 1 0]
    [0 0 0 0 1]
    [0 0 0 0 0]]

### 使用np.linspace()

创建一个等差数列。参数说明:

- start: 开始值
- stop: 结束值
- num=50: 等差数列中默认有50个数
- endpoint=True: 是否包含结束值
- retstep=False: 是否返回等差值(步长)
- dtype=None: 元素类型

    n = np.linspace(0, 10, num=6, dtype=np.int8)
    print(n)  # [ 0  2  4  6  8 10]

### 使用np.arange()

创建一个数值范围的数组，和Python中的range功能类似。

    n = np.arange(10)
    print(n)  # [0 1 2 3 4 5 6 7 8 9]
    n = np.arange(2, 10)
    print(n)  # [2 3 4 5 6 7 8 9]
    n = np.arange(2, 10, 2)
    print(n)  # [2 4 6 8]

### 使用np.random.randint()

创建一个随机整数的多维数组。

    import numpy as np
    import matplotlib.pyplot as plt
    n = np.random.randint(3)
    print(n)  # 随机范围：[0, 3)
    n = np.random.randint(3, 10)
    print(n)  # 随机范围：[3, 10)
    n = np.random.randint(3, 10, size=5)
    print(n)  # 一维
    n = np.random.randint(3, 10, size=(2, 3))
    print(n)  # 二维
    n = np.random.randint(0, 256, size=(20, 40, 3))
    plt.imshow(n)  # 图像处理
    plt.show()  # 图像显示

使用np.random.randn()创建一个服从标准正态分布的多维数组：

    n = np.random.randn()
    print(n)
    n = np.random.randn(5)
    print(n)
    n = np.random.randn(3, 4)
    print(n)

使用np.random.normal()创建一个服从正态分布的多维数组：

    n = np.random.normal(loc=10, scale=1, size=(2, 3))
    print(n)  # 均值：10，标准差：1，数组形状：2行3列

使用np.random.random()创建一个元素为[0, 1)随机数的多维数组：

    n = np.random.random(size=(2, 3))
    print(n)

使用np.random.rand()也是创建一个元素为[0, 1)随机数的多维数组，只是参数传递方式不同，random.rand()接收分开的参数。

两个函数功能完全一样，NumPy这么做可能是为了使MATLAB用户更容易学习Python+NumPy的组合。把其中一个函数去掉，所带来的麻烦远大于好处，因为有很多现存的代码使用了函数的不同版本。

## 数组属性

    n = np.ones((3, 2), dtype=np.int8)
    print(n.shape)  # 形状：(3, 2)
    print(n.ndim)  # 维度：2
    print(n.size)  # 总数据量：6
    print(n.dtype)  # 元素类型：int8

## 基本操作

### 索引

    n = np.array([1, 2, 3])
    print(n[0], n[-1])  # 1 3
    n = np.array([[1, 2, 3], [4, 5, 6]])
    print(n[-1][-1], n[-1, -1])  # 6 6

### 切片

行切片：

    n = np.array([1, 2, 3])
    print(n[0:2])  # [1 2]
    print(n[::-1])  # [3 2 1]
    n = np.array([[1, 2], [3, 4], [5, 6]])
    print(n[0])  # 取一行：[1 2]
    print(n[0:2])
    取连续行：
    [[1 2]
    [3 4]]
    print(n[[0, 2]])
    取不连续行：
    [[1 2]
    [5 6]]

列切片：

    n = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    print(n[:, 0])  # 取一列，取所有行，第0列：[1 4 7]
    print(n[:, 0:2])
    取连续列：
    [[1 2]
    [4 5]
    [7 8]]
    print(n[:, [0, 2]])
    取不连续列：
    [[1 3]
    [4 6]
    [7 9]]

行翻转（上下翻转）和列翻转（左右翻转）：

    n = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    print(n[::-1])
    行翻转
    [[7 8 9]
    [4 5 6]
    [1 2 3]]
    print(n[:, ::-1])
    列翻转
    [[3 2 1]
    [6 5 4]
    [9 8 7]]

### 数组变形

    n = np.array([1, 2, 3, 4, 5, 6])
    n2 = np.reshape(n, (2, 3))  # 2行3列
    n3 = n.reshape((2, 3))  # 2行3列
    n4 = n3.reshape(6)  # 变成一维，也可以写成 reshape(-1)
    n5 = n.reshape(2, -1)  # -1表示任意剩余维度长度

### 数组合并

    n1 = np.array([[1, 2, 3], [4, 5, 6]])
    n2 = np.array([[7, 8, 9], [10, 11, 12]])
    n3 = np.concatenate((n1, n2), axis=1)  # 默认上下合并，axis=1左右合并
    n4 = np.hstack((n1, n2))  # 水平合并，即左右合并
    n5 = np.vstack((n1, n2))  # 垂直合并，即上下合并

### 数组拆分

    n = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    n2 = np.vsplit(n, 3)  # 垂直拆分，平均拆成3份，水平拆分 hsplit()
    n3 = np.vsplit(n, (1,))  # 按照指定位置拆成
    n4 = np.split(n, 3, axis=1)  # 默认垂直拆分，axis=1水平合并

### 数组排序

- np.sort()：不改变原数组，占内存空间
- ndarray.sort()：改变原数组，不多占内存空间

    n = np.array([2, 44, 5, 3, 8])
    n2 = np.sort(n)  # 默认axis=1按行排序，axis=0按列排序
    n.sort()
    print(n, n2)

### 拷贝

    n = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    n2 = n.copy()  # 深拷贝

## 聚合函数

    n = np.array([[1, 2, 13], [4, 15, 6], [17, 8, 9]])
    print("求和:", n.sum())
    print("求和:", n.sum(axis=0))  # 每一列多行求和
    n = np.array([1, 2, 3, np.nan])
    print(np.nansum(n))  # 有nan（not a number）值时，sum无法求出和，要用nansum，它会排除掉nan之后再求和
    print("最小值:", n.min())
    print("最大值:", n.max())
    print("平均值:", n.mean())
    print("中位数:", np.median(n))
    print("百分位数:", np.percentile(n, 25))
    print("极差:", n.ptp())
    print("第一个最大值下标:", n.argmax())
    print("按条件找到所有最大值下标:", np.argwhere(n == n.max()))
    print("3次方:", np.power(n, 3))
    print("方差:", n.var())
    print("标准差:", n.std())
    print("对数:", np.log(n))
    print("减法:", np.diff(n))  # 计算数组中相邻元素之间差值
    print("符号:", np.sign(n))  # 值>0，返回1；值<0，返回-1；值=0，返回0
    n = np.array([1, 2, 13])
    weights = np.array([0.1, 0.2, 0.3])
    print("加权平均:", np.average(n, weights=weights))

## 矩阵操作

### 算术运算

    n = np.array([[11, 12, 13], [24, 15, 26], [17, 38, 39]])
    print(n + 10)  # 加
    print(n - 10)  # 减
    print(n * 10)  # 乘
    print(n / 10)  # 除
    print(n // 10)  # 整除
    print(n % 2)  # 余数
    print(n**2)  # 次方

### 线性代数

矩阵积：第一个矩阵的列数 = 第二个矩阵的行数。

    n1 = np.array([[1, 2, 3], [4, 5, 6]])
    n2 = np.array([[1, 2], [3, 4], [5, 6]])
    print(np.dot(n1, n2))

其他矩阵操作：

    n = np.array([[1, 2], [4, 5]])
    print(np.linalg.inv(n))  # 矩阵逆
    print(np.round(np.linalg.det(n)))  # 矩阵行列式
    print(np.linalg.matrix_rank(n))  # 矩阵的秩（满秩矩阵、奇异矩阵）

## 广播机制

ndarray广播机制的两条规则：

- 规则一：为缺失的维度补维度
- 规则二：缺失元素用已有值填充

    n1 = np.ones((2, 3), dtype=np.int8)
    n2 = np.arange(3)
    print(n1 + n2)
    输出
    [[1 2 3]
    [1 2 3]]

## 文件IO操作

### 数组保存和读取

NumPy可以用二进制的格式保存数据。如果不想让别人看到数据，想使用NumPy时加载的话，那完全可以用这种方式来保存数据。

使用save()来保存，保存的是一个以.npy结尾的二进制文件。加载的时候，用load()直接加载这个二进制数据文件。

    row_string = "1, 10, 5, 2, 11, 22"
    data = np.fromstring(row_string, dtype=np.int64, sep=",")
    data = data.reshape(2, 3)
    np.save("save_data.npy", data)
    npy_data = np.load("save_data.npy")
    print(npy_data)

NumPy还可以使用savez()将多个array保存到一个.npz文件中。

    train_data = np.array([1, 2, 3])
    test_data = np.array([11, 22, 33])
    np.savez("save_data.npz", train=train_data, test=test_data)
    npz_data = np.load("save_data.npz")
    print("train:", npz_data["train"])
    print("test:", npz_data["test"])

用savez()的时候，还有一个方法可以更节省空间，那就是用savez_compressed()来做一次数据压缩。

    np.savez_compressed("save_data.npz", train=train_data, test=test_data)

### 文本文件读写操作

    data = np.array([1, 10, 5, 2, 11, 22])
    np.savetxt("save_data.csv", data, delimiter=",", fmt="%s")

使用np.loadtxt()就能自定义读取数据：

    csv_data = np.loadtxt("save_data.csv", delimiter=",", dtype=np.int8)
    print(csv_data)

loadtxt()传入的关键字参数：

1. fname：文件名，数据类型为字符串
2. delimiter：分隔符，数据类型为字符串
3. usecols：读取列数，数据类型为元组, 其中元素个数有多少个，则选出多少列
4. unpack：是否解包，数据类型为布尔。如果True，读入属性将分别写入不同变量

## 高级函数

### 分段函数

简单分段，可以使用where(condition, x, y)，第一个参数表示条件，当条件成立时where方法返回x，当条件不成立时where返回y。

    x = np.array([8, 9, -1, -6])
    y = np.where(x > 0, x, np.abs(x))
    print(y)  # [8 9 1 6]

分段数较多，可以用select()。

    x = np.array([8, 9, 0, -1, -6])
    y = np.select([x < 0, x == 0, x > 0], [-1, 0, 1])
    print(y)  # [ 1  1  0 -1 -1]

where()、select()函数的所有参数都需要在调用它们之前完成计算，在计算时还会产生许多保存中间结果的数组，因此如果输入的数组很大，将会发生大量内存分配和释放。

piecewise()解决了上述问题，它只计算需要计算的值。piecewise()是专门用于计算分段的函数。

    x = np.array([8, 9, 5, 0, -1, -6])
    y = np.piecewise(x, [x < 0, x == 0, x > 0], [-1, 0, 1])
    print(y)  # [ 1  1  1  0 -1 -1]


Python科学计算模块NumPy学习笔记

推导式是Python中提供的一个非常方便的功能，可以通过一行代码实现创建list、dict、tuple、set 的同时初始化一些值。

    num_list = [ i for i in range(5)] # 列表
    print(num_list) # 结果为：[0, 1, 2, 3, 4]
    num_set = { i for i in range(5)} # 集合
    print(num_set) # 结果为：{0, 1, 2, 3, 4}
    num_dict = { i:i for i in range(5)} # 字典
    print(num_dict) # 结果为：{0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
    data = (i for i in range(5)) # 元组
    print(data) # 结果为：<generator object <genexpr> at 0x00000>
    for item in data:
    print(item)

元组不同于其他类型，不会立即执行内部循环去生成数据，而是得到一个生成器。

## 嵌套

    ## 生成一副扑克牌
    poker_list = [[color, num] for num in range(1, 14) for color in ["红桃", "黑桃", "方片", "梅花"]]
    print(poker_list)

## 烧脑面试题

    def num():
    return [lambda x: i * x for i in range(4)]
    1. 执行num()并获取返回值 [函数,函数,函数,函数] i=3
    2. for循环返回值
    3. 返回值的每个元素(2)
    result = [m(2) for m in num()]  # [6,6,6,6]
    def num():
    return (lambda x: i * x for i in range(4))
    1. 执行num()并获取返回值，得到一个生成器对象
    2. for循环返回值
    3. 返回值的每个元素(2)
    result = [m(2) for m in num()] # [0,2,4,6]

## 首字母配对

    girls = ['Python', 'Java', 'C']
    boys = ['Java', 'Python', 'C']
    letterGirls = {}
    for girl in girls:
    letterGirls.setdefault(girl[0], []).append(girl)
    print([b + ' + ' + g for b in boys for g in letterGirls[b[0]]])

输出结果如下：

    ['Java + Java', 'Python + Python', 'C + C']

`letterGirls.setdefault(girl[0], [])`是在letterGirls字典中寻找girl[0]元素（即girl变量的首字母），如果没找到，就返回默认值空列表。

那么，`letterGirls.setdefault(girl[0], [])`这部分可看作[]，即可理解为[].append(girl)。


Python推导式

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。