diff --git "a/Day01-15/13.\350\277\233\347\250\213\345\222\214\347\272\277\347\250\213.md" "b/Day01-15/13.\350\277\233\347\250\213\345\222\214\347\272\277\347\250\213.md" index b24b5b39f512f8cbc27668e85071bf7f562087e6..2c93c14fe2f9f9b46821871fdce59627b4c2e183 100644 --- "a/Day01-15/13.\350\277\233\347\250\213\345\222\214\347\272\277\347\250\213.md" +++ "b/Day01-15/13.\350\277\233\347\250\213\345\222\214\347\272\277\347\250\213.md" @@ -316,7 +316,7 @@ if __name__ == '__main__': 但是，切换作业是有代价的，比如从语文切到数学，要先收拾桌子上的语文书本、钢笔（这叫保存现场），然后，打开数学课本、找出圆规直尺（这叫准备新环境），才能开始做数学作业。操作系统在切换进程或者线程时也是一样的，它需要先保存当前执行的现场环境（CPU寄存器状态、内存页等），然后，把新任务的执行环境准备好（恢复上次的寄存器状态，切换内存页等），才能开始执行。这个切换过程虽然很快，但是也需要耗费时间。如果有几千个任务同时进行，操作系统可能就主要忙着切换任务，根本没有多少时间去执行任务了，这种情况最常见的就是硬盘狂响，点窗口无反应，系统处于假死状态。所以，多任务一旦多到一个限度，反而会使得系统性能急剧下降，最终导致所有任务都做不好。 -是否采用多任务的第二个考虑是任务的类型，可以把任务分为计算密集型和I/O密集型。计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如对视频进行编码解码或者格式转换等等，这种任务全靠CPU的运算能力，虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低。计算密集型任务由于主要消耗CPU资源，这类任务用Python这样的脚本语言去执行效率通常很低，最能胜任这类任务的是C语言，我们之前提到了Python中有嵌入C/C++代码的机制。 +是否采用多任务的第二个考虑是任务的类型，可以把任务分为计算密集型和I/O密集型。计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如对视频进行编码解码或者格式转换等等，这种任务全靠CPU的运算能力，虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低。计算密集型任务由于主要消耗CPU资源，这类任务用Python这样的脚本语言去执行效率通常很低，最能胜任这类任务的是C语言，我们之前提到过Python中有嵌入C/C++代码的机制。 除了计算密集型任务，其他的涉及到网络、存储介质I/O的任务都可以视为I/O密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待I/O操作完成（因为I/O的速度远远低于CPU和内存的速度）。对于I/O密集型任务，如果启动多任务，就可以减少I/O等待时间从而让CPU高效率的运转。有一大类的任务都属于I/O密集型任务，这其中包括了我们很快会涉及到的网络应用和Web应用。 @@ -324,9 +324,9 @@ if __name__ == '__main__': ### 单线程+异步I/O -现代操作系统对I/O操作的改进中最为重要的就是支持异步I/O。如果充分利用操作系统提供的异步I/O支持，就可以用单进程单线程模型来执行多任务，这种全新的模型称为事件驱动模型。Nginx就是支持异步I/O的Web服务器，它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上，可以运行多个进程（数量与CPU核心数相同），充分利用多核CPU。用Node.js开发的服务器端程序也使用了这种工作模式，这也是当下实现多任务编程的一种趋势。 +现代操作系统对I/O操作的改进中最为重要的就是支持异步I/O。如果充分利用操作系统提供的异步I/O支持，就可以用单进程单线程模型来执行多任务，这种全新的模型称为事件驱动模型。Nginx就是支持异步I/O的Web服务器，它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上，可以运行多个进程（数量与CPU核心数相同），充分利用多核CPU。用Node.js开发的服务器端程序也使用了这种工作模式，这也是当下并发编程的一种流行方案。 -在Python语言中，单线程+异步I/O的编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序。协程最大的优势就是极高的执行效率，因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销。协程的第二个优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不用加锁，只需要判断状态就好了，所以执行效率比多线程高很多。如果想要充分利用CPU的多核特性，最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。关于这方面的内容，我稍后会做一个专题来进行讲解。 +在Python语言中，单线程+异步I/O的编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序。协程最大的优势就是极高的执行效率，因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销。协程的第二个优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不用加锁，只需要判断状态就好了，所以执行效率比多线程高很多。如果想要充分利用CPU的多核特性，最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。关于这方面的内容，在后续的课程中会进行讲解。 ### 应用案例 diff --git "a/Day21-30/code/\345\236\203\345\234\276\345\210\206\347\261\273\346\237\245\350\257\242/index.html" "b/Day21-30/code/\345\236\203\345\234\276\345\210\206\347\261\273\346\237\245\350\257\242/index.html" index e2596c3aa4aa696cc1e3e95962deb5b2a3899e05..534ecc9746eb146c0d2b3df71a04c9938291df8f 100644 --- "a/Day21-30/code/\345\236\203\345\234\276\345\210\206\347\261\273\346\237\245\350\257\242/index.html" +++ "b/Day21-30/code/\345\236\203\345\234\276\345\210\206\347\261\273\346\237\245\350\257\242/index.html" @@ -102,7 +102,7 @@ // 查询垃圾分类的函数 search() { if (this.word.trim().length > 0) { - let key = '9636cec76ee2593ba6b195e5b770b394' + let key = 'e8c5524dd2a365f20908ced735f8e480' let url = `http://api.tianapi.com/txapi/lajifenlei/?key=${key}&word=${this.word}` fetch(url) .then(resp => resp.json()) diff --git "a/Day31-35/31-35.\347\216\251\350\275\254Linux\346\223\215\344\275\234\347\263\273\347\273\237.md" "b/Day31-35/31-35.\347\216\251\350\275\254Linux\346\223\215\344\275\234\347\263\273\347\273\237.md" index f0fe19b7cb4b8191bb310ba2850de0d63e8bc3e7..33bce52dd66c2a9155184f282ae83416aac769c5 100644 --- "a/Day31-35/31-35.\347\216\251\350\275\254Linux\346\223\215\344\275\234\347\263\273\347\273\237.md" +++ "b/Day31-35/31-35.\347\216\251\350\275\254Linux\346\223\215\344\275\234\347\263\273\347\273\237.md" @@ -954,7 +954,7 @@ Linux系统的命令通常都是如下所示的格式： 8. 创建/激活/关闭交换分区 - **mkswap** / **swapon** / **swapoff**。 -> 说明：执行上面这些命令会带有一定的风险，如果不清楚这些命令的用法，最好不用随意使用，在使用的过程中，最好对照参考资料进行操作，并在操作前确认是否要这么做。 +> **说明**：执行上面这些命令会带有一定的风险，如果不清楚这些命令的用法，最好不用随意使用，在使用的过程中，最好对照参考资料进行操作，并在操作前确认是否要这么做。 ### 编辑器 - vim diff --git a/Day36-40/code/HRS_create_and_init.sql b/Day36-40/code/HRS_create_and_init.sql index 4b991e415e41a5b2f09f695ad45a99da12019e93..933747748b5aab0d611e148ac21fe031bb4e3972 100644 --- a/Day36-40/code/HRS_create_and_init.sql +++ b/Day36-40/code/HRS_create_and_init.sql @@ -1,5 +1,5 @@ drop database if exists hrs; -create database hrs default charset utf8mb4; +create database hrs default charset utf8mb4 collate utf8_bin; use hrs; diff --git "a/Day41-55/45.\345\210\266\344\275\234\346\212\245\350\241\250.md" "b/Day41-55/45.\345\210\266\344\275\234\346\212\245\350\241\250.md" index 12d728b23b202a1b09b334d669f8ba003a89b7f0..ef9de3a70ebc5699b4ed463914397b3c37e7bef9 100644 --- "a/Day41-55/45.\345\210\266\344\275\234\346\212\245\350\241\250.md" +++ "b/Day41-55/45.\345\210\266\344\275\234\346\212\245\350\241\250.md" @@ -46,7 +46,7 @@ def export_teachers_excel(request): # 中文文件名需要处理成百分号编码 filename = quote('老师.xls') # 通过响应头告知浏览器下载该文件以及对应的文件名 - resp['content-disposition'] = f'attachment; filename*=utf-8''{filename}' + resp['content-disposition'] = f'attachment; filename*=utf-8\'\'{filename}' return resp ``` diff --git "a/Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md" "b/Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md" index e8caf862e2e95d32b2bf58c75b423c5b1c948774..672cd0d96afb0b0f7b55c5a6b921fd6bbffb6ef9 100644 --- "a/Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md" +++ "b/Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md" @@ -225,7 +225,7 @@ XPath是在XML文档中查找信息的一种语法，它使用路径表达式来 29.99 - Learning XML + 三国演义 39.95 diff --git "a/Day66-70/67.NumPy\347\232\204\345\272\224\347\224\250.md" "b/Day66-70/67.NumPy\347\232\204\345\272\224\347\224\250.md" index 3cfb855753deeaed0314c1a1776f1e0b7c39c8be..cf2a7d657315124067811b84fdd89c80ccf99163 100644 --- "a/Day66-70/67.NumPy\347\232\204\345\272\224\347\224\250.md" +++ "b/Day66-70/67.NumPy\347\232\204\345\272\224\347\224\250.md" @@ -103,7 +103,7 @@ Numpy最为核心的数据类型是`ndarray`，使用`ndarray`可以处理一维 产生10个$[1, 100)$范围的随机整数，代码： ```Python - array5 = np.random.randint(1, 101, 10) + array5 = np.random.randint(1, 100, 10) array5 ``` @@ -1124,7 +1124,7 @@ print(np.power(array37, array38)) | 函数 | 说明 | | --------------------------------- | ---- | -| `add(x, y)` / `substract(x, y)` / `multiply` | 加法函数 / 减法函数 | +| `add(x, y)` / `substract(x, y)` | 加法函数 / 减法函数 | |`multiply(x, y)` / `divide(x, y)`|乘法函数 / 除法函数| | `floor_divide(x, y)` / `mod(x, y)` | 整除函数 / 求模函数 | |`allclose(x, y)`|检查数组`x`和`y`元素是否几乎相等| @@ -1139,7 +1139,7 @@ print(np.power(array37, array38)) | `setdiff1d(x, y)` | 计算`x`和`y`的差集，返回这些元素构成的数组 | | `setxor1d(x, y)` | 计算`x`和`y`的对称差，返回这些元素构成的数组 | ->**补充说明：在二维空间内，两个向量$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \end{bmatrix}$的叉积是这样定义的：$\boldsymbol{A}\times \boldsymbol{B}=\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}=a_1b_2 - a_2b_1$，其中$\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}$称为行列式。但是一定要注意，叉积并不等同于行列式，行列式的运算结果是一个标量，而叉积运算的结果是一个向量。如果不明白，我们可以看看三维空间两个向量，$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \\ a_3 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \\ b_3 \end{bmatrix}$的叉积是$\left< \hat{i} \begin{vmatrix} a_2 \quad a_3 \\ b_2 \quad b_3 \end{vmatrix}, -\hat{j} \begin{vmatrix} a_1 \quad a_3 \\ b_1 \quad b_3 \end{vmatrix}, \hat{k} \begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix} \right>$，其中$\hat{i}, \hat{j}, \hat{k}$代表每个维度的单位向量。 +>**补充说明**：在二维空间内，两个向量$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \end{bmatrix}$的叉积是这样定义的：$\boldsymbol{A}\times \boldsymbol{B}=\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}=a_1b_2 - a_2b_1$，其中$\begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix}$称为行列式。但是一定要注意，叉积并不等同于行列式，行列式的运算结果是一个标量，而叉积运算的结果是一个向量。如果不明白，我们可以看看三维空间两个向量，$\boldsymbol{A}=\begin{bmatrix} a_1 \\ a_2 \\ a_3 \end{bmatrix}$和$\boldsymbol{B}=\begin{bmatrix} b_1 \\ b_2 \\ b_3 \end{bmatrix}$的叉积是$\left< \hat{i} \begin{vmatrix} a_2 \quad a_3 \\ b_2 \quad b_3 \end{vmatrix}, -\hat{j} \begin{vmatrix} a_1 \quad a_3 \\ b_1 \quad b_3 \end{vmatrix}, \hat{k} \begin{vmatrix} a_1 \quad a_2 \\ b_1 \quad b_2 \end{vmatrix} \right>$，其中$\hat{i}, \hat{j}, \hat{k}$代表每个维度的单位向量。 #### 广播机制 diff --git "a/Day66-70/68.Pandas\347\232\204\345\272\224\347\224\250.md" "b/Day66-70/68.Pandas\347\232\204\345\272\224\347\224\250.md" index c5c8abbd99e90a49bfbfd5035d71642e2a8f8475..7c602c01ef958a845128bb12398b4bc20a9412dd 100644 --- "a/Day66-70/68.Pandas\347\232\204\345\272\224\347\224\250.md" +++ "b/Day66-70/68.Pandas\347\232\204\345\272\224\347\224\250.md" @@ -2,23 +2,356 @@ Pandas是Wes McKinney在2008年开发的一个强大的**分析结构化数据**的工具集。Pandas以NumPy为基础（数据表示和运算），提供了用于数据处理的函数和方法，对数据分析和数据挖掘提供了很好的支持；同时Pandas还可以跟数据可视化工具Matplotlib很好的整合在一起，非常轻松愉快的实现数据的可视化展示。 -Pandas核心的数据类型是`Series`、`DataFrame`，分别用于处理一维和二维的数据，除此之外还有一个名为`Index`的类型及其子类型，它为`Series`和`DataFrame`提供了索引功能。日常工作中以`DataFrame`使用最为广泛，因为二维的数据本质就是一个有行有列的表格（想一想Excel电子表格和关系型数据库中的二维表）。上述这些类型都提供了大量的处理数据的方法，数据分析师可以以此为基础实现对数据的各种常规处理。 +Pandas核心的数据类型是`Series`（数据系列）、`DataFrame`（数据表/数据框），分别用于处理一维和二维的数据，除此之外还有一个名为`Index`的类型及其子类型，它为`Series`和`DataFrame`提供了索引功能。日常工作中以`DataFrame`使用最为广泛，因为二维的数据本质就是一个有行有列的表格（想一想Excel电子表格和关系型数据库中的二维表）。上述这些类型都提供了大量的处理数据的方法，数据分析师可以以此为基础实现对数据的各种常规处理。 ### Series的应用 +Pandas库中的`Series`对象可以用来表示一维数据结构，跟数组非常类似，但是多了一些额外的功能。`Series`的内部结构包含了两个数组，其中一个用来保存数据，另一个用来保存数据的索引，如下图所示。 + +![](res/pandas-series.png) + #### 创建Series对象 +> **提示**：在执行下面的代码之前，请先导入pandas以及相关的库文件，具体的做法可以参考上一章。 + +- 方法1：通过列表或数组创建Series对象。 + + 代码： + + ```Python + # data参数表示数据，index参数表示索引标签 + # 如果没有指定index属性，默认使用数字索引 + ser1 = pd.Series(data=[320, 180, 300, 405], index=['一季度', '二季度', '三季度', '四季度']) + ser1 + ``` + + 输出： + ``` + 一季度 320 + 二季度 180 + 三季度 300 + 四季度 405 + dtype: int64 + ``` -####基本属性和方法 +- 方法2：通过字典创建Series对象。 + 代码： + ```Python + # 字典中的键就是索引标签，字典中的值就是数据 + ser2 = pd.Series({'一季度': 320, '二季度': 180, '三季度': 300, '四季度': 405}) + ser2 + ``` + + 输出： + + ``` + 一季度 320 + 二季度 180 + 三季度 300 + 四季度 405 + dtype: int64 + ``` + +#### 索引和切片 + +跟数组一样，Series对象也可以进行索引和切片操作，不同的是Series对象因为内部维护了一个保存索引的数组，所以除了可以使用整数索引通过位置检索数据外，还可以通过自己设置的索引标签获取对应的数据。 + +- 使用正负向整数索引 + + 代码： + + ```Python + print(ser2[0], ser2[2], ser2[-1]) + ser2[0], ser2[-1] = 350, 360 + print(ser2) + ``` + + 输出： + + ``` + 320 300 405 + 一季度 350 + 二季度 180 + 三季度 300 + 四季度 360 + dtype: int64 + ``` + +- 使用自己设置的标签索引 + + 代码： + + ```Python + print(ser2['一季度'], ser2['三季度']) + ser2['一季度'] = 380 + print(ser2) + ``` + + 输出： + + ``` + 350 300 + 一季度 380 + 二季度 180 + 三季度 300 + 四季度 360 + dtype: int64 + ``` + +- 切片操作 + + 代码： + + ```Python + print(ser2[1:3]) + print(ser2['二季度':'四季度']) + ``` + + 输出： + + ``` + 二季度 180 + 三季度 300 + dtype: int64 + 二季度 500 + 三季度 500 + 四季度 520 + dtype: int64 + ``` + + 代码： + + ```Python + ser2[1:3] = 400, 500 + ser2 + ``` + + 输出： + + ``` + 一季度 380 + 二季度 400 + 三季度 500 + 四季度 360 + dtype: int64 + ``` + +- 花式索引 + + 代码： + + ```Python + print(ser2[['二季度', '四季度']]) + ser2[['二季度', '四季度']] = 500, 520 + print(ser2) + ``` + + 输出： + + ``` + 二季度 400 + 四季度 360 + dtype: int64 + 一季度 380 + 二季度 500 + 三季度 500 + 四季度 520 + dtype: int64 + ``` + +- 布尔索引 + + 代码： + + ```Python + ser2[ser2 >= 500] + ``` + + 输出： + + ``` + 二季度 500 + 三季度 500 + 四季度 520 + dtype: int64 + ``` + +####属性和方法 + +Series对象的常用属性如下表所示。 + +| 属性 | 说明 | +| ------------------------- | --------------------------------------- | +| `dtype` / `dtypes` | 返回`Series`对象的数据类型 | +| `hasnans` | 判断`Series`对象中有没有空值 | +| `at` / `iat` | 通过索引访问`Series`对象中的单个值 | +| `loc` / `iloc` | 通过一组索引访问`Series`对象中的一组值 | +| `index` | 返回`Series`对象的索引 | +| `is_monotonic` | 判断`Series`对象中的数据是否单调 | +| `is_monotonic_increasing` | 判断`Series`对象中的数据是否单调递增 | +| `is_monotonic_decreasing` | 判断`Series`对象中的数据是否单调递减 | +| `is_unique` | 判断`Series`对象中的数据是否独一无二 | +| `size` | 返回`Series`对象中元素的个数 | +| `values` | 以`ndarray`的方式返回`Series`对象中的值 | + +`Series`对象的方法很多，我们通过下面的代码为大家介绍一些常用的方法。 + +- 统计相关方法 + + 代码： + + ```Python + # 求和 + print(ser2.sum()) + # 求均值 + print(ser2.mean()) + # 求最大 + print(ser2.max()) + # 求最小 + print(ser2.min()) + # 计数 + print(ser2.count()) + # 求标准差 + print(ser2.std()) + # 求方差 + print(ser2.var()) + # 求中位数 + print(ser2.median()) + ``` + + 输出： + + ``` + 1900 + 475.0 + 520 + 380 + 4 + 64.03124237432849 + 4100.0 + 500.0 + ``` + + `Series`对象还有一个名为`describe()`的方法，可以获得上述所有的描述性统计信息，如下所示。 + + 代码： + + ```Python + ser2.describe() + ``` + + 输出： + + ``` + count 4.000000 + mean 475.000000 + std 64.031242 + min 380.000000 + 25% 470.000000 + 50% 500.000000 + 75% 505.000000 + max 520.000000 + dtype: float64 + ``` + + > **提示**：因为`describe()`返回的也是一个`Series`对象，所以也可以用`ser2.describe()['mean']`来获取平均值。 + + 如果`Series`对象的数据中有重复元素，我们可以使用`unique()`方法获得去重之后的`Series`对象，如果想要统计重复元素重复的次数，可以使用`value_counts()`方法，这个方法会返回一个`Series`对象，它的索引就是原来的`Series`对象中的元素，而每个元素出现的次数就是返回的`Series`对象中的数据，在默认情况下会按照元素出现次数做降序排列。 + + 代码： + + ```Python + ser3 = pd.Series(data=['apple', 'banana', 'apple', 'pitaya', 'apple', 'pitaya', 'durian']) + ser3.value_counts() + ``` + + 输出： + + ``` + apple 3 + pitaya 2 + durian 1 + banana 1 + dtype: int64 + ``` + +- 数据处理方法 + + `Series`对象的`dropna`和`fillna`方法分别用来删除空值和填充空值，具体的用法如下所示。 + + ```Python + ser4 = pd.Series(data=[10, 20, np.NaN, 30, np.NaN]) + ser4.dropna() + ``` + + 输出： + + ``` + 0 10.0 + 1 20.0 + 3 30.0 + dtype: float64 + ``` + + 代码： + + ```Python + # 将空值填充为40 + ser4.fillna(value=40) + ``` + + 输出： + + ``` + 0 10.0 + 1 20.0 + 2 40.0 + 3 30.0 + 4 40.0 + dtype: float64 + ``` + + 代码： + + ```Python + # backfill或bfill表示用后一个元素的值填充空值 + # ffill或pad表示用前一个元素的值填充空值 + ser4.fillna(method='ffill') + ``` + + 输出： + + ``` + 0 10.0 + 1 20.0 + 2 20.0 + 3 30.0 + 4 30.0 + dtype: float64 + ``` + + 需要提醒大家注意的是，`dropna`和`fillna`方法都有一个名为`inplace`的参数，它的默认值是`False`，表示删除空值或填充空值不会修改原来的`Series`对象，而是返回一个新的`Series`对象来表示删除或填充空值后的数据系列，如果将`inplace`参数的值修改为`True`，那么删除或填充空值会就地操作，直接修改原来的`Series`对象，那么方法的返回值是`None`。后面我们会接触到的很多方法，包括`DataFrame`对象的很多方法都会有这个参数，它们的意义跟这里是一样的。 + + `Series`对象的`apply`和`map`方法可以用于对数据进行处理，代码如下所示。 + + `Series`对象的`mask`和`where`方法可以将满足或不满足条件的值进行替换。 + + `Series`对象的`sort_index`和`sort_values`方法可以用于对索引和数据的排序，具体的用法请参考下面的例子。 + + `Series`对象的`value_counts`方法可以统计每个值出现的次数并且以从大到小的顺序进行排列，`Series`对象的`unique`方法可以获取到不重复的值。 + + #### 绘制图表 +Series对象有一个名为`plot`的方法可以用来生成图表，如果选择生成折线图、散点图、柱状图等，默认会使用Series对象的索引作为横坐标，使用Series对象的数据作为纵坐标。 + -#### Index的使用 +利用Series对象的数据也可以生成表示占比的饼图和显示数据分布的直方图，如下面的代码所示。 diff --git a/Day66-70/code/Day68.ipynb b/Day66-70/code/Day68.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..539f6390f7e2c1ffafa47d91088f67e3229e6195 --- /dev/null +++ b/Day66-70/code/Day68.ipynb @@ -0,0 +1,424 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "%config InlineBackend.figure_format='svg'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams['font.sans-serif'] = 'FZJKai-Z03S'\n", + "plt.rcParams['axes.unicode_minus'] = False" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "一季度 320\n", + "二季度 180\n", + "三季度 300\n", + "四季度 405\n", + "dtype: int64" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser1 = pd.Series(data=[320, 180, 300, 405], index=['一季度', '二季度', '三季度', '四季度'])\n", + "ser1" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "一季度 320\n", + "二季度 180\n", + "三季度 300\n", + "四季度 405\n", + "dtype: int64" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser2 = pd.Series({'一季度': 320, '二季度': 180, '三季度': 300, '四季度': 405})\n", + "ser2" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "320 300 405\n", + "一季度 350\n", + "二季度 180\n", + "三季度 300\n", + "四季度 360\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(ser2[0], ser2[2], ser2[-1])\n", + "ser2[0], ser2[-1] = 350, 360 \n", + "print(ser2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "350 300\n", + "一季度 380\n", + "二季度 180\n", + "三季度 300\n", + "四季度 360\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(ser2['一季度'], ser2['三季度'])\n", + "ser2['一季度'] = 380\n", + "print(ser2)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "二季度 180\n", + "三季度 300\n", + "dtype: int64\n", + "二季度 180\n", + "三季度 300\n", + "四季度 360\n", + "dtype: int64\n", + "一季度 380\n", + "二季度 400\n", + "三季度 500\n", + "四季度 360\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(ser2[1:3])\n", + "print(ser2['二季度': '四季度'])\n", + "ser2[1:3] = 400, 500\n", + "print(ser2)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "二季度 400\n", + "四季度 360\n", + "dtype: int64\n", + "一季度 380\n", + "二季度 500\n", + "三季度 500\n", + "四季度 520\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(ser2[['二季度', '四季度']])\n", + "ser2[['二季度', '四季度']] = 500, 520\n", + "print(ser2)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "二季度 500\n", + "三季度 500\n", + "四季度 520\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(ser2[ser2 >= 500])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1900\n", + "475.0\n", + "520\n", + "380\n", + "4\n", + "64.03124237432849\n", + "4100.0\n", + "500.0\n" + ] + } + ], + "source": [ + "# 求和\n", + "print(ser2.sum())\n", + "# 求均值\n", + "print(ser2.mean())\n", + "# 求最大\n", + "print(ser2.max())\n", + "# 求最小\n", + "print(ser2.min())\n", + "# 计数\n", + "print(ser2.count())\n", + "# 求标准差\n", + "print(ser2.std())\n", + "# 求方差\n", + "print(ser2.var())\n", + "# 求中位数\n", + "print(ser2.median())" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 4.000000\n", + "mean 475.000000\n", + "std 64.031242\n", + "min 380.000000\n", + "25% 470.000000\n", + "50% 500.000000\n", + "75% 505.000000\n", + "max 520.000000\n", + "dtype: float64" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser2.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "apple 3\n", + "pitaya 2\n", + "durian 1\n", + "banana 1\n", + "dtype: int64" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser3 = pd.Series(data=['apple', 'banana', 'apple', 'pitaya', 'apple', 'pitaya', 'durian'])\n", + "ser3.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 10.0\n", + "1 20.0\n", + "3 30.0\n", + "dtype: float64" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser4 = pd.Series(data=[10, 20, np.NaN, 30, np.NaN])\n", + "ser4.dropna()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 10.0\n", + "1 20.0\n", + "2 40.0\n", + "3 30.0\n", + "4 40.0\n", + "dtype: float64" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser4.fillna(value=40)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 10.0\n", + "1 20.0\n", + "2 20.0\n", + "3 30.0\n", + "4 30.0\n", + "dtype: float64" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ser4.fillna(method='ffill')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Day66-70/code/Day69.ipynb b/Day66-70/code/Day69.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..36803f86c8f905741dd5342388b12b07c4609166 --- /dev/null +++ b/Day66-70/code/Day69.ipynb @@ -0,0 +1,45 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Day66-70/code/Day70.ipynb b/Day66-70/code/Day70.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..36803f86c8f905741dd5342388b12b07c4609166 --- /dev/null +++ b/Day66-70/code/Day70.ipynb @@ -0,0 +1,45 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Day66-70/res/pandas-series.png b/Day66-70/res/pandas-series.png new file mode 100644 index 0000000000000000000000000000000000000000..279ba2ba20ddf2373685efb97949bda405aa03ed Binary files /dev/null and b/Day66-70/res/pandas-series.png differ diff --git "a/Day91-100/92.Docker\345\256\271\345\231\250\350\257\246\350\247\243.md" "b/Day91-100/92.Docker\345\256\271\345\231\250\346\212\200\346\234\257\350\257\246\350\247\243.md" similarity index 99% rename from "Day91-100/92.Docker\345\256\271\345\231\250\350\257\246\350\247\243.md" rename to "Day91-100/92.Docker\345\256\271\345\231\250\346\212\200\346\234\257\350\257\246\350\247\243.md" index 4fe34cc4eed14cb251b4607875904b5aa53ff14d..47bdb8d6ba79f69a908eae10c1657ca7e080236b 100644 --- "a/Day91-100/92.Docker\345\256\271\345\231\250\350\257\246\350\247\243.md" +++ "b/Day91-100/92.Docker\345\256\271\345\231\250\346\212\200\346\234\257\350\257\246\350\247\243.md" @@ -1,4 +1,4 @@ -## Docker容器详解 +## Docker容器技术详解 Docker是基于Go语言开发的开源应用容器引擎，遵从Apache Licence 2.0协议，可以让开发者打包应用以及应用的依赖包到一个可移植的容器中，然后发布到各种发行版本的Linux系统上。 diff --git a/README.md b/README.md index f725ad80b402acbe539b87d840fd4c4487af9999..32c5bb66b0cc253fb410c2661acc30861b7c5efc 100644 --- a/README.md +++ b/README.md @@ -394,7 +394,7 @@ Python在以下领域都有用武之地。 ### Day86~90 - [大数据分析概述](./Day86-90) -####Day86 - [大数据概述](./Day86-90/86.大数据概述.md) +#### Day86 - [大数据概述](./Day86-90/86.大数据概述.md) #### Day87 - [Hive查询](./Day86-90/87.Hive查询.md) diff --git "a/\347\225\252\345\244\226\347\257\207/\344\275\277\347\224\250Hexo\346\220\255\345\273\272\350\207\252\345\267\261\347\232\204\345\215\232\345\256\242.md" "b/\347\225\252\345\244\226\347\257\207/\344\275\277\347\224\250Hexo\346\220\255\345\273\272\350\207\252\345\267\261\347\232\204\345\215\232\345\256\242.md" index 0527b4730ef2b8b0ed31b906e54ef71aacabda2f..49362d2b51d8bb950f3e8634f84f3bba93deb496 100644 --- "a/\347\225\252\345\244\226\347\257\207/\344\275\277\347\224\250Hexo\346\220\255\345\273\272\350\207\252\345\267\261\347\232\204\345\215\232\345\256\242.md" +++ "b/\347\225\252\345\244\226\347\257\207/\344\275\277\347\224\250Hexo\346\220\255\345\273\272\350\207\252\345\267\261\347\232\204\345\215\232\345\256\242.md" @@ -250,7 +250,11 @@ deploy: ```Markdown --- title: Python编程惯例 -category: Python基础 +categories: +- Python基础 +tags: +- Python +- PEP8 date: 2019-8-1 --- ## Python惯例 diff --git "a/\347\225\252\345\244\226\347\257\207/\347\216\251\350\275\254PyCharm.md" "b/\347\225\252\345\244\226\347\257\207/\347\216\251\350\275\254PyCharm.md" index 3069dbde96d42b9e56c2b7c4682e2fb78b67058f..bb5c682bb18c468815a3e5e3edef0aff053bcbd8 100644 --- "a/\347\225\252\345\244\226\347\257\207/\347\216\251\350\275\254PyCharm.md" +++ "b/\347\225\252\345\244\226\347\257\207/\347\216\251\350\275\254PyCharm.md" @@ -12,23 +12,23 @@ PyCharm是由JetBrains公司开发的提供给Python专业的开发者的一个 第一次使用PyCharm时，会有一个导入设置的向导，如果之前没有使用PyCharm或者没有保存过设置的就直接选择“Do not import settings”进入下一步即可，下面是我在macOS系统下第一次使用PyCharm时的截图。 -![](./res/pycharm-import-settings.png) +![](res/pycharm-import-settings.png) 专业版的PyCharm是需要激活的，**强烈建议大家在条件允许的情况下支付费用来支持优秀的产品**，如果不用做商业用途或者不需要使用PyCharm的高级功能，我们可以暂时选择试用30天或者使用社区版的PyCharm。如果你是一名学生，希望购买PyCharm来使用，可以看看[教育优惠官方申请指南](https://sales.jetbrains.com/hc/zh-cn/articles/207154369)。如下图所示，我们需要点击“Evaluate”按钮来试用专业版PyCharm。 -![](./res/pycharm-activation.png) +![](res/pycharm-activation.png) 接下来是选择UI主题，可以根据个人喜好进行选择，深色的主题比较护眼而浅色的主题对比度更好。 -![](./res/pycharm-ui-themes.png) +![](res/pycharm-ui-themes.png) 再接下来是创建可以在“终端”或“命令行提示符”中运行PyCharm的启动脚本，当然也可以不做任何勾选，直接点击“Next: Featured plugins”按钮进入下一环节。 -![](./res/pycharm-create-launcher.png) +![](res/pycharm-create-launcher.png) 然后可以选择需要安装哪些插件，我们可以暂时什么都不安装，等需要的时候再来决定。 -![](./res/pycharm-install-plugins.png) +![](res/pycharm-install-plugins.png) 最后点击上图右下角的“Start using PyCharm”（开始使用PyCharm）就可以开启你的PyCharm之旅了。 @@ -36,17 +36,17 @@ PyCharm是由JetBrains公司开发的提供给Python专业的开发者的一个 启动PyCharm之后会来到一个欢迎页，在欢迎页上我们可以选择“创建新项目”（Create New Project）、“打开已有项目”（Open）和“从版本控制系统中检出项目”（Get from Version Control）。 -![](./res/pycharm-welcome.png) +![](res/pycharm-welcome.png) 如果选择了“Create New Project”来创建新项目就会打一个创建项目的向导页。下图所示是PyCharm专业版创建新项目的向导页，可以看出专业版支持的项目类型非常的多，而社区版只能创建纯Python项目（Pure Python），没有这一系列的选项。 -![](./res/pycharm-project-wizard.png) +![](res/pycharm-project-wizard.png) 接下来，我们要为项目创建专属的虚拟环境，每个Python项目最好都在自己专属的虚拟环境中运行，因为每个项目对Python解释器和三方库的需求并不相同，虚拟环境对不同的项目进行了隔离。在上图所示的界面在，我们可以选择新建虚拟环境（New environment using Virtualenv），这里的“Virtualenv”是PyCharm默认选择的创建虚拟环境的工具，我们就保留这个默认的选项就可以了。 项目创建完成后就可以开始新建各种文件来书写Python代码了，如下图所示。左侧是项目浏览器，可以看到刚才创建的项目文件夹以及虚拟环境文件夹。我们可以在项目上点击鼠标右键，选择“New”，在选择“Python File”来创建Python代码文件，下图中我们创建了两个Python文件，分别是`poker_game.py`和`salary_system.py`。当然，如果愿意，也可以使用复制粘贴的方式把其他地方的Python代码文件复制到项目文件夹下。 -![](./res/pycharm-workspace.png) +![](res/pycharm-workspace.png) 在工作窗口点击鼠标右键可以在上下文菜单中找到“Run”选项，例如要运行`salary_system.py`文件，右键菜单会显示“Run 'salary_system'”选项，点击这个选项我们就可以运行Python代码啦，运行结果在屏幕下方的窗口可以看到，如下图所示。